kornerr
/
research-portable-memory
1
0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Research portable Memory game | Исследовать портируемую игру Память
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
87 Commits
1 Branch
21MB
Struktur: 7f2dbfd65c
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „7f2dbfd65c“
${ noResults }
research-portable-memory/v4/cli_test.cpp

310 Zeilen
6.4KB
Originalformat Blame Verlauf 

  1. #include <map>

  2. #include <string>

  3. #include <vector>

  4. #include "cli.h"

  5. #include "cli_Context.h"

  6. #include "memory.h"

  7. #include "memory_Context.h"

  8. #include "shell.h"

  9. 

  10. std::string cli_test_exit_e(

  11. ) {

  12.   auto c = memory_createContext();

  13.   c.input = "e";

  14.   c.recentField = "input";

  15.   c = cli_exit(c);

  16.   if (

  17.     c.recentField == "exit"

  18.   ) {

  19.     return "OK: cli_exit_e";

  20.   }

  21.   return "ERR: cli_exit_e";

  22. }

  23. 

  24. std::string cli_test_exit_exit(

  25. ) {

  26.   auto c = memory_createContext();

  27.   c.input = "exit";

  28.   c.recentField = "input";

  29.   c = cli_exit(c);

  30.   if (

  31.     c.recentField == "exit"

  32.   ) {

  33.     return "OK: cli_exit_exit";

  34.   }

  35.   return "ERR: cli_exit_e";

  36. }

  37. 

  38. 

  39. 

  40. 

  41. std::string cli_test_exit_victory(

  42. ) {

  43.   auto c = memory_createContext();

  44.   c.playfieldSize = 2;

  45.   c.recentField = "playfieldSize";

  46.   c = memory_generateConstPlayfield(c);

  47.   // Match the first pair of tiles.

  48.   c.input = "1";

  49.   c.recentField = "input";

  50.   c = cli_selectItem(c);

  51.   c = memory_selectItem(c);

  52.   c.input = "2";

  53.   c.recentField = "input";

  54.   c = cli_selectItem(c);

  55.   c = memory_selectItem(c);

  56.   c = memory_hideMatchingItems(c);

  57.   // Match the second pair of tiles.

  58.   c.input = "3";

  59.   c.recentField = "input";

  60.   c = cli_selectItem(c);

  61.   c = memory_selectItem(c);

  62.   c.input = "4";

  63.   c.recentField = "input";

  64.   c = cli_selectItem(c);

  65.   c = memory_selectItem(c);

  66.   c = memory_hideMatchingItems(c);

  67.   c = memory_detectVictory(c);

  68.   c = cli_reportVictory(c);

  69.   c = cli_exit(c);

  70.   if (

  71.     c.recentField == "exit"

  72.   ) {

  73.     return "OK: cli_exit_victory";

  74.   }

  75.   return "ERR: cli_exit_victory";

  76. }

  77. 

  78. std::string cli_test_exit_q(

  79. ) {

  80.   auto c = memory_createContext();

  81.   c.input = "q";

  82.   c.recentField = "input";

  83.   c = cli_exit(c);

  84.   if (

  85.     c.recentField == "exit"

  86.   ) {

  87.     return "OK: cli_exit_q";

  88.   }

  89.   return "ERR: cli_exit_q";

  90. }

  91. 

  92. std::string cli_test_exit_quit(

  93. ) {

  94.   auto c = memory_createContext();

  95.   c.input = "quit";

  96.   c.recentField = "input";

  97.   c = cli_exit(c);

  98.   if (

  99.     c.recentField == "exit"

  100.   ) {

  101.     return "OK: cli_exit_quit";

  102.   }

  103.   return "ERR: cli_exit_quit";

  104. }

  105. 

  106. 

  107. 

  108. std::string cli_test_goOn(

  109. ) {

  110.   auto c = memory_createContext();

  111.   c.playfieldSize = 2;

  112.   c.recentField = "playfieldSize";

  113.   c = memory_generateConstPlayfield(c);

  114.   // Match the first pair of items.

  115.   c.input = "1";

  116.   c.recentField = "input";

  117.   c = cli_selectItem(c);

  118.   c = memory_selectItem(c);

  119.   c.input = "2";

  120.   c.recentField = "input";

  121.   c = cli_selectItem(c);

  122.   c = memory_selectItem(c);

  123.   c = memory_hideMatchingItems(c);

  124.   c = cli_reportMatchedItems(c);

  125.   c = cli_goOn(c);

  126.   if (

  127.     c.recentField == "outputGoOn"

  128.   ) {

  129.     return "OK: cli_goOn";

  130.   }

  131.   return "ERR: cli_goOn";

  132. }

  133. 

  134. std::string cli_test_greetUser(

  135. ) {

  136.   auto c = memory_createContext();

  137.   c.didLaunch = true;

  138.   c.recentField = "didLaunch";

  139.   c = cli_greetUser(c);

  140.   if (

  141.     c.recentField == "outputGreeting"

  142.   ) {

  143.     return "OK: cli_greetUser";

  144.   }

  145.   return "ERR: cli_greetUser";

  146. }

  147. 

  148. std::string cli_test_promptSecondItemSelection(

  149. ) {

  150.   auto c = memory_createContext();

  151.   c.input = "1";

  152.   c.recentField = "input";

  153.   c = cli_selectItem(c);

  154.   c = memory_selectItem(c);

  155.   c = cli_promptSecondItemSelection(c);

  156.   if (

  157.     c.recentField == "outputPromptSelection"

  158.   ) {

  159.     return "OK: cli_promptSecondItemSelection";

  160.   }

  161.   return "ERR: cli_promptSecondItemSelection";

  162. }

  163. 

  164. std::string cli_test_reportMatchedItems(

  165. ) {

  166.   auto c = memory_createContext();

  167.   c.playfieldSize = 2;

  168.   c.recentField = "playfieldSize";

  169.   c = memory_generateConstPlayfield(c);

  170.   c.input = "1";

  171.   c.recentField = "input";

  172.   c = cli_selectItem(c);

  173.   c = memory_selectItem(c);

  174.   c.input = "2";

  175.   c.recentField = "input";

  176.   c = cli_selectItem(c);

  177.   c = memory_selectItem(c);

  178.   c = memory_hideMatchingItems(c);

  179.   c = cli_reportMatchedItems(c);

  180.   if (

  181.     c.recentField == "outputMatchedItems"

  182.   ) {

  183.     return "OK: cli_reportMatchedItems";

  184.   }

  185.   return "ERR: cli_reportMatchedItems";

  186. }

  187. 

  188. std::string cli_test_reportMismatchedItems(

  189. ) {

  190.   auto c = memory_createContext();

  191.   c.playfieldSize = 2;

  192.   c.recentField = "playfieldSize";

  193.   c = memory_generateConstPlayfield(c);

  194.   c.input = "1";

  195.   c.recentField = "input";

  196.   c = cli_selectItem(c);

  197.   c = memory_selectItem(c);

  198.   c.input = "3";

  199.   c.recentField = "input";

  200.   c = cli_selectItem(c);

  201.   c = memory_selectItem(c);

  202.   c = memory_detectMismatchedItems(c);

  203.   c = cli_reportMismatchedItems(c);

  204.   if (

  205.     c.recentField == "outputMismatchedItems"

  206.   ) {

  207.     return "OK: cli_reportMismatchedItems";

  208.   }

  209.   return "ERR: cli_reportMismatchedItems";

  210. }

  211. 

  212. std::string cli_test_selectItem(

  213. ) {

  214.   auto c = memory_createContext();

  215.   c.input = "1";

  216.   c.recentField = "input";

  217.   c = cli_selectItem(c);

  218.   if (

  219.     c.recentField == "selectedId" &&

  220.     c.selectedId == 0

  221.   ) {

  222.     return "OK: cli_selectItem";

  223.   }

  224.   return "ERR: cli_selectItem";

  225. }

  226. 

  227. std::string cli_test_showHelp_h(

  228. ) {

  229.   auto c = memory_createContext();

  230.   c.input = "h";

  231.   c.recentField = "input";

  232.   c = cli_showHelp(c);

  233.   if (

  234.     c.recentField == "outputHelp"

  235.   ) {

  236.     return "OK: cli_showHelp_h";

  237.   }

  238.   return "ERR: cli_showHelp_h";

  239. }

  240. 

  241. std::string cli_test_showHelp_help(

  242. ) {

  243.   auto c = memory_createContext();

  244.   c.input = "help";

  245.   c.recentField = "input";

  246.   c = cli_showHelp(c);

  247.   if (

  248.     c.recentField == "outputHelp"

  249.   ) {

  250.     return "OK: cli_showHelp_help";

  251.   }

  252.   return "ERR: cli_showHelp_help";

  253. }

  254. 

  255. 

  256. 

  257. 

  258. std::string cli_test_reportVictory(

  259. ) {

  260.   auto c = memory_createContext();

  261.   c.playfieldSize = 2;

  262.   c.recentField = "playfieldSize";

  263.   c = memory_generateConstPlayfield(c);

  264.   // Match the first pair of tiles.

  265.   c.input = "1";

  266.   c.recentField = "input";

  267.   c = cli_selectItem(c);

  268.   c = memory_selectItem(c);

  269.   c.input = "2";

  270.   c.recentField = "input";

  271.   c = cli_selectItem(c);

  272.   c = memory_selectItem(c);

  273.   c = memory_hideMatchingItems(c);

  274.   // Match the second pair of tiles.

  275.   c.input = "3";

  276.   c.recentField = "input";

  277.   c = cli_selectItem(c);

  278.   c = memory_selectItem(c);

  279.   c.input = "4";

  280.   c.recentField = "input";

  281.   c = cli_selectItem(c);

  282.   c = memory_selectItem(c);

  283.   c = memory_hideMatchingItems(c);

  284.   c = memory_detectVictory(c);

  285.   c = cli_reportVictory(c);

  286.   if (

  287.     c.recentField == "outputVictory"

  288.   ) {

  289.     return "OK: cli_reportVictory";

  290.   }

  291.   return "ERR: cli_reportVictory";

  292. }

  293. 

  294. //def cli_test_shouldReportIvalidItemSelection_outOfBoundsMin(

  295. //) -> str:

  296. //  c = cli_createContext()

  297. //  c.cMemory = memory_createContext()

  298. //  c.input = "0"

  299. //  c = cli_selectItem(c)

  300. //  c = cli_shouldReportInvalidItemSelection(c)

  301. //  if (

  302. //    c.recentField == "outputInvalidItemSelection"

  303. //  ):

  304. //    return "OK: cli_shouldReportInvalidItemSelection"

  305. //  //}

  306. //  return "ERR: cli_shouldReportInvalidItemSelection"

  307. ////}

  308. //