check_stack.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090
  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. char input = {1,2,3,4,5,6,7,8,9};
  502. Int32 len = 9;
  503. Int32 ret;
  504. char *mem = malloc(13 * sizeof(Byte));
  505. ret = encoder_encodeBuiltInDatatypeArray((void*)input,len, BYTE_ARRAY,
  506. &position, mem);
  507. ck_assert_int_eq(mem[4], 0x01);
  508. ck_assert_int_eq(mem[5], 0x02);
  509. ck_assert_int_eq(mem[6], 0x03);
  510. ck_assert_int_eq(mem[7], 0x04);
  511. ck_assert_int_eq(mem[8], 0x05);
  512. ck_assert_int_eq(mem[9], 0x06);
  513. ck_assert_int_eq(mem[10], 0x07);
  514. ck_assert_int_eq(mem[11], 0x08);
  515. ck_assert_int_eq(mem[12], 0x09);
  516. ck_assert_int_eq(position, sizeof(Int32) + 9);
  517. ck_assert_int_eq(ret, UA_NO_ERROR);
  518. free(mem);
  519. }
  520. END_TEST
  521. Suite *testSuite_getPacketType(void)
  522. {
  523. Suite *s = suite_create("getPacketType");
  524. TCase *tc_core = tcase_create("Core");
  525. tcase_add_test(tc_core,test_getPacketType_validParameter);
  526. suite_add_tcase(s,tc_core);
  527. return s;
  528. }
  529. Suite *testSuite_decodeByte(void)
  530. {
  531. Suite *s = suite_create("decodeByte_test");
  532. TCase *tc_core = tcase_create("Core");
  533. tcase_add_test(tc_core, decodeByte_test);
  534. suite_add_tcase(s,tc_core);
  535. return s;
  536. }
  537. Suite *testSuite_encodeByte(void)
  538. {
  539. Suite *s = suite_create("encodeByte_test");
  540. TCase *tc_core = tcase_create("Core");
  541. tcase_add_test(tc_core, encodeByte_test);
  542. suite_add_tcase(s,tc_core);
  543. return s;
  544. }
  545. Suite *testSuite_decodeInt16(void)
  546. {
  547. Suite *s = suite_create("decodeInt16_test");
  548. TCase *tc_core = tcase_create("Core");
  549. tcase_add_test(tc_core, decodeInt16_test_positives);
  550. tcase_add_test(tc_core, decodeInt16_test_negatives);
  551. suite_add_tcase(s,tc_core);
  552. return s;
  553. }
  554. Suite*testSuite_encodeInt16(void)
  555. {
  556. Suite *s = suite_create("encodeInt16_test");
  557. TCase *tc_core = tcase_create("Core");
  558. tcase_add_test(tc_core, encodeInt16_test);
  559. suite_add_tcase(s,tc_core);
  560. return s;
  561. }
  562. Suite *testSuite_decodeUInt16(void)
  563. {
  564. Suite *s = suite_create("decodeUInt16_test");
  565. TCase *tc_core = tcase_create("Core");
  566. tcase_add_test(tc_core, decodeUInt16_test);
  567. suite_add_tcase(s,tc_core);
  568. return s;
  569. }
  570. Suite*testSuite_encodeUInt16(void)
  571. {
  572. Suite *s = suite_create("encodeUInt16_test");
  573. TCase *tc_core = tcase_create("Core");
  574. tcase_add_test(tc_core, encodeUInt16_test);
  575. suite_add_tcase(s,tc_core);
  576. return s;
  577. }
  578. Suite*testSuite_decodeUInt32(void)
  579. {
  580. Suite *s = suite_create("decodeUInt32_test");
  581. TCase *tc_core = tcase_create("Core");
  582. tcase_add_test(tc_core, decodeUInt32_test);
  583. suite_add_tcase(s,tc_core);
  584. return s;
  585. }
  586. Suite*testSuite_encodeUInt32(void)
  587. {
  588. Suite *s = suite_create("encodeUInt32_test");
  589. TCase *tc_core = tcase_create("Core");
  590. tcase_add_test(tc_core, encodeUInt32_test);
  591. suite_add_tcase(s,tc_core);
  592. return s;
  593. }
  594. Suite*testSuite_decodeInt32(void)
  595. {
  596. Suite *s = suite_create("decodeInt32_test");
  597. TCase *tc_core = tcase_create("Core");
  598. tcase_add_test(tc_core, decodeInt32_test);
  599. suite_add_tcase(s,tc_core);
  600. return s;
  601. }
  602. Suite*testSuite_encodeInt32(void)
  603. {
  604. Suite *s = suite_create("encodeInt32_test");
  605. TCase *tc_core = tcase_create("Core");
  606. tcase_add_test(tc_core, encodeInt32_test);
  607. suite_add_tcase(s,tc_core);
  608. return s;
  609. }
  610. Suite*testSuite_decodeUInt64(void)
  611. {
  612. Suite *s = suite_create("decodeUInt64_test");
  613. TCase *tc_core = tcase_create("Core");
  614. tcase_add_test(tc_core, decodeUInt64_test);
  615. suite_add_tcase(s,tc_core);
  616. return s;
  617. }
  618. Suite*testSuite_encodeUInt64(void)
  619. {
  620. Suite *s = suite_create("encodeUInt64_test");
  621. TCase *tc_core = tcase_create("Core");
  622. tcase_add_test(tc_core, encodeUInt64_test);
  623. suite_add_tcase(s,tc_core);
  624. return s;
  625. }
  626. Suite*testSuite_decodeInt64(void)
  627. {
  628. Suite *s = suite_create("decodeInt64_test");
  629. TCase *tc_core = tcase_create("Core");
  630. tcase_add_test(tc_core, decodeInt64_test);
  631. suite_add_tcase(s,tc_core);
  632. return s;
  633. }
  634. Suite*testSuite_encodeInt64(void)
  635. {
  636. Suite *s = suite_create("encodeInt64_test");
  637. TCase *tc_core = tcase_create("Core");
  638. tcase_add_test(tc_core, encodeInt64_test);
  639. suite_add_tcase(s,tc_core);
  640. return s;
  641. }
  642. Suite *testSuite_encodeFloat(void)
  643. {
  644. Suite *s = suite_create("encodeFloat_test");
  645. TCase *tc_core = tcase_create("Core");
  646. tcase_add_test(tc_core, encodeFloat_test);
  647. suite_add_tcase(s,tc_core);
  648. return s;
  649. }
  650. Suite *testSuite_decodeFloat(void)
  651. {
  652. Suite *s = suite_create("decodeFloat_test");
  653. TCase *tc_core = tcase_create("Core");
  654. tcase_add_test(tc_core, decodeFloat_test);
  655. suite_add_tcase(s,tc_core);
  656. return s;
  657. }
  658. Suite *testSuite_encodeDouble(void)
  659. {
  660. Suite *s = suite_create("encodeDouble_test");
  661. TCase *tc_core = tcase_create("Core");
  662. tcase_add_test(tc_core, encodeDouble_test);
  663. suite_add_tcase(s,tc_core);
  664. return s;
  665. }
  666. Suite *testSuite_decodeDouble(void)
  667. {
  668. Suite *s = suite_create("decodeDouble_test");
  669. TCase *tc_core = tcase_create("Core");
  670. tcase_add_test(tc_core, decodeDouble_test);
  671. suite_add_tcase(s,tc_core);
  672. return s;
  673. }
  674. Suite * testSuite_encodeUAString(void)
  675. {
  676. Suite *s = suite_create("encodeUAString_test");
  677. TCase *tc_core = tcase_create("Core");
  678. tcase_add_test(tc_core, encodeUAString_test);
  679. suite_add_tcase(s,tc_core);
  680. return s;
  681. }
  682. Suite * testSuite_decodeUAString(void)
  683. {
  684. Suite *s = suite_create("decodeUAString_test");
  685. TCase *tc_core = tcase_create("Core");
  686. tcase_add_test(tc_core, decodeUAString_test);
  687. suite_add_tcase(s,tc_core);
  688. return s;
  689. }
  690. Suite* testSuite_encodeDataValue()
  691. {
  692. Suite *s = suite_create("encodeDataValue");
  693. TCase *tc_core = tcase_create("Core");
  694. tcase_add_test(tc_core, encodeDataValue_test);
  695. suite_add_tcase(s,tc_core);
  696. return s;
  697. }
  698. Suite* testSuite_expandedNodeId_calcSize(void)
  699. {
  700. Suite *s = suite_create("expandedNodeId_calcSize");
  701. TCase *tc_core = tcase_create("Core");
  702. tcase_add_test(tc_core,expandedNodeId_calcSize_test);
  703. suite_add_tcase(s,tc_core);
  704. return s;
  705. }
  706. /*
  707. Suite* TL_<TESTSUITENAME>(void)
  708. {
  709. Suite *s = suite_create("<TESTSUITENAME>");
  710. TCase *tc_core = tcase_create("Core");
  711. tcase_add_test(tc_core,<TEST_NAME>);
  712. suite_add_tcase(s,tc_core);
  713. return s;
  714. }
  715. */
  716. Suite* testSuite_diagnosticInfo_calcSize()
  717. {
  718. Suite *s = suite_create("diagnosticInfo_calcSize");
  719. TCase *tc_core = tcase_create("Core");
  720. tcase_add_test(tc_core, diagnosticInfo_calcSize_test);
  721. suite_add_tcase(s,tc_core);
  722. return s;
  723. }
  724. Suite* testSuite_extensionObject_calcSize()
  725. {
  726. Suite *s = suite_create("extensionObject_calcSize");
  727. TCase *tc_core = tcase_create("Core");
  728. tcase_add_test(tc_core, extensionObject_calcSize_test);
  729. suite_add_tcase(s,tc_core);
  730. return s;
  731. }
  732. Suite* testSuite_responseHeader_calcSize()
  733. {
  734. Suite *s = suite_create("responseHeader_calcSize");
  735. TCase *tc_core = tcase_create("Core");
  736. tcase_add_test(tc_core, responseHeader_calcSize_test);
  737. suite_add_tcase(s,tc_core);
  738. return s;
  739. }
  740. Suite* testSuite_dataValue_calcSize(void)
  741. {
  742. Suite *s = suite_create("dataValue_calcSize");
  743. TCase *tc_core = tcase_create("Core");
  744. tcase_add_test(tc_core,DataValue_calcSize_test);
  745. suite_add_tcase(s,tc_core);
  746. return s;
  747. }
  748. Suite *testSuite_encoder_encodeBuiltInDatatypeArray_test(void)
  749. {
  750. Suite *s = suite_create("encoder_encodeBuiltInDatatypeArray_test");
  751. TCase *tc_core = tcase_create("Core");
  752. tcase_add_test(tc_core, encoder_encodeBuiltInDatatypeArray_test);
  753. suite_add_tcase(s,tc_core);
  754. return s;
  755. }
  756. int main (void)
  757. {
  758. int number_failed = 0;
  759. Suite *s = testSuite_getPacketType();
  760. SRunner *sr = srunner_create(s);
  761. srunner_run_all(sr,CK_NORMAL);
  762. number_failed = srunner_ntests_failed(sr);
  763. srunner_free(sr);
  764. s = testSuite_encoder_encodeBuiltInDatatypeArray_test();
  765. sr = srunner_create(s);
  766. srunner_run_all(sr,CK_NORMAL);
  767. number_failed += srunner_ntests_failed(sr);
  768. srunner_free(sr);
  769. s = testSuite_decodeByte();
  770. sr = srunner_create(s);
  771. srunner_run_all(sr,CK_NORMAL);
  772. number_failed = srunner_ntests_failed(sr);
  773. srunner_free(sr);
  774. s = testSuite_decodeInt16();
  775. sr = srunner_create(s);
  776. srunner_run_all(sr,CK_NORMAL);
  777. number_failed += srunner_ntests_failed(sr);
  778. srunner_free(sr);
  779. s = testSuite_encodeInt16();
  780. sr = srunner_create(s);
  781. srunner_run_all(sr,CK_NORMAL);
  782. number_failed += srunner_ntests_failed(sr);
  783. srunner_free(sr);
  784. s = testSuite_decodeUInt16();
  785. sr = srunner_create(s);
  786. srunner_run_all(sr,CK_NORMAL);
  787. number_failed += srunner_ntests_failed(sr);
  788. srunner_free(sr);
  789. s = testSuite_encodeUInt16();
  790. sr = srunner_create(s);
  791. srunner_run_all(sr,CK_NORMAL);
  792. number_failed += srunner_ntests_failed(sr);
  793. srunner_free(sr);
  794. s = testSuite_decodeUInt32();
  795. sr = srunner_create(s);
  796. srunner_run_all(sr,CK_NORMAL);
  797. number_failed += srunner_ntests_failed(sr);
  798. srunner_free(sr);
  799. s = testSuite_encodeUInt32();
  800. sr = srunner_create(s);
  801. srunner_run_all(sr,CK_NORMAL);
  802. number_failed += srunner_ntests_failed(sr);
  803. srunner_free(sr);
  804. s = testSuite_decodeInt32();
  805. sr = srunner_create(s);
  806. srunner_run_all(sr,CK_NORMAL);
  807. number_failed += srunner_ntests_failed(sr);
  808. srunner_free(sr);
  809. s = testSuite_encodeInt32();
  810. sr = srunner_create(s);
  811. srunner_run_all(sr,CK_NORMAL);
  812. number_failed += srunner_ntests_failed(sr);
  813. srunner_free(sr);
  814. s = testSuite_decodeUInt64();
  815. sr = srunner_create(s);
  816. srunner_run_all(sr,CK_NORMAL);
  817. number_failed += srunner_ntests_failed(sr);
  818. srunner_free(sr);
  819. s = testSuite_encodeUInt64();
  820. sr = srunner_create(s);
  821. srunner_run_all(sr,CK_NORMAL);
  822. number_failed += srunner_ntests_failed(sr);
  823. srunner_free(sr);
  824. s = testSuite_decodeInt64();
  825. sr = srunner_create(s);
  826. srunner_run_all(sr,CK_NORMAL);
  827. number_failed += srunner_ntests_failed(sr);
  828. srunner_free(sr);
  829. s = testSuite_encodeInt64();
  830. sr = srunner_create(s);
  831. srunner_run_all(sr,CK_NORMAL);
  832. number_failed += srunner_ntests_failed(sr);
  833. srunner_free(sr);
  834. s = testSuite_encodeFloat();
  835. sr = srunner_create(s);
  836. srunner_run_all(sr,CK_NORMAL);
  837. number_failed += srunner_ntests_failed(sr);
  838. srunner_free(sr);
  839. s = testSuite_encodeDouble();
  840. sr = srunner_create(s);
  841. srunner_run_all(sr,CK_NORMAL);
  842. number_failed += srunner_ntests_failed(sr);
  843. srunner_free(sr);
  844. s = testSuite_encodeByte();
  845. sr = srunner_create(s);
  846. srunner_run_all(sr,CK_NORMAL);
  847. number_failed += srunner_ntests_failed(sr);
  848. srunner_free(sr);
  849. s = testSuite_encodeUAString();
  850. sr = srunner_create(s);
  851. srunner_run_all(sr,CK_NORMAL);
  852. number_failed += srunner_ntests_failed(sr);
  853. srunner_free(sr);
  854. s = testSuite_decodeUAString();
  855. sr = srunner_create(s);
  856. srunner_run_all(sr,CK_NORMAL);
  857. number_failed += srunner_ntests_failed(sr);
  858. srunner_free(sr);
  859. s = testSuite_diagnosticInfo_calcSize();
  860. sr = srunner_create(s);
  861. srunner_run_all(sr,CK_NORMAL);
  862. number_failed += srunner_ntests_failed(sr);
  863. srunner_free(sr);
  864. s = testSuite_extensionObject_calcSize();
  865. sr = srunner_create(s);
  866. srunner_run_all(sr,CK_NORMAL);
  867. number_failed += srunner_ntests_failed(sr);
  868. srunner_free(sr);
  869. s = testSuite_responseHeader_calcSize();
  870. sr = srunner_create(s);
  871. srunner_run_all(sr,CK_NORMAL);
  872. number_failed += srunner_ntests_failed(sr);
  873. srunner_free(sr);
  874. s = testSuite_encodeDataValue();
  875. sr = srunner_create(s);
  876. srunner_run_all(sr,CK_NORMAL);
  877. number_failed += srunner_ntests_failed(sr);
  878. srunner_free(sr);
  879. s = testSuite_expandedNodeId_calcSize();
  880. sr = srunner_create(s);
  881. srunner_run_all(sr,CK_NORMAL);
  882. number_failed += srunner_ntests_failed(sr);
  883. srunner_free(sr);
  884. s = testSuite_dataValue_calcSize();
  885. sr = srunner_create(s);
  886. srunner_run_all(sr,CK_NORMAL);
  887. number_failed += srunner_ntests_failed(sr);
  888. srunner_free(sr);
  889. /* <TESTSUITE_TEMPLATE>
  890. s = <TESTSUITENAME>;
  891. sr = srunner_create(s);
  892. srunner_run_all(sr,CK_NORMAL);
  893. number_failed += srunner_ntests_failed(sr);
  894. srunner_free(sr);
  895. */
  896. return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
  897. }