kornerr
/
research-portable-memory
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Research portable Memory game | Исследовать портируемую игру Память
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
89 Revīzijas
1 Atzars
21MB
Koks: d619522f7d
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'd619522f7d'
${ noResults }
research-portable-memory/v4/cli_test.cpp

307 rindas
6.4KB
Neapstrādāts Vainot Vēsture 

  1. #include <map>

  2. #include <string>

  3. #include <vector>

  4. #include "memory_Context.h"

  5. #include "main.h"

  6. 

  7. std::string cli_test_exit_e(

  8. ) {

  9.   auto c = memory_createContext();

  10.   c.input = "e";

  11.   c.recentField = "input";

  12.   c = cli_exit(c);

  13.   if (

  14.     c.recentField == "exit"

  15.   ) {

  16.     return "OK: cli_exit_e";

  17.   }

  18.   return "ERR: cli_exit_e";

  19. }

  20. 

  21. std::string cli_test_exit_exit(

  22. ) {

  23.   auto c = memory_createContext();

  24.   c.input = "exit";

  25.   c.recentField = "input";

  26.   c = cli_exit(c);

  27.   if (

  28.     c.recentField == "exit"

  29.   ) {

  30.     return "OK: cli_exit_exit";

  31.   }

  32.   return "ERR: cli_exit_e";

  33. }

  34. 

  35. 

  36. 

  37. 

  38. std::string cli_test_exit_victory(

  39. ) {

  40.   auto c = memory_createContext();

  41.   c.playfieldSize = 2;

  42.   c.recentField = "playfieldSize";

  43.   c = memory_generateConstPlayfield(c);

  44.   // Match the first pair of tiles.

  45.   c.input = "1";

  46.   c.recentField = "input";

  47.   c = cli_selectItem(c);

  48.   c = memory_selectItem(c);

  49.   c.input = "2";

  50.   c.recentField = "input";

  51.   c = cli_selectItem(c);

  52.   c = memory_selectItem(c);

  53.   c = memory_hideMatchingItems(c);

  54.   // Match the second pair of tiles.

  55.   c.input = "3";

  56.   c.recentField = "input";

  57.   c = cli_selectItem(c);

  58.   c = memory_selectItem(c);

  59.   c.input = "4";

  60.   c.recentField = "input";

  61.   c = cli_selectItem(c);

  62.   c = memory_selectItem(c);

  63.   c = memory_hideMatchingItems(c);

  64.   c = memory_detectVictory(c);

  65.   c = cli_reportVictory(c);

  66.   c = cli_exit(c);

  67.   if (

  68.     c.recentField == "exit"

  69.   ) {

  70.     return "OK: cli_exit_victory";

  71.   }

  72.   return "ERR: cli_exit_victory";

  73. }

  74. 

  75. std::string cli_test_exit_q(

  76. ) {

  77.   auto c = memory_createContext();

  78.   c.input = "q";

  79.   c.recentField = "input";

  80.   c = cli_exit(c);

  81.   if (

  82.     c.recentField == "exit"

  83.   ) {

  84.     return "OK: cli_exit_q";

  85.   }

  86.   return "ERR: cli_exit_q";

  87. }

  88. 

  89. std::string cli_test_exit_quit(

  90. ) {

  91.   auto c = memory_createContext();

  92.   c.input = "quit";

  93.   c.recentField = "input";

  94.   c = cli_exit(c);

  95.   if (

  96.     c.recentField == "exit"

  97.   ) {

  98.     return "OK: cli_exit_quit";

  99.   }

  100.   return "ERR: cli_exit_quit";

  101. }

  102. 

  103. 

  104. 

  105. std::string cli_test_goOn(

  106. ) {

  107.   auto c = memory_createContext();

  108.   c.playfieldSize = 2;

  109.   c.recentField = "playfieldSize";

  110.   c = memory_generateConstPlayfield(c);

  111.   // Match the first pair of items.

  112.   c.input = "1";

  113.   c.recentField = "input";

  114.   c = cli_selectItem(c);

  115.   c = memory_selectItem(c);

  116.   c.input = "2";

  117.   c.recentField = "input";

  118.   c = cli_selectItem(c);

  119.   c = memory_selectItem(c);

  120.   c = memory_hideMatchingItems(c);

  121.   c = cli_reportMatchedItems(c);

  122.   c = cli_goOn(c);

  123.   if (

  124.     c.recentField == "outputGoOn"

  125.   ) {

  126.     return "OK: cli_goOn";

  127.   }

  128.   return "ERR: cli_goOn";

  129. }

  130. 

  131. std::string cli_test_greetUser(

  132. ) {

  133.   auto c = memory_createContext();

  134.   c.didLaunch = true;

  135.   c.recentField = "didLaunch";

  136.   c = cli_greetUser(c);

  137.   if (

  138.     c.recentField == "outputGreeting"

  139.   ) {

  140.     return "OK: cli_greetUser";

  141.   }

  142.   return "ERR: cli_greetUser";

  143. }

  144. 

  145. std::string cli_test_promptSecondItemSelection(

  146. ) {

  147.   auto c = memory_createContext();

  148.   c.input = "1";

  149.   c.recentField = "input";

  150.   c = cli_selectItem(c);

  151.   c = memory_selectItem(c);

  152.   c = cli_promptSecondItemSelection(c);

  153.   if (

  154.     c.recentField == "outputPromptSelection"

  155.   ) {

  156.     return "OK: cli_promptSecondItemSelection";

  157.   }

  158.   return "ERR: cli_promptSecondItemSelection";

  159. }

  160. 

  161. std::string cli_test_reportMatchedItems(

  162. ) {

  163.   auto c = memory_createContext();

  164.   c.playfieldSize = 2;

  165.   c.recentField = "playfieldSize";

  166.   c = memory_generateConstPlayfield(c);

  167.   c.input = "1";

  168.   c.recentField = "input";

  169.   c = cli_selectItem(c);

  170.   c = memory_selectItem(c);

  171.   c.input = "2";

  172.   c.recentField = "input";

  173.   c = cli_selectItem(c);

  174.   c = memory_selectItem(c);

  175.   c = memory_hideMatchingItems(c);

  176.   c = cli_reportMatchedItems(c);

  177.   if (

  178.     c.recentField == "outputMatchedItems"

  179.   ) {

  180.     return "OK: cli_reportMatchedItems";

  181.   }

  182.   return "ERR: cli_reportMatchedItems";

  183. }

  184. 

  185. std::string cli_test_reportMismatchedItems(

  186. ) {

  187.   auto c = memory_createContext();

  188.   c.playfieldSize = 2;

  189.   c.recentField = "playfieldSize";

  190.   c = memory_generateConstPlayfield(c);

  191.   c.input = "1";

  192.   c.recentField = "input";

  193.   c = cli_selectItem(c);

  194.   c = memory_selectItem(c);

  195.   c.input = "3";

  196.   c.recentField = "input";

  197.   c = cli_selectItem(c);

  198.   c = memory_selectItem(c);

  199.   c = memory_detectMismatchedItems(c);

  200.   c = cli_reportMismatchedItems(c);

  201.   if (

  202.     c.recentField == "outputMismatchedItems"

  203.   ) {

  204.     return "OK: cli_reportMismatchedItems";

  205.   }

  206.   return "ERR: cli_reportMismatchedItems";

  207. }

  208. 

  209. std::string cli_test_selectItem(

  210. ) {

  211.   auto c = memory_createContext();

  212.   c.input = "1";

  213.   c.recentField = "input";

  214.   c = cli_selectItem(c);

  215.   if (

  216.     c.recentField == "selectedId" &&

  217.     c.selectedId == 0

  218.   ) {

  219.     return "OK: cli_selectItem";

  220.   }

  221.   return "ERR: cli_selectItem";

  222. }

  223. 

  224. std::string cli_test_showHelp_h(

  225. ) {

  226.   auto c = memory_createContext();

  227.   c.input = "h";

  228.   c.recentField = "input";

  229.   c = cli_showHelp(c);

  230.   if (

  231.     c.recentField == "outputHelp"

  232.   ) {

  233.     return "OK: cli_showHelp_h";

  234.   }

  235.   return "ERR: cli_showHelp_h";

  236. }

  237. 

  238. std::string cli_test_showHelp_help(

  239. ) {

  240.   auto c = memory_createContext();

  241.   c.input = "help";

  242.   c.recentField = "input";

  243.   c = cli_showHelp(c);

  244.   if (

  245.     c.recentField == "outputHelp"

  246.   ) {

  247.     return "OK: cli_showHelp_help";

  248.   }

  249.   return "ERR: cli_showHelp_help";

  250. }

  251. 

  252. 

  253. 

  254. 

  255. std::string cli_test_reportVictory(

  256. ) {

  257.   auto c = memory_createContext();

  258.   c.playfieldSize = 2;

  259.   c.recentField = "playfieldSize";

  260.   c = memory_generateConstPlayfield(c);

  261.   // Match the first pair of tiles.

  262.   c.input = "1";

  263.   c.recentField = "input";

  264.   c = cli_selectItem(c);

  265.   c = memory_selectItem(c);

  266.   c.input = "2";

  267.   c.recentField = "input";

  268.   c = cli_selectItem(c);

  269.   c = memory_selectItem(c);

  270.   c = memory_hideMatchingItems(c);

  271.   // Match the second pair of tiles.

  272.   c.input = "3";

  273.   c.recentField = "input";

  274.   c = cli_selectItem(c);

  275.   c = memory_selectItem(c);

  276.   c.input = "4";

  277.   c.recentField = "input";

  278.   c = cli_selectItem(c);

  279.   c = memory_selectItem(c);

  280.   c = memory_hideMatchingItems(c);

  281.   c = memory_detectVictory(c);

  282.   c = cli_reportVictory(c);

  283.   if (

  284.     c.recentField == "outputVictory"

  285.   ) {

  286.     return "OK: cli_reportVictory";

  287.   }

  288.   return "ERR: cli_reportVictory";

  289. }

  290. 

  291. //def cli_test_shouldReportIvalidItemSelection_outOfBoundsMin(

  292. //) -> str:

  293. //  c = cli_createContext()

  294. //  c.cMemory = memory_createContext()

  295. //  c.input = "0"

  296. //  c = cli_selectItem(c)

  297. //  c = cli_shouldReportInvalidItemSelection(c)

  298. //  if (

  299. //    c.recentField == "outputInvalidItemSelection"

  300. //  ):

  301. //    return "OK: cli_shouldReportInvalidItemSelection"

  302. //  //}

  303. //  return "ERR: cli_shouldReportInvalidItemSelection"

  304. ////}

  305. //