kornerr
/
research-portable-memory
1
0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Research portable Memory game | Исследовать портируемую игру Память
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
90 Commits
1 Branch
21MB
Tag: ed7d1cd486
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de ed7d1cd486
${ noResults }
research-portable-memory/v4/cli_test.cpp

308 linhas
6.4KB
Original Anotar Histórico 

  1. #include <map>

  2. #include <string>

  3. #include <vector>

  4. #include "llm.h"

  5. #include "memory_Context.h"

  6. #include "main.h"

  7. 

  8. std::string cli_test_exit_e(

  9. ) {

  10.   auto c = memory_createContext();

  11.   c.input = "e";

  12.   c.recentField = "input";

  13.   c = cli_exit(c);

  14.   if (

  15.     c.recentField == "exit"

  16.   ) {

  17.     return "OK: cli_exit_e";

  18.   }

  19.   return "ERR: cli_exit_e";

  20. }

  21. 

  22. std::string cli_test_exit_exit(

  23. ) {

  24.   auto c = memory_createContext();

  25.   c.input = "exit";

  26.   c.recentField = "input";

  27.   c = cli_exit(c);

  28.   if (

  29.     c.recentField == "exit"

  30.   ) {

  31.     return "OK: cli_exit_exit";

  32.   }

  33.   return "ERR: cli_exit_e";

  34. }

  35. 

  36. 

  37. 

  38. 

  39. std::string cli_test_exit_victory(

  40. ) {

  41.   auto c = memory_createContext();

  42.   c.playfieldSize = 2;

  43.   c.recentField = "playfieldSize";

  44.   c = memory_generateConstPlayfield(c);

  45.   // Match the first pair of tiles.

  46.   c.input = "1";

  47.   c.recentField = "input";

  48.   c = cli_selectItem(c);

  49.   c = memory_selectItem(c);

  50.   c.input = "2";

  51.   c.recentField = "input";

  52.   c = cli_selectItem(c);

  53.   c = memory_selectItem(c);

  54.   c = memory_hideMatchingItems(c);

  55.   // Match the second pair of tiles.

  56.   c.input = "3";

  57.   c.recentField = "input";

  58.   c = cli_selectItem(c);

  59.   c = memory_selectItem(c);

  60.   c.input = "4";

  61.   c.recentField = "input";

  62.   c = cli_selectItem(c);

  63.   c = memory_selectItem(c);

  64.   c = memory_hideMatchingItems(c);

  65.   c = memory_detectVictory(c);

  66.   c = cli_reportVictory(c);

  67.   c = cli_exit(c);

  68.   if (

  69.     c.recentField == "exit"

  70.   ) {

  71.     return "OK: cli_exit_victory";

  72.   }

  73.   return "ERR: cli_exit_victory";

  74. }

  75. 

  76. std::string cli_test_exit_q(

  77. ) {

  78.   auto c = memory_createContext();

  79.   c.input = "q";

  80.   c.recentField = "input";

  81.   c = cli_exit(c);

  82.   if (

  83.     c.recentField == "exit"

  84.   ) {

  85.     return "OK: cli_exit_q";

  86.   }

  87.   return "ERR: cli_exit_q";

  88. }

  89. 

  90. std::string cli_test_exit_quit(

  91. ) {

  92.   auto c = memory_createContext();

  93.   c.input = "quit";

  94.   c.recentField = "input";

  95.   c = cli_exit(c);

  96.   if (

  97.     c.recentField == "exit"

  98.   ) {

  99.     return "OK: cli_exit_quit";

  100.   }

  101.   return "ERR: cli_exit_quit";

  102. }

  103. 

  104. 

  105. 

  106. std::string cli_test_goOn(

  107. ) {

  108.   auto c = memory_createContext();

  109.   c.playfieldSize = 2;

  110.   c.recentField = "playfieldSize";

  111.   c = memory_generateConstPlayfield(c);

  112.   // Match the first pair of items.

  113.   c.input = "1";

  114.   c.recentField = "input";

  115.   c = cli_selectItem(c);

  116.   c = memory_selectItem(c);

  117.   c.input = "2";

  118.   c.recentField = "input";

  119.   c = cli_selectItem(c);

  120.   c = memory_selectItem(c);

  121.   c = memory_hideMatchingItems(c);

  122.   c = cli_reportMatchedItems(c);

  123.   c = cli_goOn(c);

  124.   if (

  125.     c.recentField == "outputGoOn"

  126.   ) {

  127.     return "OK: cli_goOn";

  128.   }

  129.   return "ERR: cli_goOn";

  130. }

  131. 

  132. std::string cli_test_greetUser(

  133. ) {

  134.   auto c = memory_createContext();

  135.   c.didLaunch = true;

  136.   c.recentField = "didLaunch";

  137.   c = cli_greetUser(c);

  138.   if (

  139.     c.recentField == "outputGreeting"

  140.   ) {

  141.     return "OK: cli_greetUser";

  142.   }

  143.   return "ERR: cli_greetUser";

  144. }

  145. 

  146. std::string cli_test_promptSecondItemSelection(

  147. ) {

  148.   auto c = memory_createContext();

  149.   c.input = "1";

  150.   c.recentField = "input";

  151.   c = cli_selectItem(c);

  152.   c = memory_selectItem(c);

  153.   c = cli_promptSecondItemSelection(c);

  154.   if (

  155.     c.recentField == "outputPromptSelection"

  156.   ) {

  157.     return "OK: cli_promptSecondItemSelection";

  158.   }

  159.   return "ERR: cli_promptSecondItemSelection";

  160. }

  161. 

  162. std::string cli_test_reportMatchedItems(

  163. ) {

  164.   auto c = memory_createContext();

  165.   c.playfieldSize = 2;

  166.   c.recentField = "playfieldSize";

  167.   c = memory_generateConstPlayfield(c);

  168.   c.input = "1";

  169.   c.recentField = "input";

  170.   c = cli_selectItem(c);

  171.   c = memory_selectItem(c);

  172.   c.input = "2";

  173.   c.recentField = "input";

  174.   c = cli_selectItem(c);

  175.   c = memory_selectItem(c);

  176.   c = memory_hideMatchingItems(c);

  177.   c = cli_reportMatchedItems(c);

  178.   if (

  179.     c.recentField == "outputMatchedItems"

  180.   ) {

  181.     return "OK: cli_reportMatchedItems";

  182.   }

  183.   return "ERR: cli_reportMatchedItems";

  184. }

  185. 

  186. std::string cli_test_reportMismatchedItems(

  187. ) {

  188.   auto c = memory_createContext();

  189.   c.playfieldSize = 2;

  190.   c.recentField = "playfieldSize";

  191.   c = memory_generateConstPlayfield(c);

  192.   c.input = "1";

  193.   c.recentField = "input";

  194.   c = cli_selectItem(c);

  195.   c = memory_selectItem(c);

  196.   c.input = "3";

  197.   c.recentField = "input";

  198.   c = cli_selectItem(c);

  199.   c = memory_selectItem(c);

  200.   c = memory_detectMismatchedItems(c);

  201.   c = cli_reportMismatchedItems(c);

  202.   if (

  203.     c.recentField == "outputMismatchedItems"

  204.   ) {

  205.     return "OK: cli_reportMismatchedItems";

  206.   }

  207.   return "ERR: cli_reportMismatchedItems";

  208. }

  209. 

  210. std::string cli_test_selectItem(

  211. ) {

  212.   auto c = memory_createContext();

  213.   c.input = "1";

  214.   c.recentField = "input";

  215.   c = cli_selectItem(c);

  216.   if (

  217.     c.recentField == "selectedId" &&

  218.     c.selectedId == 0

  219.   ) {

  220.     return "OK: cli_selectItem";

  221.   }

  222.   return "ERR: cli_selectItem";

  223. }

  224. 

  225. std::string cli_test_showHelp_h(

  226. ) {

  227.   auto c = memory_createContext();

  228.   c.input = "h";

  229.   c.recentField = "input";

  230.   c = cli_showHelp(c);

  231.   if (

  232.     c.recentField == "outputHelp"

  233.   ) {

  234.     return "OK: cli_showHelp_h";

  235.   }

  236.   return "ERR: cli_showHelp_h";

  237. }

  238. 

  239. std::string cli_test_showHelp_help(

  240. ) {

  241.   auto c = memory_createContext();

  242.   c.input = "help";

  243.   c.recentField = "input";

  244.   c = cli_showHelp(c);

  245.   if (

  246.     c.recentField == "outputHelp"

  247.   ) {

  248.     return "OK: cli_showHelp_help";

  249.   }

  250.   return "ERR: cli_showHelp_help";

  251. }

  252. 

  253. 

  254. 

  255. 

  256. std::string cli_test_reportVictory(

  257. ) {

  258.   auto c = memory_createContext();

  259.   c.playfieldSize = 2;

  260.   c.recentField = "playfieldSize";

  261.   c = memory_generateConstPlayfield(c);

  262.   // Match the first pair of tiles.

  263.   c.input = "1";

  264.   c.recentField = "input";

  265.   c = cli_selectItem(c);

  266.   c = memory_selectItem(c);

  267.   c.input = "2";

  268.   c.recentField = "input";

  269.   c = cli_selectItem(c);

  270.   c = memory_selectItem(c);

  271.   c = memory_hideMatchingItems(c);

  272.   // Match the second pair of tiles.

  273.   c.input = "3";

  274.   c.recentField = "input";

  275.   c = cli_selectItem(c);

  276.   c = memory_selectItem(c);

  277.   c.input = "4";

  278.   c.recentField = "input";

  279.   c = cli_selectItem(c);

  280.   c = memory_selectItem(c);

  281.   c = memory_hideMatchingItems(c);

  282.   c = memory_detectVictory(c);

  283.   c = cli_reportVictory(c);

  284.   if (

  285.     c.recentField == "outputVictory"

  286.   ) {

  287.     return "OK: cli_reportVictory";

  288.   }

  289.   return "ERR: cli_reportVictory";

  290. }

  291. 

  292. //def cli_test_shouldReportIvalidItemSelection_outOfBoundsMin(

  293. //) -> str:

  294. //  c = cli_createContext()

  295. //  c.cMemory = memory_createContext()

  296. //  c.input = "0"

  297. //  c = cli_selectItem(c)

  298. //  c = cli_shouldReportInvalidItemSelection(c)

  299. //  if (

  300. //    c.recentField == "outputInvalidItemSelection"

  301. //  ):

  302. //    return "OK: cli_shouldReportInvalidItemSelection"

  303. //  //}

  304. //  return "ERR: cli_shouldReportInvalidItemSelection"

  305. ////}

  306. //