check_stack.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921
  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. START_TEST(encodeDataValue_test)
  386. {
  387. UA_DataValue dataValue;
  388. Int32 pos = 0;
  389. char *buf = (char*)opcua_malloc(15);
  390. UA_DateTime dateTime;
  391. dateTime = 80;
  392. dataValue.ServerTimestamp = dateTime;
  393. //--without Variant
  394. dataValue.EncodingMask = 0x08; //Only the SourvePicoseconds
  395. encodeDataValue(&dataValue, &pos, buf);
  396. ck_assert_int_eq(pos, 9);// represents the length
  397. ck_assert_int_eq(buf[0], 0x08);
  398. ck_assert_int_eq(buf[1], 80);
  399. ck_assert_int_eq(buf[2], 0);
  400. ck_assert_int_eq(buf[3], 0);
  401. ck_assert_int_eq(buf[4], 0);
  402. ck_assert_int_eq(buf[5], 0);
  403. ck_assert_int_eq(buf[6], 0);
  404. ck_assert_int_eq(buf[7], 0);
  405. ck_assert_int_eq(buf[8], 0);
  406. //TestCase for a DataValue with a Variant!
  407. //ToDo: Need to be checked after the function for encoding variants has been implemented
  408. pos = 0;
  409. dataValue.EncodingMask = 0x01 || 0x08; //Variant & SourvePicoseconds
  410. UA_Variant variant;
  411. variant.ArrayLength = 0;
  412. variant.EncodingMask = VTEMT_INT32;
  413. UA_VariantUnion variantUnion;
  414. variantUnion.Int32 = 45;
  415. variant.Value = &variantUnion;
  416. dataValue.Value = variant;
  417. encodeDataValue(&dataValue, &pos, buf);
  418. ck_assert_int_eq(pos, 14);// represents the length
  419. ck_assert_int_eq(buf[0], 0x08);
  420. ck_assert_int_eq(buf[1], 0x06);
  421. ck_assert_int_eq(buf[2], 45);
  422. ck_assert_int_eq(buf[3], 0);
  423. ck_assert_int_eq(buf[4], 0);
  424. ck_assert_int_eq(buf[5], 0);
  425. ck_assert_int_eq(buf[6], 80);
  426. ck_assert_int_eq(buf[7], 0);
  427. }
  428. END_TEST
  429. Suite *testSuite_getPacketType(void)
  430. {
  431. Suite *s = suite_create("getPacketType");
  432. TCase *tc_core = tcase_create("Core");
  433. tcase_add_test(tc_core,test_getPacketType_validParameter);
  434. suite_add_tcase(s,tc_core);
  435. return s;
  436. }
  437. Suite *testSuite_encodeByte(void)
  438. {
  439. Suite *s = suite_create("encodeByte_test");
  440. TCase *tc_core = tcase_create("Core");
  441. tcase_add_test(tc_core, encodeByte_test);
  442. suite_add_tcase(s,tc_core);
  443. return s;
  444. }
  445. Suite *testSuite_decodeInt16(void)
  446. {
  447. Suite *s = suite_create("decodeInt16_test");
  448. TCase *tc_core = tcase_create("Core");
  449. tcase_add_test(tc_core, decodeInt16_test);
  450. suite_add_tcase(s,tc_core);
  451. return s;
  452. }
  453. Suite*testSuite_encodeInt16(void)
  454. {
  455. Suite *s = suite_create("encodeInt16_test");
  456. TCase *tc_core = tcase_create("Core");
  457. tcase_add_test(tc_core, encodeInt16_test);
  458. suite_add_tcase(s,tc_core);
  459. return s;
  460. }
  461. Suite *testSuite_decodeUInt16(void)
  462. {
  463. Suite *s = suite_create("decodeUInt16_test");
  464. TCase *tc_core = tcase_create("Core");
  465. tcase_add_test(tc_core, decodeUInt16_test);
  466. suite_add_tcase(s,tc_core);
  467. return s;
  468. }
  469. Suite*testSuite_encodeUInt16(void)
  470. {
  471. Suite *s = suite_create("encodeUInt16_test");
  472. TCase *tc_core = tcase_create("Core");
  473. tcase_add_test(tc_core, encodeUInt16_test);
  474. suite_add_tcase(s,tc_core);
  475. return s;
  476. }
  477. Suite*testSuite_decodeUInt32(void)
  478. {
  479. Suite *s = suite_create("decodeUInt32_test");
  480. TCase *tc_core = tcase_create("Core");
  481. tcase_add_test(tc_core, decodeUInt32_test);
  482. suite_add_tcase(s,tc_core);
  483. return s;
  484. }
  485. Suite*testSuite_encodeUInt32(void)
  486. {
  487. Suite *s = suite_create("encodeUInt32_test");
  488. TCase *tc_core = tcase_create("Core");
  489. tcase_add_test(tc_core, encodeUInt32_test);
  490. suite_add_tcase(s,tc_core);
  491. return s;
  492. }
  493. Suite*testSuite_decodeInt32(void)
  494. {
  495. Suite *s = suite_create("decodeInt32_test");
  496. TCase *tc_core = tcase_create("Core");
  497. tcase_add_test(tc_core, decodeInt32_test);
  498. suite_add_tcase(s,tc_core);
  499. return s;
  500. }
  501. Suite*testSuite_encodeInt32(void)
  502. {
  503. Suite *s = suite_create("encodeInt32_test");
  504. TCase *tc_core = tcase_create("Core");
  505. tcase_add_test(tc_core, encodeInt32_test);
  506. suite_add_tcase(s,tc_core);
  507. return s;
  508. }
  509. Suite*testSuite_decodeUInt64(void)
  510. {
  511. Suite *s = suite_create("decodeUInt64_test");
  512. TCase *tc_core = tcase_create("Core");
  513. tcase_add_test(tc_core, decodeUInt64_test);
  514. suite_add_tcase(s,tc_core);
  515. return s;
  516. }
  517. Suite*testSuite_encodeUInt64(void)
  518. {
  519. Suite *s = suite_create("encodeUInt64_test");
  520. TCase *tc_core = tcase_create("Core");
  521. tcase_add_test(tc_core, encodeUInt64_test);
  522. suite_add_tcase(s,tc_core);
  523. return s;
  524. }
  525. Suite*testSuite_decodeInt64(void)
  526. {
  527. Suite *s = suite_create("decodeInt64_test");
  528. TCase *tc_core = tcase_create("Core");
  529. tcase_add_test(tc_core, decodeInt64_test);
  530. suite_add_tcase(s,tc_core);
  531. return s;
  532. }
  533. Suite*testSuite_encodeInt64(void)
  534. {
  535. Suite *s = suite_create("encodeInt64_test");
  536. TCase *tc_core = tcase_create("Core");
  537. tcase_add_test(tc_core, encodeInt64_test);
  538. suite_add_tcase(s,tc_core);
  539. return s;
  540. }
  541. Suite *testSuite_encodeFloat(void)
  542. {
  543. Suite *s = suite_create("encodeFloat_test");
  544. TCase *tc_core = tcase_create("Core");
  545. tcase_add_test(tc_core, encodeFloat_test);
  546. suite_add_tcase(s,tc_core);
  547. return s;
  548. }
  549. Suite *testSuite_decodeFloat(void)
  550. {
  551. Suite *s = suite_create("decodeFloat_test");
  552. TCase *tc_core = tcase_create("Core");
  553. tcase_add_test(tc_core, decodeFloat_test);
  554. suite_add_tcase(s,tc_core);
  555. return s;
  556. }
  557. Suite *testSuite_encodeDouble(void)
  558. {
  559. Suite *s = suite_create("encodeDouble_test");
  560. TCase *tc_core = tcase_create("Core");
  561. tcase_add_test(tc_core, encodeDouble_test);
  562. suite_add_tcase(s,tc_core);
  563. return s;
  564. }
  565. Suite *testSuite_decodeDouble(void)
  566. {
  567. Suite *s = suite_create("decodeDouble_test");
  568. TCase *tc_core = tcase_create("Core");
  569. tcase_add_test(tc_core, decodeDouble_test);
  570. suite_add_tcase(s,tc_core);
  571. return s;
  572. }
  573. Suite * testSuite_encodeUAString(void)
  574. {
  575. Suite *s = suite_create("encodeUAString_test");
  576. TCase *tc_core = tcase_create("Core");
  577. tcase_add_test(tc_core, encodeUAString_test);
  578. suite_add_tcase(s,tc_core);
  579. return s;
  580. }
  581. Suite * testSuite_decodeUAString(void)
  582. {
  583. Suite *s = suite_create("decodeUAString_test");
  584. TCase *tc_core = tcase_create("Core");
  585. tcase_add_test(tc_core, decodeUAString_test);
  586. suite_add_tcase(s,tc_core);
  587. return s;
  588. }
  589. Suite* testSuite_encodeDataValue()
  590. {
  591. Suite *s = suite_create("encodeDataValue");
  592. TCase *tc_core = tcase_create("Core");
  593. tcase_add_test(tc_core, encodeDataValue_test);
  594. suite_add_tcase(s,tc_core);
  595. return s;
  596. }
  597. /*
  598. Suite* TL_<TESTSUITENAME>(void)
  599. {
  600. Suite *s = suite_create("<TESTSUITENAME>");
  601. TCase *tc_core = tcase_create("Core");
  602. tcase_add_test(tc_core,<TEST_NAME>);
  603. suite_add_tcase(s,tc_core);
  604. return s;
  605. }
  606. */
  607. Suite* testSuite_diagnosticInfo_calcSize()
  608. {
  609. Suite *s = suite_create("diagnosticInfo_calcSize");
  610. TCase *tc_core = tcase_create("Core");
  611. tcase_add_test(tc_core, diagnosticInfo_calcSize_test);
  612. suite_add_tcase(s,tc_core);
  613. return s;
  614. }
  615. Suite* testSuite_extensionObject_calcSize()
  616. {
  617. Suite *s = suite_create("extensionObject_calcSize");
  618. TCase *tc_core = tcase_create("Core");
  619. tcase_add_test(tc_core, extensionObject_calcSize_test);
  620. suite_add_tcase(s,tc_core);
  621. return s;
  622. }
  623. Suite* testSuite_responseHeader_calcSize()
  624. {
  625. Suite *s = suite_create("responseHeader_calcSize");
  626. TCase *tc_core = tcase_create("Core");
  627. tcase_add_test(tc_core, responseHeader_calcSize_test);
  628. suite_add_tcase(s,tc_core);
  629. return s;
  630. }
  631. int main (void)
  632. {
  633. int number_failed = 0;
  634. Suite *s = testSuite_getPacketType();
  635. SRunner *sr = srunner_create(s);
  636. srunner_run_all(sr,CK_NORMAL);
  637. number_failed = srunner_ntests_failed(sr);
  638. srunner_free(sr);
  639. s = testSuite_decodeInt16();
  640. sr = srunner_create(s);
  641. srunner_run_all(sr,CK_NORMAL);
  642. number_failed += srunner_ntests_failed(sr);
  643. srunner_free(sr);
  644. s = testSuite_encodeInt16();
  645. sr = srunner_create(s);
  646. srunner_run_all(sr,CK_NORMAL);
  647. number_failed += srunner_ntests_failed(sr);
  648. srunner_free(sr);
  649. s = testSuite_decodeUInt16();
  650. sr = srunner_create(s);
  651. srunner_run_all(sr,CK_NORMAL);
  652. number_failed += srunner_ntests_failed(sr);
  653. srunner_free(sr);
  654. s = testSuite_encodeUInt16();
  655. sr = srunner_create(s);
  656. srunner_run_all(sr,CK_NORMAL);
  657. number_failed += srunner_ntests_failed(sr);
  658. srunner_free(sr);
  659. s = testSuite_decodeUInt32();
  660. sr = srunner_create(s);
  661. srunner_run_all(sr,CK_NORMAL);
  662. number_failed += srunner_ntests_failed(sr);
  663. srunner_free(sr);
  664. s = testSuite_encodeUInt32();
  665. sr = srunner_create(s);
  666. srunner_run_all(sr,CK_NORMAL);
  667. number_failed += srunner_ntests_failed(sr);
  668. srunner_free(sr);
  669. s = testSuite_decodeInt32();
  670. sr = srunner_create(s);
  671. srunner_run_all(sr,CK_NORMAL);
  672. number_failed += srunner_ntests_failed(sr);
  673. srunner_free(sr);
  674. s = testSuite_encodeInt32();
  675. sr = srunner_create(s);
  676. srunner_run_all(sr,CK_NORMAL);
  677. number_failed += srunner_ntests_failed(sr);
  678. srunner_free(sr);
  679. s = testSuite_decodeUInt64();
  680. sr = srunner_create(s);
  681. srunner_run_all(sr,CK_NORMAL);
  682. number_failed += srunner_ntests_failed(sr);
  683. srunner_free(sr);
  684. s = testSuite_encodeUInt64();
  685. sr = srunner_create(s);
  686. srunner_run_all(sr,CK_NORMAL);
  687. number_failed += srunner_ntests_failed(sr);
  688. srunner_free(sr);
  689. s = testSuite_decodeInt64();
  690. sr = srunner_create(s);
  691. srunner_run_all(sr,CK_NORMAL);
  692. number_failed += srunner_ntests_failed(sr);
  693. srunner_free(sr);
  694. s = testSuite_encodeInt64();
  695. sr = srunner_create(s);
  696. srunner_run_all(sr,CK_NORMAL);
  697. number_failed += srunner_ntests_failed(sr);
  698. srunner_free(sr);
  699. s = testSuite_encodeFloat();
  700. sr = srunner_create(s);
  701. srunner_run_all(sr,CK_NORMAL);
  702. number_failed += srunner_ntests_failed(sr);
  703. srunner_free(sr);
  704. s = testSuite_encodeDouble();
  705. sr = srunner_create(s);
  706. srunner_run_all(sr,CK_NORMAL);
  707. number_failed += srunner_ntests_failed(sr);
  708. srunner_free(sr);
  709. s = testSuite_encodeByte();
  710. sr = srunner_create(s);
  711. srunner_run_all(sr,CK_NORMAL);
  712. number_failed += srunner_ntests_failed(sr);
  713. srunner_free(sr);
  714. s = testSuite_encodeUAString();
  715. sr = srunner_create(s);
  716. srunner_run_all(sr,CK_NORMAL);
  717. number_failed += srunner_ntests_failed(sr);
  718. srunner_free(sr);
  719. s = testSuite_decodeUAString();
  720. sr = srunner_create(s);
  721. srunner_run_all(sr,CK_NORMAL);
  722. number_failed += srunner_ntests_failed(sr);
  723. srunner_free(sr);
  724. s = testSuite_diagnosticInfo_calcSize();
  725. sr = srunner_create(s);
  726. srunner_run_all(sr,CK_NORMAL);
  727. number_failed += srunner_ntests_failed(sr);
  728. srunner_free(sr);
  729. s = testSuite_extensionObject_calcSize();
  730. sr = srunner_create(s);
  731. srunner_run_all(sr,CK_NORMAL);
  732. number_failed += srunner_ntests_failed(sr);
  733. srunner_free(sr);
  734. s = testSuite_responseHeader_calcSize();
  735. sr = srunner_create(s);
  736. srunner_run_all(sr,CK_NORMAL);
  737. number_failed += srunner_ntests_failed(sr);
  738. srunner_free(sr);
  739. s = testSuite_encodeDataValue();
  740. sr = srunner_create(s);
  741. srunner_run_all(sr,CK_NORMAL);
  742. number_failed += srunner_ntests_failed(sr);
  743. srunner_free(sr);
  744. /* <TESTSUITE_TEMPLATE>
  745. s = <TESTSUITENAME>;
  746. sr = srunner_create(s);
  747. srunner_run_all(sr,CK_NORMAL);
  748. number_failed += srunner_ntests_failed(sr);
  749. srunner_free(sr);
  750. */
  751. return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
  752. }