check_stack.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095
  1. /*
  2. ============================================================================
  3. Name : check_stack.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. Int32 pos = 0;
  22. UA_ByteString msg;
  23. msg.Data = buf;
  24. msg.Length = 3;
  25. ck_assert_int_eq(TL_getPacketType(&msg, &pos),packetType_CLO);
  26. }
  27. END_TEST
  28. START_TEST(decodeByte_test)
  29. {
  30. AD_RawMessage rawMessage;
  31. Int32 position = 0;
  32. //EncodeByte
  33. char *mem = malloc(sizeof(Byte));
  34. UInt16 Ui16Val;
  35. rawMessage.message = mem;
  36. rawMessage.length = 1;
  37. mem[0] = 0x08;
  38. position = 0;
  39. decoder_decodeBuiltInDatatype(rawMessage.message, BYTE, &position, &Ui16Val);
  40. ck_assert_int_eq(Ui16Val, 0x08);
  41. ck_assert_int_eq(position, 1);
  42. free(mem);
  43. }
  44. END_TEST
  45. START_TEST(encodeByte_test)
  46. {
  47. AD_RawMessage rawMessage;
  48. Int32 position = 0;
  49. //EncodeByte
  50. char *mem = malloc(sizeof(Byte));
  51. rawMessage.message = mem;
  52. Byte testByte = 0x08;
  53. rawMessage.length = 1;
  54. position = 0;
  55. encodeByte(testByte, &position, rawMessage.message);
  56. ck_assert_int_eq(rawMessage.message[0], 0x08);
  57. ck_assert_int_eq(rawMessage.length, 1);
  58. ck_assert_int_eq(position, 1);
  59. free(mem);
  60. }
  61. END_TEST
  62. /*
  63. START_TEST(decodeRequestHeader_test_validParameter)
  64. {
  65. char testMessage = {0x00,0x00,0x72,0xf1,0xdc,0xc9,0x87,0x0b,
  66. 0xcf,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
  67. 0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,
  68. 0x00,0x00,0x00,0x00,0x00};
  69. AD_RawMessage rawMessage;
  70. rawMessage.message = &testMessage;
  71. rawMessage.length = 29;
  72. Int32 position = 0;
  73. T_RequestHeader requestHeader;
  74. decodeRequestHeader(rawMessage,&position,&requestHeader);
  75. ck_assert_int_eq(requestHeader.authenticationToken.EncodingByte,0);
  76. ck_assert_int_eq(requestHeader.returnDiagnostics,0);
  77. ck_assert_int_eq(requestHeader.authenticationToken.EncodingByte,0);
  78. }
  79. END_TEST
  80. */
  81. START_TEST(decodeInt16_test_positives)
  82. {
  83. Int32 p = 0;
  84. Int16 val;
  85. AD_RawMessage rawMessage;
  86. char mem[] = {
  87. 0x00,0x00, // 0
  88. 0x01,0x00, // 1
  89. 0xFF,0x00, // 255
  90. 0x00,0x01, // 256
  91. };
  92. rawMessage.message = mem;
  93. rawMessage.length = sizeof(mem);
  94. ck_assert_int_eq(rawMessage.length,8);
  95. decoder_decodeBuiltInDatatype(rawMessage.message,INT16,&p,&val);
  96. ck_assert_int_eq(val,0);
  97. decoder_decodeBuiltInDatatype(rawMessage.message,INT16,&p,&val);
  98. ck_assert_int_eq(val,1);
  99. decoder_decodeBuiltInDatatype(rawMessage.message,INT16,&p,&val);
  100. ck_assert_int_eq(val,255);
  101. decoder_decodeBuiltInDatatype(rawMessage.message,INT16,&p,&val);
  102. ck_assert_int_eq(val,256);
  103. }
  104. END_TEST
  105. START_TEST(decodeInt16_test_negatives)
  106. {
  107. Int32 p = 0;
  108. Int16 val;
  109. AD_RawMessage rawMessage;
  110. char mem[] = {
  111. 0xFF,0xFF, // -1
  112. 0x00,0x80, // -32768
  113. };
  114. rawMessage.message = mem;
  115. rawMessage.length = sizeof(mem);
  116. ck_assert_int_eq(rawMessage.length,4);
  117. decoder_decodeBuiltInDatatype(rawMessage.message,INT16,&p,&val);
  118. ck_assert_int_eq(val,-1);
  119. decoder_decodeBuiltInDatatype(rawMessage.message,INT16,&p,&val);
  120. ck_assert_int_eq(val,-32768);
  121. }
  122. END_TEST
  123. START_TEST(encodeInt16_test)
  124. {
  125. AD_RawMessage rawMessage;
  126. Int32 position = 0;
  127. //EncodeUInt16
  128. char *mem = malloc(sizeof(UInt16));
  129. rawMessage.message = mem;
  130. UInt16 testUInt16 = 1;
  131. rawMessage.length = 2;
  132. position = 0;
  133. encodeUInt16(testUInt16, &position, rawMessage.message);
  134. //encodeUInt16(testUInt16, &position, &rawMessage);
  135. ck_assert_int_eq(position, 2);
  136. Int32 p = 0;
  137. Int16 val;
  138. decoder_decodeBuiltInDatatype(rawMessage.message, INT16, &p, &val);
  139. ck_assert_int_eq(val,testUInt16);
  140. //ck_assert_int_eq(rawMessage.message[0], 0xAB);
  141. }
  142. END_TEST
  143. START_TEST(decodeUInt16_test)
  144. {
  145. AD_RawMessage rawMessage;
  146. Int32 position = 0;
  147. //EncodeUInt16
  148. char mem[2] = {0x01,0x00};
  149. rawMessage.message = mem;
  150. rawMessage.length = 2;
  151. //encodeUInt16(testUInt16, &position, &rawMessage);
  152. Int32 p = 0;
  153. UInt16 val;
  154. decoder_decodeBuiltInDatatype(rawMessage.message,UINT16,&p,&val);
  155. ck_assert_int_eq(val,1);
  156. //ck_assert_int_eq(p, 2);
  157. //ck_assert_int_eq(rawMessage.message[0], 0xAB);
  158. }
  159. END_TEST
  160. START_TEST(encodeUInt16_test)
  161. {
  162. AD_RawMessage rawMessage;
  163. Int32 position = 0;
  164. //EncodeUInt16
  165. char *mem = malloc(sizeof(UInt16));
  166. rawMessage.message = mem;
  167. UInt16 testUInt16 = 1;
  168. rawMessage.length = 2;
  169. position = 0;
  170. encodeUInt16(testUInt16, &position, rawMessage.message);
  171. //encodeUInt16(testUInt16, &position, &rawMessage);
  172. ck_assert_int_eq(position, 2);
  173. Int32 p = 0;
  174. UInt16 val;
  175. decoder_decodeBuiltInDatatype(rawMessage.message, UINT16, &p, &val);
  176. ck_assert_int_eq(val,testUInt16);
  177. //ck_assert_int_eq(rawMessage.message[0], 0xAB);
  178. }
  179. END_TEST
  180. START_TEST(decodeUInt32_test)
  181. {
  182. AD_RawMessage rawMessage;
  183. Int32 position = 0;
  184. //EncodeUInt16
  185. char mem[4] = {0xFF,0x00,0x00,0x00};
  186. rawMessage.message = mem;
  187. rawMessage.length = 4;
  188. Int32 p = 0;
  189. UInt32 val;
  190. decoder_decodeBuiltInDatatype(rawMessage.message, UINT32, &p, &val);
  191. ck_assert_uint_eq(val,255);
  192. }
  193. END_TEST
  194. START_TEST(encodeUInt32_test)
  195. {
  196. AD_RawMessage rawMessage;
  197. Int32 position = 0;
  198. UInt32 value = 0x0101FF00;
  199. //EncodeUInt16
  200. rawMessage.message = (char*)opcua_malloc(2 * sizeof(UInt32));
  201. rawMessage.length = 8;
  202. Int32 p = 4;
  203. //encodeUInt32(value, &p,rawMessage.message);
  204. encoder_encodeBuiltInDatatype(&value,UINT32,&p,rawMessage.message);
  205. ck_assert_uint_eq((Byte)rawMessage.message[4],0x00);
  206. ck_assert_uint_eq((Byte)rawMessage.message[5],0xFF);
  207. ck_assert_uint_eq((Byte)rawMessage.message[6],0x01);
  208. ck_assert_uint_eq((Byte)rawMessage.message[7],0x01);
  209. ck_assert_int_eq(p,8);
  210. }
  211. END_TEST
  212. START_TEST(decodeInt32_test)
  213. {
  214. AD_RawMessage rawMessage;
  215. Int32 position = 0;
  216. //EncodeUInt16
  217. char mem[4] = {0x00,0xCA,0x9A,0x3B};
  218. rawMessage.message = mem;
  219. rawMessage.length = 4;
  220. Int32 p = 0;
  221. Int32 val;
  222. decoder_decodeBuiltInDatatype(rawMessage.message, INT32, &p, &val);
  223. ck_assert_int_eq(val,1000000000);
  224. }
  225. END_TEST
  226. START_TEST(encodeInt32_test)
  227. {
  228. }
  229. END_TEST
  230. START_TEST(decodeUInt64_test)
  231. {
  232. AD_RawMessage rawMessage;
  233. Int32 position = 0;
  234. UInt64 expectedVal = 0xFF;
  235. expectedVal = expectedVal << 56;
  236. char mem[8] = {00,00,00,00,0x00,0x00,0x00,0xFF};
  237. rawMessage.message = mem;
  238. rawMessage.length = 8;
  239. Int32 p = 0;
  240. UInt64 val;
  241. decoder_decodeBuiltInDatatype(rawMessage.message, UINT64, &p, &val);
  242. ck_assert_uint_eq(val, expectedVal);
  243. }
  244. END_TEST
  245. START_TEST(encodeUInt64_test)
  246. {
  247. AD_RawMessage rawMessage;
  248. Int32 position = 0;
  249. UInt64 value = 0x0101FF00FF00FF00;
  250. //EncodeUInt16
  251. rawMessage.message = (char*)opcua_malloc(sizeof(UInt32));
  252. rawMessage.length = 8;
  253. Int32 p = 0;
  254. encodeUInt64(value, &p,rawMessage.message);
  255. ck_assert_uint_eq((Byte)rawMessage.message[0],0x00);
  256. ck_assert_uint_eq((Byte)rawMessage.message[1],0xFF);
  257. ck_assert_uint_eq((Byte)rawMessage.message[2],0x00);
  258. ck_assert_uint_eq((Byte)rawMessage.message[3],0xFF);
  259. ck_assert_uint_eq((Byte)rawMessage.message[4],0x00);
  260. ck_assert_uint_eq((Byte)rawMessage.message[5],0xFF);
  261. ck_assert_uint_eq((Byte)rawMessage.message[6],0x01);
  262. ck_assert_uint_eq((Byte)rawMessage.message[7],0x01);
  263. }
  264. END_TEST
  265. START_TEST(decodeInt64_test)
  266. {
  267. AD_RawMessage rawMessage;
  268. Int32 position = 0;
  269. Int64 expectedVal = 0xFF;
  270. expectedVal = expectedVal << 56;
  271. char mem[8] = {00,00,00,00,0x00,0x00,0x00,0xFF};
  272. rawMessage.message = mem;
  273. rawMessage.length = 8;
  274. Int32 p = 0;
  275. Int64 val;
  276. decoder_decodeBuiltInDatatype(rawMessage.message, INT64, &p, &val);
  277. ck_assert_uint_eq(val, expectedVal);
  278. }
  279. END_TEST
  280. START_TEST(encodeInt64_test)
  281. {
  282. AD_RawMessage rawMessage;
  283. Int32 position = 0;
  284. UInt64 value = 0x0101FF00FF00FF00;
  285. //EncodeUInt16
  286. rawMessage.message = (char*)opcua_malloc(sizeof(UInt32));
  287. rawMessage.length = 8;
  288. Int32 p = 0;
  289. encodeUInt64(value, &p,rawMessage.message);
  290. ck_assert_uint_eq((Byte)rawMessage.message[0],0x00);
  291. ck_assert_uint_eq((Byte)rawMessage.message[1],0xFF);
  292. ck_assert_uint_eq((Byte)rawMessage.message[2],0x00);
  293. ck_assert_uint_eq((Byte)rawMessage.message[3],0xFF);
  294. ck_assert_uint_eq((Byte)rawMessage.message[4],0x00);
  295. ck_assert_uint_eq((Byte)rawMessage.message[5],0xFF);
  296. ck_assert_uint_eq((Byte)rawMessage.message[6],0x01);
  297. ck_assert_uint_eq((Byte)rawMessage.message[7],0x01);
  298. }
  299. END_TEST
  300. START_TEST(decodeFloat_test)
  301. {
  302. Float expectedValue = -6.5;
  303. Int32 pos = 0;
  304. char buf[4] = {0x00,0x00,0xD0,0xC0};
  305. Float calcVal;
  306. decoder_decodeBuiltInDatatype(buf, FLOAT, &pos, &calcVal);
  307. //val should be -6.5
  308. Int32 val = (calcVal > -6.501 && calcVal < -6.499);
  309. ck_assert_int_gt(val,0);
  310. opcua_free(buf);
  311. }
  312. END_TEST
  313. START_TEST(encodeFloat_test)
  314. {
  315. Float value = -6.5;
  316. Int32 pos = 0;
  317. char *buf = (char*)opcua_malloc(sizeof(Float));
  318. encodeFloat(value,&pos,buf);
  319. ck_assert_uint_eq((Byte)buf[2],0xD0);
  320. ck_assert_uint_eq((Byte)buf[3],0xC0);
  321. opcua_free(buf);
  322. }
  323. END_TEST
  324. START_TEST(decodeDouble_test)
  325. {
  326. }
  327. END_TEST
  328. START_TEST(encodeDouble_test)
  329. {
  330. Float value = -6.5;
  331. Int32 pos = 0;
  332. char *buf = (char*)opcua_malloc(sizeof(Float));
  333. encodeDouble(value,&pos,buf);
  334. ck_assert_uint_eq((Byte)buf[6],0xD0);
  335. ck_assert_uint_eq((Byte)buf[7],0xC0);
  336. opcua_free(buf);
  337. }
  338. END_TEST
  339. START_TEST(encodeUAString_test)
  340. {
  341. Int32 pos = 0;
  342. UA_String string;
  343. Int32 l = 11;
  344. char mem[11] = "ACPLT OPCUA";
  345. char *dstBuf = (char*) malloc(sizeof(Int32)+l);
  346. string.Data = mem;
  347. string.Length = 11;
  348. encodeUAString(&string, &pos, dstBuf);
  349. ck_assert_int_eq(dstBuf[0],11);
  350. ck_assert_int_eq(dstBuf[0+sizeof(Int32)],'A');
  351. }
  352. END_TEST
  353. START_TEST(decodeUAString_test)
  354. {
  355. Int32 pos = 0;
  356. UA_String string;
  357. Int32 l = 11;
  358. char binString[15] = {11,0x00,0x00,0x00,'A','C','P','L','T',' ','U','A'};
  359. char *dstBuf = (char*) malloc(l-sizeof(Int32));
  360. string.Data = dstBuf;
  361. string.Length = 0;
  362. decodeUAString(binString, &pos, &string);
  363. ck_assert_int_eq(string.Length,11);
  364. ck_assert_int_eq(string.Data[3],'L');
  365. }
  366. END_TEST
  367. START_TEST(diagnosticInfo_calcSize_test)
  368. {
  369. Int32 valreal = 0;
  370. Int32 valcalc = 0;
  371. UA_DiagnosticInfo diagnosticInfo;
  372. diagnosticInfo.EncodingMask = 0x01 | 0x02 | 0x04 | 0x08 | 0x10;
  373. diagnosticInfo.SymbolicId = 30;
  374. diagnosticInfo.NamespaceUri = 25;
  375. diagnosticInfo.LocalizedText = 22;
  376. diagnosticInfo.AdditionalInfo.Data = "OPCUA";
  377. diagnosticInfo.AdditionalInfo.Length = 5;
  378. valcalc = diagnosticInfo_calcSize(&diagnosticInfo);
  379. valreal = 26;
  380. ck_assert_int_eq(valcalc,valreal);
  381. }
  382. END_TEST
  383. START_TEST(extensionObject_calcSize_test)
  384. {
  385. Int32 valreal = 0;
  386. Int32 valcalc = 0;
  387. Byte data[3] = {1,2,3};
  388. UA_ExtensionObject extensionObject;
  389. // empty ExtensionObject
  390. valcalc = extensionObject_calcSize(&the_empty_UA_ExtensionObject);
  391. ck_assert_int_eq(valcalc, 1 + 1 + 1);
  392. // empty ExtensionObject, handcoded
  393. extensionObject.TypeId.EncodingByte = NIEVT_TWO_BYTE;
  394. extensionObject.TypeId.Identifier.Numeric = 0;
  395. extensionObject.Encoding = NO_BODY_IS_ENCODED;
  396. valcalc = extensionObject_calcSize(&extensionObject);
  397. ck_assert_int_eq(valcalc, 1 + 1 + 1);
  398. // ExtensionObject with ByteString-Body
  399. extensionObject.Encoding = BODY_IS_BYTE_STRING;
  400. extensionObject.Body.Data = data;
  401. extensionObject.Body.Length = 3;
  402. valcalc = extensionObject_calcSize(&extensionObject);
  403. ck_assert_int_eq(valcalc, 3 + 4 + 3);
  404. }
  405. END_TEST
  406. START_TEST(responseHeader_calcSize_test)
  407. {
  408. UA_AD_ResponseHeader responseHeader;
  409. UA_DiagnosticInfo diagnosticInfo;
  410. UA_ExtensionObject extensionObject;
  411. //Should have the size of 26 Bytes
  412. diagnosticInfo.EncodingMask = DIEMT_SYMBOLIC_ID | DIEMT_NAMESPACE | DIEMT_LOCALIZED_TEXT | DIEMT_LOCALE | DIEMT_ADDITIONAL_INFO; // Byte: 1
  413. // Indices into to Stringtable of the responseHeader (62541-6 §5.5.12 )
  414. diagnosticInfo.SymbolicId = -1; // Int32: 4
  415. diagnosticInfo.NamespaceUri = -1; // Int32: 4
  416. diagnosticInfo.LocalizedText = -1; // Int32: 4
  417. diagnosticInfo.Locale = -1; // Int32: 4
  418. // Additional Info
  419. diagnosticInfo.AdditionalInfo.Length = 5; // Int32: 4
  420. diagnosticInfo.AdditionalInfo.Data = "OPCUA"; // Byte[]: 5
  421. responseHeader.serviceDiagnostics = &diagnosticInfo;
  422. ck_assert_int_eq(diagnosticInfo_calcSize(&diagnosticInfo),1+(4+4+4+4)+(4+5));
  423. responseHeader.noOfStringTable = -1; // Int32: 4
  424. responseHeader.stringTable = NULL;
  425. responseHeader.additionalHeader = &the_empty_UA_ExtensionObject; // 3
  426. ck_assert_int_eq(responseHeader_calcSize(&responseHeader),16+26+4+3);
  427. }
  428. END_TEST
  429. //ToDo: Function needs to be filled
  430. START_TEST(expandedNodeId_calcSize_test)
  431. {
  432. Int32 valreal = 300;
  433. Int32 valcalc = 0;
  434. ck_assert_int_eq(valcalc,valreal);
  435. }
  436. END_TEST
  437. START_TEST(encodeDataValue_test)
  438. {
  439. UA_DataValue dataValue;
  440. Int32 pos = 0;
  441. char *buf = (char*)opcua_malloc(15);
  442. UA_DateTime dateTime;
  443. dateTime = 80;
  444. dataValue.ServerTimestamp = dateTime;
  445. //--without Variant
  446. dataValue.EncodingMask = 0x08; //Only the SourvePicoseconds
  447. encodeDataValue(&dataValue, &pos, buf);
  448. ck_assert_int_eq(pos, 9);// represents the length
  449. ck_assert_int_eq(buf[0], 0x08);
  450. ck_assert_int_eq(buf[1], 80);
  451. ck_assert_int_eq(buf[2], 0);
  452. ck_assert_int_eq(buf[3], 0);
  453. ck_assert_int_eq(buf[4], 0);
  454. ck_assert_int_eq(buf[5], 0);
  455. ck_assert_int_eq(buf[6], 0);
  456. ck_assert_int_eq(buf[7], 0);
  457. ck_assert_int_eq(buf[8], 0);
  458. //TestCase for a DataValue with a Variant!
  459. //ToDo: Need to be checked after the function for encoding variants has been implemented
  460. pos = 0;
  461. dataValue.EncodingMask = 0x01 || 0x08; //Variant & SourvePicoseconds
  462. UA_Variant variant;
  463. variant.ArrayLength = 0;
  464. variant.EncodingMask = VTEMT_INT32;
  465. UA_VariantUnion variantUnion;
  466. //ToDo: needs to be adjusted: variantUnion.Int32 = 45;
  467. fail(); ////ToDo: needs to be adjusted: Just to see that see that this needs to be adjusted
  468. variant.Value = &variantUnion;
  469. dataValue.Value = variant;
  470. encodeDataValue(&dataValue, &pos, buf);
  471. ck_assert_int_eq(pos, 14);// represents the length
  472. ck_assert_int_eq(buf[0], 0x08);
  473. ck_assert_int_eq(buf[1], 0x06);
  474. ck_assert_int_eq(buf[2], 45);
  475. ck_assert_int_eq(buf[3], 0);
  476. ck_assert_int_eq(buf[4], 0);
  477. ck_assert_int_eq(buf[5], 0);
  478. ck_assert_int_eq(buf[6], 80);
  479. ck_assert_int_eq(buf[7], 0);
  480. }
  481. END_TEST
  482. START_TEST(DataValue_calcSize_test)
  483. {
  484. UA_DataValue dataValue;
  485. dataValue.EncodingMask = 0x02 + 0x04 + 0x10;
  486. dataValue.Status = 12;
  487. UA_DateTime dateTime;
  488. dateTime = 80;
  489. dataValue.SourceTimestamp = dateTime;
  490. UA_DateTime sourceTime;
  491. dateTime = 214;
  492. dataValue.SourcePicoseconds = sourceTime;
  493. int size = 0;
  494. size = DataValue_calcSize(&dataValue);
  495. ck_assert_int_eq(size, 21);
  496. }
  497. END_TEST
  498. START_TEST(encoder_encodeBuiltInDatatypeArray_test)
  499. {
  500. Int32 position = 0;
  501. Int32 i;
  502. char vals[9];
  503. char *pVals[9];
  504. //generate data, numbers from 0-9
  505. for(i = 0; i < 9; i++){
  506. vals[i] = i;
  507. pVals[i] = &vals[i];
  508. }
  509. Int32 len = 9;
  510. Int32 ret;
  511. char *mem = malloc(13 * sizeof(Byte));
  512. ret = encoder_encodeBuiltInDatatypeArray((void*)pVals,len, BYTE_ARRAY,
  513. &position, mem);
  514. for(i = 0; i < 9; i++){
  515. ck_assert_int_eq(mem[i+sizeof(Int32)], i);
  516. }
  517. ck_assert_int_eq(position, sizeof(Int32) + 9);
  518. ck_assert_int_eq(ret, UA_NO_ERROR);
  519. free(mem);
  520. }
  521. END_TEST
  522. Suite *testSuite_getPacketType(void)
  523. {
  524. Suite *s = suite_create("getPacketType");
  525. TCase *tc_core = tcase_create("Core");
  526. tcase_add_test(tc_core,test_getPacketType_validParameter);
  527. suite_add_tcase(s,tc_core);
  528. return s;
  529. }
  530. Suite *testSuite_decodeByte(void)
  531. {
  532. Suite *s = suite_create("decodeByte_test");
  533. TCase *tc_core = tcase_create("Core");
  534. tcase_add_test(tc_core, decodeByte_test);
  535. suite_add_tcase(s,tc_core);
  536. return s;
  537. }
  538. Suite *testSuite_encodeByte(void)
  539. {
  540. Suite *s = suite_create("encodeByte_test");
  541. TCase *tc_core = tcase_create("Core");
  542. tcase_add_test(tc_core, encodeByte_test);
  543. suite_add_tcase(s,tc_core);
  544. return s;
  545. }
  546. Suite *testSuite_decodeInt16(void)
  547. {
  548. Suite *s = suite_create("decodeInt16_test");
  549. TCase *tc_core = tcase_create("Core");
  550. tcase_add_test(tc_core, decodeInt16_test_positives);
  551. tcase_add_test(tc_core, decodeInt16_test_negatives);
  552. suite_add_tcase(s,tc_core);
  553. return s;
  554. }
  555. Suite*testSuite_encodeInt16(void)
  556. {
  557. Suite *s = suite_create("encodeInt16_test");
  558. TCase *tc_core = tcase_create("Core");
  559. tcase_add_test(tc_core, encodeInt16_test);
  560. suite_add_tcase(s,tc_core);
  561. return s;
  562. }
  563. Suite *testSuite_decodeUInt16(void)
  564. {
  565. Suite *s = suite_create("decodeUInt16_test");
  566. TCase *tc_core = tcase_create("Core");
  567. tcase_add_test(tc_core, decodeUInt16_test);
  568. suite_add_tcase(s,tc_core);
  569. return s;
  570. }
  571. Suite*testSuite_encodeUInt16(void)
  572. {
  573. Suite *s = suite_create("encodeUInt16_test");
  574. TCase *tc_core = tcase_create("Core");
  575. tcase_add_test(tc_core, encodeUInt16_test);
  576. suite_add_tcase(s,tc_core);
  577. return s;
  578. }
  579. Suite*testSuite_decodeUInt32(void)
  580. {
  581. Suite *s = suite_create("decodeUInt32_test");
  582. TCase *tc_core = tcase_create("Core");
  583. tcase_add_test(tc_core, decodeUInt32_test);
  584. suite_add_tcase(s,tc_core);
  585. return s;
  586. }
  587. Suite*testSuite_encodeUInt32(void)
  588. {
  589. Suite *s = suite_create("encodeUInt32_test");
  590. TCase *tc_core = tcase_create("Core");
  591. tcase_add_test(tc_core, encodeUInt32_test);
  592. suite_add_tcase(s,tc_core);
  593. return s;
  594. }
  595. Suite*testSuite_decodeInt32(void)
  596. {
  597. Suite *s = suite_create("decodeInt32_test");
  598. TCase *tc_core = tcase_create("Core");
  599. tcase_add_test(tc_core, decodeInt32_test);
  600. suite_add_tcase(s,tc_core);
  601. return s;
  602. }
  603. Suite*testSuite_encodeInt32(void)
  604. {
  605. Suite *s = suite_create("encodeInt32_test");
  606. TCase *tc_core = tcase_create("Core");
  607. tcase_add_test(tc_core, encodeInt32_test);
  608. suite_add_tcase(s,tc_core);
  609. return s;
  610. }
  611. Suite*testSuite_decodeUInt64(void)
  612. {
  613. Suite *s = suite_create("decodeUInt64_test");
  614. TCase *tc_core = tcase_create("Core");
  615. tcase_add_test(tc_core, decodeUInt64_test);
  616. suite_add_tcase(s,tc_core);
  617. return s;
  618. }
  619. Suite*testSuite_encodeUInt64(void)
  620. {
  621. Suite *s = suite_create("encodeUInt64_test");
  622. TCase *tc_core = tcase_create("Core");
  623. tcase_add_test(tc_core, encodeUInt64_test);
  624. suite_add_tcase(s,tc_core);
  625. return s;
  626. }
  627. Suite*testSuite_decodeInt64(void)
  628. {
  629. Suite *s = suite_create("decodeInt64_test");
  630. TCase *tc_core = tcase_create("Core");
  631. tcase_add_test(tc_core, decodeInt64_test);
  632. suite_add_tcase(s,tc_core);
  633. return s;
  634. }
  635. Suite*testSuite_encodeInt64(void)
  636. {
  637. Suite *s = suite_create("encodeInt64_test");
  638. TCase *tc_core = tcase_create("Core");
  639. tcase_add_test(tc_core, encodeInt64_test);
  640. suite_add_tcase(s,tc_core);
  641. return s;
  642. }
  643. Suite *testSuite_encodeFloat(void)
  644. {
  645. Suite *s = suite_create("encodeFloat_test");
  646. TCase *tc_core = tcase_create("Core");
  647. tcase_add_test(tc_core, encodeFloat_test);
  648. suite_add_tcase(s,tc_core);
  649. return s;
  650. }
  651. Suite *testSuite_decodeFloat(void)
  652. {
  653. Suite *s = suite_create("decodeFloat_test");
  654. TCase *tc_core = tcase_create("Core");
  655. tcase_add_test(tc_core, decodeFloat_test);
  656. suite_add_tcase(s,tc_core);
  657. return s;
  658. }
  659. Suite *testSuite_encodeDouble(void)
  660. {
  661. Suite *s = suite_create("encodeDouble_test");
  662. TCase *tc_core = tcase_create("Core");
  663. tcase_add_test(tc_core, encodeDouble_test);
  664. suite_add_tcase(s,tc_core);
  665. return s;
  666. }
  667. Suite *testSuite_decodeDouble(void)
  668. {
  669. Suite *s = suite_create("decodeDouble_test");
  670. TCase *tc_core = tcase_create("Core");
  671. tcase_add_test(tc_core, decodeDouble_test);
  672. suite_add_tcase(s,tc_core);
  673. return s;
  674. }
  675. Suite * testSuite_encodeUAString(void)
  676. {
  677. Suite *s = suite_create("encodeUAString_test");
  678. TCase *tc_core = tcase_create("Core");
  679. tcase_add_test(tc_core, encodeUAString_test);
  680. suite_add_tcase(s,tc_core);
  681. return s;
  682. }
  683. Suite * testSuite_decodeUAString(void)
  684. {
  685. Suite *s = suite_create("decodeUAString_test");
  686. TCase *tc_core = tcase_create("Core");
  687. tcase_add_test(tc_core, decodeUAString_test);
  688. suite_add_tcase(s,tc_core);
  689. return s;
  690. }
  691. Suite* testSuite_encodeDataValue()
  692. {
  693. Suite *s = suite_create("encodeDataValue");
  694. TCase *tc_core = tcase_create("Core");
  695. tcase_add_test(tc_core, encodeDataValue_test);
  696. suite_add_tcase(s,tc_core);
  697. return s;
  698. }
  699. Suite* testSuite_expandedNodeId_calcSize(void)
  700. {
  701. Suite *s = suite_create("expandedNodeId_calcSize");
  702. TCase *tc_core = tcase_create("Core");
  703. tcase_add_test(tc_core,expandedNodeId_calcSize_test);
  704. suite_add_tcase(s,tc_core);
  705. return s;
  706. }
  707. /*
  708. Suite* TL_<TESTSUITENAME>(void)
  709. {
  710. Suite *s = suite_create("<TESTSUITENAME>");
  711. TCase *tc_core = tcase_create("Core");
  712. tcase_add_test(tc_core,<TEST_NAME>);
  713. suite_add_tcase(s,tc_core);
  714. return s;
  715. }
  716. */
  717. Suite* testSuite_diagnosticInfo_calcSize()
  718. {
  719. Suite *s = suite_create("diagnosticInfo_calcSize");
  720. TCase *tc_core = tcase_create("Core");
  721. tcase_add_test(tc_core, diagnosticInfo_calcSize_test);
  722. suite_add_tcase(s,tc_core);
  723. return s;
  724. }
  725. Suite* testSuite_extensionObject_calcSize()
  726. {
  727. Suite *s = suite_create("extensionObject_calcSize");
  728. TCase *tc_core = tcase_create("Core");
  729. tcase_add_test(tc_core, extensionObject_calcSize_test);
  730. suite_add_tcase(s,tc_core);
  731. return s;
  732. }
  733. Suite* testSuite_responseHeader_calcSize()
  734. {
  735. Suite *s = suite_create("responseHeader_calcSize");
  736. TCase *tc_core = tcase_create("Core");
  737. tcase_add_test(tc_core, responseHeader_calcSize_test);
  738. suite_add_tcase(s,tc_core);
  739. return s;
  740. }
  741. Suite* testSuite_dataValue_calcSize(void)
  742. {
  743. Suite *s = suite_create("dataValue_calcSize");
  744. TCase *tc_core = tcase_create("Core");
  745. tcase_add_test(tc_core,DataValue_calcSize_test);
  746. suite_add_tcase(s,tc_core);
  747. return s;
  748. }
  749. Suite *testSuite_encoder_encodeBuiltInDatatypeArray_test(void)
  750. {
  751. Suite *s = suite_create("encoder_encodeBuiltInDatatypeArray_test");
  752. TCase *tc_core = tcase_create("Core");
  753. tcase_add_test(tc_core, encoder_encodeBuiltInDatatypeArray_test);
  754. suite_add_tcase(s,tc_core);
  755. return s;
  756. }
  757. int main (void)
  758. {
  759. int number_failed = 0;
  760. Suite *s = testSuite_getPacketType();
  761. SRunner *sr = srunner_create(s);
  762. srunner_run_all(sr,CK_NORMAL);
  763. number_failed = srunner_ntests_failed(sr);
  764. srunner_free(sr);
  765. s = testSuite_encoder_encodeBuiltInDatatypeArray_test();
  766. sr = srunner_create(s);
  767. srunner_run_all(sr,CK_NORMAL);
  768. number_failed += srunner_ntests_failed(sr);
  769. srunner_free(sr);
  770. s = testSuite_decodeByte();
  771. sr = srunner_create(s);
  772. srunner_run_all(sr,CK_NORMAL);
  773. number_failed = srunner_ntests_failed(sr);
  774. srunner_free(sr);
  775. s = testSuite_decodeInt16();
  776. sr = srunner_create(s);
  777. srunner_run_all(sr,CK_NORMAL);
  778. number_failed += srunner_ntests_failed(sr);
  779. srunner_free(sr);
  780. s = testSuite_encodeInt16();
  781. sr = srunner_create(s);
  782. srunner_run_all(sr,CK_NORMAL);
  783. number_failed += srunner_ntests_failed(sr);
  784. srunner_free(sr);
  785. s = testSuite_decodeUInt16();
  786. sr = srunner_create(s);
  787. srunner_run_all(sr,CK_NORMAL);
  788. number_failed += srunner_ntests_failed(sr);
  789. srunner_free(sr);
  790. s = testSuite_encodeUInt16();
  791. sr = srunner_create(s);
  792. srunner_run_all(sr,CK_NORMAL);
  793. number_failed += srunner_ntests_failed(sr);
  794. srunner_free(sr);
  795. s = testSuite_decodeUInt32();
  796. sr = srunner_create(s);
  797. srunner_run_all(sr,CK_NORMAL);
  798. number_failed += srunner_ntests_failed(sr);
  799. srunner_free(sr);
  800. s = testSuite_encodeUInt32();
  801. sr = srunner_create(s);
  802. srunner_run_all(sr,CK_NORMAL);
  803. number_failed += srunner_ntests_failed(sr);
  804. srunner_free(sr);
  805. s = testSuite_decodeInt32();
  806. sr = srunner_create(s);
  807. srunner_run_all(sr,CK_NORMAL);
  808. number_failed += srunner_ntests_failed(sr);
  809. srunner_free(sr);
  810. s = testSuite_encodeInt32();
  811. sr = srunner_create(s);
  812. srunner_run_all(sr,CK_NORMAL);
  813. number_failed += srunner_ntests_failed(sr);
  814. srunner_free(sr);
  815. s = testSuite_decodeUInt64();
  816. sr = srunner_create(s);
  817. srunner_run_all(sr,CK_NORMAL);
  818. number_failed += srunner_ntests_failed(sr);
  819. srunner_free(sr);
  820. s = testSuite_encodeUInt64();
  821. sr = srunner_create(s);
  822. srunner_run_all(sr,CK_NORMAL);
  823. number_failed += srunner_ntests_failed(sr);
  824. srunner_free(sr);
  825. s = testSuite_decodeInt64();
  826. sr = srunner_create(s);
  827. srunner_run_all(sr,CK_NORMAL);
  828. number_failed += srunner_ntests_failed(sr);
  829. srunner_free(sr);
  830. s = testSuite_encodeInt64();
  831. sr = srunner_create(s);
  832. srunner_run_all(sr,CK_NORMAL);
  833. number_failed += srunner_ntests_failed(sr);
  834. srunner_free(sr);
  835. s = testSuite_encodeFloat();
  836. sr = srunner_create(s);
  837. srunner_run_all(sr,CK_NORMAL);
  838. number_failed += srunner_ntests_failed(sr);
  839. srunner_free(sr);
  840. s = testSuite_encodeDouble();
  841. sr = srunner_create(s);
  842. srunner_run_all(sr,CK_NORMAL);
  843. number_failed += srunner_ntests_failed(sr);
  844. srunner_free(sr);
  845. s = testSuite_encodeByte();
  846. sr = srunner_create(s);
  847. srunner_run_all(sr,CK_NORMAL);
  848. number_failed += srunner_ntests_failed(sr);
  849. srunner_free(sr);
  850. s = testSuite_encodeUAString();
  851. sr = srunner_create(s);
  852. srunner_run_all(sr,CK_NORMAL);
  853. number_failed += srunner_ntests_failed(sr);
  854. srunner_free(sr);
  855. s = testSuite_decodeUAString();
  856. sr = srunner_create(s);
  857. srunner_run_all(sr,CK_NORMAL);
  858. number_failed += srunner_ntests_failed(sr);
  859. srunner_free(sr);
  860. s = testSuite_diagnosticInfo_calcSize();
  861. sr = srunner_create(s);
  862. srunner_run_all(sr,CK_NORMAL);
  863. number_failed += srunner_ntests_failed(sr);
  864. srunner_free(sr);
  865. s = testSuite_extensionObject_calcSize();
  866. sr = srunner_create(s);
  867. srunner_run_all(sr,CK_NORMAL);
  868. number_failed += srunner_ntests_failed(sr);
  869. srunner_free(sr);
  870. s = testSuite_responseHeader_calcSize();
  871. sr = srunner_create(s);
  872. srunner_run_all(sr,CK_NORMAL);
  873. number_failed += srunner_ntests_failed(sr);
  874. srunner_free(sr);
  875. s = testSuite_encodeDataValue();
  876. sr = srunner_create(s);
  877. srunner_run_all(sr,CK_NORMAL);
  878. number_failed += srunner_ntests_failed(sr);
  879. srunner_free(sr);
  880. s = testSuite_expandedNodeId_calcSize();
  881. sr = srunner_create(s);
  882. srunner_run_all(sr,CK_NORMAL);
  883. number_failed += srunner_ntests_failed(sr);
  884. srunner_free(sr);
  885. s = testSuite_dataValue_calcSize();
  886. sr = srunner_create(s);
  887. srunner_run_all(sr,CK_NORMAL);
  888. number_failed += srunner_ntests_failed(sr);
  889. srunner_free(sr);
  890. /* <TESTSUITE_TEMPLATE>
  891. s = <TESTSUITENAME>;
  892. sr = srunner_create(s);
  893. srunner_run_all(sr,CK_NORMAL);
  894. number_failed += srunner_ntests_failed(sr);
  895. srunner_free(sr);
  896. */
  897. return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
  898. }