check_stack.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856
  1. /*
  2. ============================================================================
  3. Name : opcuaServer.c
  4. Author :
  5. Version :
  6. Copyright : Your copyright notice
  7. Description :
  8. ============================================================================
  9. */
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include "../src/opcua_transportLayer.h"
  13. #include "../src/opcua_binaryEncDec.h"
  14. #include "../src/opcua_encodingLayer.h"
  15. #include "../src/opcua_advancedDatatypes.h"
  16. //#include "check_stdint.h"
  17. #include "check.h"
  18. START_TEST(test_getPacketType_validParameter)
  19. {
  20. char buf[] = {'C','L','O'};
  21. AD_RawMessage rawMessage;
  22. rawMessage.message = buf;
  23. rawMessage.length = 3;
  24. ck_assert_int_eq(TL_getPacketType(&rawMessage),packetType_CLO);
  25. }
  26. END_TEST
  27. START_TEST(encodeByte_test)
  28. {
  29. AD_RawMessage rawMessage;
  30. Int32 position = 0;
  31. //EncodeByte
  32. char *mem = malloc(sizeof(Byte));
  33. rawMessage.message = mem;
  34. Byte testByte = 0x08;
  35. rawMessage.length = 1;
  36. position = 0;
  37. encodeByte(testByte, &position, rawMessage.message);
  38. ck_assert_int_eq(rawMessage.message[0], 0x08);
  39. ck_assert_int_eq(rawMessage.length, 1);
  40. ck_assert_int_eq(position, 1);
  41. free(mem);
  42. }
  43. END_TEST
  44. /*
  45. START_TEST(decodeRequestHeader_test_validParameter)
  46. {
  47. char testMessage = {0x00,0x00,0x72,0xf1,0xdc,0xc9,0x87,0x0b,
  48. 0xcf,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
  49. 0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,
  50. 0x00,0x00,0x00,0x00,0x00};
  51. AD_RawMessage rawMessage;
  52. rawMessage.message = &testMessage;
  53. rawMessage.length = 29;
  54. Int32 position = 0;
  55. T_RequestHeader requestHeader;
  56. decodeRequestHeader(rawMessage,&position,&requestHeader);
  57. ck_assert_int_eq(requestHeader.authenticationToken.EncodingByte,0);
  58. ck_assert_int_eq(requestHeader.returnDiagnostics,0);
  59. ck_assert_int_eq(requestHeader.authenticationToken.EncodingByte,0);
  60. }
  61. END_TEST
  62. */
  63. START_TEST(decodeInt16_test)
  64. {
  65. AD_RawMessage rawMessage;
  66. Int32 position = 0;
  67. //EncodeUInt16
  68. char mem[2] = {0x01,0x00};
  69. rawMessage.message = mem;
  70. rawMessage.length = 2;
  71. //encodeUInt16(testUInt16, &position, &rawMessage);
  72. Int32 p = 0;
  73. Int16 val;
  74. decoder_decodeBuiltInDatatype(rawMessage.message,INT16,&p,&val);
  75. ck_assert_int_eq(val,1);
  76. //ck_assert_int_eq(p, 2);
  77. //ck_assert_int_eq(rawMessage.message[0], 0xAB);
  78. }
  79. END_TEST
  80. START_TEST(encodeInt16_test)
  81. {
  82. AD_RawMessage rawMessage;
  83. Int32 position = 0;
  84. //EncodeUInt16
  85. char *mem = malloc(sizeof(UInt16));
  86. rawMessage.message = mem;
  87. UInt16 testUInt16 = 1;
  88. rawMessage.length = 2;
  89. position = 0;
  90. encodeUInt16(testUInt16, &position, rawMessage.message);
  91. //encodeUInt16(testUInt16, &position, &rawMessage);
  92. ck_assert_int_eq(position, 2);
  93. Int32 p = 0;
  94. Int16 val;
  95. decoder_decodeBuiltInDatatype(rawMessage.message, INT16, &p, &val);
  96. ck_assert_int_eq(val,testUInt16);
  97. //ck_assert_int_eq(rawMessage.message[0], 0xAB);
  98. }
  99. END_TEST
  100. START_TEST(decodeUInt16_test)
  101. {
  102. AD_RawMessage rawMessage;
  103. Int32 position = 0;
  104. //EncodeUInt16
  105. char mem[2] = {0x01,0x00};
  106. rawMessage.message = mem;
  107. rawMessage.length = 2;
  108. //encodeUInt16(testUInt16, &position, &rawMessage);
  109. Int32 p = 0;
  110. UInt16 val;
  111. decoder_decodeBuiltInDatatype(rawMessage.message,UINT16,&p,&val);
  112. ck_assert_int_eq(val,1);
  113. //ck_assert_int_eq(p, 2);
  114. //ck_assert_int_eq(rawMessage.message[0], 0xAB);
  115. }
  116. END_TEST
  117. START_TEST(encodeUInt16_test)
  118. {
  119. AD_RawMessage rawMessage;
  120. Int32 position = 0;
  121. //EncodeUInt16
  122. char *mem = malloc(sizeof(UInt16));
  123. rawMessage.message = mem;
  124. UInt16 testUInt16 = 1;
  125. rawMessage.length = 2;
  126. position = 0;
  127. encodeUInt16(testUInt16, &position, rawMessage.message);
  128. //encodeUInt16(testUInt16, &position, &rawMessage);
  129. ck_assert_int_eq(position, 2);
  130. Int32 p = 0;
  131. UInt16 val;
  132. decoder_decodeBuiltInDatatype(rawMessage.message, UINT16, &p, &val);
  133. ck_assert_int_eq(val,testUInt16);
  134. //ck_assert_int_eq(rawMessage.message[0], 0xAB);
  135. }
  136. END_TEST
  137. START_TEST(decodeUInt32_test)
  138. {
  139. AD_RawMessage rawMessage;
  140. Int32 position = 0;
  141. //EncodeUInt16
  142. char mem[4] = {0xFF,0x00,0x00,0x00};
  143. rawMessage.message = mem;
  144. rawMessage.length = 4;
  145. Int32 p = 0;
  146. UInt32 val;
  147. decoder_decodeBuiltInDatatype(rawMessage.message, UINT32, &p, &val);
  148. ck_assert_uint_eq(val,255);
  149. }
  150. END_TEST
  151. START_TEST(encodeUInt32_test)
  152. {
  153. AD_RawMessage rawMessage;
  154. Int32 position = 0;
  155. UInt32 value = 0x0101FF00;
  156. //EncodeUInt16
  157. rawMessage.message = (char*)opcua_malloc(sizeof(UInt32));
  158. rawMessage.length = 4;
  159. Int32 p = 0;
  160. encodeUInt32(value, &p,rawMessage.message);
  161. ck_assert_uint_eq((Byte)rawMessage.message[0],0x00);
  162. ck_assert_uint_eq((Byte)rawMessage.message[1],0xFF);
  163. ck_assert_uint_eq((Byte)rawMessage.message[2],0x01);
  164. ck_assert_uint_eq((Byte)rawMessage.message[3],0x01);
  165. }
  166. END_TEST
  167. START_TEST(decodeInt32_test)
  168. {
  169. AD_RawMessage rawMessage;
  170. Int32 position = 0;
  171. //EncodeUInt16
  172. char mem[4] = {0x00,0xCA,0x9A,0x3B};
  173. rawMessage.message = mem;
  174. rawMessage.length = 4;
  175. Int32 p = 0;
  176. Int32 val;
  177. decoder_decodeBuiltInDatatype(rawMessage.message, INT32, &p, &val);
  178. ck_assert_int_eq(val,1000000000);
  179. }
  180. END_TEST
  181. START_TEST(encodeInt32_test)
  182. {
  183. }
  184. END_TEST
  185. START_TEST(decodeUInt64_test)
  186. {
  187. AD_RawMessage rawMessage;
  188. Int32 position = 0;
  189. UInt64 expectedVal = 0xFF;
  190. expectedVal = expectedVal << 56;
  191. char mem[8] = {00,00,00,00,0x00,0x00,0x00,0xFF};
  192. rawMessage.message = mem;
  193. rawMessage.length = 8;
  194. Int32 p = 0;
  195. UInt64 val;
  196. decoder_decodeBuiltInDatatype(rawMessage.message, UINT64, &p, &val);
  197. ck_assert_uint_eq(val, expectedVal);
  198. }
  199. END_TEST
  200. START_TEST(encodeUInt64_test)
  201. {
  202. AD_RawMessage rawMessage;
  203. Int32 position = 0;
  204. UInt64 value = 0x0101FF00FF00FF00;
  205. //EncodeUInt16
  206. rawMessage.message = (char*)opcua_malloc(sizeof(UInt32));
  207. rawMessage.length = 8;
  208. Int32 p = 0;
  209. encodeUInt64(value, &p,rawMessage.message);
  210. ck_assert_uint_eq((Byte)rawMessage.message[0],0x00);
  211. ck_assert_uint_eq((Byte)rawMessage.message[1],0xFF);
  212. ck_assert_uint_eq((Byte)rawMessage.message[2],0x00);
  213. ck_assert_uint_eq((Byte)rawMessage.message[3],0xFF);
  214. ck_assert_uint_eq((Byte)rawMessage.message[4],0x00);
  215. ck_assert_uint_eq((Byte)rawMessage.message[5],0xFF);
  216. ck_assert_uint_eq((Byte)rawMessage.message[6],0x01);
  217. ck_assert_uint_eq((Byte)rawMessage.message[7],0x01);
  218. }
  219. END_TEST
  220. START_TEST(decodeInt64_test)
  221. {
  222. AD_RawMessage rawMessage;
  223. Int32 position = 0;
  224. Int64 expectedVal = 0xFF;
  225. expectedVal = expectedVal << 56;
  226. char mem[8] = {00,00,00,00,0x00,0x00,0x00,0xFF};
  227. rawMessage.message = mem;
  228. rawMessage.length = 8;
  229. Int32 p = 0;
  230. Int64 val;
  231. decoder_decodeBuiltInDatatype(rawMessage.message, INT64, &p, &val);
  232. ck_assert_uint_eq(val, expectedVal);
  233. }
  234. END_TEST
  235. START_TEST(encodeInt64_test)
  236. {
  237. AD_RawMessage rawMessage;
  238. Int32 position = 0;
  239. UInt64 value = 0x0101FF00FF00FF00;
  240. //EncodeUInt16
  241. rawMessage.message = (char*)opcua_malloc(sizeof(UInt32));
  242. rawMessage.length = 8;
  243. Int32 p = 0;
  244. encodeUInt64(value, &p,rawMessage.message);
  245. ck_assert_uint_eq((Byte)rawMessage.message[0],0x00);
  246. ck_assert_uint_eq((Byte)rawMessage.message[1],0xFF);
  247. ck_assert_uint_eq((Byte)rawMessage.message[2],0x00);
  248. ck_assert_uint_eq((Byte)rawMessage.message[3],0xFF);
  249. ck_assert_uint_eq((Byte)rawMessage.message[4],0x00);
  250. ck_assert_uint_eq((Byte)rawMessage.message[5],0xFF);
  251. ck_assert_uint_eq((Byte)rawMessage.message[6],0x01);
  252. ck_assert_uint_eq((Byte)rawMessage.message[7],0x01);
  253. }
  254. END_TEST
  255. START_TEST(decodeFloat_test)
  256. {
  257. Float expectedValue = -6.5;
  258. Int32 pos = 0;
  259. char buf[4] = {0x00,0x00,0xD0,0xC0};
  260. Float calcVal;
  261. decoder_decodeBuiltInDatatype(buf, FLOAT, &pos, &calcVal);
  262. //val should be -6.5
  263. Int32 val = (calcVal > -6.501 && calcVal < -6.499);
  264. ck_assert_int_gt(val,0);
  265. opcua_free(buf);
  266. }
  267. END_TEST
  268. START_TEST(encodeFloat_test)
  269. {
  270. Float value = -6.5;
  271. Int32 pos = 0;
  272. char *buf = (char*)opcua_malloc(sizeof(Float));
  273. encodeFloat(value,&pos,buf);
  274. ck_assert_uint_eq((Byte)buf[2],0xD0);
  275. ck_assert_uint_eq((Byte)buf[3],0xC0);
  276. opcua_free(buf);
  277. }
  278. END_TEST
  279. START_TEST(decodeDouble_test)
  280. {
  281. }
  282. END_TEST
  283. START_TEST(encodeDouble_test)
  284. {
  285. Float value = -6.5;
  286. Int32 pos = 0;
  287. char *buf = (char*)opcua_malloc(sizeof(Float));
  288. encodeDouble(value,&pos,buf);
  289. ck_assert_uint_eq((Byte)buf[6],0xD0);
  290. ck_assert_uint_eq((Byte)buf[7],0xC0);
  291. opcua_free(buf);
  292. }
  293. END_TEST
  294. START_TEST(encodeUAString_test)
  295. {
  296. Int32 pos = 0;
  297. UA_String string;
  298. Int32 l = 11;
  299. char mem[11] = "ACPLT OPCUA";
  300. char *dstBuf = (char*) malloc(sizeof(Int32)+l);
  301. string.Data = mem;
  302. string.Length = 11;
  303. encodeUAString(&string, &pos, dstBuf);
  304. ck_assert_int_eq(dstBuf[0],11);
  305. ck_assert_int_eq(dstBuf[0+sizeof(Int32)],'A');
  306. }
  307. END_TEST
  308. START_TEST(decodeUAString_test)
  309. {
  310. Int32 pos = 0;
  311. UA_String string;
  312. Int32 l = 11;
  313. char binString[15] = {11,0x00,0x00,0x00,'A','C','P','L','T',' ','U','A'};
  314. char *dstBuf = (char*) malloc(l-sizeof(Int32));
  315. string.Data = dstBuf;
  316. string.Length = 0;
  317. decodeUAString(binString, &pos, &string);
  318. ck_assert_int_eq(string.Length,11);
  319. ck_assert_int_eq(string.Data[3],'L');
  320. }
  321. END_TEST
  322. START_TEST(diagnosticInfo_calcSize_test)
  323. {
  324. Int32 valreal = 0;
  325. Int32 valcalc = 0;
  326. UA_DiagnosticInfo diagnosticInfo;
  327. diagnosticInfo.EncodingMask = 0x01 | 0x02 | 0x04 | 0x08 | 0x10;
  328. diagnosticInfo.SymbolicId = 30;
  329. diagnosticInfo.NamespaceUri = 25;
  330. diagnosticInfo.LocalizedText = 22;
  331. diagnosticInfo.AdditionalInfo.Data = "OPCUA";
  332. diagnosticInfo.AdditionalInfo.Length = 5;
  333. valcalc = diagnosticInfo_calcSize(&diagnosticInfo);
  334. valreal = 26;
  335. ck_assert_int_eq(valcalc,valreal);
  336. }
  337. END_TEST
  338. START_TEST(extensionObject_calcSize_test)
  339. {
  340. Int32 valreal = 0;
  341. Int32 valcalc = 0;
  342. Byte data[3] = {1,2,3};
  343. UA_ExtensionObject extensionObject;
  344. extensionObject.TypeId.EncodingByte = NIEVT_TWO_BYTE;; // Numeric TWO BYTES
  345. extensionObject.TypeId.Identifier.Numeric = 0;
  346. extensionObject.Encoding = 0x00;
  347. extensionObject.Length = 0;
  348. //extensionObject.Body = &data;
  349. valcalc = extensionObject_calcSize(&extensionObject);
  350. valreal = 3;
  351. ck_assert_int_eq(valcalc, valreal);
  352. }
  353. END_TEST
  354. START_TEST(responseHeader_calcSize_test)
  355. {
  356. Int32 valreal = 0;
  357. Int32 valcalc = 0;
  358. T_ResponseHeader responseHeader;
  359. UA_DiagnosticInfo diagnosticInfo;
  360. UA_ExtensionObject extensionObject;
  361. //Should have the size of 16 Bytes
  362. responseHeader.timestamp = 150014;
  363. responseHeader.requestHandle = 514;
  364. responseHeader.serviceResult = 504;
  365. //Should have the size of 26 Bytes
  366. diagnosticInfo.EncodingMask = 0x01 | 0x02 | 0x04 | 0x08 | 0x10;
  367. diagnosticInfo.SymbolicId = 30;
  368. diagnosticInfo.NamespaceUri = 25;
  369. diagnosticInfo.LocalizedText = 22;
  370. diagnosticInfo.AdditionalInfo.Data = "OPCUA";
  371. diagnosticInfo.AdditionalInfo.Length = 5;
  372. responseHeader.serviceDiagnostics = &diagnosticInfo;
  373. //Should have the size of 4 Bytes
  374. responseHeader.noOfStringTable = 0;
  375. //Should have the size of 3 Bytes
  376. extensionObject.TypeId.EncodingByte = NIEVT_TWO_BYTE;
  377. extensionObject.TypeId.Identifier.Numeric = 0;
  378. extensionObject.Encoding = 0x00; //binaryBody = false, xmlBody = false
  379. responseHeader.additionalHeader = extensionObject;
  380. valcalc = responseHeader_calcSize(&responseHeader);
  381. valreal = 49;
  382. ck_assert_int_eq(valcalc,valreal);
  383. }
  384. END_TEST
  385. Suite *testSuite_getPacketType(void)
  386. {
  387. Suite *s = suite_create("getPacketType");
  388. TCase *tc_core = tcase_create("Core");
  389. tcase_add_test(tc_core,test_getPacketType_validParameter);
  390. suite_add_tcase(s,tc_core);
  391. return s;
  392. }
  393. Suite *testSuite_encodeByte(void)
  394. {
  395. Suite *s = suite_create("encodeByte_test");
  396. TCase *tc_core = tcase_create("Core");
  397. tcase_add_test(tc_core, encodeByte_test);
  398. suite_add_tcase(s,tc_core);
  399. return s;
  400. }
  401. Suite *testSuite_decodeInt16(void)
  402. {
  403. Suite *s = suite_create("decodeInt16_test");
  404. TCase *tc_core = tcase_create("Core");
  405. tcase_add_test(tc_core, decodeInt16_test);
  406. suite_add_tcase(s,tc_core);
  407. return s;
  408. }
  409. Suite*testSuite_encodeInt16(void)
  410. {
  411. Suite *s = suite_create("encodeInt16_test");
  412. TCase *tc_core = tcase_create("Core");
  413. tcase_add_test(tc_core, encodeInt16_test);
  414. suite_add_tcase(s,tc_core);
  415. return s;
  416. }
  417. Suite *testSuite_decodeUInt16(void)
  418. {
  419. Suite *s = suite_create("decodeUInt16_test");
  420. TCase *tc_core = tcase_create("Core");
  421. tcase_add_test(tc_core, decodeUInt16_test);
  422. suite_add_tcase(s,tc_core);
  423. return s;
  424. }
  425. Suite*testSuite_encodeUInt16(void)
  426. {
  427. Suite *s = suite_create("encodeUInt16_test");
  428. TCase *tc_core = tcase_create("Core");
  429. tcase_add_test(tc_core, encodeUInt16_test);
  430. suite_add_tcase(s,tc_core);
  431. return s;
  432. }
  433. Suite*testSuite_decodeUInt32(void)
  434. {
  435. Suite *s = suite_create("decodeUInt32_test");
  436. TCase *tc_core = tcase_create("Core");
  437. tcase_add_test(tc_core, decodeUInt32_test);
  438. suite_add_tcase(s,tc_core);
  439. return s;
  440. }
  441. Suite*testSuite_encodeUInt32(void)
  442. {
  443. Suite *s = suite_create("encodeUInt32_test");
  444. TCase *tc_core = tcase_create("Core");
  445. tcase_add_test(tc_core, encodeUInt32_test);
  446. suite_add_tcase(s,tc_core);
  447. return s;
  448. }
  449. Suite*testSuite_decodeInt32(void)
  450. {
  451. Suite *s = suite_create("decodeInt32_test");
  452. TCase *tc_core = tcase_create("Core");
  453. tcase_add_test(tc_core, decodeInt32_test);
  454. suite_add_tcase(s,tc_core);
  455. return s;
  456. }
  457. Suite*testSuite_encodeInt32(void)
  458. {
  459. Suite *s = suite_create("encodeInt32_test");
  460. TCase *tc_core = tcase_create("Core");
  461. tcase_add_test(tc_core, encodeInt32_test);
  462. suite_add_tcase(s,tc_core);
  463. return s;
  464. }
  465. Suite*testSuite_decodeUInt64(void)
  466. {
  467. Suite *s = suite_create("decodeUInt64_test");
  468. TCase *tc_core = tcase_create("Core");
  469. tcase_add_test(tc_core, decodeUInt64_test);
  470. suite_add_tcase(s,tc_core);
  471. return s;
  472. }
  473. Suite*testSuite_encodeUInt64(void)
  474. {
  475. Suite *s = suite_create("encodeUInt64_test");
  476. TCase *tc_core = tcase_create("Core");
  477. tcase_add_test(tc_core, encodeUInt64_test);
  478. suite_add_tcase(s,tc_core);
  479. return s;
  480. }
  481. Suite*testSuite_decodeInt64(void)
  482. {
  483. Suite *s = suite_create("decodeInt64_test");
  484. TCase *tc_core = tcase_create("Core");
  485. tcase_add_test(tc_core, decodeInt64_test);
  486. suite_add_tcase(s,tc_core);
  487. return s;
  488. }
  489. Suite*testSuite_encodeInt64(void)
  490. {
  491. Suite *s = suite_create("encodeInt64_test");
  492. TCase *tc_core = tcase_create("Core");
  493. tcase_add_test(tc_core, encodeInt64_test);
  494. suite_add_tcase(s,tc_core);
  495. return s;
  496. }
  497. Suite *testSuite_encodeFloat(void)
  498. {
  499. Suite *s = suite_create("encodeFloat_test");
  500. TCase *tc_core = tcase_create("Core");
  501. tcase_add_test(tc_core, encodeFloat_test);
  502. suite_add_tcase(s,tc_core);
  503. return s;
  504. }
  505. Suite *testSuite_decodeFloat(void)
  506. {
  507. Suite *s = suite_create("decodeFloat_test");
  508. TCase *tc_core = tcase_create("Core");
  509. tcase_add_test(tc_core, decodeFloat_test);
  510. suite_add_tcase(s,tc_core);
  511. return s;
  512. }
  513. Suite *testSuite_encodeDouble(void)
  514. {
  515. Suite *s = suite_create("encodeDouble_test");
  516. TCase *tc_core = tcase_create("Core");
  517. tcase_add_test(tc_core, encodeDouble_test);
  518. suite_add_tcase(s,tc_core);
  519. return s;
  520. }
  521. Suite *testSuite_decodeDouble(void)
  522. {
  523. Suite *s = suite_create("decodeDouble_test");
  524. TCase *tc_core = tcase_create("Core");
  525. tcase_add_test(tc_core, decodeDouble_test);
  526. suite_add_tcase(s,tc_core);
  527. return s;
  528. }
  529. Suite * testSuite_encodeUAString(void)
  530. {
  531. Suite *s = suite_create("encodeUAString_test");
  532. TCase *tc_core = tcase_create("Core");
  533. tcase_add_test(tc_core, encodeUAString_test);
  534. suite_add_tcase(s,tc_core);
  535. return s;
  536. }
  537. Suite * testSuite_decodeUAString(void)
  538. {
  539. Suite *s = suite_create("decodeUAString_test");
  540. TCase *tc_core = tcase_create("Core");
  541. tcase_add_test(tc_core, decodeUAString_test);
  542. suite_add_tcase(s,tc_core);
  543. return s;
  544. }
  545. /*
  546. Suite* TL_<TESTSUITENAME>(void)
  547. {
  548. Suite *s = suite_create("<TESTSUITENAME>");
  549. TCase *tc_core = tcase_create("Core");
  550. tcase_add_test(tc_core,<TEST_NAME>);
  551. suite_add_tcase(s,tc_core);
  552. return s;
  553. }
  554. */
  555. Suite* testSuite_diagnosticInfo_calcSize()
  556. {
  557. Suite *s = suite_create("diagnosticInfo_calcSize");
  558. TCase *tc_core = tcase_create("Core");
  559. tcase_add_test(tc_core, diagnosticInfo_calcSize_test);
  560. suite_add_tcase(s,tc_core);
  561. return s;
  562. }
  563. Suite* testSuite_extensionObject_calcSize()
  564. {
  565. Suite *s = suite_create("extensionObject_calcSize");
  566. TCase *tc_core = tcase_create("Core");
  567. tcase_add_test(tc_core, extensionObject_calcSize_test);
  568. suite_add_tcase(s,tc_core);
  569. return s;
  570. }
  571. Suite* testSuite_responseHeader_calcSize()
  572. {
  573. Suite *s = suite_create("responseHeader_calcSize");
  574. TCase *tc_core = tcase_create("Core");
  575. tcase_add_test(tc_core, responseHeader_calcSize_test);
  576. suite_add_tcase(s,tc_core);
  577. return s;
  578. }
  579. int main (void)
  580. {
  581. int number_failed = 0;
  582. Suite *s = testSuite_getPacketType();
  583. SRunner *sr = srunner_create(s);
  584. srunner_run_all(sr,CK_NORMAL);
  585. number_failed = srunner_ntests_failed(sr);
  586. srunner_free(sr);
  587. s = testSuite_decodeInt16();
  588. sr = srunner_create(s);
  589. srunner_run_all(sr,CK_NORMAL);
  590. number_failed += srunner_ntests_failed(sr);
  591. srunner_free(sr);
  592. s = testSuite_encodeInt16();
  593. sr = srunner_create(s);
  594. srunner_run_all(sr,CK_NORMAL);
  595. number_failed += srunner_ntests_failed(sr);
  596. srunner_free(sr);
  597. s = testSuite_decodeUInt16();
  598. sr = srunner_create(s);
  599. srunner_run_all(sr,CK_NORMAL);
  600. number_failed += srunner_ntests_failed(sr);
  601. srunner_free(sr);
  602. s = testSuite_encodeUInt16();
  603. sr = srunner_create(s);
  604. srunner_run_all(sr,CK_NORMAL);
  605. number_failed += srunner_ntests_failed(sr);
  606. srunner_free(sr);
  607. s = testSuite_decodeUInt32();
  608. sr = srunner_create(s);
  609. srunner_run_all(sr,CK_NORMAL);
  610. number_failed += srunner_ntests_failed(sr);
  611. srunner_free(sr);
  612. s = testSuite_encodeUInt32();
  613. sr = srunner_create(s);
  614. srunner_run_all(sr,CK_NORMAL);
  615. number_failed += srunner_ntests_failed(sr);
  616. srunner_free(sr);
  617. s = testSuite_decodeInt32();
  618. sr = srunner_create(s);
  619. srunner_run_all(sr,CK_NORMAL);
  620. number_failed += srunner_ntests_failed(sr);
  621. srunner_free(sr);
  622. s = testSuite_encodeInt32();
  623. sr = srunner_create(s);
  624. srunner_run_all(sr,CK_NORMAL);
  625. number_failed += srunner_ntests_failed(sr);
  626. srunner_free(sr);
  627. s = testSuite_decodeUInt64();
  628. sr = srunner_create(s);
  629. srunner_run_all(sr,CK_NORMAL);
  630. number_failed += srunner_ntests_failed(sr);
  631. srunner_free(sr);
  632. s = testSuite_encodeUInt64();
  633. sr = srunner_create(s);
  634. srunner_run_all(sr,CK_NORMAL);
  635. number_failed += srunner_ntests_failed(sr);
  636. srunner_free(sr);
  637. s = testSuite_decodeInt64();
  638. sr = srunner_create(s);
  639. srunner_run_all(sr,CK_NORMAL);
  640. number_failed += srunner_ntests_failed(sr);
  641. srunner_free(sr);
  642. s = testSuite_encodeInt64();
  643. sr = srunner_create(s);
  644. srunner_run_all(sr,CK_NORMAL);
  645. number_failed += srunner_ntests_failed(sr);
  646. srunner_free(sr);
  647. s = testSuite_encodeFloat();
  648. sr = srunner_create(s);
  649. srunner_run_all(sr,CK_NORMAL);
  650. number_failed += srunner_ntests_failed(sr);
  651. srunner_free(sr);
  652. s = testSuite_encodeDouble();
  653. sr = srunner_create(s);
  654. srunner_run_all(sr,CK_NORMAL);
  655. number_failed += srunner_ntests_failed(sr);
  656. srunner_free(sr);
  657. s = testSuite_encodeByte();
  658. sr = srunner_create(s);
  659. srunner_run_all(sr,CK_NORMAL);
  660. number_failed += srunner_ntests_failed(sr);
  661. srunner_free(sr);
  662. s = testSuite_encodeUAString();
  663. sr = srunner_create(s);
  664. srunner_run_all(sr,CK_NORMAL);
  665. number_failed += srunner_ntests_failed(sr);
  666. srunner_free(sr);
  667. s = testSuite_decodeUAString();
  668. sr = srunner_create(s);
  669. srunner_run_all(sr,CK_NORMAL);
  670. number_failed += srunner_ntests_failed(sr);
  671. srunner_free(sr);
  672. s = testSuite_diagnosticInfo_calcSize();
  673. sr = srunner_create(s);
  674. srunner_run_all(sr,CK_NORMAL);
  675. number_failed += srunner_ntests_failed(sr);
  676. srunner_free(sr);
  677. s = testSuite_extensionObject_calcSize();
  678. sr = srunner_create(s);
  679. srunner_run_all(sr,CK_NORMAL);
  680. number_failed += srunner_ntests_failed(sr);
  681. srunner_free(sr);
  682. s = testSuite_responseHeader_calcSize();
  683. sr = srunner_create(s);
  684. srunner_run_all(sr,CK_NORMAL);
  685. number_failed += srunner_ntests_failed(sr);
  686. srunner_free(sr);
  687. /* <TESTSUITE_TEMPLATE>
  688. s = <TESTSUITENAME>;
  689. sr = srunner_create(s);
  690. srunner_run_all(sr,CK_NORMAL);
  691. number_failed += srunner_ntests_failed(sr);
  692. srunner_free(sr);
  693. */
  694. return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
  695. }