binary_serialize_variant.cpp
Go to the documentation of this file.
1 
11 #include "common.h"
12 
13 #include <opc/ua/protocol/extension_identifiers.h>
14 #include <opc/ua/protocol/message_identifiers.h>
15 #include <opc/ua/protocol/binary/stream.h>
16 #include <opc/ua/protocol/data_value.h>
17 #include <opc/ua/protocol/types.h>
18 #include <opc/ua/protocol/variant.h>
19 
20 #include <algorithm>
21 #include <stdexcept>
22 
23 //-------------------------------------------------------
24 // Serialization
25 //-------------------------------------------------------
26 
27 TEST_F(OpcUaBinarySerialization, Variant_NUL)
28 {
29 
30  using namespace OpcUa;
31  using namespace OpcUa::Binary;
32 
33  Variant var;
34 
35  GetStream() << var << flush;
36 
37  const std::vector<char> expectedData =
38  {
39  0
40  };
41 
42  ASSERT_EQ(expectedData.size(), RawSize(var));
43  ASSERT_EQ(expectedData, GetChannel().SerializedData) << PrintData(GetChannel().SerializedData) << std::endl << PrintData(expectedData);
44 }
45 
46 TEST_F(OpcUaBinarySerialization, Variant_BOOLEAN)
47 {
48 
49  using namespace OpcUa;
50  using namespace OpcUa::Binary;
51 
52  Variant var = true;
53 
54  GetStream() << var << flush;
55 
56  char encodingMask = static_cast<uint8_t>(VariantType::BOOLEAN);
57  const std::vector<char> expectedData =
58  {
59  encodingMask,
60  1
61  };
62 
63  ASSERT_EQ(expectedData.size(), RawSize(var));
64  ASSERT_EQ(expectedData, GetChannel().SerializedData) << PrintData(GetChannel().SerializedData) << std::endl << PrintData(expectedData);
65 }
66 
67 TEST_F(OpcUaBinarySerialization, Variant_BOOLEAN_Array)
68 {
69 
70  using namespace OpcUa;
71  using namespace OpcUa::Binary;
72 
73  Variant var = std::vector<bool> {true, true};
74 
75  GetStream() << var << flush;
76 
77  char encodingMask = static_cast<uint8_t>(VariantType::BOOLEAN) | HAS_ARRAY_MASK;
78  const std::vector<char> expectedData =
79  {
80  encodingMask,
81  2, 0, 0, 0,
82  1,
83  1
84  };
85 
86  ASSERT_EQ(expectedData.size(), RawSize(var));
87  ASSERT_EQ(expectedData, GetChannel().SerializedData) << PrintData(GetChannel().SerializedData) << std::endl << PrintData(expectedData);
88 }
89 
90 
91 TEST_F(OpcUaBinarySerialization, Variant_BOOLEAN_DIMENSIONS)
92 {
93 
94  using namespace OpcUa;
95  using namespace OpcUa::Binary;
96 
97  Variant var = true;
98  var.Dimensions.push_back(1);
99 
100  GetStream() << var << flush;
101 
102  char encodingMask = static_cast<uint8_t>(VariantType::BOOLEAN) | HAS_DIMENSIONS_MASK;
103  const std::vector<char> expectedData =
104  {
105  encodingMask,
106  1,
107  1, 0, 0, 0,
108  1, 0, 0, 0
109  };
110 
111  ASSERT_EQ(expectedData.size(), RawSize(var));
112  ASSERT_EQ(expectedData, GetChannel().SerializedData) << PrintData(GetChannel().SerializedData) << std::endl << PrintData(expectedData);
113 }
114 
115 
116 //-------------------------------------------------------
117 // Deserialization
118 //-------------------------------------------------------
119 
120 TEST_F(OpcUaBinaryDeserialization, Variant_NUL)
121 {
122  using namespace OpcUa;
123  using namespace OpcUa::Binary;
124 
125  const std::vector<char> expectedData =
126  {
127  0
128  };
129 
130  GetChannel().SetData(expectedData);
131 
132  Variant var;
133  GetStream() >> var;
134 
135  ASSERT_EQ(var.Type(), VariantType::NUL);
136  ASSERT_TRUE(var.IsNul());
137  ASSERT_FALSE(var.IsArray());
138 }
139 
140 TEST_F(OpcUaBinaryDeserialization, Variant_BOOLEAN)
141 {
142  using namespace OpcUa;
143  using namespace OpcUa::Binary;
144 
145  char encodingMask = static_cast<uint8_t>(VariantType::BOOLEAN);
146 
147  const std::vector<char> expectedData =
148  {
149  encodingMask,
150  1
151  };
152 
153  GetChannel().SetData(expectedData);
154 
155  Variant var;
156  GetStream() >> var;
157 
158  ASSERT_EQ(var.Type(), VariantType::BOOLEAN);
159  ASSERT_TRUE(var.As<bool>());
160  ASSERT_FALSE(var.IsNul());
161  ASSERT_FALSE(var.IsArray());
162 }
163 
164 TEST_F(OpcUaBinaryDeserialization, Variant_BOOLEAN_Array)
165 {
166  using namespace OpcUa;
167  using namespace OpcUa::Binary;
168 
169  char encodingMask = static_cast<uint8_t>(VariantType::BOOLEAN) | HAS_ARRAY_MASK;
170 
171  const std::vector<char> expectedData =
172  {
173  encodingMask,
174  2, 0, 0, 0,
175  1,
176  1
177  };
178 
179  GetChannel().SetData(expectedData);
180 
181  Variant var;
182  GetStream() >> var;
183 
184  ASSERT_EQ(var.Type(), VariantType::BOOLEAN);
185  std::vector<bool> vals;
186  ASSERT_NO_THROW(vals = var.As<std::vector<bool>>());
187  ASSERT_EQ(vals.size(), 2);
188  ASSERT_EQ(vals[0], true);
189  ASSERT_EQ(vals[1], true);
190  ASSERT_FALSE(var.IsNul());
191  ASSERT_TRUE(var.IsArray());
192 }
193 
194 
195 TEST_F(OpcUaBinaryDeserialization, Variant_BOOLEAN_DIMENSIONS)
196 {
197  using namespace OpcUa;
198  using namespace OpcUa::Binary;
199 
200  char encodingMask = static_cast<uint8_t>(VariantType::BOOLEAN) | HAS_DIMENSIONS_MASK;
201 
202  const std::vector<char> expectedData =
203  {
204  encodingMask,
205  1,
206  1, 0, 0, 0,
207  1, 0, 0, 0,
208  };
209 
210  GetChannel().SetData(expectedData);
211 
212  Variant var;
213  GetStream() >> var;
214 
215  ASSERT_EQ(var.Type(), VariantType::BOOLEAN);
216  ASSERT_TRUE(var.As<bool>());
217  ASSERT_FALSE(var.IsNul());
218  ASSERT_FALSE(var.IsArray());
219 }
221 TEST_F(OpcUaBinaryDeserialization, Variant_BYTE)
222 {
223  using namespace OpcUa;
224  using namespace OpcUa::Binary;
225 
226  char encodingMask = static_cast<char>(VariantType::BYTE);
227 
228  const std::vector<char> expectedData =
229  {
230  encodingMask,
231  (char)200
232  };
233 
234  GetChannel().SetData(expectedData);
235 
236  Variant var;
237  GetStream() >> var;
238 
239  ASSERT_EQ(var.Type(), VariantType::BYTE);
240  ASSERT_EQ(var.As<uint8_t>(), 200);
241  ASSERT_FALSE(var.IsNul());
242  ASSERT_FALSE(var.IsArray());
243 }
244 
245 TEST_F(OpcUaBinaryDeserialization, Variant_BYTE_Array)
246 {
247  using namespace OpcUa;
248  using namespace OpcUa::Binary;
249 
250  char encodingMask = static_cast<uint8_t>(VariantType::BYTE) | HAS_ARRAY_MASK;
251 
252  const std::vector<char> expectedData =
253  {
254  encodingMask,
255  2, 0, 0, 0,
256  (char)200,
257  (char)201
258  };
259 
260  GetChannel().SetData(expectedData);
261 
262  Variant var;
263  GetStream() >> var;
264 
265  ASSERT_EQ(var.Type(), VariantType::BYTE);
266  std::vector<uint8_t> vals;
267  ASSERT_NO_THROW(vals = var.As<std::vector<uint8_t>>());
268  ASSERT_EQ(vals.size(), 2);
269  ASSERT_EQ(vals[0], 200);
270  ASSERT_EQ(vals[1], 201);
271  ASSERT_FALSE(var.IsNul());
272  ASSERT_TRUE(var.IsArray());
273  ASSERT_TRUE(var.Dimensions.empty());
274 }
275 
276 
277 TEST_F(OpcUaBinaryDeserialization, Variant_BYTE_DIMENSIONS)
278 {
279  using namespace OpcUa;
280  using namespace OpcUa::Binary;
281 
282  char encodingMask = static_cast<uint8_t>(VariantType::BYTE) | HAS_DIMENSIONS_MASK;
283 
284  const std::vector<char> expectedData =
285  {
286  encodingMask,
287  (char)200,
288  2, 0, 0, 0,
289  2, 0, 0, 0,
290  3, 0, 0, 0,
291  };
292 
293  GetChannel().SetData(expectedData);
294 
295  Variant var;
296  GetStream() >> var;
297 
298  ASSERT_EQ(var.Type(), VariantType::BYTE);
299  ASSERT_EQ(var.As<uint8_t>(), 200);
300  ASSERT_FALSE(var.IsNul());
301  ASSERT_FALSE(var.IsArray());
302  ASSERT_EQ(var.Dimensions.size(), 2);
303  ASSERT_EQ(var.Dimensions[0], 2);
304  ASSERT_EQ(var.Dimensions[1], 3);
305 }
307 TEST_F(OpcUaBinaryDeserialization, Variant_SBYTE)
308 {
309  using namespace OpcUa;
310  using namespace OpcUa::Binary;
311 
312  char encodingMask = static_cast<char>(VariantType::SBYTE);
313 
314  const std::vector<char> expectedData =
315  {
316  encodingMask,
317  (char) - 5
318  };
319 
320  GetChannel().SetData(expectedData);
321 
322  Variant var;
323  GetStream() >> var;
324 
325  ASSERT_EQ(var.Type(), VariantType::SBYTE);
326  ASSERT_EQ(var.As<int8_t>(), -5);
327  ASSERT_FALSE(var.IsNul());
328  ASSERT_FALSE(var.IsArray());
329 }
330 
331 TEST_F(OpcUaBinaryDeserialization, Variant_SBYTE_Array)
332 {
333  using namespace OpcUa;
334  using namespace OpcUa::Binary;
335 
336  char encodingMask = static_cast<uint8_t>(VariantType::SBYTE) | HAS_ARRAY_MASK;
337 
338  const std::vector<char> expectedData =
339  {
340  encodingMask,
341  2, 0, 0, 0,
342  -2,
343  -3
344  };
345 
346  GetChannel().SetData(expectedData);
347 
348  Variant var;
349  GetStream() >> var;
350 
351  ASSERT_EQ(var.Type(), VariantType::SBYTE);
352  std::vector<int8_t> vals;
353  ASSERT_NO_THROW(vals = var.As<std::vector<int8_t>>());
354  ASSERT_EQ(vals.size(), 2);
355  ASSERT_EQ(vals[0], -2);
356  ASSERT_EQ(vals[1], -3);
357  ASSERT_FALSE(var.IsNul());
358  ASSERT_TRUE(var.IsArray());
359  ASSERT_TRUE(var.Dimensions.empty());
360 }
361 
362 
363 TEST_F(OpcUaBinaryDeserialization, Variant_SBYTE_DIMENSIONS)
364 {
365  using namespace OpcUa;
366  using namespace OpcUa::Binary;
367 
368  char encodingMask = static_cast<uint8_t>(VariantType::SBYTE) | HAS_DIMENSIONS_MASK;
369 
370  const std::vector<char> expectedData =
371  {
372  encodingMask,
373  -5,
374  1, 0, 0, 0,
375  1, 0, 0, 0,
376  };
377 
378  GetChannel().SetData(expectedData);
379 
380  Variant var;
381  GetStream() >> var;
382 
383  ASSERT_EQ(var.Type(), VariantType::SBYTE);
384  ASSERT_EQ(var.As<int8_t>(), -5);
385  ASSERT_FALSE(var.IsNul());
386  ASSERT_FALSE(var.IsArray());
387 }
388 
390 TEST_F(OpcUaBinaryDeserialization, Variant_INT16)
391 {
392  using namespace OpcUa;
393  using namespace OpcUa::Binary;
394 
395  char encodingMask = static_cast<char>(VariantType::INT16);
396 
397  const std::vector<char> expectedData =
398  {
399  encodingMask,
400  0x00, 0x20 // 0x2000
401  };
402 
403  GetChannel().SetData(expectedData);
404 
405  Variant var;
406  GetStream() >> var;
407 
408  ASSERT_EQ(var.Type(), VariantType::INT16);
409  ASSERT_EQ(var.As<int16_t>(), 8192);
410  ASSERT_FALSE(var.IsNul());
411  ASSERT_FALSE(var.IsArray());
412  ASSERT_TRUE(var.Dimensions.empty());
413 }
414 
415 TEST_F(OpcUaBinaryDeserialization, Variant_INT16_Array)
416 {
417  using namespace OpcUa;
418  using namespace OpcUa::Binary;
419 
420  char encodingMask = static_cast<uint8_t>(VariantType::INT16) | HAS_ARRAY_MASK;
421 
422  const std::vector<char> expectedData =
423  {
424  encodingMask,
425  2, 0, 0, 0,
426  0x00, 0x20, // 0x2000
427  0x00, 0x20 // 0x2000
428  };
429 
430  GetChannel().SetData(expectedData);
431 
432  Variant var;
433  GetStream() >> var;
434 
435  ASSERT_EQ(var.Type(), VariantType::INT16);
436  std::vector<int16_t> vals;
437  ASSERT_NO_THROW(vals = var.As<std::vector<int16_t>>());
438  ASSERT_EQ(vals.size(), 2);
439  ASSERT_EQ(vals[0], 8192);
440  ASSERT_EQ(vals[1], 8192);
441  ASSERT_FALSE(var.IsNul());
442  ASSERT_TRUE(var.IsArray());
443  ASSERT_TRUE(var.Dimensions.empty());
444 }
445 
446 
447 TEST_F(OpcUaBinaryDeserialization, Variant_INT16_DIMENSIONS)
448 {
449  using namespace OpcUa;
450  using namespace OpcUa::Binary;
451 
452  char encodingMask = static_cast<uint8_t>(VariantType::INT16) | HAS_DIMENSIONS_MASK;
453 
454  const std::vector<char> expectedData =
455  {
456  encodingMask,
457  0x00, 0x20, // 0x2000
458  1, 0, 0, 0,
459  1, 0, 0, 0,
460  };
461 
462  GetChannel().SetData(expectedData);
463 
464  Variant var;
465  GetStream() >> var;
466 
467  ASSERT_EQ(var.Type(), VariantType::INT16);
468  ASSERT_EQ(var.As<int16_t>(), 8192);
469  ASSERT_FALSE(var.IsNul());
470  ASSERT_FALSE(var.IsArray());
471  ASSERT_EQ(var.Dimensions.size(), 1);
472  ASSERT_EQ(var.Dimensions[0], 1);
473 }
474 
476 TEST_F(OpcUaBinaryDeserialization, Variant_UINT16)
477 {
478  using namespace OpcUa;
479  using namespace OpcUa::Binary;
480 
481  char encodingMask = static_cast<char>(VariantType::UINT16);
482 
483  const std::vector<char> expectedData =
484  {
485  encodingMask,
486  0x00, 0x20 // 0x2000
487  };
488 
489  GetChannel().SetData(expectedData);
490 
491  Variant var;
492  GetStream() >> var;
493 
494  ASSERT_EQ(var.Type(), VariantType::UINT16);
495  ASSERT_EQ(var.As<uint16_t>(), 8192);
496  ASSERT_FALSE(var.IsNul());
497  ASSERT_FALSE(var.IsArray());
498  ASSERT_TRUE(var.Dimensions.empty());
499 }
500 
501 TEST_F(OpcUaBinaryDeserialization, Variant_UINT16_Array)
502 {
503  using namespace OpcUa;
504  using namespace OpcUa::Binary;
505 
506  char encodingMask = static_cast<uint8_t>(VariantType::UINT16) | HAS_ARRAY_MASK;
507 
508  const std::vector<char> expectedData =
509  {
510  encodingMask,
511  2, 0, 0, 0,
512  0x00, 0x20, // 0x2000
513  0x00, 0x20 // 0x2000
514  };
515 
516  GetChannel().SetData(expectedData);
517 
518  Variant var;
519  GetStream() >> var;
520 
521  ASSERT_EQ(var.Type(), VariantType::UINT16);
522  std::vector<uint16_t> vals;
523  ASSERT_NO_THROW(vals = var.As<std::vector<uint16_t>>());
524  ASSERT_EQ(vals.size(), 2);
525  ASSERT_EQ(vals[0], 8192);
526  ASSERT_EQ(vals[1], 8192);
527  ASSERT_FALSE(var.IsNul());
528  ASSERT_TRUE(var.IsArray());
529  ASSERT_TRUE(var.Dimensions.empty());
530 }
531 
532 
533 TEST_F(OpcUaBinaryDeserialization, Variant_UINT16_DIMENSIONS)
534 {
535  using namespace OpcUa;
536  using namespace OpcUa::Binary;
537 
538  char encodingMask = static_cast<uint8_t>(VariantType::UINT16) | HAS_DIMENSIONS_MASK;
539 
540  const std::vector<char> expectedData =
541  {
542  encodingMask,
543  0x00, 0x20, // 0x2000
544  1, 0, 0, 0,
545  1, 0, 0, 0,
546  };
547 
548  GetChannel().SetData(expectedData);
549 
550  Variant var;
551  GetStream() >> var;
552 
553  ASSERT_EQ(var.Type(), VariantType::UINT16);
554  ASSERT_EQ(var.As<uint16_t>(), 8192);
555  ASSERT_FALSE(var.IsNul());
556  ASSERT_FALSE(var.IsArray());
557  ASSERT_EQ(var.Dimensions.size(), 1);
558  ASSERT_EQ(var.Dimensions[0], 1);
559 }
560 
562 TEST_F(OpcUaBinaryDeserialization, Variant_INT32)
563 {
564  using namespace OpcUa;
565  using namespace OpcUa::Binary;
566 
567  char encodingMask = static_cast<char>(VariantType::INT32);
568 
569  const std::vector<char> expectedData =
570  {
571  encodingMask,
572  0x00, 0x20, 0, 0 // 0x2000
573  };
574 
575  GetChannel().SetData(expectedData);
576 
577  Variant var;
578  GetStream() >> var;
579 
580  ASSERT_EQ(var.Type(), VariantType::INT32);
581  ASSERT_EQ(var.As<int32_t>(), 8192);
582  ASSERT_FALSE(var.IsNul());
583  ASSERT_FALSE(var.IsArray());
584  ASSERT_TRUE(var.Dimensions.empty());
585 }
586 
587 TEST_F(OpcUaBinaryDeserialization, Variant_INT32_Array)
588 {
589  using namespace OpcUa;
590  using namespace OpcUa::Binary;
591 
592  char encodingMask = static_cast<uint8_t>(VariantType::INT32) | HAS_ARRAY_MASK;
593 
594  const std::vector<char> expectedData =
595  {
596  encodingMask,
597  2, 0, 0, 0,
598  0x00, 0x20, 0, 0, // 0x2000
599  0x00, 0x20, 0, 0 // 0x2000
600  };
601 
602  GetChannel().SetData(expectedData);
603 
604  Variant var;
605  GetStream() >> var;
606 
607  ASSERT_EQ(var.Type(), VariantType::INT32);
608  std::vector<int32_t> vals;
609  ASSERT_NO_THROW(vals = var.As<std::vector<int32_t>>());
610  ASSERT_EQ(vals.size(), 2);
611  ASSERT_EQ(vals[0], 8192);
612  ASSERT_EQ(vals[1], 8192);
613  ASSERT_FALSE(var.IsNul());
614  ASSERT_TRUE(var.IsArray());
615  ASSERT_TRUE(var.Dimensions.empty());
616 }
617 
618 
619 TEST_F(OpcUaBinaryDeserialization, Variant_INT32_DIMENSIONS)
620 {
621  using namespace OpcUa;
622  using namespace OpcUa::Binary;
623 
624  char encodingMask = static_cast<uint8_t>(VariantType::INT32) | HAS_DIMENSIONS_MASK;
625 
626  const std::vector<char> expectedData =
627  {
628  encodingMask,
629  0x00, 0x20, 0, 0,// 0x2000
630  1, 0, 0, 0,
631  1, 0, 0, 0,
632  };
633 
634  GetChannel().SetData(expectedData);
635 
636  Variant var;
637  GetStream() >> var;
638 
639  ASSERT_EQ(var.Type(), VariantType::INT32);
640  ASSERT_EQ(var.As<int32_t>(), 8192);
641  ASSERT_FALSE(var.IsNul());
642  ASSERT_FALSE(var.IsArray());
643  ASSERT_EQ(var.Dimensions.size(), 1);
644  ASSERT_EQ(var.Dimensions[0], 1);
645 }
646 
648 TEST_F(OpcUaBinaryDeserialization, Variant_UINT32)
649 {
650  using namespace OpcUa;
651  using namespace OpcUa::Binary;
652 
653  char encodingMask = static_cast<char>(VariantType::UINT32);
654 
655  const std::vector<char> expectedData =
656  {
657  encodingMask,
658  0x00, 0x20, 0, 0 // 0x2000
659  };
660 
661  GetChannel().SetData(expectedData);
662 
663  Variant var;
664  GetStream() >> var;
665 
666  ASSERT_EQ(var.Type(), VariantType::UINT32);
667  ASSERT_EQ(var.As<uint32_t>(), 8192);
668  ASSERT_FALSE(var.IsNul());
669  ASSERT_FALSE(var.IsArray());
670  ASSERT_TRUE(var.Dimensions.empty());
671 }
672 
673 TEST_F(OpcUaBinaryDeserialization, Variant_UINT32_Array)
674 {
675  using namespace OpcUa;
676  using namespace OpcUa::Binary;
677 
678  char encodingMask = static_cast<uint8_t>(VariantType::UINT32) | HAS_ARRAY_MASK;
679 
680  const std::vector<char> expectedData =
681  {
682  encodingMask,
683  2, 0, 0, 0,
684  0x00, 0x20, 0, 0, // 0x2000
685  0x00, 0x20, 0, 0 // 0x2000
686  };
687 
688  GetChannel().SetData(expectedData);
689 
690  Variant var;
691  GetStream() >> var;
692 
693  ASSERT_EQ(var.Type(), VariantType::UINT32);
694  std::vector<uint32_t> vals;
695  ASSERT_NO_THROW(vals = var.As<std::vector<uint32_t>>());
696  ASSERT_EQ(vals.size(), 2);
697  ASSERT_EQ(vals[0], 8192);
698  ASSERT_EQ(vals[1], 8192);
699  ASSERT_FALSE(var.IsNul());
700  ASSERT_TRUE(var.IsArray());
701  ASSERT_TRUE(var.Dimensions.empty());
702 }
703 
704 
705 TEST_F(OpcUaBinaryDeserialization, Variant_UINT32_DIMENSIONS)
706 {
707  using namespace OpcUa;
708  using namespace OpcUa::Binary;
709 
710  char encodingMask = static_cast<uint8_t>(VariantType::UINT32) | HAS_DIMENSIONS_MASK;
711 
712  const std::vector<char> expectedData =
713  {
714  encodingMask,
715  0x00, 0x20, 0, 0, // 0x2000
716  1, 0, 0, 0,
717  1, 0, 0, 0,
718  };
719 
720  GetChannel().SetData(expectedData);
721 
722  Variant var;
723  GetStream() >> var;
724 
725  ASSERT_EQ(var.Type(), VariantType::UINT32);
726  ASSERT_EQ(var.As<uint32_t>(), 8192);
727  ASSERT_FALSE(var.IsNul());
728  ASSERT_FALSE(var.IsArray());
729  ASSERT_EQ(var.Dimensions.size(), 1);
730  ASSERT_EQ(var.Dimensions[0], 1);
731 }
732 
734 TEST_F(OpcUaBinaryDeserialization, Variant_INT64)
735 {
736  using namespace OpcUa;
737  using namespace OpcUa::Binary;
738 
739  char encodingMask = static_cast<char>(VariantType::INT64);
740 
741  const std::vector<char> expectedData =
742  {
743  encodingMask,
744  0x00, 0x20, 0, 0, 0, 0, 0, 0 // 0x2000
745  };
746 
747  GetChannel().SetData(expectedData);
748 
749  Variant var;
750  GetStream() >> var;
751 
752  ASSERT_EQ(var.Type(), VariantType::INT64);
753  ASSERT_EQ(var.As<int64_t>(), 8192);
754  ASSERT_FALSE(var.IsNul());
755  ASSERT_FALSE(var.IsArray());
756  ASSERT_TRUE(var.Dimensions.empty());
757 }
758 
759 TEST_F(OpcUaBinaryDeserialization, Variant_INT64_Array)
760 {
761  using namespace OpcUa;
762  using namespace OpcUa::Binary;
763 
764  char encodingMask = static_cast<uint8_t>(VariantType::INT64) | HAS_ARRAY_MASK;
765 
766  const std::vector<char> expectedData =
767  {
768  encodingMask,
769  2, 0, 0, 0,
770  0x00, 0x20, 0, 0, 0, 0, 0, 0, // 0x2000
771  0x00, 0x20, 0, 0, 0, 0, 0, 0 // 0x2000
772  };
773 
774  GetChannel().SetData(expectedData);
775 
776  Variant var;
777  GetStream() >> var;
778 
779  ASSERT_EQ(var.Type(), VariantType::INT64);
780  std::vector<int64_t> vals;
781  ASSERT_NO_THROW(vals = var.As<std::vector<int64_t>>());
782  ASSERT_EQ(vals.size(), 2);
783  ASSERT_EQ(vals[0], 8192);
784  ASSERT_EQ(vals[1], 8192);
785  ASSERT_FALSE(var.IsNul());
786  ASSERT_TRUE(var.IsArray());
787  ASSERT_TRUE(var.Dimensions.empty());
788 }
789 
790 
791 TEST_F(OpcUaBinaryDeserialization, Variant_INT64_DIMENSIONS)
792 {
793  using namespace OpcUa;
794  using namespace OpcUa::Binary;
795 
796  char encodingMask = static_cast<uint8_t>(VariantType::INT64) | HAS_DIMENSIONS_MASK;
797 
798  const std::vector<char> expectedData =
799  {
800  encodingMask,
801  0x00, 0x20, 0, 0, 0, 0, 0, 0, // 0x2000
802  1, 0, 0, 0,
803  1, 0, 0, 0,
804  };
805 
806  GetChannel().SetData(expectedData);
807 
808  Variant var;
809  GetStream() >> var;
810 
811  ASSERT_EQ(var.Type(), VariantType::INT64);
812  ASSERT_EQ(var.As<int64_t>(), 8192);
813  ASSERT_FALSE(var.IsNul());
814  ASSERT_FALSE(var.IsArray());
815  ASSERT_EQ(var.Dimensions.size(), 1);
816  ASSERT_EQ(var.Dimensions[0], 1);
817 }
818 
820 TEST_F(OpcUaBinaryDeserialization, Variant_UINT64)
821 {
822  using namespace OpcUa;
823  using namespace OpcUa::Binary;
824 
825  char encodingMask = static_cast<char>(VariantType::UINT64);
826 
827  const std::vector<char> expectedData =
828  {
829  encodingMask,
830  0x00, 0x20, 0, 0, 0, 0, 0, 0 // 0x2000
831  };
832 
833  GetChannel().SetData(expectedData);
834 
835  Variant var;
836  GetStream() >> var;
837 
838  ASSERT_EQ(var.Type(), VariantType::UINT64);
839  ASSERT_EQ(var.As<uint64_t>(), 8192);
840  ASSERT_FALSE(var.IsNul());
841  ASSERT_FALSE(var.IsArray());
842  ASSERT_TRUE(var.Dimensions.empty());
843 }
844 
845 TEST_F(OpcUaBinaryDeserialization, Variant_UINT64_Array)
846 {
847  using namespace OpcUa;
848  using namespace OpcUa::Binary;
849 
850  char encodingMask = static_cast<uint8_t>(VariantType::UINT64) | HAS_ARRAY_MASK;
851 
852  const std::vector<char> expectedData =
853  {
854  encodingMask,
855  2, 0, 0, 0,
856  0x00, 0x20, 0, 0, 0, 0, 0, 0, // 0x2000
857  0x00, 0x20, 0, 0, 0, 0, 0, 0 // 0x2000
858  };
859 
860  GetChannel().SetData(expectedData);
861 
862  Variant var;
863  GetStream() >> var;
864 
865  ASSERT_EQ(var.Type(), VariantType::UINT64);
866  std::vector<uint64_t> vals;
867  ASSERT_NO_THROW(vals = var.As<std::vector<uint64_t>>());
868  ASSERT_EQ(vals.size(), 2);
869  ASSERT_EQ(vals[0], 8192);
870  ASSERT_EQ(vals[1], 8192);
871  ASSERT_FALSE(var.IsNul());
872  ASSERT_TRUE(var.IsArray());
873  ASSERT_TRUE(var.Dimensions.empty());
874 }
875 
876 
877 TEST_F(OpcUaBinaryDeserialization, Variant_UINT64_DIMENSIONS)
878 {
879  using namespace OpcUa;
880  using namespace OpcUa::Binary;
881 
882  char encodingMask = static_cast<uint8_t>(VariantType::UINT64) | HAS_DIMENSIONS_MASK;
883 
884  const std::vector<char> expectedData =
885  {
886  encodingMask,
887  0x00, 0x20, 0, 0, 0, 0, 0, 0, // 0x2000
888  1, 0, 0, 0,
889  1, 0, 0, 0,
890  };
891 
892  GetChannel().SetData(expectedData);
893 
894  Variant var;
895  GetStream() >> var;
896 
897  ASSERT_EQ(var.Type(), VariantType::UINT64);
898  ASSERT_EQ(var.As<uint64_t>(), 8192);
899  ASSERT_FALSE(var.IsNul());
900  ASSERT_FALSE(var.IsArray());
901  ASSERT_EQ(var.Dimensions.size(), 1);
902  ASSERT_EQ(var.Dimensions[0], 1);
903 }
904 
906 TEST_F(OpcUaBinaryDeserialization, Variant_FLOAT)
907 {
908  using namespace OpcUa;
909  using namespace OpcUa::Binary;
910 
911  char encodingMask = static_cast<char>(VariantType::FLOAT);
912 
913  const std::vector<char> expectedData =
914  {
915  encodingMask,
916  //(char)0xC0, (char)0xD0, 0, 0 // -6.5
917  0, 0, (char)0xD0, (char)0xC0 // -6.5
918  };
919 
920  GetChannel().SetData(expectedData);
921 
922  Variant var;
923  GetStream() >> var;
924 
925  ASSERT_EQ(var.Type(), VariantType::FLOAT);
926  ASSERT_EQ(var.As<float>(), -6.5);
927  ASSERT_FALSE(var.IsNul());
928  ASSERT_FALSE(var.IsArray());
929  ASSERT_TRUE(var.Dimensions.empty());
930 }
931 
932 TEST_F(OpcUaBinaryDeserialization, Variant_FLOAT_Array)
933 {
934  using namespace OpcUa;
935  using namespace OpcUa::Binary;
936 
937  char encodingMask = static_cast<uint8_t>(VariantType::FLOAT) | HAS_ARRAY_MASK;
938 
939  const std::vector<char> expectedData =
940  {
941  encodingMask,
942  2, 0, 0, 0,
943  0, 0, (char)0xD0, (char)0xC0, // -6.5
944  0, 0, (char)0xD0, (char)0xC0 // -6.5
945  //(char)0xC0, (char)0xD0, 0, 0, // -6.5
946  //(char)0xC0, (char)0xD0, 0, 0 // -6.5
947  };
948 
949  GetChannel().SetData(expectedData);
950 
951  Variant var;
952  GetStream() >> var;
953 
954  ASSERT_EQ(var.Type(), VariantType::FLOAT);
955  std::vector<float> vals;
956  ASSERT_NO_THROW(vals = var.As<std::vector<float>>());
957  ASSERT_EQ(vals.size(), 2);
958  ASSERT_EQ(vals[0], -6.5);
959  ASSERT_EQ(vals[1], -6.5);
960  ASSERT_FALSE(var.IsNul());
961  ASSERT_TRUE(var.IsArray());
962  ASSERT_TRUE(var.Dimensions.empty());
963 }
964 
965 
966 TEST_F(OpcUaBinaryDeserialization, Variant_FLOAT_DIMENSIONS)
967 {
968  using namespace OpcUa;
969  using namespace OpcUa::Binary;
970 
971  char encodingMask = static_cast<uint8_t>(VariantType::FLOAT) | HAS_DIMENSIONS_MASK;
972 
973  const std::vector<char> expectedData =
974  {
975  encodingMask,
976  0, 0, (char)0xD0, (char)0xC0, // -6.5
977  //(char)0xC0, (char)0xD0, 0, 0, // -6.5
978  1, 0, 0, 0,
979  1, 0, 0, 0,
980  };
981 
982  GetChannel().SetData(expectedData);
983 
984  Variant var;
985  GetStream() >> var;
986 
987  ASSERT_EQ(var.Type(), VariantType::FLOAT);
988  ASSERT_EQ(var.As<float>(), -6.5);
989  ASSERT_FALSE(var.IsNul());
990  ASSERT_FALSE(var.IsArray());
991  ASSERT_EQ(var.Dimensions.size(), 1);
992  ASSERT_EQ(var.Dimensions[0], 1);
993 }
994 
996 TEST_F(OpcUaBinaryDeserialization, Variant_DOUBLE)
997 {
998  using namespace OpcUa;
999  using namespace OpcUa::Binary;
1000 
1001  char encodingMask = static_cast<char>(VariantType::DOUBLE);
1002 
1003  const std::vector<char> expectedData =
1004  {
1005  encodingMask,
1006  0, 0, 0, 0, (char)0x80, (char)0x4f, (char)0x32, (char)0x41 // 1200000
1007  };
1008 
1009  GetChannel().SetData(expectedData);
1010 
1011  Variant var;
1012  GetStream() >> var;
1013 
1014  ASSERT_EQ(var.Type(), VariantType::DOUBLE);
1015  ASSERT_EQ(var.As<double>(), 1200000);
1016  ASSERT_FALSE(var.IsNul());
1017  ASSERT_FALSE(var.IsArray());
1018  ASSERT_TRUE(var.Dimensions.empty());
1019 }
1020 
1021 TEST_F(OpcUaBinaryDeserialization, Variant_DOUBLE_Array)
1022 {
1023  using namespace OpcUa;
1024  using namespace OpcUa::Binary;
1025 
1026  char encodingMask = static_cast<uint8_t>(VariantType::DOUBLE) | HAS_ARRAY_MASK;
1027 
1028  const std::vector<char> expectedData =
1029  {
1030  encodingMask,
1031  2, 0, 0, 0,
1032  0, 0, 0, 0, (char)0x80, (char)0x4f, (char)0x32, (char)0x41, // 1200000
1033  0, 0, 0, 0, (char)0x80, (char)0x4f, (char)0x32, (char)0x41 // 1200000
1034  };
1035 
1036  GetChannel().SetData(expectedData);
1037 
1038  Variant var;
1039  GetStream() >> var;
1040 
1041  ASSERT_EQ(var.Type(), VariantType::DOUBLE);
1042  std::vector<double> vals;
1043  ASSERT_NO_THROW(vals = var.As<std::vector<double>>());
1044  ASSERT_EQ(vals.size(), 2);
1045  ASSERT_EQ(vals[0], 1200000);
1046  ASSERT_EQ(vals[1], 1200000);
1047  ASSERT_FALSE(var.IsNul());
1048  ASSERT_TRUE(var.IsArray());
1049  ASSERT_TRUE(var.Dimensions.empty());
1050 }
1051 
1052 
1053 TEST_F(OpcUaBinaryDeserialization, Variant_DOUBLE_DIMENSIONS)
1054 {
1055  using namespace OpcUa;
1056  using namespace OpcUa::Binary;
1057 
1058  char encodingMask = static_cast<uint8_t>(VariantType::DOUBLE) | HAS_DIMENSIONS_MASK;
1059 
1060  const std::vector<char> expectedData =
1061  {
1062  encodingMask,
1063  0, 0, 0, 0, (char)0x80, (char)0x4f, (char)0x32, (char)0x41, // 1200000
1064  1, 0, 0, 0,
1065  1, 0, 0, 0,
1066  };
1067 
1068  GetChannel().SetData(expectedData);
1069 
1070  Variant var;
1071  GetStream() >> var;
1072 
1073  ASSERT_EQ(var.Type(), VariantType::DOUBLE);
1074  ASSERT_EQ(var.As<double>(), 1200000);
1075  ASSERT_FALSE(var.IsNul());
1076  ASSERT_FALSE(var.IsArray());
1077  ASSERT_EQ(var.Dimensions.size(), 1);
1078  ASSERT_EQ(var.Dimensions[0], 1);
1079 }
1080 
1081 OpcUa::Guid CreateTestGuid()
1082 {
1083  OpcUa::Guid guid;
1084  guid.Data1 = 0x01020304;
1085  guid.Data2 = 0x0506;
1086  guid.Data3 = 0x0708;
1087 
1088  for (unsigned i = 0; i < 8; ++i)
1089  {
1090  guid.Data4[i] = i + 1;
1091  }
1092 
1093  return guid;
1094 }
1095 
1097 TEST_F(OpcUaBinaryDeserialization, Variant_GUId)
1098 {
1099  using namespace OpcUa;
1100  using namespace OpcUa::Binary;
1101 
1102  char encodingMask = static_cast<char>(VariantType::GUId);
1103 
1104  const std::vector<char> expectedData =
1105  {
1106  encodingMask,
1107  4, 3, 2, 1, 6, 5, 8, 7, 1, 2, 3, 4, 5, 6, 7, 8
1108  };
1109 
1110  GetChannel().SetData(expectedData);
1111 
1112  Variant var;
1113  GetStream() >> var;
1114 
1115  OpcUa::Guid guid = CreateTestGuid();
1116 
1117  ASSERT_EQ(var.Type(), VariantType::GUId);
1118  ASSERT_EQ(var.As<Guid>(), guid);
1119  ASSERT_FALSE(var.IsNul());
1120  ASSERT_FALSE(var.IsArray());
1121  ASSERT_TRUE(var.Dimensions.empty());
1122 }
1123 
1124 TEST_F(OpcUaBinaryDeserialization, Variant_GUId_Array)
1125 {
1126  using namespace OpcUa;
1127  using namespace OpcUa::Binary;
1128 
1129  char encodingMask = static_cast<uint8_t>(VariantType::GUId) | HAS_ARRAY_MASK;
1130 
1131  const std::vector<char> expectedData =
1132  {
1133  encodingMask,
1134  2, 0, 0, 0,
1135  4, 3, 2, 1, 6, 5, 8, 7, 1, 2, 3, 4, 5, 6, 7, 8,
1136  4, 3, 2, 1, 6, 5, 8, 7, 1, 2, 3, 4, 5, 6, 7, 8
1137  };
1138 
1139  GetChannel().SetData(expectedData);
1140 
1141  Variant var;
1142  GetStream() >> var;
1143 
1144  OpcUa::Guid guid = CreateTestGuid();
1145 
1146  ASSERT_EQ(var.Type(), VariantType::GUId);
1147  std::vector<Guid> vals;
1148  ASSERT_NO_THROW(vals = var.As<std::vector<Guid>>());
1149  ASSERT_EQ(vals.size(), 2);
1150  ASSERT_EQ(vals[0], guid);
1151  ASSERT_EQ(vals[1], guid);
1152  ASSERT_FALSE(var.IsNul());
1153  ASSERT_TRUE(var.IsArray());
1154  ASSERT_TRUE(var.Dimensions.empty());
1155 }
1156 
1157 
1158 TEST_F(OpcUaBinaryDeserialization, Variant_GUId_DIMENSIONS)
1159 {
1160  using namespace OpcUa;
1161  using namespace OpcUa::Binary;
1162 
1163  char encodingMask = static_cast<uint8_t>(VariantType::GUId) | HAS_DIMENSIONS_MASK;
1164 
1165  const std::vector<char> expectedData =
1166  {
1167  encodingMask,
1168  4, 3, 2, 1, 6, 5, 8, 7, 1, 2, 3, 4, 5, 6, 7, 8,
1169  1, 0, 0, 0,
1170  1, 0, 0, 0,
1171  };
1172 
1173  GetChannel().SetData(expectedData);
1174 
1175  Variant var;
1176  GetStream() >> var;
1177 
1178  OpcUa::Guid guid = CreateTestGuid();
1179 
1180  ASSERT_EQ(var.Type(), VariantType::GUId);
1181  ASSERT_EQ(var.As<Guid>(), guid);
1182  ASSERT_FALSE(var.IsNul());
1183  ASSERT_FALSE(var.IsArray());
1184  ASSERT_EQ(var.Dimensions.size(), 1);
1185  ASSERT_EQ(var.Dimensions[0], 1);
1186 }
1187 
1189 TEST_F(OpcUaBinaryDeserialization, Variant_STRING)
1190 {
1191  using namespace OpcUa;
1192  using namespace OpcUa::Binary;
1193 
1194  char encodingMask = static_cast<char>(VariantType::STRING);
1195 
1196  const std::vector<char> expectedData =
1197  {
1198  encodingMask,
1199  4, 0, 0, 0, 'R', 'o', 'o', 't'
1200  };
1201 
1202  GetChannel().SetData(expectedData);
1203 
1204  Variant var;
1205  GetStream() >> var;
1206 
1207  ASSERT_EQ(var.Type(), VariantType::STRING);
1208  ASSERT_EQ(var.As<std::string>(), std::string("Root"));
1209  ASSERT_FALSE(var.IsNul());
1210  ASSERT_FALSE(var.IsArray());
1211  ASSERT_TRUE(var.Dimensions.empty());
1212 }
1213 
1214 TEST_F(OpcUaBinaryDeserialization, Variant_STRING_Array)
1215 {
1216  using namespace OpcUa;
1217  using namespace OpcUa::Binary;
1218 
1219  char encodingMask = static_cast<uint8_t>(VariantType::STRING) | HAS_ARRAY_MASK;
1220 
1221  const std::vector<char> expectedData =
1222  {
1223  encodingMask,
1224  2, 0, 0, 0,
1225  4, 0, 0, 0, 'R', 'o', 'o', 't',
1226  4, 0, 0, 0, 'R', 'o', 'o', 't'
1227  };
1228 
1229  GetChannel().SetData(expectedData);
1230 
1231  Variant var;
1232  GetStream() >> var;
1233 
1234 // OpcUa::Guid guid = CreateTestGuid();
1235 
1236  ASSERT_EQ(var.Type(), VariantType::STRING);
1237  std::vector<std::string> vals;
1238  ASSERT_NO_THROW(vals = var.As<std::vector<std::string>>());
1239  ASSERT_EQ(vals.size(), 2);
1240  ASSERT_EQ(vals[0], std::string("Root"));
1241  ASSERT_EQ(vals[1], std::string("Root"));
1242  ASSERT_FALSE(var.IsNul());
1243  ASSERT_TRUE(var.IsArray());
1244  ASSERT_TRUE(var.Dimensions.empty());
1245 }
1246 
1247 
1248 TEST_F(OpcUaBinaryDeserialization, Variant_STRING_DIMENSIONS)
1249 {
1250  using namespace OpcUa;
1251  using namespace OpcUa::Binary;
1252 
1253  char encodingMask = static_cast<uint8_t>(VariantType::STRING) | HAS_DIMENSIONS_MASK;
1254 
1255  const std::vector<char> expectedData =
1256  {
1257  encodingMask,
1258  4, 0, 0, 0, 'R', 'o', 'o', 't',
1259  1, 0, 0, 0,
1260  1, 0, 0, 0,
1261  };
1262 
1263  GetChannel().SetData(expectedData);
1264 
1265  Variant var;
1266  GetStream() >> var;
1267 
1268 // OpcUa::Guid guid = CreateTestGuid();
1269 
1270  ASSERT_EQ(var.Type(), VariantType::STRING);
1271  ASSERT_EQ(var.As<std::string>(), std::string("Root"));
1272  ASSERT_FALSE(var.IsNul());
1273  ASSERT_FALSE(var.IsArray());
1274  ASSERT_EQ(var.Dimensions.size(), 1);
1275  ASSERT_EQ(var.Dimensions[0], 1);
1276 }
1277 
1279 TEST_F(OpcUaBinaryDeserialization, Variant_BYTE_STRING)
1280 {
1281  using namespace OpcUa;
1282  using namespace OpcUa::Binary;
1283 
1284  char encodingMask = static_cast<char>(VariantType::BYTE_STRING);
1285 
1286  const std::vector<char> expectedData =
1287  {
1288  encodingMask,
1289  2, 0, 0, 0, 1, 2
1290  };
1291 
1292  GetChannel().SetData(expectedData);
1293 
1294  Variant var;
1295  GetStream() >> var;
1296 
1297  ASSERT_EQ(var.Type(), VariantType::BYTE_STRING);
1298  ASSERT_EQ(var.As<ByteString>(), ByteString(std::vector<uint8_t> {1, 2}));
1299  ASSERT_FALSE(var.IsNul());
1300  ASSERT_FALSE(var.IsArray());
1301  ASSERT_TRUE(var.Dimensions.empty());
1302 }
1303 
1304 TEST_F(OpcUaBinaryDeserialization, Variant_BYTE_STRING_Array)
1305 {
1306  using namespace OpcUa;
1307  using namespace OpcUa::Binary;
1308 
1309  char encodingMask = static_cast<uint8_t>(VariantType::BYTE_STRING) | HAS_ARRAY_MASK;
1310 
1311  const std::vector<char> expectedData =
1312  {
1313  encodingMask,
1314  2, 0, 0, 0,
1315  2, 0, 0, 0, 1, 2,
1316  2, 0, 0, 0, 1, 2
1317  };
1318 
1319  GetChannel().SetData(expectedData);
1320 
1321  Variant var;
1322  GetStream() >> var;
1323 
1324  ASSERT_EQ(var.Type(), VariantType::BYTE_STRING);
1325  std::vector<ByteString> vals;
1326  ASSERT_NO_THROW(vals = var.As<std::vector<ByteString>>());
1327  ASSERT_EQ(vals.size(), 2);
1328  ASSERT_EQ(vals[0], ByteString(std::vector<uint8_t> {1, 2}));
1329  ASSERT_EQ(vals[1], ByteString(std::vector<uint8_t> {1, 2}));
1330  ASSERT_FALSE(var.IsNul());
1331  ASSERT_TRUE(var.IsArray());
1332  ASSERT_TRUE(var.Dimensions.empty());
1333 }
1334 
1335 
1336 TEST_F(OpcUaBinaryDeserialization, Variant_BYTE_STRING_DIMENSIONS)
1337 {
1338  using namespace OpcUa;
1339  using namespace OpcUa::Binary;
1340 
1341  char encodingMask = static_cast<uint8_t>(VariantType::BYTE_STRING) | HAS_DIMENSIONS_MASK;
1342 
1343  const std::vector<char> expectedData =
1344  {
1345  encodingMask,
1346  2, 0, 0, 0, 1, 2,
1347  1, 0, 0, 0,
1348  1, 0, 0, 0,
1349  };
1350 
1351  GetChannel().SetData(expectedData);
1352 
1353  Variant var;
1354  GetStream() >> var;
1355 
1356 // OpcUa::Guid guid = CreateTestGuid();
1357 
1358  ASSERT_EQ(var.Type(), VariantType::BYTE_STRING);
1359  ASSERT_EQ(var.As<ByteString>(), ByteString(std::vector<uint8_t> {1, 2}));
1360  ASSERT_FALSE(var.IsNul());
1361  ASSERT_FALSE(var.IsArray());
1362  ASSERT_EQ(var.Dimensions.size(), 1);
1363  ASSERT_EQ(var.Dimensions[0], 1);
1364 }
1365 
1367 TEST_F(OpcUaBinaryDeserialization, Variant_DATETIME)
1368 {
1369  using namespace OpcUa;
1370  using namespace OpcUa::Binary;
1371 
1372  char encodingMask = static_cast<char>(VariantType::DATE_TIME);
1373 
1374  const std::vector<char> expectedData =
1375  {
1376  encodingMask,
1377  8, 7, 6, 5, 4, 3, 2, 1
1378  };
1379 
1380  GetChannel().SetData(expectedData);
1381 
1382  Variant var;
1383  GetStream() >> var;
1384 
1385  ASSERT_EQ(var.Type(), VariantType::DATE_TIME);
1386  ASSERT_EQ(var.As<DateTime>(), 0x0102030405060708);
1387  ASSERT_FALSE(var.IsNul());
1388  ASSERT_FALSE(var.IsArray());
1389  ASSERT_TRUE(var.Dimensions.empty());
1390 }
1391 
1392 TEST_F(OpcUaBinaryDeserialization, Variant_DATE_TIME_Array)
1393 {
1394  using namespace OpcUa;
1395  using namespace OpcUa::Binary;
1396 
1397  char encodingMask = static_cast<uint8_t>(VariantType::DATE_TIME) | HAS_ARRAY_MASK;
1398 
1399  const std::vector<char> expectedData =
1400  {
1401  encodingMask,
1402  2, 0, 0, 0,
1403  8, 7, 6, 5, 4, 3, 2, 1,
1404  8, 7, 6, 5, 4, 3, 2, 1
1405  };
1406 
1407  GetChannel().SetData(expectedData);
1408 
1409  Variant var;
1410  GetStream() >> var;
1411 
1412  ASSERT_EQ(var.Type(), VariantType::DATE_TIME);
1413  std::vector<DateTime> vals;
1414  ASSERT_NO_THROW(vals = var.As<std::vector<DateTime>>());
1415  ASSERT_EQ(vals.size(), 2);
1416  ASSERT_EQ(vals[0], 0x0102030405060708);
1417  ASSERT_EQ(vals[1], 0x0102030405060708);
1418  ASSERT_FALSE(var.IsNul());
1419  ASSERT_TRUE(var.IsArray());
1420  ASSERT_TRUE(var.Dimensions.empty());
1421 }
1422 
1423 
1424 TEST_F(OpcUaBinaryDeserialization, Variant_DATE_TIME_DIMENSIONS)
1425 {
1426  using namespace OpcUa;
1427  using namespace OpcUa::Binary;
1428 
1429  char encodingMask = static_cast<uint8_t>(VariantType::DATE_TIME) | HAS_DIMENSIONS_MASK;
1430 
1431  const std::vector<char> expectedData =
1432  {
1433  encodingMask,
1434  8, 7, 6, 5, 4, 3, 2, 1,
1435  1, 0, 0, 0,
1436  1, 0, 0, 0,
1437  };
1438 
1439  GetChannel().SetData(expectedData);
1440 
1441  Variant var;
1442  GetStream() >> var;
1443 
1444  ASSERT_EQ(var.Type(), VariantType::DATE_TIME);
1445  ASSERT_EQ(var.As<DateTime>(), 0x0102030405060708);
1446  ASSERT_FALSE(var.IsNul());
1447  ASSERT_FALSE(var.IsArray());
1448  ASSERT_EQ(var.Dimensions.size(), 1);
1449  ASSERT_EQ(var.Dimensions[0], 1);
1450 }
1451 
1453 TEST_F(OpcUaBinaryDeserialization, Variant_LOCALIZED_TEXT)
1454 {
1455  using namespace OpcUa;
1456  using namespace OpcUa::Binary;
1457 
1458  char encodingMask = static_cast<char>(VariantType::LOCALIZED_TEXT);
1459 
1460  const std::vector<char> expectedData =
1461  {
1462  encodingMask,
1463  2, 4, 0, 0, 0, 't', 'e', 'x', 't'
1464  };
1465 
1466  GetChannel().SetData(expectedData);
1467 
1468  Variant var;
1469  GetStream() >> var;
1470 
1471  ASSERT_EQ(var.Type(), VariantType::LOCALIZED_TEXT);
1472  ASSERT_EQ(var.As<LocalizedText>(), LocalizedText("text"));
1473  ASSERT_FALSE(var.IsNul());
1474  ASSERT_FALSE(var.IsArray());
1475  ASSERT_TRUE(var.Dimensions.empty());
1476 }
1477 
1478 TEST_F(OpcUaBinaryDeserialization, Variant_LOCALIZED_TEXT_Array)
1479 {
1480  using namespace OpcUa;
1481  using namespace OpcUa::Binary;
1482 
1483  char encodingMask = static_cast<uint8_t>(VariantType::LOCALIZED_TEXT) | HAS_ARRAY_MASK;
1484 
1485  const std::vector<char> expectedData =
1486  {
1487  encodingMask,
1488  2, 0, 0, 0,
1489  2, 4, 0, 0, 0, 't', 'e', 'x', 't',
1490  2, 4, 0, 0, 0, 't', 'e', 'x', 't'
1491  };
1492 
1493  GetChannel().SetData(expectedData);
1494 
1495  Variant var;
1496  GetStream() >> var;
1497 
1498  ASSERT_EQ(var.Type(), VariantType::LOCALIZED_TEXT);
1499  std::vector<LocalizedText> vals;
1500  ASSERT_NO_THROW(vals = var.As<std::vector<LocalizedText>>());
1501  ASSERT_EQ(vals.size(), 2);
1502  ASSERT_EQ(vals[0], LocalizedText("text"));
1503  ASSERT_EQ(vals[1], LocalizedText("text"));
1504  ASSERT_FALSE(var.IsNul());
1505  ASSERT_TRUE(var.IsArray());
1506  ASSERT_TRUE(var.Dimensions.empty());
1507 }
1508 
1509 
1510 TEST_F(OpcUaBinaryDeserialization, Variant_LOCALIZED_TEXT_DIMENSIONS)
1511 {
1512  using namespace OpcUa;
1513  using namespace OpcUa::Binary;
1514 
1515  char encodingMask = static_cast<uint8_t>(VariantType::LOCALIZED_TEXT) | HAS_DIMENSIONS_MASK;
1516 
1517  const std::vector<char> expectedData =
1518  {
1519  encodingMask,
1520  2, 4, 0, 0, 0, 't', 'e', 'x', 't',
1521  1, 0, 0, 0,
1522  1, 0, 0, 0,
1523  };
1524 
1525  GetChannel().SetData(expectedData);
1526 
1527  Variant var;
1528  GetStream() >> var;
1529 
1530  ASSERT_EQ(var.Type(), VariantType::LOCALIZED_TEXT);
1531  ASSERT_EQ(var.As<LocalizedText>(), LocalizedText("text"));
1532  ASSERT_FALSE(var.IsNul());
1533  ASSERT_FALSE(var.IsArray());
1534  ASSERT_EQ(var.Dimensions.size(), 1);
1535  ASSERT_EQ(var.Dimensions[0], 1);
1536 }
1537 
1539 TEST_F(OpcUaBinaryDeserialization, Variant_QUALIFIED_NAME)
1540 {
1541  using namespace OpcUa;
1542  using namespace OpcUa::Binary;
1543 
1544  char encodingMask = static_cast<char>(VariantType::QUALIFIED_NAME);
1545 
1546  const std::vector<char> expectedData =
1547  {
1548  encodingMask,
1549  1, 0, 4, 0, 0, 0, 'n', 'a', 'm', 'e'
1550  };
1551 
1552  GetChannel().SetData(expectedData);
1553 
1554  Variant var;
1555  GetStream() >> var;
1556 
1557  ASSERT_EQ(var.Type(), VariantType::QUALIFIED_NAME);
1558  ASSERT_EQ(var.As<QualifiedName>(), QualifiedName(1, "name"));
1559  ASSERT_FALSE(var.IsNul());
1560  ASSERT_FALSE(var.IsArray());
1561  ASSERT_TRUE(var.Dimensions.empty());
1562 }
1563 
1564 TEST_F(OpcUaBinaryDeserialization, Variant_QUALIFIED_NAME_Array)
1565 {
1566  using namespace OpcUa;
1567  using namespace OpcUa::Binary;
1568 
1569  char encodingMask = static_cast<uint8_t>(VariantType::QUALIFIED_NAME) | HAS_ARRAY_MASK;
1570 
1571  const std::vector<char> expectedData =
1572  {
1573  encodingMask,
1574  2, 0, 0, 0,
1575  1, 0, 4, 0, 0, 0, 'n', 'a', 'm', 'e',
1576  1, 0, 4, 0, 0, 0, 'n', 'a', 'm', 'e'
1577  };
1578 
1579  GetChannel().SetData(expectedData);
1580 
1581  Variant var;
1582  GetStream() >> var;
1583 
1584  ASSERT_EQ(var.Type(), VariantType::QUALIFIED_NAME);
1585  std::vector<QualifiedName> vals;
1586  ASSERT_NO_THROW(vals = var.As<std::vector<QualifiedName>>());
1587  ASSERT_EQ(vals.size(), 2);
1588  ASSERT_EQ(vals[0], QualifiedName(1, "name"));
1589  ASSERT_EQ(vals[1], QualifiedName(1, "name"));
1590  ASSERT_FALSE(var.IsNul());
1591  ASSERT_TRUE(var.IsArray());
1592  ASSERT_TRUE(var.Dimensions.empty());
1593 }
1594 
1595 
1596 TEST_F(OpcUaBinaryDeserialization, Variant_QUALIFIED_NAME_DIMENSIONS)
1597 {
1598  using namespace OpcUa;
1599  using namespace OpcUa::Binary;
1600 
1601  char encodingMask = static_cast<uint8_t>(VariantType::QUALIFIED_NAME) | HAS_DIMENSIONS_MASK;
1602 
1603  const std::vector<char> expectedData =
1604  {
1605  encodingMask,
1606  1, 0, 4, 0, 0, 0, 'n', 'a', 'm', 'e',
1607  1, 0, 0, 0,
1608  1, 0, 0, 0,
1609  };
1610 
1611  GetChannel().SetData(expectedData);
1612 
1613  Variant var;
1614  GetStream() >> var;
1615 
1616  ASSERT_EQ(var.Type(), VariantType::QUALIFIED_NAME);
1617  ASSERT_EQ(var.As<QualifiedName>(), QualifiedName(1, "name"));
1618  ASSERT_FALSE(var.IsNul());
1619  ASSERT_FALSE(var.IsArray());
1620  ASSERT_EQ(var.Dimensions.size(), 1);
1621  ASSERT_EQ(var.Dimensions[0], 1);
1622 }
1623 
1625 TEST_F(OpcUaBinaryDeserialization, Variant_NODE_Id)
1626 {
1627  using namespace OpcUa;
1628  using namespace OpcUa::Binary;
1629 
1630  char encodingMask = static_cast<char>(VariantType::NODE_Id);
1631 
1632  const std::vector<char> expectedData =
1633  {
1634  encodingMask,
1635  1, 0, (char)0xC1, 0x1
1636  };
1637 
1638  GetChannel().SetData(expectedData);
1639 
1640  Variant var;
1641  GetStream() >> var;
1642 
1643  ASSERT_EQ(var.Type(), VariantType::NODE_Id);
1644  ASSERT_EQ(var.As<NodeId>(), OpcUa::FourByteNodeId(449));
1645  ASSERT_FALSE(var.IsNul());
1646  ASSERT_FALSE(var.IsArray());
1647  ASSERT_TRUE(var.Dimensions.empty());
1648 }
1649 
1650 TEST_F(OpcUaBinaryDeserialization, Variant_NODE_Id_Array)
1651 {
1652  using namespace OpcUa;
1653  using namespace OpcUa::Binary;
1654 
1655  char encodingMask = static_cast<uint8_t>(VariantType::NODE_Id) | HAS_ARRAY_MASK;
1656 
1657  const std::vector<char> expectedData =
1658  {
1659  encodingMask,
1660  2, 0, 0, 0,
1661  1, 0, (char)0xC1, 0x1,
1662  1, 0, (char)0xC1, 0x1
1663  };
1664 
1665  GetChannel().SetData(expectedData);
1666 
1667  Variant var;
1668  GetStream() >> var;
1669 
1670  ASSERT_EQ(var.Type(), VariantType::NODE_Id);
1671  std::vector<NodeId> vals;
1672  ASSERT_NO_THROW(vals = var.As<std::vector<NodeId>>());
1673  ASSERT_EQ(vals.size(), 2);
1674  ASSERT_EQ(vals[0], OpcUa::FourByteNodeId(449));
1675  ASSERT_EQ(vals[1], OpcUa::FourByteNodeId(449));
1676  ASSERT_FALSE(var.IsNul());
1677  ASSERT_TRUE(var.IsArray());
1678  ASSERT_TRUE(var.Dimensions.empty());
1679 }
1680 
1681 TEST_F(OpcUaBinaryDeserialization, Variant_NODE_Id_DIMENSIONS)
1682 {
1683  using namespace OpcUa;
1684  using namespace OpcUa::Binary;
1685 
1686  char encodingMask = static_cast<uint8_t>(VariantType::NODE_Id) | HAS_DIMENSIONS_MASK;
1687 
1688  const std::vector<char> expectedData =
1689  {
1690  encodingMask,
1691  1, 0, (char)0xC1, 0x1,
1692  1, 0, 0, 0,
1693  1, 0, 0, 0,
1694  };
1695 
1696  GetChannel().SetData(expectedData);
1697 
1698  Variant var;
1699  GetStream() >> var;
1700 
1701  ASSERT_EQ(var.Type(), VariantType::NODE_Id);
1702  ASSERT_EQ(var.As<NodeId>(), OpcUa::FourByteNodeId(449));
1703  ASSERT_FALSE(var.IsNul());
1704  ASSERT_FALSE(var.IsArray());
1705  ASSERT_EQ(var.Dimensions.size(), 1);
1706  ASSERT_EQ(var.Dimensions[0], 1);
1707 }
1708 
1710 
1711 TEST(Variant, InitializeNUL)
1712 {
1713  const OpcUa::Variant var;
1714  ASSERT_EQ(var.Type(), OpcUa::VariantType::NUL);
1715  ASSERT_FALSE(var.IsArray());
1716  ASSERT_TRUE(var.IsNul());
1717 }
1718 
1719 TEST(Variant, InitializeWithBoolValue)
1720 {
1721  const OpcUa::Variant var(true);
1722  ASSERT_EQ(var.Type(), OpcUa::VariantType::BOOLEAN);
1723  ASSERT_FALSE(var.IsArray());
1724  ASSERT_FALSE(var.IsNul());
1725 }
1726 
1727 TEST(Variant, AssignBoolValue)
1728 {
1729  OpcUa::Variant var;
1730  var = true;
1731  ASSERT_EQ(var.Type(), OpcUa::VariantType::BOOLEAN);
1732  ASSERT_FALSE(var.IsArray());
1733  ASSERT_FALSE(var.IsNul());
1734 }
1735 
1736 // TODO add tests for assign and initializing of variant with different types
1737 
1738 TEST(Variant, InitializeWithBoolVector)
1739 {
1740  const std::vector<bool> vec{true, false};
1741  const OpcUa::Variant var(vec);
1742  ASSERT_EQ(var.Type(), OpcUa::VariantType::BOOLEAN);
1743  ASSERT_TRUE(var.IsArray());
1744  ASSERT_FALSE(var.IsNul());
1745 }
1746 
1747 TEST(Variant, InitializeWithString)
1748 {
1749  const OpcUa::Variant var(std::string("string"));
1750  ASSERT_EQ(var.Type(), OpcUa::VariantType::STRING);
1751  ASSERT_FALSE(var.IsArray());
1752  ASSERT_FALSE(var.IsNul());
1753 }
1754 
1755 TEST(Variant, InitializeWithVariant)
1756 {
1757  const OpcUa::Variant var((uint32_t)OpcUa::NodeClass::Object);
1758  ASSERT_EQ(var.Type(), OpcUa::VariantType::UINT32);
1759  ASSERT_FALSE(var.IsArray());
1760  ASSERT_FALSE(var.IsNul());
1761 }
1762 
1763 TEST(Variant, InitializeObjectId)
1764 {
1765  const OpcUa::Variant var = OpcUa::ObjectId::RootFolder;
1766  ASSERT_EQ(var.Type(), OpcUa::VariantType::NODE_Id);
1767  ASSERT_EQ(var, OpcUa::ObjectId::RootFolder);
1768  ASSERT_FALSE(var.IsArray());
1769  ASSERT_FALSE(var.IsNul());
1770 }
1771 
1772 TEST(Variant, InitializeMessageId)
1773 {
1774  const OpcUa::Variant var = OpcUa::MessageId::READ_RESPONSE;
1775  ASSERT_EQ(var.Type(), OpcUa::VariantType::NODE_Id);
1776  ASSERT_EQ(var, OpcUa::MessageId::READ_RESPONSE);
1777  ASSERT_FALSE(var.IsArray());
1778  ASSERT_FALSE(var.IsNul());
1779 }
1780 
1781 /*
1782 
1783 TEST(Variant, InitializeWithBoolInitializerList)
1784 {
1785  const OpcUa::Variant var{true};
1786  ASSERT_EQ(var.Type, OpcUa::VariantType::BOOLEAN);
1787  ASSERT_FALSE(var.IsArray());
1788  ASSERT_FALSE(var.IsNul());
1789 }
1790 
1791 
1792 
1793  case VariantType::BOOLEAN: var.Boolean = value.Boolean; break;
1794  case VariantType::SBYTE: var.SByte = value.SByte; break;
1795  case VariantType::BYTE: var.Byte = value.Byte; break;
1796  case VariantType::INT16: var.Int16 = value.Int16; break;
1797  case VariantType::UINT16: var.UInt16 = value.UInt16; break;
1798  case VariantType::INT32: var.Int32 = value.Int32; break;
1799  case VariantType::UINT32: var.UInt32 = value.UInt32; break;
1800  case VariantType::INT64: var.Int64 = value.Int64; break;
1801  case VariantType::UINT64: var.UInt64 = value.UInt64; break;
1802  case VariantType::FLOAT: var.Float = value.Float; break;
1803  case VariantType::DOUBLE: var.Double = value.Double; break;
1804  case VariantType::STRING: var.String = value.String; break;
1805  case VariantType::DATE_TIME: var.Time = value.Time; break;
1806  case VariantType::GUId: var.Guids = value.Guids; break;
1807  case VariantType::BYTE_STRING: var.ByteString = value.ByteString; break;
1808  case VariantType::XML_ELEMENT: var.String = value.String; break;
1809  case VariantType::NODE_Id: var.Node = value.Node; break;
1810  case VariantType::EXPANDED_NODE_Id: var.Node = value.Node; break;
1811  case VariantType::STATUS_CODE: var.StatusCode = value.StatusCode; break;
1812  case VariantType::QUALIFIED_NAME: var.Name = value.Name; break;
1813  case VariantType::LOCALIZED_TEXT: var.Text = value.Text; break;
1814  case VariantType::DIAGNOSTIC_INFO: var.Diagnostic = value.Diagnostic; break;
1815  case VariantType::VARIANT: var.Variants = value.Variants; break;
1816  case VariantType::DATA_VALUE: var.Value = value.Value; break;
1817  */
1818 
1819 TEST(Variant, Comparable)
1820 {
1821  ASSERT_EQ(OpcUa::Variant(), OpcUa::Variant());
1822 
1823  ASSERT_EQ(OpcUa::Variant(1), OpcUa::Variant(1));
1824  ASSERT_EQ(OpcUa::Variant(1), 1);
1825  ASSERT_NE(OpcUa::Variant(1), 2);
1826 
1827  ASSERT_EQ(OpcUa::Variant(true), OpcUa::Variant(true));
1828  ASSERT_EQ(OpcUa::Variant(true), true);
1829 
1830  ASSERT_NE(OpcUa::Variant(true), OpcUa::Variant(false));
1831  ASSERT_NE(OpcUa::Variant(true), false);
1832 }
OpcUa::Guid::Data2
uint16_t Data2
Definition: guid.h:22
PrintData
std::string PrintData(const std::vector< char > &vec)
Test of opc ua binary handshake. GNU LGPL.
Definition: tests/protocol/common.h:29
OpcUa::Variant::IsNul
bool IsNul() const
Definition: binary_variant.cpp:358
OpcUa::Guid::Data1
uint32_t Data1
Definition: guid.h:21
CreateTestGuid
OpcUa::Guid CreateTestGuid()
Definition: binary_serialize_variant.cpp:1081
OpcUa::HAS_DIMENSIONS_MASK
const uint8_t HAS_DIMENSIONS_MASK
Definition: variant.h:58
OpcUa::HAS_ARRAY_MASK
const uint8_t HAS_ARRAY_MASK
Definition: variant.h:59
OpcUa::Binary::flush
OStream< ChannelType > & flush(OStream< ChannelType > &os)
Definition: stream.h:147
ASSERT_NE
#define ASSERT_NE(val1, val2)
Definition: gmock/fused-src/gtest/gtest.h:21024
OpcUa::Guid::Data3
uint16_t Data3
Definition: guid.h:23
OpcUa::Variant::Type
VariantType Type() const
Definition: binary_variant.cpp:391
extension_identifiers.h
ASSERT_NO_THROW
#define ASSERT_NO_THROW(statement)
Definition: gmock/fused-src/gtest/gtest.h:20553
OpcUa
OPC UA Address space part. GNU LGPL.
Definition: ua/client/addon.h:18
data_value.h
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition: gmock/fused-src/gtest/gtest.h:20567
OpcUa::Variant::Dimensions
std::vector< uint32_t > Dimensions
Definition: variant.h:163
OpcUa::Guid::Data4
uint8_t Data4[8]
Definition: guid.h:24
message_identifiers.h
ASSERT_EQ
#define ASSERT_EQ(val1, val2)
Definition: gmock/fused-src/gtest/gtest.h:21020
OpcUa::Variant::IsArray
bool IsArray() const
Definition: binary_variant.cpp:363
OpcUa::Variant::As
T As() const
Definition: variant.h:271
TEST_F
TEST_F(OpcUaBinarySerialization, Variant_NUL)
Test of opc ua binary attributes. GNU LGPL.
Definition: binary_serialize_variant.cpp:27
TEST
TEST(Variant, InitializeNUL)
Definition: binary_serialize_variant.cpp:1711
ASSERT_FALSE
#define ASSERT_FALSE(condition)
Definition: gmock/fused-src/gtest/gtest.h:20570
OpcUa::FourByteNodeId
NodeId FourByteNodeId(uint16_t value, uint8_t namespaceIndex=0)
Definition: nodeid.h:209
OpcUa::Binary::RawSize
std::size_t RawSize(const T &obj)

ros_opcua_impl_freeopcua
Author(s): Denis Štogl
autogenerated on Tue Jan 19 2021 03:06:04