node_id.cpp
Go to the documentation of this file.
1 
11 #include "common.h"
12 
13 using namespace testing;
14 using namespace OpcUa;
15 
16 class NodeDeserialization : public OpcUaBinaryDeserialization
17 {
18 };
19 
20 class NodeSerialization : public OpcUaBinarySerialization
21 {
22 };
23 
24 class NodeComparing : public OpcUaBinarySerialization
25 {
26 };
27 
28 
29 TEST(NodeId, DefaultConstructor)
30 {
31  NodeId id;
32  ASSERT_EQ(id.Encoding, EV_TWO_BYTE);
33  ASSERT_EQ(id.TwoByteData.Identifier, 0);
34  ASSERT_EQ(id.ServerIndex, 0);
35  ASSERT_EQ(id.NamespaceURI, std::string());
36 }
37 
38 TEST(NodeId, NumericConstructor)
39 {
40  NodeId id(99, 1);
41  ASSERT_EQ(id.Encoding, EV_NUMERIC);
42  ASSERT_EQ(id.NumericData.Identifier, 99);
43  ASSERT_EQ(id.GetNamespaceIndex(), 1);
44 }
45 
46 TEST(Node, StringConstructor)
47 {
48  NodeId id("StrId", 10);
49  ASSERT_EQ(id.Encoding, EV_STRING);
50  ASSERT_EQ(id.GetStringIdentifier(), "StrId");
51  ASSERT_EQ(id.GetNamespaceIndex(), 10);
52 }
53 
54 TEST(Node, ConstructFromMessageId)
55 {
56  NodeId id(ACTIVATE_SESSION_REQUEST);
57  ASSERT_EQ(id.Encoding, EV_FOUR_BYTE);
58  ASSERT_EQ(id.FourByteData.Identifier, ACTIVATE_SESSION_REQUEST);
59  ASSERT_EQ(id.ServerIndex, 0);
60  ASSERT_EQ(id.NamespaceURI, std::string());
61 }
62 
63 TEST(Node, ConstructFromReferenceId)
64 {
65  NodeId id(ReferenceId::HasChild);
66  ASSERT_EQ(id.Encoding, EV_NUMERIC);
67  ASSERT_EQ(id.NumericData.Identifier, static_cast<uint16_t>(ReferenceId::HasChild));
68  ASSERT_EQ(id.ServerIndex, 0);
69  ASSERT_EQ(id.NamespaceURI, std::string());
70 }
71 
72 TEST(Node, EqualIfSameType)
73 {
74  NodeId id1(ReferenceId::HasChild);
75  NodeId id2(ReferenceId::HasChild);
76  ASSERT_EQ(id1, id2);
77 }
78 
79 TEST(Node, NotEqualByReferenceId)
80 {
81  NodeId id1(ReferenceId::HasChild);
82  NodeId id2(ReferenceId::Organizes);
83  ASSERT_NE(id1, id2);
84 }
85 
86 TEST(Node, NotEqualByObjectId)
87 {
88  NodeId id(ReferenceId::Organizes);
89  ASSERT_NE(id, ObjectId::RootFolder);
90 }
91 
92 TEST(Node, EqualIfDifferentTypeButEqualIdentifier)
93 {
94  NodeId id1;
95  id1.Encoding = EV_TWO_BYTE;
96  id1.TwoByteData.Identifier = 1;
97 
98  NodeId id2;
99  id2.Encoding = EV_FOUR_BYTE;
100  id2.FourByteData.Identifier = 1;
101  ASSERT_EQ(id1, id2);
102 }
103 
104 TEST(Node, DefferentIfDifferentNameSpace)
105 {
106  NodeId id1;
107  id1.Encoding = EV_FOUR_BYTE;
108  id1.FourByteData.NamespaceIndex = 1;
109  id1.FourByteData.Identifier = 1;
110 
111  NodeId id2;
112  id2.Encoding = EV_FOUR_BYTE;
113  id2.FourByteData.NamespaceIndex = 2;
114  id2.FourByteData.Identifier = 1;
115 
116  ASSERT_NE(id1, id2);
117 }
118 
119 
120 
121 //---------------------------------------------------------
122 // Deserialization
123 //---------------------------------------------------------
124 
125 TEST_F(NodeDeserialization, TwoByte)
126 {
127  const std::vector<char> expectedData =
128  {
129  EV_TWO_BYTE,
130  1
131  };
132 
133  GetChannel().SetData(expectedData);
134 
135  NodeId id;
136  GetStream() >> id;
137 
138  ASSERT_EQ(id.Encoding, EV_TWO_BYTE);
139  ASSERT_EQ(id.TwoByteData.Identifier, 0x1);
140 }
141 
142 TEST_F(NodeDeserialization, FourByte)
143 {
144  using namespace OpcUa;
145 
146  const std::vector<char> expectedData =
147  {
148  EV_FOUR_BYTE,
149  1,
150  2, 0
151  };
152 
153  GetChannel().SetData(expectedData);
154 
155  NodeId id;
156  GetStream() >> id;
157 
158  ASSERT_EQ(id.Encoding, EV_FOUR_BYTE);
159  ASSERT_EQ(id.FourByteData.NamespaceIndex, 0x1);
160  ASSERT_EQ(id.FourByteData.Identifier, 0x2);
161 }
162 
163 TEST_F(NodeDeserialization, Numeric)
164 {
165  using namespace OpcUa;
166 
167  const std::vector<char> expectedData =
168  {
169  EV_NUMERIC,
170  1, 0,
171  2, 0, 0, 0
172  };
173 
174  GetChannel().SetData(expectedData);
175 
176  NodeId id;
177  GetStream() >> id;
178 
179  ASSERT_EQ(id.Encoding, EV_NUMERIC);
180  ASSERT_EQ(id.NumericData.NamespaceIndex, 0x1);
181  ASSERT_EQ(id.NumericData.Identifier, 0x2);
182 }
183 
184 TEST_F(NodeDeserialization, String)
185 {
186  using namespace OpcUa;
187 
188  const std::vector<char> expectedData =
189  {
190  EV_STRING,
191  1, 0,
192  2, 0, 0, 0,
193  'i', 'd'
194  };
195 
196  GetChannel().SetData(expectedData);
197 
198  NodeId id;
199  GetStream() >> id;
200 
201  ASSERT_EQ(id.Encoding, EV_STRING);
202  ASSERT_EQ(id.StringData.NamespaceIndex, 0x1);
203  ASSERT_EQ(id.StringData.Identifier, "id");
204 }
205 
206 TEST_F(NodeDeserialization, Guid)
207 {
208  using namespace OpcUa;
209 
210  const std::vector<char> expectedData =
211  {
212  EV_BYTE_STRING,
213  1, 0,
214  4, 0, 0, 0,
215  1, 2, 3, 4
216  };
217 
218  GetChannel().SetData(expectedData);
219 
220  NodeId id;
221  GetStream() >> id;
222 
223  ASSERT_EQ(id.Encoding, EV_BYTE_STRING);
224  ASSERT_EQ(id.BinaryData.NamespaceIndex, 0x1);
225  std::vector<uint8_t> expectedBytes = {1, 2, 3, 4};
226  ASSERT_EQ(id.BinaryData.Identifier, expectedBytes);
227 }
228 
229 TEST_F(NodeDeserialization, ByteString)
230 {
231  using namespace OpcUa;
232 
233  const std::vector<char> expectedData =
234  {
235  EV_GUId,
236  1, 0,
237  4, 3, 2, 1,
238  6, 5,
239  8, 7,
240  1, 2, 3, 4, 5, 6, 7, 8
241  };
242 
243  GetChannel().SetData(expectedData);
244 
245  NodeId id;
246  GetStream() >> id;
247 
248  ASSERT_EQ(id.Encoding, EV_GUId);
249  ASSERT_EQ(id.GuidData.NamespaceIndex, 0x1);
250  ASSERT_EQ(id.GuidData.Identifier.Data1, 0x01020304);
251  ASSERT_EQ(id.GuidData.Identifier.Data2, 0x0506);
252  ASSERT_EQ(id.GuidData.Identifier.Data3, 0x0708);
253  ASSERT_EQ(id.GuidData.Identifier.Data4[0], 0x01);
254  ASSERT_EQ(id.GuidData.Identifier.Data4[1], 0x02);
255  ASSERT_EQ(id.GuidData.Identifier.Data4[2], 0x03);
256  ASSERT_EQ(id.GuidData.Identifier.Data4[3], 0x04);
257  ASSERT_EQ(id.GuidData.Identifier.Data4[4], 0x05);
258  ASSERT_EQ(id.GuidData.Identifier.Data4[5], 0x06);
259  ASSERT_EQ(id.GuidData.Identifier.Data4[6], 0x07);
260  ASSERT_EQ(id.GuidData.Identifier.Data4[7], 0x08);
261 }
262 
263 TEST_F(NodeDeserialization, NamespaceUri)
264 {
265  using namespace OpcUa;
266 
267  const std::vector<char> expectedData =
268  {
269  int8_t(EV_STRING | EV_NAMESPACE_URI_FLAG),
270  1, 0,
271  2, 0, 0, 0,
272  'i', 'd',
273  3, 0, 0, 0,
274  'u', 'r', 'i'
275  };
276 
277  GetChannel().SetData(expectedData);
278 
279  NodeId id;
280  GetStream() >> id;
281 
282  ASSERT_EQ(id.Encoding, uint8_t(EV_STRING | EV_NAMESPACE_URI_FLAG));
283  ASSERT_EQ(id.StringData.NamespaceIndex, 0x1);
284  ASSERT_EQ(id.StringData.Identifier, "id");
285  ASSERT_EQ(id.NamespaceURI, "uri");
286 }
287 
288 TEST_F(NodeDeserialization, ServerIndexFlag)
289 {
290  using namespace OpcUa;
291 
292  const std::vector<char> expectedData =
293  {
294  int8_t(EV_STRING | EV_Server_INDEX_FLAG),
295  1, 0,
296  2, 0, 0, 0,
297  'i', 'd',
298  1, 0, 0, 0,
299  };
300 
301  GetChannel().SetData(expectedData);
302 
303  NodeId id;
304  GetStream() >> id;
305 
306  ASSERT_EQ(id.Encoding, uint8_t(EV_STRING | EV_Server_INDEX_FLAG));
307  ASSERT_EQ(id.StringData.NamespaceIndex, 0x1);
308  ASSERT_EQ(id.StringData.Identifier, "id");
309  ASSERT_EQ(id.ServerIndex, 1);
310 }
311 
312 TEST_F(NodeDeserialization, NamespaceUriAndServerIndex)
313 {
314  using namespace OpcUa;
315 
316  const std::vector<char> expectedData =
317  {
318  int8_t(EV_STRING | EV_NAMESPACE_URI_FLAG | EV_Server_INDEX_FLAG),
319  1, 0,
320  2, 0, 0, 0,
321  'i', 'd',
322  3, 0, 0, 0,
323  'u', 'r', 'i',
324  1, 0, 0, 0
325  };
326 
327  GetChannel().SetData(expectedData);
328 
329  NodeId id;
330  GetStream() >> id;
331 
332  ASSERT_EQ(id.Encoding, uint8_t(EV_STRING | EV_NAMESPACE_URI_FLAG | EV_Server_INDEX_FLAG));
333  ASSERT_EQ(id.StringData.NamespaceIndex, 0x1);
334  ASSERT_EQ(id.StringData.Identifier, "id");
335  ASSERT_EQ(id.NamespaceURI, "uri");
336  ASSERT_EQ(id.ServerIndex, 1);
337 }
338 
339 //---------------------------------------------------------
340 // Serialization
341 //---------------------------------------------------------
342 
343 TEST_F(NodeSerialization, ToByte)
344 {
345  using namespace OpcUa;
346  using namespace OpcUa::Binary;
347  NodeId id;
348  id.Encoding = EV_TWO_BYTE;
349  id.TwoByteData.Identifier = 0x1;
350 
351  const std::vector<char> expectedData =
352  {
353  EV_TWO_BYTE,
354  1
355  };
356 
357  GetStream() << id << flush;
358 
359  ASSERT_EQ(expectedData, GetChannel().SerializedData);
360  ASSERT_EQ(expectedData.size(), RawSize(id));
361 }
362 
363 TEST_F(NodeSerialization, FourByte)
364 {
365  using namespace OpcUa;
366  using namespace OpcUa::Binary;
367  NodeId id;
368  id.Encoding = EV_FOUR_BYTE;
369  id.FourByteData.NamespaceIndex = 0x1;
370  id.FourByteData.Identifier = 0x2;
371 
372  const std::vector<char> expectedData =
373  {
374  EV_FOUR_BYTE,
375  1,
376  2, 0
377  };
378 
379  GetStream() << id << flush;
380 
381  ASSERT_EQ(expectedData, GetChannel().SerializedData);
382  ASSERT_EQ(expectedData.size(), RawSize(id));
383 }
384 
385 TEST_F(NodeSerialization, Numeric)
386 {
387  using namespace OpcUa;
388  using namespace OpcUa::Binary;
389  NodeId id;
390  id.Encoding = EV_NUMERIC;
391  id.NumericData.NamespaceIndex = 0x1;
392  id.NumericData.Identifier = 0x2;
393 
394  const std::vector<char> expectedData =
395  {
396  EV_NUMERIC,
397  1, 0,
398  2, 0, 0, 0
399  };
400 
401  GetStream() << id << flush;
402 
403  ASSERT_EQ(expectedData, GetChannel().SerializedData);
404  ASSERT_EQ(expectedData.size(), RawSize(id));
405 }
406 
407 TEST_F(NodeSerialization, String)
408 {
409  using namespace OpcUa;
410  using namespace OpcUa::Binary;
411  NodeId id;
412  id.Encoding = EV_STRING;
413  id.StringData.NamespaceIndex = 0x1;
414  id.StringData.Identifier = "id";
415 
416  const std::vector<char> expectedData =
417  {
418  EV_STRING,
419  1, 0,
420  2, 0, 0, 0,
421  'i', 'd'
422  };
423 
424  GetStream() << id << flush;
425 
426  ASSERT_EQ(expectedData, GetChannel().SerializedData);
427  ASSERT_EQ(expectedData.size(), RawSize(id));
428 }
429 
430 TEST_F(NodeSerialization, ByteString)
431 {
432  using namespace OpcUa;
433  using namespace OpcUa::Binary;
434  NodeId id;
435  id.Encoding = EV_BYTE_STRING;
436  id.BinaryData.NamespaceIndex = 0x1;
437  id.BinaryData.Identifier = {1, 2, 3, 4};
438 
439  const std::vector<char> expectedData =
440  {
441  EV_BYTE_STRING,
442  1, 0,
443  4, 0, 0, 0,
444  1, 2, 3, 4
445  };
446 
447  GetStream() << id << flush;
448 
449  ASSERT_EQ(expectedData, GetChannel().SerializedData);
450  ASSERT_EQ(expectedData.size(), RawSize(id));
451 }
452 
453 TEST_F(NodeSerialization, Guid)
454 {
455  using namespace OpcUa;
456  using namespace OpcUa::Binary;
457  NodeId id;
458  id.Encoding = EV_GUId;
459  id.GuidData.NamespaceIndex = 0x1;
460  id.GuidData.Identifier.Data1 = 0x01020304;
461  id.GuidData.Identifier.Data2 = 0x0506;
462  id.GuidData.Identifier.Data3 = 0x0708;
463  id.GuidData.Identifier.Data4[0] = 0x01;
464  id.GuidData.Identifier.Data4[1] = 0x02;
465  id.GuidData.Identifier.Data4[2] = 0x03;
466  id.GuidData.Identifier.Data4[3] = 0x04;
467  id.GuidData.Identifier.Data4[4] = 0x05;
468  id.GuidData.Identifier.Data4[5] = 0x06;
469  id.GuidData.Identifier.Data4[6] = 0x07;
470  id.GuidData.Identifier.Data4[7] = 0x08;
471 
472  const std::vector<char> expectedData =
473  {
474  EV_GUId,
475  1, 0,
476  4, 3, 2, 1,
477  6, 5,
478  8, 7,
479  1, 2, 3, 4, 5, 6, 7, 8
480  };
481 
482  GetStream() << id << flush;
483 
484  ASSERT_EQ(expectedData, GetChannel().SerializedData);
485  ASSERT_EQ(expectedData.size(), RawSize(id));
486 }
487 
488 TEST_F(NodeSerialization, NamespaceUri)
489 {
490  using namespace OpcUa;
491  using namespace OpcUa::Binary;
492  ExpandedNodeId id;
493  id.Encoding = static_cast<NodeIdEncoding>(EV_STRING | EV_NAMESPACE_URI_FLAG);
494  id.StringData.NamespaceIndex = 0x1;
495  id.StringData.Identifier = "id";
496  id.NamespaceURI = "uri";
497 
498  const std::vector<char> expectedData =
499  {
500  int8_t(EV_STRING | EV_NAMESPACE_URI_FLAG),
501  1, 0,
502  2, 0, 0, 0,
503  'i', 'd',
504  3, 0, 0, 0,
505  'u', 'r', 'i'
506  };
507 
508  GetStream() << id << flush;
509 
510  ASSERT_EQ(expectedData, GetChannel().SerializedData);
511  ASSERT_EQ(expectedData.size(), RawSize(id));
512 }
513 
514 TEST_F(NodeSerialization, ServerIndexFlag)
515 {
516  using namespace OpcUa;
517  using namespace OpcUa::Binary;
518  ExpandedNodeId id;
519  id.Encoding = static_cast<NodeIdEncoding>(EV_STRING | EV_Server_INDEX_FLAG);
520  id.StringData.NamespaceIndex = 0x1;
521  id.StringData.Identifier = "id";
522  id.ServerIndex = 1;
523 
524  const std::vector<char> expectedData =
525  {
526  int8_t(EV_STRING | EV_Server_INDEX_FLAG),
527  1, 0,
528  2, 0, 0, 0,
529  'i', 'd',
530  1, 0, 0, 0,
531  };
532 
533  GetStream() << id << flush;
534 
535  ASSERT_EQ(expectedData, GetChannel().SerializedData);
536  ASSERT_EQ(expectedData.size(), RawSize(id));
537 }
538 
539 TEST_F(NodeSerialization, NamespaceUriAndServerIndex)
540 {
541  using namespace OpcUa;
542  using namespace OpcUa::Binary;
543  ExpandedNodeId id;
544  id.Encoding = static_cast<NodeIdEncoding>(EV_STRING | EV_NAMESPACE_URI_FLAG | EV_Server_INDEX_FLAG);
545  id.StringData.NamespaceIndex = 0x1;
546  id.StringData.Identifier = "id";
547  id.NamespaceURI = "uri";
548  id.ServerIndex = 1;
549 
550  const std::vector<char> expectedData =
551  {
552  int8_t(EV_STRING | EV_NAMESPACE_URI_FLAG | EV_Server_INDEX_FLAG),
553  1, 0,
554  2, 0, 0, 0,
555  'i', 'd',
556  3, 0, 0, 0,
557  'u', 'r', 'i',
558  1, 0, 0, 0
559  };
560 
561  GetStream() << id << flush;
562 
563  ASSERT_EQ(expectedData, GetChannel().SerializedData);
564  ASSERT_EQ(expectedData.size(), RawSize(id));
565 }
566 
567 //-----------------------------------------------------------------
568 // Comparing for less
569 //-----------------------------------------------------------------
570 
571 TEST_F(NodeComparing, TwoByteForLess)
572 {
573  EXPECT_TRUE(TwoByteNodeId(1) < TwoByteNodeId(2));
574 }
575 
576 TEST_F(NodeComparing, TwoByteForNotLess)
577 {
578  EXPECT_FALSE(TwoByteNodeId(2) < TwoByteNodeId(2));
579 }
580 
581 TEST_F(NodeComparing, TwoByteForEqual)
582 {
583  EXPECT_TRUE(TwoByteNodeId(2) == TwoByteNodeId(2));
584 }
585 
586 TEST_F(NodeComparing, FourByteForLess)
587 {
588  EXPECT_TRUE(FourByteNodeId(1) < FourByteNodeId(2));
589 }
590 
591 TEST_F(NodeComparing, FourByteForNotLess)
592 {
593  EXPECT_FALSE(FourByteNodeId(2) < FourByteNodeId(2));
594 }
595 
596 TEST_F(NodeComparing, FourByteForEqual)
597 {
598  EXPECT_TRUE(FourByteNodeId(2) == FourByteNodeId(2));
599 }
600 
601 TEST_F(NodeComparing, NumericForLess)
602 {
603  EXPECT_TRUE(NumericNodeId(1) < NumericNodeId(2));
604 }
605 
606 TEST_F(NodeComparing, NumericNotLess)
607 {
608  EXPECT_FALSE(NumericNodeId(2) < NumericNodeId(2));
609 }
610 
611 TEST_F(NodeComparing, NumericEqual)
612 {
613  EXPECT_TRUE(NumericNodeId(2) == NumericNodeId(2));
614 }
615 
616 TEST_F(NodeComparing, StringForLess)
617 {
618  EXPECT_TRUE(StringNodeId("1") < StringNodeId("2"));
619 }
620 
621 TEST_F(NodeComparing, StringNotLess)
622 {
623  EXPECT_FALSE(StringNodeId("2") < StringNodeId("2"));
624 }
625 
626 TEST_F(NodeComparing, StringEqual)
627 {
628  EXPECT_TRUE(StringNodeId("2") == StringNodeId("2"));
629 }
630 
631 TEST_F(NodeComparing, BinaryForLess)
632 {
633  EXPECT_TRUE(BinaryNodeId({1, 1}) < BinaryNodeId({2, 2}));
634 }
635 
636 TEST_F(NodeComparing, BinaryNotLess)
637 {
638  EXPECT_FALSE(BinaryNodeId({2, 3}) < BinaryNodeId({2, 3}));
639 }
640 
641 TEST_F(NodeComparing, BinaryEqual)
642 {
643  EXPECT_TRUE(BinaryNodeId({2, 2}) == BinaryNodeId({2, 2}));
644 }
645 
646 TEST_F(NodeComparing, GuidForLess)
647 {
648  Guid l;
649  l.Data1 = 1;
650  Guid r;
651  r.Data1 = 2;
652  EXPECT_TRUE(GuidNodeId(l) < GuidNodeId(r));
653 }
654 
655 TEST_F(NodeComparing, GuidNotLess)
656 {
657  Guid l;
658  l.Data1 = 1;
659  Guid r;
660  r.Data1 = 1;
661  EXPECT_FALSE(GuidNodeId(l) < GuidNodeId(r));
662 }
663 
664 TEST_F(NodeComparing, GuidEqual)
665 {
666  Guid l;
667  l.Data1 = 1;
668  Guid r;
669  r.Data1 = 1;
670  EXPECT_TRUE(GuidNodeId(l) == GuidNodeId(r));
671 }
672 
673 TEST_F(NodeComparing, NodesEqual)
674 {
675  uint32_t id = 1;
676  uint32_t ns = 2;
677 
678  NodeId node1 = NumericNodeId(id, ns);
679  NodeId node2;
680  node2 = node1;
681  ASSERT_EQ(node1, node2);
682  ASSERT_EQ(node1, NodeId(node1));
683 }
684 
685 TEST(NodeId, SettingNamespaceUri_And_Index)
686 {
687  uint32_t id = 1;
688  uint32_t ns = 2;
689  NodeId node = NumericNodeId(id, ns);
690  node.SetNamespaceURI("uri");
691  node.SetServerIndex(3);
692 
693  ASSERT_TRUE(node.HasNamespaceURI());
694  ASSERT_TRUE(node.HasServerIndex());
695 }
OpcUa::TwoByteNodeId
NodeId TwoByteNodeId(uint8_t value)
Definition: nodeid.h:201
testing::TEST_F
TEST_F(TestInfoTest, Names)
Definition: gmock/gtest/test/gtest_unittest.cc:5195
OpcUa::Guid::Data1
uint32_t Data1
Definition: guid.h:21
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gmock/fused-src/gtest/gtest.h:20561
OpcUa::NodeId::HasNamespaceURI
bool HasNamespaceURI() const
Definition: nodeid.cpp:470
OpcUa::Binary::flush
OStream< ChannelType > & flush(OStream< ChannelType > &os)
Definition: stream.h:147
OpcUa::NodeId::TwoByteData
struct OpcUa::NodeId::TwoByteDataType TwoByteData
ASSERT_NE
#define ASSERT_NE(val1, val2)
Definition: gmock/fused-src/gtest/gtest.h:21024
OpcUa::NodeId::SetNamespaceURI
void SetNamespaceURI(const std::string &uri)
Definition: nodeid.cpp:480
OpcUa::NodeId::SetServerIndex
void SetServerIndex(uint32_t index)
Definition: nodeid.cpp:486
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gmock/fused-src/gtest/gtest.h:20564
OpcUa::GuidNodeId
NodeId GuidNodeId(Guid value, uint16_t namespaceIndex=0)
Definition: nodeid.h:245
testing::TEST
TEST(GTestEnvVarTest, Dummy)
Definition: gmock/gtest/test/gtest_env_var_test_.cc:50
OpcUa::Names::Organizes
const char Organizes[]
Definition: strings.h:123
OpcUa::NodeId::FourByteData
struct OpcUa::NodeId::FourByteDataType FourByteData
OpcUa
OPC UA Address space part. GNU LGPL.
Definition: ua/client/addon.h:18
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition: gmock/fused-src/gtest/gtest.h:20567
OpcUa::NodeId::HasServerIndex
bool HasServerIndex() const
Definition: nodeid.cpp:475
OpcUa::NodeIdEncoding
NodeIdEncoding
Definition: nodeid.h:27
ASSERT_EQ
#define ASSERT_EQ(val1, val2)
Definition: gmock/fused-src/gtest/gtest.h:21020
OpcUa::Node
A Node object represent an OPC-UA node. It is high level object intended for developper who want to e...
Definition: node.h:42
OpcUa::NodeId::Encoding
NodeIdEncoding Encoding
Definition: nodeid.h:46
OpcUa::BinaryNodeId
NodeId BinaryNodeId(std::vector< uint8_t > value, uint16_t namespaceIndex=0)
Definition: nodeid.h:236
OpcUa::StringNodeId
NodeId StringNodeId(std::string value, uint16_t namespaceIndex=0)
Definition: nodeid.h:227
OpcUa::Names::HasChild
const char HasChild[]
Definition: strings.h:68
OpcUa::NumericNodeId
NodeId NumericNodeId(uint32_t value, uint16_t namespaceIndex=0)
Definition: nodeid.h:218
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:12:07