check_stack.c 25 KB

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