linyongji
/
TrainCamp_linyongji_Algorithm1
1
0
フォーク 0
コード 課題 0 プルリクエスト 0 リリース 0 Wiki アクティビティ
林永吉的Algorithm库
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。
58 コミット
1 ブランチ
361 KiB
 
 
ブランチ: master
ブランチ タグ
${ item.name }
ブランチ ${ searchTerm } を作成
'master' から
${ noResults }
TrainCamp_linyongji_Algorithm1/Alogrithm/UnitTest/UnitTest.cpp

512 行
19 KiB
Raw パーマリンク Blame 履歴 

  1. #include "pch.h"

  2. #include "CppUnitTest.h"

  3. using namespace Microsoft::VisualStudio::CppUnitTestFramework;

  4. 

  5. #define FileName_1  "../Alogrithm/config/1_ContainsNearbyDuplicate.ini"

  6. #define FileName_2  "../Alogrithm/config/2_ExcelSheetColumnTiTle.ini"

  7. #define FileName_3  "../Alogrithm/config/3_bool IsUgly.ini"

  8. #define FileName_4  "../Alogrithm/config/4_IsPalindrome.ini"

  9. #define FileName_5  "../Alogrithm/config/5_MinDepth.ini"

  10. #define FileName_6  "../Alogrithm/config/6_ContainsDuplicate.ini"

  11. #define FileName_7  "../Alogrithm/config/7_MaxDepth.ini"

  12. #define FileName_8  "../Alogrithm/config/8_HammingWeight.ini"

  13. #define FileName_9  "../Alogrithm/config/9_AddBinary.ini"

  14. #define FileName_10 "../Alogrithm/config/10_BinaryTreePaths.ini"

  15. #define FileName_11 "../Alogrithm/config/11_CanWinNim.ini"

  16. #define FileName_12 "../Alogrithm/config/12_IsValid.ini"

  17. #define FileName_13 "../Alogrithm/config/13_MyAtoi.ini"

  18. #define FileName_14 "../Alogrithm/config/14_SingleNumber.ini"

  19. #define FileName_15 "../Alogrithm/config/15_WordPattern.ini"

  20. #define FileName_16 "../Alogrithm/config/16_ReverseBits.ini"

  21. #define FileName_17 "../Alogrithm/config/17_WordBreak.ini"

  22. #define FileName_18 "../Alogrithm/config/18_PlusOne.ini"

  23. #define FileName_19 "../Alogrithm/config/19_MySqrt.ini"

  24. #define FileName_20 "../Alogrithm/config/20_MoveZeroes.ini"

  25. #define FileName_21 "../Alogrithm/config/21_Reverse.ini"

  26. #define FileName_22 "../Alogrithm/config/22_Rotate.ini"

  27. #define FileName_23 "../Alogrithm/config/23_RestoreIpAddresses.ini"

  28. #define FileName_24 "../Alogrithm/config/24_LengthOfLongestSubstring.ini"

  29. #define FileName_25 "../Alogrithm/config/25_Partition.ini"

  30. 

  31. 

  32. 

  33. namespace UnitTest

  34. {

  35. 	TEST_CLASS(UnitTest_1)

  36. 	{

  37. 		TEST_METHOD(TestMethode1)

  38. 		{

  39. 			char Section_Name[100][10] = { 0 };

  40. 			int  Section_Count = CalcCount(100, Section_Name, FileName_1);

  41. 			int array_count = 0;

  42. 			int* Section_Value;

  43. 			CString Na, Nb, nExpect;

  44. 			for (int i = 0; i < Section_Count; i++) {

  45. 				GetPrivateProfileString(Section_Name[i], "array", " ", Na.GetBuffer(200), 200, FileName_1);

  46. 				GetPrivateProfileString(Section_Name[i], "key", " ", Nb.GetBuffer(20), 20, FileName_1);

  47. 				GetPrivateProfileString(Section_Name[i], "output", " ", nExpect.GetBuffer(20), 20, FileName_1);

  48. 				Section_Value = str_device(Na, &array_count);

  49. 				bool nReal = ContainsNearbyDuplicate(Section_Value, array_count, _ttoi(Nb));

  50. 				Assert::AreEqual(nReal, CstrToBool(nExpect));

  51. 			}

  52. 		}

  53. 	};

  54. 	TEST_CLASS(UnitTest_2)

  55. 		{

  56. 			TEST_METHOD(TestMethode1)

  57. 			{

  58. 				char Section_Name[100][10] = { 0 };

  59. 				int  Section_Count = CalcCount(100, Section_Name, FileName_2);

  60. 				CString Na, nExpect;

  61. 				for (int i = 0; i < Section_Count; i++) {

  62. 					GetPrivateProfileString(Section_Name[i], "Na", " ", Na.GetBuffer(20), 20, FileName_2);

  63. 					GetPrivateProfileString(Section_Name[i], "nExpect", " ", nExpect.GetBuffer(100), 100, FileName_2);

  64. 					char* nReal = ExcelSheetColumnTitle(_ttoi(Na));

  65. 					Assert::AreEqual(nReal, nExpect);

  66. 				}

  67. 			}

  68. 	};

  69. 	TEST_CLASS(UnitTest_3)

  70. 		{

  71. 			TEST_METHOD(TestMethode3)

  72. 			{

  73. 				char Section_Name[100][10] = { 0 };

  74. 				int  Section_Count = CalcCount(100, Section_Name, FileName_3);

  75. 				CString Na, nExpect;

  76. 				for (int i = 0; i < Section_Count; i++) {

  77. 					GetPrivateProfileString(Section_Name[i], "Na", " ", Na.GetBuffer(20), 20, FileName_3);

  78. 					GetPrivateProfileString(Section_Name[i], "nExpect", " ", nExpect.GetBuffer(20), 20, FileName_3);

  79. 					bool nReal = IsUgly(_ttoi(Na));

  80. 					Assert::AreEqual(nReal, CstrToBool(nExpect));

  81. 				}

  82. 			}

  83. 	};

  84. 	TEST_CLASS(UnitTest_4)

  85. 	{

  86. 		TEST_METHOD(TestMethode1)

  87. 		{

  88. 			char Section_Name[100][10] = { 0 };

  89. 			int  Section_Count = CalcCount(100, Section_Name, FileName_4);

  90. 			CString Na, nExpect;

  91. 			for (int i = 0; i < Section_Count; i++) {

  92. 				GetPrivateProfileString(Section_Name[i], "Na", " ", Na.GetBuffer(20), 20, FileName_4);

  93. 				GetPrivateProfileString(Section_Name[i], "nExpect", " ", nExpect.GetBuffer(20), 20, FileName_4);

  94. 				bool nReal = IsPalindrome(_ttoi(Na));

  95. 				Assert::AreEqual(nReal, CstrToBool(nExpect));

  96. 			}

  97. 		}

  98. 	};

  99. 	TEST_CLASS(UnitTest_5)

  100. 	{

  101. 		TEST_METHOD(TestMethode1)

  102. 		{

  103. 			char Section_Name[100][10] = { 0 };

  104. 			int  Section_Count = CalcCount(100, Section_Name, FileName_5);

  105. 			CString Na, nExpect;

  106. 			for (int i = 0; i < Section_Count; i++) {

  107. 				GetPrivateProfileString(Section_Name[i], "input", " ", Na.GetBuffer(200), 200, FileName_5);

  108. 				GetPrivateProfileString(Section_Name[i], "output", " ", nExpect.GetBuffer(20), 20, FileName_5);

  109. 				char return_str[100][50] = { 0 };

  110. 				int return_count = str_device2(Na, return_str);

  111. 				TreeNode* root = CreatBitTree(return_str, return_count);

  112. 				int nReal = MinDepth(root);

  113. 				Assert::AreEqual(nReal,_ttoi(nExpect));

  114. 				free_tree(root);

  115. 			}

  116. 		}

  117. 	};

  118. 	TEST_CLASS(UnitTest_6)

  119. 	{

  120. 		TEST_METHOD(TestMethode1)

  121. 		{

  122. 			char Section_Name[100][10] = { 0 };

  123. 			int  Section_Count = CalcCount(100, Section_Name, FileName_6);

  124. 			int array_count = 0;

  125. 			int* Section_Value;

  126. 			CString Na, Nb, nExpect;

  127. 			for (int i = 0; i < Section_Count; i++) {

  128. 				GetPrivateProfileString(Section_Name[i], "input", " ", Na.GetBuffer(200), 200, FileName_6);

  129. 				GetPrivateProfileString(Section_Name[i], "output", " ", nExpect.GetBuffer(20), 20, FileName_6);

  130. 				Section_Value = str_device(Na, &array_count);

  131. 				bool nReal = containsDuplicate(Section_Value, array_count);

  132. 				Assert::AreEqual(nReal, CstrToBool(nExpect));

  133. 			}

  134. 		}

  135. 	};

  136. 	TEST_CLASS(UnitTest_7)

  137. 	{

  138. 		TEST_METHOD(TestMethode1)

  139. 		{

  140. 			char Section_Name[100][10] = { 0 };

  141. 			int  Section_Count = CalcCount(100, Section_Name, FileName_7);

  142. 			CString Na, nExpect;

  143. 			for (int i = 0; i < Section_Count; i++) {

  144. 				GetPrivateProfileString(Section_Name[i], "input", " ", Na.GetBuffer(200), 200, FileName_7);

  145. 				GetPrivateProfileString(Section_Name[i], "output", " ", nExpect.GetBuffer(20), 20, FileName_7);

  146. 				char return_str[100][50] = { 0 };

  147. 				int return_count = str_device2(Na, return_str);

  148. 				TreeNode2* root = CreatBitTree2(return_str, return_count);

  149. 				int nReal = MaxDepth(root);

  150. 				Assert::AreEqual(nReal, _ttoi(nExpect));

  151. 				free_tree2(root);

  152. 			}

  153. 		}

  154. 	};

  155. 	TEST_CLASS(UnitTest_8)

  156. 	{

  157. 		TEST_METHOD(TestMethode1)

  158. 		{

  159. 			char Section_Name[100][10] = { 0 };

  160. 			int  Section_Count = CalcCount(100, Section_Name, FileName_8);

  161. 			CString Na, nExpect;

  162. 			for (int i = 0; i < Section_Count; i++) {

  163. 				GetPrivateProfileString(Section_Name[i], "input", " ", Na.GetBuffer(20), 20, FileName_8);

  164. 				GetPrivateProfileString(Section_Name[i], "output", " ", nExpect.GetBuffer(100), 100, FileName_8);

  165. 				int nReal = HammingWeight(_ttoi(Na));

  166. 				Assert::AreEqual(nReal, _ttoi(nExpect));

  167. 			}

  168. 		}

  169. 	};

  170. 	TEST_CLASS(UnitTest_9)

  171. 	{

  172. 		TEST_METHOD(TestMethode1)

  173. 		{

  174. 			char Section_Name[100][10] = { 0 };

  175. 			int  Section_Count = CalcCount(100, Section_Name, FileName_9);

  176. 			CString input1,input2, output;	

  177. 			for (int i = 0; i < Section_Count; i++) {

  178. 				GetPrivateProfileString(Section_Name[i], "input1", " ", input1.GetBuffer(100), 100, FileName_9);

  179. 				GetPrivateProfileString(Section_Name[i], "input2", " ", input2.GetBuffer(100), 100, FileName_9);

  180. 				GetPrivateProfileString(Section_Name[i], "output", " ", output.GetBuffer(200), 200, FileName_9);

  181. 				char p1[100];

  182. 				char p2[100];

  183. 				strcpy(p1, input1);

  184. 				strcpy(p2, input2);

  185. 				char* nReal = AddBinary(p1,p2);

  186. 				Assert::AreEqual(nReal, output);

  187. 			}

  188. 		}

  189. 	};

  190. 	TEST_CLASS(UnitTest_10)

  191. 	{

  192. 		TEST_METHOD(TestMethode1)

  193. 		{

  194. 			char Section_Name[100][10] = { 0 };

  195. 			int  Section_Count = CalcCount(100, Section_Name, FileName_10);

  196. 			CString Na, nExpect;

  197. 			for (int i = 0; i < Section_Count; i++) {

  198. 				GetPrivateProfileString(Section_Name[i], "input", " ", Na.GetBuffer(200), 200, FileName_10);

  199. 				GetPrivateProfileString(Section_Name[i], "output", " ", nExpect.GetBuffer(500), 500, FileName_10);

  200. 				char return_str[100][50] = { 0 };

  201. 				int return_count = str_device2(Na, return_str);

  202. 				TreeNode3* root = CreatBitTree3(return_str, return_count);

  203. 				int returnSize = 0;

  204. 				char** returnStr=NULL;

  205. 				returnStr = binaryTreePaths(root, &returnSize);

  206. 				char nReal[500] = { 0 };

  207. 				for (int i = 0; i < returnSize; i++)

  208. 				{

  209. 					strcat(nReal, returnStr[i]);

  210. 					if (i != (returnSize - 1))

  211. 					{

  212. 						nReal[strlen(nReal)] = ',';

  213. 					}

  214. 				}

  215. 

  216. 				Assert::AreEqual(nReal,nExpect);

  217. 				free_tree3(root);

  218. 			}

  219. 		}

  220. 	};

  221. 	TEST_CLASS(UnitTest_11)

  222. 	{

  223. 		TEST_METHOD(TestMethode1)

  224. 		{

  225. 			char Section_Name[100][10] = { 0 };

  226. 			int  Section_Count = CalcCount(100, Section_Name, FileName_11);

  227. 			CString input,output;

  228. 			for (int i = 0; i < Section_Count; i++) {

  229. 				GetPrivateProfileString(Section_Name[i], "input", " ", input.GetBuffer(20), 20, FileName_11);

  230. 				GetPrivateProfileString(Section_Name[i], "output", " ", output.GetBuffer(20), 20, FileName_11);

  231. 				bool nReal = CanWinNim(_ttoi(input));

  232. 				Assert::AreEqual(nReal, CstrToBool(output));

  233. 			}

  234. 		}

  235. 	};

  236. 	TEST_CLASS(UnitTest_12)

  237. 	{

  238. 		TEST_METHOD(TestMethode1)

  239. 		{

  240. 			char Section_Name[100][10] = { 0 };

  241. 			int  Section_Count = CalcCount(100, Section_Name, FileName_12);

  242. 			char input_char[1024] = { 0 };

  243. 			CString input,output;

  244. 			for (int i = 0; i < Section_Count; i++) {

  245. 				GetPrivateProfileString(Section_Name[i], "input", " ", input.GetBuffer(200), 200, FileName_12);

  246. 				GetPrivateProfileString(Section_Name[i], "output", " ", output.GetBuffer(20), 20, FileName_12);

  247. 				strcpy(input_char, input);

  248. 				bool nReal = IsValid(input_char);

  249. 				Assert::AreEqual(nReal, CstrToBool(output));

  250. 			}

  251. 		}

  252. 	};

  253. 	TEST_CLASS(UnitTest_13)

  254. 	{

  255. 		TEST_METHOD(TestMethode1)

  256. 		{

  257. 			char Section_Name[100][10] = { 0 };

  258. 			int  Section_Count = CalcCount(100, Section_Name, FileName_13);

  259. 			char input_char[1024] = { 0 };

  260. 			CString input, output;

  261. 			for (int i = 0; i < Section_Count; i++) {

  262. 				GetPrivateProfileString(Section_Name[i], "input", " ", input.GetBuffer(200), 200, FileName_13);

  263. 				GetPrivateProfileString(Section_Name[i], "output", " ", output.GetBuffer(20), 20, FileName_13);

  264. 				strcpy(input_char, input);

  265. 				int nReal = MyAtoi(input_char);

  266. 				Assert::AreEqual(nReal, _ttoi(output));

  267. 			}

  268. 		}

  269. 	};

  270. 	TEST_CLASS(UnitTest_14)

  271. 	{

  272. 		TEST_METHOD(TestMethode1)

  273. 		{

  274. 			char Section_Name[100][10] = { 0 };

  275. 			int  Section_Count = CalcCount(100, Section_Name, FileName_14);

  276. 			int array_count = 0;

  277. 			int* Section_Value;

  278. 			CString input,output;

  279. 			for (int i = 0; i < Section_Count; i++) {

  280. 				GetPrivateProfileString(Section_Name[i], "input", " ", input.GetBuffer(200), 200, FileName_14);

  281. 				GetPrivateProfileString(Section_Name[i], "output", " ", output.GetBuffer(20), 20, FileName_14);

  282. 				Section_Value = str_device(input, &array_count);

  283. 				int nReal = SingleNumber(Section_Value, array_count);

  284. 				Assert::AreEqual(nReal, _ttoi(output));

  285. 			}

  286. 		}

  287. 	};

  288. 	TEST_CLASS(UnitTest_15)

  289. 	{

  290. 		TEST_METHOD(TestMethode1)

  291. 		{

  292. 			char Section_Name[100][10] = { 0 };

  293. 			int  Section_Count = CalcCount(100, Section_Name, FileName_15);

  294. 			char Pattern_char[1024] = { 0 };

  295. 			char Str_char[1024] = { 0 };

  296. 			CString Pattern, Str, Output;

  297. 			for (int i = 0; i < Section_Count; i++) {

  298. 				GetPrivateProfileString(Section_Name[i], "Pattern", " ", Pattern.GetBuffer(200), 200, FileName_15);

  299. 				GetPrivateProfileString(Section_Name[i], "Str", " ", Str.GetBuffer(400), 400, FileName_15);

  300. 				GetPrivateProfileString(Section_Name[i], "Output", " ", Output.GetBuffer(20), 20, FileName_15);

  301. 				strcpy(Pattern_char, Pattern);

  302. 				strcpy(Str_char, Str);

  303. 				bool nReal = WordPattern(Pattern_char, Str_char);

  304. 				Assert::AreEqual(nReal, CstrToBool(Output));

  305. 			}

  306. 		}

  307. 	};

  308. 	TEST_CLASS(UnitTest_16)

  309. 	{

  310. 		TEST_METHOD(TestMethode1)

  311. 		{

  312. 			char Section_Name[100][10] = { 0 };

  313. 			int  Section_Count = CalcCount(100, Section_Name, FileName_16);

  314. 			CString input,output;

  315. 			for (int i = 0; i < Section_Count; i++) {

  316. 				GetPrivateProfileString(Section_Name[i], "Input", " ", input.GetBuffer(200), 200, FileName_16);

  317. 				GetPrivateProfileString(Section_Name[i], "Output", " ", output.GetBuffer(200), 200, FileName_16);

  318. 				uint32_t nReal = ReverseBits((uint32_t)_atoi64(input));

  319. 				Assert::AreEqual(nReal, (uint32_t)_atoi64(output));

  320. 			}

  321. 		}

  322. 	};

  323. 

  324. 	TEST_CLASS(UnitTest_17)

  325. 	{

  326. 		TEST_METHOD(TestMethode1)

  327. 		{

  328. 			char Section_Name[100][10] = { 0 };

  329. 			int  Section_Count = CalcCount(100, Section_Name, FileName_17);

  330. 			CString Input1, Input2, Output;

  331. 			char Str_char[1024] = { 0 };

  332. 			char* WordDic[100];

  333. 			for (int i = 0; i < Section_Count; i++) {

  334. 				GetPrivateProfileString(Section_Name[i], "Input1", " ", Input1.GetBuffer(200), 200, FileName_17);

  335. 				GetPrivateProfileString(Section_Name[i], "Input2", " ", Input2.GetBuffer(500), 500, FileName_17);

  336. 				GetPrivateProfileString(Section_Name[i], "Output", " ", Output.GetBuffer(20), 20, FileName_17);

  337. 				strcpy(Str_char, Input1);

  338. 				int Wordic_count = str_device3(Input2, WordDic);

  339. 				bool nReal = WordBreak(Str_char, WordDic, Wordic_count);

  340. 				Assert::AreEqual(nReal, CstrToBool(Output));

  341. 			}

  342. 		}

  343. 	};

  344. 	TEST_CLASS(UnitTest_18)

  345. 	{

  346. 		TEST_METHOD(TestMethode1)

  347. 		{

  348. 			char Section_Name[100][10] = { 0 };

  349. 			int  Section_Count = CalcCount(100, Section_Name, FileName_18);

  350. 			int input_count = 0, output_count = 0, returnSize = 0;

  351. 			int* input_value;

  352. 			int* output_value;

  353. 			CString input,output;

  354. 			for (int i = 0; i < Section_Count; i++) {

  355. 				GetPrivateProfileString(Section_Name[i], "Input", " ", input.GetBuffer(200), 200, FileName_18);

  356. 				GetPrivateProfileString(Section_Name[i], "Output", " ", output.GetBuffer(200), 200, FileName_18);

  357. 				input_value = str_device(input, &input_count);

  358. 				output_value = str_device(output, &output_count);

  359. 				int* nReal = PlusOne(input_value, input_count, &returnSize);

  360. 				for (int i = 0; i < input_count; i++) {

  361. 					Assert::AreEqual(nReal[i], output_value[i]);

  362. 				}

  363. 			}

  364. 		}

  365. 	};

  366. 	TEST_CLASS(UnitTest_19)

  367. 	{

  368. 		TEST_METHOD(TestMethode1)

  369. 		{

  370. 			char Section_Name[100][10] = { 0 };

  371. 			int  Section_Count = CalcCount(100, Section_Name, FileName_19);

  372. 			CString input,output;

  373. 			for (int i = 0; i < Section_Count; i++) {

  374. 				GetPrivateProfileString(Section_Name[i], "Input", " ", input.GetBuffer(100), 100, FileName_19);

  375. 				GetPrivateProfileString(Section_Name[i], "Output", " ", output.GetBuffer(100), 100, FileName_19);

  376. 				int nReal = MySqrt(_ttoi(input));

  377. 				Assert::AreEqual(nReal, _ttoi(output));

  378. 			}

  379. 		}

  380. 	};

  381. 	TEST_CLASS(UnitTest_20)

  382. 	{

  383. 		TEST_METHOD(TestMethode1)

  384. 		{

  385. 			char Section_Name[100][10] = { 0 };

  386. 			int  Section_Count = CalcCount(100, Section_Name, FileName_20);

  387. 			int input_count = 0, output_count = 0, returnSize = 0;

  388. 			int* input_value;

  389. 			int* output_value;

  390. 			CString input, output;

  391. 			for (int i = 0; i < Section_Count; i++) {

  392. 				GetPrivateProfileString(Section_Name[i], "Input", " ", input.GetBuffer(200), 200, FileName_20);

  393. 				GetPrivateProfileString(Section_Name[i], "Output", " ", output.GetBuffer(200), 200, FileName_20);

  394. 				input_value = str_device(input, &input_count);

  395. 				output_value = str_device(output, &output_count);

  396. 				MoveZeroes(input_value, input_count);

  397. 				for (int i = 0; i < input_count; i++) {

  398. 					Assert::AreEqual(input_value[i], output_value[i]);

  399. 				}

  400. 			}

  401. 		}

  402. 	};

  403. 	TEST_CLASS(UnitTest_21)

  404. 	{

  405. 		TEST_METHOD(TestMethode1)

  406. 		{

  407. 			char Section_Name[100][10] = { 0 };

  408. 			int  Section_Count = CalcCount(100, Section_Name, FileName_21);

  409. 			CString input, output;

  410. 			for (int i = 0; i < Section_Count; i++) {

  411. 				GetPrivateProfileString(Section_Name[i], "Input", " ", input.GetBuffer(100), 100, FileName_21);

  412. 				GetPrivateProfileString(Section_Name[i], "Output", " ", output.GetBuffer(100), 100, FileName_21);

  413. 				int nReal = Reverse(_ttoi(input));

  414. 				Assert::AreEqual(nReal, _ttoi(output));

  415. 			}

  416. 		}

  417. 	};

  418. 	TEST_CLASS(UnitTest_22)

  419. 	{

  420. 		TEST_METHOD(TestMethode1)

  421. 		{

  422. 			char Section_Name[100][10] = { 0 };

  423. 			int  Section_Count = CalcCount(100, Section_Name, FileName_22);

  424. 			int input_count = 0, output_count = 0, returnSize = 0;

  425. 			int* input_value;

  426. 			int* output_value;

  427. 			CString input, output,k;

  428. 			for (int i = 0; i < Section_Count; i++) {

  429. 				GetPrivateProfileString(Section_Name[i], "Input", " ", input.GetBuffer(200), 200, FileName_22);

  430. 				GetPrivateProfileString(Section_Name[i], "k", " ", k.GetBuffer(20), 20, FileName_22);

  431. 				GetPrivateProfileString(Section_Name[i], "Output", " ", output.GetBuffer(200), 200, FileName_22);

  432. 				input_value = str_device(input, &input_count);

  433. 				output_value = str_device(output, &output_count);

  434. 				 Rotate1(input_value, input_count, _ttoi(k));

  435. 				for (int i = 0; i < input_count; i++) {

  436. 					Assert::AreEqual(input_value[i], output_value[i]);

  437. 				}

  438. 			}

  439. 		}

  440. 	};

  441. 	TEST_CLASS(UnitTest_23)

  442. 	{

  443. 		TEST_METHOD(TestMethode1)

  444. 		{

  445. 			char Section_Name[100][10] = { 0 };

  446. 			int  Section_Count = CalcCount(100, Section_Name, FileName_23);

  447. 			CString Input, Output;

  448. 			char Str_char[20];

  449. 			char** return_char ;

  450. 			int return_len = 0;

  451. 			char output_char[100][50];

  452. 			int output_len = 0;

  453. 			for (int i = 0; i < Section_Count; i++) {

  454. 				GetPrivateProfileString(Section_Name[i], "Input", " ", Input.GetBuffer(20), 20, FileName_23);

  455. 				GetPrivateProfileString(Section_Name[i], "Output", " ", Output.GetBuffer(1024), 1024, FileName_23);

  456. 				output_len = str_device2(Output, output_char);

  457. 				strcpy(Str_char, Input);

  458. 				return_char = RestoreIpAddresses(Str_char, &return_len);

  459. 				Assert::AreEqual(return_len, output_len);		//先判断个数是否相等

  460. 				for (int j = 0; j < return_len; j++) {			//循环挨个比较

  461. 					Assert::AreEqual(return_char[j], output_char[j]);

  462. 				}

  463. 			}

  464. 		}

  465. 	};

  466. 	TEST_CLASS(UnitTest_24)

  467. 	{

  468. 		TEST_METHOD(TestMethode1)

  469. 		{

  470. 			char Section_Name[100][10] = { 0 };

  471. 			int  Section_Count = CalcCount(100, Section_Name, FileName_24);

  472. 			CString Input, Output;

  473. 			char Str_char[1024] = { 0 };

  474. 			char* WordDic[100];

  475. 			for (int i = 0; i < Section_Count; i++) {

  476. 				GetPrivateProfileString(Section_Name[i], "Input", " ", Input.GetBuffer(200), 200, FileName_24);

  477. 				GetPrivateProfileString(Section_Name[i], "Output", " ", Output.GetBuffer(20), 20, FileName_24);

  478. 				strcpy(Str_char, Input);

  479. 				int nReal = LengthOfLongestSubstring(Str_char);

  480. 				Assert::AreEqual(nReal, _ttoi(Output));

  481. 			}

  482. 		}

  483. 	};

  484. 	TEST_CLASS(UnitTest_25)

  485. 	{

  486. 		TEST_METHOD(TestMethode1)

  487. 		{

  488. 			char Section_Name[100][10] = { 0 };

  489. 			int  Section_Count = CalcCount(100, Section_Name, FileName_25);

  490. 			int input_count = 0, output_count = 0, returnSize = 0;

  491. 			int* input_value;

  492. 			int* output_value;

  493. 			CString input1, input2,output;

  494. 			for (int i = 0; i < Section_Count; i++) {

  495. 				GetPrivateProfileString(Section_Name[i], "Input1", " ", input1.GetBuffer(200), 200, FileName_25);

  496. 				GetPrivateProfileString(Section_Name[i], "Input2", " ", input2.GetBuffer(20), 20, FileName_25);

  497. 				GetPrivateProfileString(Section_Name[i], "Output", " ", output.GetBuffer(200), 200, FileName_25);

  498. 				input_value = str_device(input1, &input_count);

  499. 				output_value = str_device(output, &output_count);

  500. 				struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));

  501. 				CreatListNode(input_value,input_count,head);

  502. 				struct ListNode* returnHead = Partition(head, atoi(input2));

  503. 				Assert::AreEqual(input_count, output_count);

  504. 				for (int i = 0; i < input_count; i++) {

  505. 					Assert::AreEqual(returnHead->val, output_value[i]);

  506. 					returnHead = returnHead->next;

  507. 				}

  508. 			}

  509. 		}

  510. 	};

  511. }