1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation;
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17 #include "ns3/test.h"
18 #include "ns3/names.h"
19
20
21 /**
22 * \file
23 * \ingroup core-tests
24 * \ingroup config
25 * \ingroup names-tests
26 * Object Names test suite.
27 */
28
29 /**
30 * \ingroup core-tests
31 * \defgroup names-tests Object Names test suite
32 */
33
34 namespace ns3 {
35
36 namespace tests {
37
38
39 /**
40 * \ingroup names-tests
41 * Simple test object to exercise the Name service.
42 */
43 class TestObject : public Object
44 {
45 public:
46 /**
47 * Register this type.
48 * \return The TypeId.
49 */
GetTypeId(void)50 static TypeId GetTypeId (void)
51 {
52 static TypeId tid = TypeId ("TestObject")
53 .SetParent<Object> ()
54 .SetGroupName ("Core")
55 .HideFromDocumentation ()
56 .AddConstructor<TestObject> ();
57 return tid;
58 }
59 /** Constructor. */
TestObject()60 TestObject ()
61 {}
62 };
63
64 /**
65 * \ingroup names-tests
66 * Alternate test object for the Name service.
67 */
68 class AlternateTestObject : public Object
69 {
70 public:
71 /**
72 * Register this type.
73 * \return The TypeId.
74 */
GetTypeId(void)75 static TypeId GetTypeId (void)
76 {
77 static TypeId tid = TypeId ("AlternateTestObject")
78 .SetParent<Object> ()
79 .SetGroupName ("Core")
80 .HideFromDocumentation ()
81 .AddConstructor<AlternateTestObject> ();
82 return tid;
83 }
84 /** Constructor. */
AlternateTestObject()85 AlternateTestObject ()
86 {}
87 };
88
89 /**
90 * \ingroup names-tests
91 * Test the Object Name Service can do its most basic job.
92 *
93 * Add associations between Objects using the lowest level add
94 * function, which is:
95 *
96 * Add (Ptr<Object> context, std::string name, Ptr<Object> object);
97 *
98 * All other add functions will just translate into this form, so this is the
99 * most basic Add functionality.
100 */
101 class BasicAddTestCase : public TestCase
102 {
103 public:
104 /** Constructor. */
105 BasicAddTestCase ();
106 /** Destructor. */
107 virtual ~BasicAddTestCase ();
108
109 private:
110 virtual void DoRun (void);
111 virtual void DoTeardown (void);
112 };
113
BasicAddTestCase()114 BasicAddTestCase::BasicAddTestCase ()
115 : TestCase ("Check low level Names::Add and Names::FindName functionality")
116 {}
117
~BasicAddTestCase()118 BasicAddTestCase::~BasicAddTestCase ()
119 {}
120
121 void
DoTeardown(void)122 BasicAddTestCase::DoTeardown (void)
123 {
124 Names::Clear ();
125 }
126
127 void
DoRun(void)128 BasicAddTestCase::DoRun (void)
129 {
130 std::string found;
131
132 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
133 Names::Add (Ptr<Object> (0, false), "Name One", objectOne);
134
135 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
136 Names::Add (Ptr<Object> (0, false), "Name Two", objectTwo);
137
138 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
139 Names::Add (objectOne, "Child", childOfObjectOne);
140
141 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
142 Names::Add (objectTwo, "Child", childOfObjectTwo);
143
144 found = Names::FindName (objectOne);
145 NS_TEST_ASSERT_MSG_EQ (found, "Name One", "Could not Names::Add and Names::FindName an Object");
146
147 found = Names::FindName (objectTwo);
148 NS_TEST_ASSERT_MSG_EQ (found, "Name Two", "Could not Names::Add and Names::FindName a second Object");
149
150 found = Names::FindName (childOfObjectOne);
151 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
152
153 found = Names::FindName (childOfObjectTwo);
154 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
155 }
156
157 /**
158 * \ingroup names-tests
159 * Test the Object Name Service can correctly use a string context.
160 *
161 * Add (std::string context, std::string name, Ptr<Object> object);
162 *
163 * High level path-based functions will translate into this form, so this is
164 * the second most basic Add functionality.
165 */
166 class StringContextAddTestCase : public TestCase
167 {
168 public:
169 /** Constructor. */
170 StringContextAddTestCase ();
171 /** Destructor. */
172 virtual ~StringContextAddTestCase ();
173
174 private:
175 virtual void DoRun (void);
176 virtual void DoTeardown (void);
177 };
178
StringContextAddTestCase()179 StringContextAddTestCase::StringContextAddTestCase ()
180 : TestCase ("Check string context Names::Add and Names::FindName functionality")
181
182 {}
183
~StringContextAddTestCase()184 StringContextAddTestCase::~StringContextAddTestCase ()
185 {}
186
187 void
DoTeardown(void)188 StringContextAddTestCase::DoTeardown (void)
189 {
190 Names::Clear ();
191 }
192
193 void
DoRun(void)194 StringContextAddTestCase::DoRun (void)
195 {
196 std::string found;
197
198 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
199 Names::Add ("/Names", "Name One", objectOne);
200
201 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
202 Names::Add ("/Names", "Name Two", objectTwo);
203
204 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
205 Names::Add ("/Names/Name One", "Child", childOfObjectOne);
206
207 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
208 Names::Add ("/Names/Name Two", "Child", childOfObjectTwo);
209
210 found = Names::FindName (objectOne);
211 NS_TEST_ASSERT_MSG_EQ (found, "Name One", "Could not Names::Add and Names::FindName an Object");
212
213 found = Names::FindName (objectTwo);
214 NS_TEST_ASSERT_MSG_EQ (found, "Name Two", "Could not Names::Add and Names::FindName a second Object");
215
216 found = Names::FindName (childOfObjectOne);
217 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
218
219 found = Names::FindName (childOfObjectTwo);
220 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
221 }
222
223 /**
224 * \ingroup names-tests
225 * Test the Object Name Service can correctly use a
226 * fully qualified path to add associations.
227 *
228 * Add (std::string name, Ptr<Object> object);
229 *
230 */
231 class FullyQualifiedAddTestCase : public TestCase
232 {
233 public:
234 /** Constructor. */
235 FullyQualifiedAddTestCase ();
236 /** Destructor. */
237 virtual ~FullyQualifiedAddTestCase ();
238
239 private:
240 virtual void DoRun (void);
241 virtual void DoTeardown (void);
242 };
243
FullyQualifiedAddTestCase()244 FullyQualifiedAddTestCase::FullyQualifiedAddTestCase ()
245 : TestCase ("Check fully qualified path Names::Add and Names::FindName functionality")
246
247 {}
248
~FullyQualifiedAddTestCase()249 FullyQualifiedAddTestCase::~FullyQualifiedAddTestCase ()
250 {}
251
252 void
DoTeardown(void)253 FullyQualifiedAddTestCase::DoTeardown (void)
254 {
255 Names::Clear ();
256 }
257
258 void
DoRun(void)259 FullyQualifiedAddTestCase::DoRun (void)
260 {
261 std::string found;
262
263 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
264 Names::Add ("/Names/Name One", objectOne);
265
266 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
267 Names::Add ("/Names/Name Two", objectTwo);
268
269 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
270 Names::Add ("/Names/Name One/Child", childOfObjectOne);
271
272 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
273 Names::Add ("/Names/Name Two/Child", childOfObjectTwo);
274
275 found = Names::FindName (objectOne);
276 NS_TEST_ASSERT_MSG_EQ (found, "Name One", "Could not Names::Add and Names::FindName an Object");
277
278 found = Names::FindName (objectTwo);
279 NS_TEST_ASSERT_MSG_EQ (found, "Name Two", "Could not Names::Add and Names::FindName a second Object");
280
281 found = Names::FindName (childOfObjectOne);
282 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
283
284 found = Names::FindName (childOfObjectTwo);
285 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
286 }
287
288 /**
289 * \ingroup names-tests
290 * Test the Object Name Service can correctly use a
291 * relative path to add associations.
292 *
293 * This functionality is provided as a convenience so clients
294 * don't always have to provide the name service namespace name
295 * in all of their strings.
296 *
297 * Add (std::string name, Ptr<Object> object);
298 *
299 */
300 class RelativeAddTestCase : public TestCase
301 {
302 public:
303 /** Constructor. */
304 RelativeAddTestCase ();
305 /** Destructor. */
306 virtual ~RelativeAddTestCase ();
307
308 private:
309 virtual void DoRun (void);
310 virtual void DoTeardown (void);
311 };
312
RelativeAddTestCase()313 RelativeAddTestCase::RelativeAddTestCase ()
314 : TestCase ("Check relative path Names::Add and Names::FindName functionality")
315
316 {}
317
~RelativeAddTestCase()318 RelativeAddTestCase::~RelativeAddTestCase ()
319 {}
320
321 void
DoTeardown(void)322 RelativeAddTestCase::DoTeardown (void)
323 {
324 Names::Clear ();
325 }
326
327 void
DoRun(void)328 RelativeAddTestCase::DoRun (void)
329 {
330 std::string found;
331
332 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
333 Names::Add ("Name One", objectOne);
334
335 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
336 Names::Add ("Name Two", objectTwo);
337
338 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
339 Names::Add ("Name One/Child", childOfObjectOne);
340
341 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
342 Names::Add ("Name Two/Child", childOfObjectTwo);
343
344 found = Names::FindName (objectOne);
345 NS_TEST_ASSERT_MSG_EQ (found, "Name One", "Could not Names::Add and Names::FindName an Object");
346
347 found = Names::FindName (objectTwo);
348 NS_TEST_ASSERT_MSG_EQ (found, "Name Two", "Could not Names::Add and Names::FindName a second Object");
349
350 found = Names::FindName (childOfObjectOne);
351 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
352
353 found = Names::FindName (childOfObjectTwo);
354 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
355 }
356
357 /**
358 * \ingroup names-tests
359 * Test the Object Name Service can rename objects.
360 *
361 * Rename (Ptr<Object> context, std::string oldname, std::string newname);
362 *
363 * All other rename functions will just translate into this form, so this is the
364 * most basic rename functionality.
365 */
366 class BasicRenameTestCase : public TestCase
367 {
368 public:
369 /** Constructor. */
370 BasicRenameTestCase ();
371 /** Destructor. */
372 virtual ~BasicRenameTestCase ();
373
374 private:
375 virtual void DoRun (void);
376 virtual void DoTeardown (void);
377 };
378
BasicRenameTestCase()379 BasicRenameTestCase::BasicRenameTestCase ()
380 : TestCase ("Check low level Names::Rename functionality")
381 {}
382
~BasicRenameTestCase()383 BasicRenameTestCase::~BasicRenameTestCase ()
384 {}
385
386 void
DoTeardown(void)387 BasicRenameTestCase::DoTeardown (void)
388 {
389 Names::Clear ();
390 }
391
392 void
DoRun(void)393 BasicRenameTestCase::DoRun (void)
394 {
395 std::string found;
396
397 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
398 Names::Add (Ptr<Object> (0, false), "Name", objectOne);
399
400 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
401 Names::Add (objectOne, "Child", childOfObjectOne);
402
403 found = Names::FindName (objectOne);
404 NS_TEST_ASSERT_MSG_EQ (found, "Name", "Could not Names::Add and Names::FindName an Object");
405
406 Names::Rename (Ptr<Object> (0, false), "Name", "New Name");
407
408 found = Names::FindName (objectOne);
409 NS_TEST_ASSERT_MSG_EQ (found, "New Name", "Could not Names::Rename an Object");
410
411 found = Names::FindName (childOfObjectOne);
412 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
413
414 Names::Rename (objectOne, "Child", "New Child");
415
416 found = Names::FindName (childOfObjectOne);
417 NS_TEST_ASSERT_MSG_EQ (found, "New Child", "Could not Names::Rename a child Object");
418 }
419
420 /**
421 * \ingroup names-tests
422 * Test the Object Name Service can rename objects
423 * using a string context.
424 *
425 * Rename (std::string context, std::string oldname, std::string newname);
426 *
427 */
428 class StringContextRenameTestCase : public TestCase
429 {
430 public:
431 /** Constructor. */
432 StringContextRenameTestCase ();
433 /** Destructor. */
434 virtual ~StringContextRenameTestCase ();
435
436 private:
437 virtual void DoRun (void);
438 virtual void DoTeardown (void);
439 };
440
StringContextRenameTestCase()441 StringContextRenameTestCase::StringContextRenameTestCase ()
442 : TestCase ("Check string context-based Names::Rename functionality")
443 {}
444
~StringContextRenameTestCase()445 StringContextRenameTestCase::~StringContextRenameTestCase ()
446 {}
447
448 void
DoTeardown(void)449 StringContextRenameTestCase::DoTeardown (void)
450 {
451 Names::Clear ();
452 }
453
454 void
DoRun(void)455 StringContextRenameTestCase::DoRun (void)
456 {
457 std::string found;
458
459 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
460 Names::Add ("/Names", "Name", objectOne);
461
462 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
463 Names::Add ("/Names/Name", "Child", childOfObjectOne);
464
465 found = Names::FindName (objectOne);
466 NS_TEST_ASSERT_MSG_EQ (found, "Name", "Could not Names::Add and Names::FindName an Object");
467
468 Names::Rename ("/Names", "Name", "New Name");
469
470 found = Names::FindName (objectOne);
471 NS_TEST_ASSERT_MSG_EQ (found, "New Name", "Could not Names::Rename an Object");
472
473 found = Names::FindName (childOfObjectOne);
474 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
475
476 Names::Rename ("/Names/New Name", "Child", "New Child");
477
478 found = Names::FindName (childOfObjectOne);
479 NS_TEST_ASSERT_MSG_EQ (found, "New Child", "Could not Names::Rename a child Object");
480 }
481
482 /**
483 * \ingroup names-tests
484 * Test the Object Name Service can rename objects
485 * using a fully qualified path name.
486 *
487 * Rename (std::string oldpath, std::string newname);
488 *
489 */
490 class FullyQualifiedRenameTestCase : public TestCase
491 {
492 public:
493 /** Constructor. */
494 FullyQualifiedRenameTestCase ();
495 /** Destructor. */
496 virtual ~FullyQualifiedRenameTestCase ();
497
498 private:
499 virtual void DoRun (void);
500 virtual void DoTeardown (void);
501 };
502
FullyQualifiedRenameTestCase()503 FullyQualifiedRenameTestCase::FullyQualifiedRenameTestCase ()
504 : TestCase ("Check fully qualified path Names::Rename functionality")
505 {}
506
~FullyQualifiedRenameTestCase()507 FullyQualifiedRenameTestCase::~FullyQualifiedRenameTestCase ()
508 {}
509
510 void
DoTeardown(void)511 FullyQualifiedRenameTestCase::DoTeardown (void)
512 {
513 Names::Clear ();
514 }
515
516 void
DoRun(void)517 FullyQualifiedRenameTestCase::DoRun (void)
518 {
519 std::string found;
520
521 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
522 Names::Add ("/Names/Name", objectOne);
523
524 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
525 Names::Add ("/Names/Name/Child", childOfObjectOne);
526
527 found = Names::FindName (objectOne);
528 NS_TEST_ASSERT_MSG_EQ (found, "Name", "Could not Names::Add and Names::FindName an Object");
529
530 Names::Rename ("/Names/Name", "New Name");
531
532 found = Names::FindName (objectOne);
533 NS_TEST_ASSERT_MSG_EQ (found, "New Name", "Could not Names::Rename an Object");
534
535 found = Names::FindName (childOfObjectOne);
536 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
537
538 Names::Rename ("/Names/New Name/Child", "New Child");
539
540 found = Names::FindName (childOfObjectOne);
541 NS_TEST_ASSERT_MSG_EQ (found, "New Child", "Could not Names::Rename a child Object");
542 }
543
544 /**
545 * \ingroup names-tests
546 * Test the Object Name Service can rename objects
547 * using a relative path name.
548 *
549 * Rename (std::string oldpath, std::string newname);
550 *
551 */
552 class RelativeRenameTestCase : public TestCase
553 {
554 public:
555 /** Constructor. */
556 RelativeRenameTestCase ();
557 /** Destructor. */
558 virtual ~RelativeRenameTestCase ();
559
560 private:
561 virtual void DoRun (void);
562 virtual void DoTeardown (void);
563 };
564
RelativeRenameTestCase()565 RelativeRenameTestCase::RelativeRenameTestCase ()
566 : TestCase ("Check relative path Names::Rename functionality")
567 {}
568
~RelativeRenameTestCase()569 RelativeRenameTestCase::~RelativeRenameTestCase ()
570 {}
571
572 void
DoTeardown(void)573 RelativeRenameTestCase::DoTeardown (void)
574 {
575 Names::Clear ();
576 }
577
578 void
DoRun(void)579 RelativeRenameTestCase::DoRun (void)
580 {
581 std::string found;
582
583 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
584 Names::Add ("Name", objectOne);
585
586 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
587 Names::Add ("Name/Child", childOfObjectOne);
588
589 found = Names::FindName (objectOne);
590 NS_TEST_ASSERT_MSG_EQ (found, "Name", "Could not Names::Add and Names::FindName an Object");
591
592 Names::Rename ("Name", "New Name");
593
594 found = Names::FindName (objectOne);
595 NS_TEST_ASSERT_MSG_EQ (found, "New Name", "Could not Names::Rename an Object");
596
597 found = Names::FindName (childOfObjectOne);
598 NS_TEST_ASSERT_MSG_EQ (found, "Child", "Could not Names::Add and Names::FindName a child Object");
599
600 Names::Rename ("New Name/Child", "New Child");
601
602 found = Names::FindName (childOfObjectOne);
603 NS_TEST_ASSERT_MSG_EQ (found, "New Child", "Could not Names::Rename a child Object");
604 }
605
606 /**
607 * \ingroup names-tests
608 * Test the Object Name Service can look up an object
609 * and return its fully qualified path name.
610 *
611 * FindPath (Ptr<Object> object);
612 *
613 */
614 class FindPathTestCase : public TestCase
615 {
616 public:
617 /** Constructor. */
618 FindPathTestCase ();
619 /** Destructor. */
620 virtual ~FindPathTestCase ();
621
622 private:
623 virtual void DoRun (void);
624 virtual void DoTeardown (void);
625 };
626
FindPathTestCase()627 FindPathTestCase::FindPathTestCase ()
628 : TestCase ("Check Names::FindPath functionality")
629 {}
630
~FindPathTestCase()631 FindPathTestCase::~FindPathTestCase ()
632 {}
633
634 void
DoTeardown(void)635 FindPathTestCase::DoTeardown (void)
636 {
637 Names::Clear ();
638 }
639
640 void
DoRun(void)641 FindPathTestCase::DoRun (void)
642 {
643 std::string found;
644
645 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
646 Names::Add ("Name", objectOne);
647
648 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
649 Names::Add ("/Names/Name/Child", childOfObjectOne);
650
651 found = Names::FindPath (objectOne);
652 NS_TEST_ASSERT_MSG_EQ (found, "/Names/Name", "Could not Names::Add and Names::FindPath an Object");
653
654 found = Names::FindPath (childOfObjectOne);
655 NS_TEST_ASSERT_MSG_EQ (found, "/Names/Name/Child", "Could not Names::Add and Names::FindPath a child Object");
656
657 Ptr<TestObject> objectNotThere = CreateObject<TestObject> ();
658 found = Names::FindPath (objectNotThere);
659 NS_TEST_ASSERT_MSG_EQ (found, "", "Unexpectedly found a non-existent Object");
660 }
661
662 /**
663 * \ingroup names-tests
664 * Test the Object Name Service can find Objects.
665 *
666 * Find (Ptr<Object> context, std::string name);
667 *
668 */
669 class BasicFindTestCase : public TestCase
670 {
671 public:
672 /** Constructor. */
673 BasicFindTestCase ();
674 /** Destructor. */
675 virtual ~BasicFindTestCase ();
676
677 private:
678 virtual void DoRun (void);
679 virtual void DoTeardown (void);
680 };
681
BasicFindTestCase()682 BasicFindTestCase::BasicFindTestCase ()
683 : TestCase ("Check low level Names::Find functionality")
684 {}
685
~BasicFindTestCase()686 BasicFindTestCase::~BasicFindTestCase ()
687 {}
688
689 void
DoTeardown(void)690 BasicFindTestCase::DoTeardown (void)
691 {
692 Names::Clear ();
693 }
694
695 void
DoRun(void)696 BasicFindTestCase::DoRun (void)
697 {
698 Ptr<TestObject> found;
699
700 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
701 Names::Add ("Name One", objectOne);
702
703 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
704 Names::Add ("Name Two", objectTwo);
705
706 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
707 Names::Add ("Name One/Child", childOfObjectOne);
708
709 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
710 Names::Add ("Name Two/Child", childOfObjectTwo);
711
712 found = Names::Find<TestObject> (Ptr<Object> (0, false), "Name One");
713 NS_TEST_ASSERT_MSG_EQ (found, objectOne, "Could not find a previously named Object via object context");
714
715 found = Names::Find<TestObject> (Ptr<Object> (0, false), "Name Two");
716 NS_TEST_ASSERT_MSG_EQ (found, objectTwo, "Could not find a previously named Object via object context");
717
718 found = Names::Find<TestObject> (objectOne, "Child");
719 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectOne, "Could not find a previously named child Object via object context");
720
721 found = Names::Find<TestObject> (objectTwo, "Child");
722 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectTwo, "Could not find a previously named child Object via object context");
723 }
724
725 /**
726 * \ingroup names-tests
727 * Test the Object Name Service can find Objects using
728 * a string context.
729 *
730 * Find (std::string context, std::string name);
731 *
732 */
733 class StringContextFindTestCase : public TestCase
734 {
735 public:
736 /** Constructor. */
737 StringContextFindTestCase ();
738 /** Destructor. */
739 virtual ~StringContextFindTestCase ();
740
741 private:
742 virtual void DoRun (void);
743 virtual void DoTeardown (void);
744 };
745
StringContextFindTestCase()746 StringContextFindTestCase::StringContextFindTestCase ()
747 : TestCase ("Check string context-based Names::Find functionality")
748 {}
749
~StringContextFindTestCase()750 StringContextFindTestCase::~StringContextFindTestCase ()
751 {}
752
753 void
DoTeardown(void)754 StringContextFindTestCase::DoTeardown (void)
755 {
756 Names::Clear ();
757 }
758
759 void
DoRun(void)760 StringContextFindTestCase::DoRun (void)
761 {
762 Ptr<TestObject> found;
763
764 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
765 Names::Add ("Name One", objectOne);
766
767 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
768 Names::Add ("Name Two", objectTwo);
769
770 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
771 Names::Add ("Name One/Child", childOfObjectOne);
772
773 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
774 Names::Add ("Name Two/Child", childOfObjectTwo);
775
776 found = Names::Find<TestObject> ("/Names", "Name One");
777 NS_TEST_ASSERT_MSG_EQ (found, objectOne, "Could not find a previously named Object via string context");
778
779 found = Names::Find<TestObject> ("/Names", "Name Two");
780 NS_TEST_ASSERT_MSG_EQ (found, objectTwo, "Could not find a previously named Object via stribng context");
781
782 found = Names::Find<TestObject> ("/Names/Name One", "Child");
783 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectOne, "Could not find a previously named child Object via string context");
784
785 found = Names::Find<TestObject> ("/Names/Name Two", "Child");
786 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectTwo, "Could not find a previously named child Object via string context");
787 }
788
789 /**
790 * \ingroup names-tests
791 * Test the Object Name Service can find Objects using
792 * a fully qualified path name.
793 *
794 * Find (std::string name);
795 *
796 */
797 class FullyQualifiedFindTestCase : public TestCase
798 {
799 public:
800 /** Constructor. */
801 FullyQualifiedFindTestCase ();
802 /** Destructor. */
803 virtual ~FullyQualifiedFindTestCase ();
804
805 private:
806 virtual void DoRun (void);
807 virtual void DoTeardown (void);
808 };
809
FullyQualifiedFindTestCase()810 FullyQualifiedFindTestCase::FullyQualifiedFindTestCase ()
811 : TestCase ("Check fully qualified path Names::Find functionality")
812 {}
813
~FullyQualifiedFindTestCase()814 FullyQualifiedFindTestCase::~FullyQualifiedFindTestCase ()
815 {}
816
817 void
DoTeardown(void)818 FullyQualifiedFindTestCase::DoTeardown (void)
819 {
820 Names::Clear ();
821 }
822
823 void
DoRun(void)824 FullyQualifiedFindTestCase::DoRun (void)
825 {
826 Ptr<TestObject> found;
827
828 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
829 Names::Add ("/Names/Name One", objectOne);
830
831 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
832 Names::Add ("/Names/Name Two", objectTwo);
833
834 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
835 Names::Add ("/Names/Name One/Child", childOfObjectOne);
836
837 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
838 Names::Add ("/Names/Name Two/Child", childOfObjectTwo);
839
840 found = Names::Find<TestObject> ("/Names/Name One");
841 NS_TEST_ASSERT_MSG_EQ (found, objectOne, "Could not find a previously named Object via string context");
842
843 found = Names::Find<TestObject> ("/Names/Name Two");
844 NS_TEST_ASSERT_MSG_EQ (found, objectTwo, "Could not find a previously named Object via stribng context");
845
846 found = Names::Find<TestObject> ("/Names/Name One/Child");
847 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectOne, "Could not find a previously named child Object via string context");
848
849 found = Names::Find<TestObject> ("/Names/Name Two/Child");
850 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectTwo, "Could not find a previously named child Object via string context");
851 }
852
853 /**
854 * \ingroup names-tests
855 * Test the Object Name Service can find Objects using
856 * a relative path name.
857 *
858 * Find (std::string name);
859 *
860 */
861 class RelativeFindTestCase : public TestCase
862 {
863 public:
864 /** Constructor. */
865 RelativeFindTestCase ();
866 /** Destructor. */
867 virtual ~RelativeFindTestCase ();
868
869 private:
870 virtual void DoRun (void);
871 virtual void DoTeardown (void);
872 };
873
RelativeFindTestCase()874 RelativeFindTestCase::RelativeFindTestCase ()
875 : TestCase ("Check relative path Names::Find functionality")
876 {}
877
~RelativeFindTestCase()878 RelativeFindTestCase::~RelativeFindTestCase ()
879 {}
880
881 void
DoTeardown(void)882 RelativeFindTestCase::DoTeardown (void)
883 {
884 Names::Clear ();
885 }
886
887 void
DoRun(void)888 RelativeFindTestCase::DoRun (void)
889 {
890 Ptr<TestObject> found;
891
892 Ptr<TestObject> objectOne = CreateObject<TestObject> ();
893 Names::Add ("Name One", objectOne);
894
895 Ptr<TestObject> objectTwo = CreateObject<TestObject> ();
896 Names::Add ("Name Two", objectTwo);
897
898 Ptr<TestObject> childOfObjectOne = CreateObject<TestObject> ();
899 Names::Add ("Name One/Child", childOfObjectOne);
900
901 Ptr<TestObject> childOfObjectTwo = CreateObject<TestObject> ();
902 Names::Add ("Name Two/Child", childOfObjectTwo);
903
904 found = Names::Find<TestObject> ("Name One");
905 NS_TEST_ASSERT_MSG_EQ (found, objectOne, "Could not find a previously named Object via string context");
906
907 found = Names::Find<TestObject> ("Name Two");
908 NS_TEST_ASSERT_MSG_EQ (found, objectTwo, "Could not find a previously named Object via stribng context");
909
910 found = Names::Find<TestObject> ("Name One/Child");
911 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectOne, "Could not find a previously named child Object via string context");
912
913 found = Names::Find<TestObject> ("Name Two/Child");
914 NS_TEST_ASSERT_MSG_EQ (found, childOfObjectTwo, "Could not find a previously named child Object via string context");
915 }
916
917 /**
918 * \ingroup names-tests
919 * Test the Object Name Service can find Objects using
920 * a second type.
921 */
922 class AlternateFindTestCase : public TestCase
923 {
924 public:
925 /** Constructor. */
926 AlternateFindTestCase ();
927 /** Destructor. */
928 virtual ~AlternateFindTestCase ();
929
930 private:
931 virtual void DoRun (void);
932 virtual void DoTeardown (void);
933 };
934
AlternateFindTestCase()935 AlternateFindTestCase::AlternateFindTestCase ()
936 : TestCase ("Check GetObject operation in Names::Find")
937 {}
938
~AlternateFindTestCase()939 AlternateFindTestCase::~AlternateFindTestCase ()
940 {}
941
942 void
DoTeardown(void)943 AlternateFindTestCase::DoTeardown (void)
944 {
945 Names::Clear ();
946 }
947
948 void
DoRun(void)949 AlternateFindTestCase::DoRun (void)
950 {
951 Ptr<TestObject> testObject = CreateObject<TestObject> ();
952 Names::Add ("Test Object", testObject);
953
954 Ptr<AlternateTestObject> alternateTestObject = CreateObject<AlternateTestObject> ();
955 Names::Add ("Alternate Test Object", alternateTestObject);
956
957 Ptr<TestObject> foundTestObject;
958 Ptr<AlternateTestObject> foundAlternateTestObject;
959
960 foundTestObject = Names::Find<TestObject> ("Test Object");
961 NS_TEST_ASSERT_MSG_EQ (foundTestObject, testObject,
962 "Could not find a previously named TestObject via GetObject");
963
964 foundAlternateTestObject = Names::Find<AlternateTestObject> ("Alternate Test Object");
965 NS_TEST_ASSERT_MSG_EQ (foundAlternateTestObject, alternateTestObject,
966 "Could not find a previously named AlternateTestObject via GetObject");
967
968
969 foundAlternateTestObject = Names::Find<AlternateTestObject> ("Test Object");
970 NS_TEST_ASSERT_MSG_EQ (foundAlternateTestObject, 0,
971 "Unexpectedly able to GetObject<AlternateTestObject> on a TestObject");
972
973 foundTestObject = Names::Find<TestObject> ("Alternate Test Object");
974 NS_TEST_ASSERT_MSG_EQ (foundTestObject, 0,
975 "Unexpectedly able to GetObject<TestObject> on an AlternateTestObject");
976 }
977
978 /**
979 * \ingroup names-tests
980 * Names Test Suite
981 */
982 class NamesTestSuite : public TestSuite
983 {
984 public:
985 /** Constructor. */
986 NamesTestSuite ();
987 };
988
NamesTestSuite()989 NamesTestSuite::NamesTestSuite ()
990 : TestSuite ("object-name-service")
991 {
992 AddTestCase (new BasicAddTestCase);
993 AddTestCase (new StringContextAddTestCase);
994 AddTestCase (new FullyQualifiedAddTestCase);
995 AddTestCase (new RelativeAddTestCase);
996 AddTestCase (new BasicRenameTestCase);
997 AddTestCase (new StringContextRenameTestCase);
998 AddTestCase (new FullyQualifiedRenameTestCase);
999 AddTestCase (new RelativeRenameTestCase);
1000 AddTestCase (new FindPathTestCase);
1001 AddTestCase (new BasicFindTestCase);
1002 AddTestCase (new StringContextFindTestCase);
1003 AddTestCase (new FullyQualifiedFindTestCase);
1004 AddTestCase (new RelativeFindTestCase);
1005 AddTestCase (new AlternateFindTestCase);
1006 }
1007
1008 /**
1009 * \ingroup names-tests
1010 * NamesTestSuite instance variable.
1011 */
1012 static NamesTestSuite g_namesTestSuite;
1013
1014
1015 } // namespace tests
1016
1017 } // namespace ns3
1018