A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
test-epc-tft-classifier.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011-2018 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Authors:
18 * Nicola Baldo <nbaldo@cttc.es>
19 * Manuel Requena <manuel.requena@cttc.es>
20 */
21
22#include "ns3/epc-tft-classifier.h"
23#include "ns3/ipv4-header.h"
24#include "ns3/ipv4-l3-protocol.h"
25#include "ns3/ipv6-header.h"
26#include "ns3/ipv6-l3-protocol.h"
27#include "ns3/log.h"
28#include "ns3/packet.h"
29#include "ns3/tcp-header.h"
30#include "ns3/tcp-l4-protocol.h"
31#include "ns3/test.h"
32#include "ns3/udp-header.h"
33#include "ns3/udp-l4-protocol.h"
34
35#include <iomanip>
36
37using namespace ns3;
38
39NS_LOG_COMPONENT_DEFINE("TestEpcTftClassifier");
40
49class EpcTftClassifierTestCase : public TestCase
50{
51 public:
66 EpcTftClassifierTestCase(Ptr<EpcTftClassifier> c,
67 EpcTft::Direction d,
68 std::string sa,
69 std::string da,
70 uint16_t sp,
71 uint16_t dp,
72 uint8_t tos,
73 uint32_t tftId,
74 bool useIpv6);
75
76 ~EpcTftClassifierTestCase() override;
77
78 private:
79 Ptr<EpcTftClassifier> m_c;
80 EpcTft::Direction m_d;
81 uint8_t m_tftId;
82 bool m_useIpv6;
83 Ipv4Header m_ipHeader;
84 Ipv6Header m_ipv6Header;
85 UdpHeader m_udpHeader;
86 TcpHeader m_tcpHeader;
87
102 static std::string BuildNameString(Ptr<EpcTftClassifier> c,
103 EpcTft::Direction d,
104 std::string sa,
105 std::string da,
106 uint16_t sp,
107 uint16_t dp,
108 uint8_t tos,
109 uint32_t tftId,
110 bool useIpv6);
111
112 void DoRun() override;
113};
114
115EpcTftClassifierTestCase::EpcTftClassifierTestCase(Ptr<EpcTftClassifier> c,
116 EpcTft::Direction d,
117 std::string sa,
118 std::string da,
119 uint16_t sp,
120 uint16_t dp,
121 uint8_t tos,
122 uint32_t tftId,
123 bool useIpv6)
124 : TestCase(BuildNameString(c, d, sa, da, sp, dp, tos, tftId, useIpv6)),
125 m_c(c),
126 m_d(d),
127 m_tftId(tftId),
128 m_useIpv6(useIpv6)
129{
130 NS_LOG_FUNCTION(this << c << d << sa << da << sp << dp << tos << tftId << useIpv6);
131
132 if (m_useIpv6)
133 {
134 m_ipv6Header.SetSource(Ipv6Address::MakeIpv4MappedAddress(Ipv4Address(sa.c_str())));
135 m_ipv6Header.SetDestination(Ipv6Address::MakeIpv4MappedAddress(Ipv4Address(da.c_str())));
136 m_ipv6Header.SetTrafficClass(tos);
137 m_ipv6Header.SetPayloadLength(8); // Full UDP header
138 m_ipv6Header.SetNextHeader(UdpL4Protocol::PROT_NUMBER);
139 }
140 else
141 {
142 m_ipHeader.SetSource(Ipv4Address(sa.c_str()));
143 m_ipHeader.SetDestination(Ipv4Address(da.c_str()));
144 m_ipHeader.SetTos(tos);
145 m_ipHeader.SetPayloadSize(8); // Full UDP header
146 m_ipHeader.SetProtocol(UdpL4Protocol::PROT_NUMBER);
147 }
148
149 m_udpHeader.SetSourcePort(sp);
150 m_udpHeader.SetDestinationPort(dp);
151}
152
153EpcTftClassifierTestCase::~EpcTftClassifierTestCase()
154{
155}
156
157std::string
158EpcTftClassifierTestCase::BuildNameString(Ptr<EpcTftClassifier> c,
159 EpcTft::Direction d,
160 std::string sa,
161 std::string da,
162 uint16_t sp,
163 uint16_t dp,
164 uint8_t tos,
165 uint32_t tftId,
166 bool useIpv6)
167{
168 std::ostringstream oss;
169 oss << c << " d = " << d;
170 if (useIpv6)
171 {
172 oss << ", sa = " << Ipv6Address::MakeIpv4MappedAddress(Ipv4Address(sa.c_str()))
173 << ", da = " << Ipv6Address::MakeIpv4MappedAddress(Ipv4Address(da.c_str()));
174 }
175 else
176 {
177 oss << ", sa = " << sa << ", da = " << da;
178 }
179 oss << ", sp = " << sp << ", dp = " << dp << ", tos = 0x" << std::hex << (int)tos
180 << " --> tftId = " << tftId;
181 return oss.str();
182}
183
184void
185EpcTftClassifierTestCase::DoRun()
186{
187 ns3::PacketMetadata::Enable();
188
189 Ptr<Packet> udpPacket = Create<Packet>();
190 udpPacket->AddHeader(m_udpHeader);
191 if (m_useIpv6)
192 {
193 udpPacket->AddHeader(m_ipv6Header);
194 }
195 else
196 {
197 udpPacket->AddHeader(m_ipHeader);
198 }
199 NS_LOG_LOGIC(this << *udpPacket);
200 uint32_t obtainedTftId =
201 m_c->Classify(udpPacket,
202 m_d,
203 m_useIpv6 ? Ipv6L3Protocol::PROT_NUMBER : Ipv4L3Protocol::PROT_NUMBER);
204 NS_TEST_ASSERT_MSG_EQ(obtainedTftId, (uint16_t)m_tftId, "bad classification of UDP packet");
205}
206
212class EpcTftClassifierTestSuite : public TestSuite
213{
214 public:
215 EpcTftClassifierTestSuite();
216};
217
222static EpcTftClassifierTestSuite g_lteTftClassifierTestSuite;
223
224EpcTftClassifierTestSuite::EpcTftClassifierTestSuite()
225 : TestSuite("eps-tft-classifier", UNIT)
226{
227 NS_LOG_FUNCTION(this);
228
230 // Same testcases using IPv4 and IPv6 addresses
231 // IPv6 addresses are IPv4 mapped addresses, i.e. 1.2.3.4 -> 0::ffff:1.2.3.4
232 // Currently, we use the format '0::ffff:0102:0304' because
233 // the format '0::ffff:1.2.3.4' is not supported by the Ipv6Address class
235
236 for (bool useIpv6 : {false, true})
237 {
239 // check some TFT matches
241
242 Ptr<EpcTftClassifier> c1 = Create<EpcTftClassifier>();
243
244 Ptr<EpcTft> tft1_1 = Create<EpcTft>();
245
246 EpcTft::PacketFilter pf1_1_1;
247 if (useIpv6)
248 {
249 pf1_1_1.remoteIpv6Address.Set("0::ffff:0100:0000");
250 pf1_1_1.remoteIpv6Prefix = Ipv6Prefix(96 + 8);
251 pf1_1_1.localIpv6Address.Set("0::ffff:0200:0000");
252 pf1_1_1.localIpv6Prefix = Ipv6Prefix(96 + 8);
253 }
254 else
255 {
256 pf1_1_1.remoteAddress.Set("1.0.0.0");
257 pf1_1_1.remoteMask.Set(0xff000000);
258 pf1_1_1.localAddress.Set("2.0.0.0");
259 pf1_1_1.localMask.Set(0xff000000);
260 }
261 tft1_1->Add(pf1_1_1);
262
263 EpcTft::PacketFilter pf1_1_2;
264 if (useIpv6)
265 {
266 pf1_1_2.remoteIpv6Address.Set("0::ffff:0303:0300");
267 pf1_1_2.remoteIpv6Prefix = Ipv6Prefix(96 + 24);
268 pf1_1_2.localIpv6Address.Set("0::ffff:0404:0400");
269 pf1_1_2.localIpv6Prefix = Ipv6Prefix(96 + 24);
270 }
271 else
272 {
273 pf1_1_2.remoteAddress.Set("3.3.3.0");
274 pf1_1_2.remoteMask.Set(0xffffff00);
275 pf1_1_2.localAddress.Set("4.4.4.0");
276 pf1_1_2.localMask.Set(0xffffff00);
277 }
278 tft1_1->Add(pf1_1_2);
279
280 c1->Add(tft1_1, 1);
281
282 Ptr<EpcTft> tft1_2 = Create<EpcTft>();
283
284 EpcTft::PacketFilter pf1_2_1;
285 pf1_2_1.remotePortStart = 1024;
286 pf1_2_1.remotePortEnd = 1035;
287 tft1_2->Add(pf1_2_1);
288
289 EpcTft::PacketFilter pf1_2_2;
290 pf1_2_2.localPortStart = 3456;
291 pf1_2_2.localPortEnd = 3489;
292 tft1_2->Add(pf1_2_2);
293
294 EpcTft::PacketFilter pf1_2_3;
295 pf1_2_3.localPortStart = 7895;
296 pf1_2_3.localPortEnd = 7895;
297 tft1_2->Add(pf1_2_3);
298
299 EpcTft::PacketFilter pf1_2_4;
300 pf1_2_4.remotePortStart = 5897;
301 pf1_2_4.remotePortEnd = 5897;
302 tft1_2->Add(pf1_2_4);
303
304 c1->Add(tft1_2, 2);
305
306 // --------------------------------classifier----direction-------src_addr---dst_addr--src_port--dst_port--ToS--TFT_id
307
308 // test IP addresses
309 AddTestCase(new EpcTftClassifierTestCase(c1,
310 EpcTft::UPLINK,
311 "2.2.3.4",
312 "1.1.1.1",
313 4,
314 1234,
315 0,
316 1,
317 useIpv6),
318 TestCase::QUICK);
319 AddTestCase(new EpcTftClassifierTestCase(c1,
320 EpcTft::UPLINK,
321 "2.2.3.4",
322 "1.0.0.0",
323 2,
324 123,
325 5,
326 1,
327 useIpv6),
328 TestCase::QUICK);
329 AddTestCase(new EpcTftClassifierTestCase(c1,
330 EpcTft::UPLINK,
331 "6.2.3.4",
332 "1.1.1.1",
333 4,
334 1234,
335 0,
336 0,
337 useIpv6),
338 TestCase::QUICK);
339 AddTestCase(new EpcTftClassifierTestCase(c1,
340 EpcTft::DOWNLINK,
341 "3.3.3.4",
342 "4.4.4.1",
343 4,
344 1234,
345 0,
346 1,
347 useIpv6),
348 TestCase::QUICK);
349 AddTestCase(new EpcTftClassifierTestCase(c1,
350 EpcTft::DOWNLINK,
351 "3.3.4.4",
352 "4.4.4.1",
353 4,
354 1234,
355 0,
356 0,
357 useIpv6),
358 TestCase::QUICK);
359 AddTestCase(new EpcTftClassifierTestCase(c1,
360 EpcTft::UPLINK,
361 "3.3.3.4",
362 "4.4.2.1",
363 4,
364 1234,
365 0,
366 0,
367 useIpv6),
368 TestCase::QUICK);
369
370 // test remote port
371 AddTestCase(new EpcTftClassifierTestCase(c1,
372 EpcTft::UPLINK,
373 "9.1.1.1",
374 "8.1.1.1",
375 4,
376 1024,
377 0,
378 2,
379 useIpv6),
380 TestCase::QUICK);
381 AddTestCase(new EpcTftClassifierTestCase(c1,
382 EpcTft::UPLINK,
383 "9.1.1.1",
384 "8.1.1.1",
385 4,
386 1025,
387 0,
388 2,
389 useIpv6),
390 TestCase::QUICK);
391 AddTestCase(new EpcTftClassifierTestCase(c1,
392 EpcTft::UPLINK,
393 "9.1.1.1",
394 "8.1.1.1",
395 4,
396 1035,
397 0,
398 2,
399 useIpv6),
400 TestCase::QUICK);
401 AddTestCase(new EpcTftClassifierTestCase(c1,
402 EpcTft::UPLINK,
403 "9.1.1.1",
404 "8.1.1.1",
405 4,
406 1234,
407 0,
408 0,
409 useIpv6),
410 TestCase::QUICK);
411 AddTestCase(new EpcTftClassifierTestCase(c1,
412 EpcTft::DOWNLINK,
413 "9.1.1.1",
414 "8.1.1.1",
415 4,
416 1024,
417 0,
418 0,
419 useIpv6),
420 TestCase::QUICK);
421 AddTestCase(new EpcTftClassifierTestCase(c1,
422 EpcTft::DOWNLINK,
423 "9.1.1.1",
424 "8.1.1.1",
425 4,
426 1025,
427 0,
428 0,
429 useIpv6),
430 TestCase::QUICK);
431 AddTestCase(new EpcTftClassifierTestCase(c1,
432 EpcTft::DOWNLINK,
433 "9.1.1.1",
434 "8.1.1.1",
435 4,
436 1035,
437 0,
438 0,
439 useIpv6),
440 TestCase::QUICK);
441
442 // test local port
443 AddTestCase(new EpcTftClassifierTestCase(c1,
444 EpcTft::UPLINK,
445 "9.1.1.1",
446 "8.1.1.1",
447 4,
448 3456,
449 0,
450 0,
451 useIpv6),
452 TestCase::QUICK);
453 AddTestCase(new EpcTftClassifierTestCase(c1,
454 EpcTft::UPLINK,
455 "9.1.1.1",
456 "8.1.1.1",
457 4,
458 3457,
459 0,
460 0,
461 useIpv6),
462 TestCase::QUICK);
463 AddTestCase(new EpcTftClassifierTestCase(c1,
464 EpcTft::UPLINK,
465 "9.1.1.1",
466 "8.1.1.1",
467 4,
468 3489,
469 0,
470 0,
471 useIpv6),
472 TestCase::QUICK);
473 AddTestCase(new EpcTftClassifierTestCase(c1,
474 EpcTft::UPLINK,
475 "9.1.1.1",
476 "8.1.1.1",
477 3456,
478 6,
479 0,
480 2,
481 useIpv6),
482 TestCase::QUICK);
483 AddTestCase(new EpcTftClassifierTestCase(c1,
484 EpcTft::DOWNLINK,
485 "9.1.1.1",
486 "8.1.1.1",
487 3461,
488 3461,
489 0,
490 2,
491 useIpv6),
492 TestCase::QUICK);
493 AddTestCase(new EpcTftClassifierTestCase(c1,
494 EpcTft::DOWNLINK,
495 "9.1.1.1",
496 "8.1.1.1",
497 9,
498 3489,
499 0,
500 2,
501 useIpv6),
502 TestCase::QUICK);
503 AddTestCase(new EpcTftClassifierTestCase(c1,
504 EpcTft::DOWNLINK,
505 "9.1.1.1",
506 "8.1.1.1",
507 9,
508 7895,
509 0,
510 2,
511 useIpv6),
512 TestCase::QUICK);
513 AddTestCase(new EpcTftClassifierTestCase(c1,
514 EpcTft::UPLINK,
515 "9.1.1.1",
516 "8.1.1.1",
517 7895,
518 10,
519 0,
520 2,
521 useIpv6),
522 TestCase::QUICK);
523 AddTestCase(new EpcTftClassifierTestCase(c1,
524 EpcTft::UPLINK,
525 "9.1.1.1",
526 "8.1.1.1",
527 9,
528 5897,
529 0,
530 2,
531 useIpv6),
532 TestCase::QUICK);
533 AddTestCase(new EpcTftClassifierTestCase(c1,
534 EpcTft::DOWNLINK,
535 "9.1.1.1",
536 "8.1.1.1",
537 5897,
538 10,
539 0,
540 2,
541 useIpv6),
542 TestCase::QUICK);
543
545 // check default TFT
547
548 Ptr<EpcTftClassifier> c2 = Create<EpcTftClassifier>();
549 c2->Add(EpcTft::Default(), 1);
550
551 // --------------------------------classifier---direction--------src_addr---dst_addr--src_port--dst_port--ToS--TFT
552 // id
553
554 // test IP addresses
555 AddTestCase(new EpcTftClassifierTestCase(c2,
556 EpcTft::UPLINK,
557 "2.2.3.4",
558 "1.1.1.1",
559 4,
560 1234,
561 0,
562 1,
563 useIpv6),
564 TestCase::QUICK);
565 AddTestCase(new EpcTftClassifierTestCase(c2,
566 EpcTft::UPLINK,
567 "2.2.3.4",
568 "1.0.0.0",
569 2,
570 123,
571 5,
572 1,
573 useIpv6),
574 TestCase::QUICK);
575 AddTestCase(new EpcTftClassifierTestCase(c2,
576 EpcTft::UPLINK,
577 "6.2.3.4",
578 "1.1.1.1",
579 4,
580 1234,
581 0,
582 1,
583 useIpv6),
584 TestCase::QUICK);
585 AddTestCase(new EpcTftClassifierTestCase(c2,
586 EpcTft::DOWNLINK,
587 "3.3.3.4",
588 "4.4.4.1",
589 4,
590 1234,
591 0,
592 1,
593 useIpv6),
594 TestCase::QUICK);
595 AddTestCase(new EpcTftClassifierTestCase(c2,
596 EpcTft::DOWNLINK,
597 "3.3.4.4",
598 "4.4.4.1",
599 4,
600 1234,
601 0,
602 1,
603 useIpv6),
604 TestCase::QUICK);
605 AddTestCase(new EpcTftClassifierTestCase(c2,
606 EpcTft::UPLINK,
607 "3.3.3.4",
608 "4.4.2.1",
609 4,
610 1234,
611 0,
612 1,
613 useIpv6),
614 TestCase::QUICK);
615
616 // test remote port
617 AddTestCase(new EpcTftClassifierTestCase(c2,
618 EpcTft::UPLINK,
619 "9.1.1.1",
620 "8.1.1.1",
621 4,
622 1024,
623 0,
624 1,
625 useIpv6),
626 TestCase::QUICK);
627 AddTestCase(new EpcTftClassifierTestCase(c2,
628 EpcTft::UPLINK,
629 "9.1.1.1",
630 "8.1.1.1",
631 4,
632 1025,
633 0,
634 1,
635 useIpv6),
636 TestCase::QUICK);
637 AddTestCase(new EpcTftClassifierTestCase(c2,
638 EpcTft::UPLINK,
639 "9.1.1.1",
640 "8.1.1.1",
641 4,
642 1035,
643 0,
644 1,
645 useIpv6),
646 TestCase::QUICK);
647 AddTestCase(new EpcTftClassifierTestCase(c2,
648 EpcTft::UPLINK,
649 "9.1.1.1",
650 "8.1.1.1",
651 4,
652 1234,
653 0,
654 1,
655 useIpv6),
656 TestCase::QUICK);
657 AddTestCase(new EpcTftClassifierTestCase(c2,
658 EpcTft::DOWNLINK,
659 "9.1.1.1",
660 "8.1.1.1",
661 4,
662 1024,
663 0,
664 1,
665 useIpv6),
666 TestCase::QUICK);
667 AddTestCase(new EpcTftClassifierTestCase(c2,
668 EpcTft::DOWNLINK,
669 "9.1.1.1",
670 "8.1.1.1",
671 4,
672 1025,
673 0,
674 1,
675 useIpv6),
676 TestCase::QUICK);
677 AddTestCase(new EpcTftClassifierTestCase(c2,
678 EpcTft::DOWNLINK,
679 "9.1.1.1",
680 "8.1.1.1",
681 4,
682 1035,
683 0,
684 1,
685 useIpv6),
686 TestCase::QUICK);
687
688 // test local port
689 AddTestCase(new EpcTftClassifierTestCase(c2,
690 EpcTft::UPLINK,
691 "9.1.1.1",
692 "8.1.1.1",
693 4,
694 3456,
695 0,
696 1,
697 useIpv6),
698 TestCase::QUICK);
699 AddTestCase(new EpcTftClassifierTestCase(c2,
700 EpcTft::UPLINK,
701 "9.1.1.1",
702 "8.1.1.1",
703 4,
704 3457,
705 0,
706 1,
707 useIpv6),
708 TestCase::QUICK);
709 AddTestCase(new EpcTftClassifierTestCase(c2,
710 EpcTft::UPLINK,
711 "9.1.1.1",
712 "8.1.1.1",
713 4,
714 3489,
715 0,
716 1,
717 useIpv6),
718 TestCase::QUICK);
719 AddTestCase(new EpcTftClassifierTestCase(c2,
720 EpcTft::UPLINK,
721 "9.1.1.1",
722 "8.1.1.1",
723 3456,
724 6,
725 0,
726 1,
727 useIpv6),
728 TestCase::QUICK);
729 AddTestCase(new EpcTftClassifierTestCase(c2,
730 EpcTft::DOWNLINK,
731 "9.1.1.1",
732 "8.1.1.1",
733 3461,
734 3461,
735 0,
736 1,
737 useIpv6),
738 TestCase::QUICK);
739 AddTestCase(new EpcTftClassifierTestCase(c2,
740 EpcTft::DOWNLINK,
741 "9.1.1.1",
742 "8.1.1.1",
743 9,
744 3489,
745 0,
746 1,
747 useIpv6),
748 TestCase::QUICK);
749
751 // check default TFT plus dedicated ones
753
754 Ptr<EpcTftClassifier> c3 = Create<EpcTftClassifier>();
755 c3->Add(EpcTft::Default(), 1);
756 c3->Add(tft1_1, 2);
757 c3->Add(tft1_2, 3);
758
759 // --------------------------------classifier---direction--------src_addr---dst_addr---src_port--dst_port--ToS--TFT_id
760
761 // test IP addresses
762 AddTestCase(new EpcTftClassifierTestCase(c3,
763 EpcTft::UPLINK,
764 "2.2.3.4",
765 "1.1.1.1",
766 4,
767 1234,
768 0,
769 2,
770 useIpv6),
771 TestCase::QUICK);
772 AddTestCase(new EpcTftClassifierTestCase(c3,
773 EpcTft::UPLINK,
774 "2.2.3.4",
775 "1.0.0.0",
776 2,
777 123,
778 5,
779 2,
780 useIpv6),
781 TestCase::QUICK);
782 AddTestCase(new EpcTftClassifierTestCase(c3,
783 EpcTft::UPLINK,
784 "6.2.3.4",
785 "1.1.1.1",
786 4,
787 1234,
788 0,
789 1,
790 useIpv6),
791 TestCase::QUICK);
792 AddTestCase(new EpcTftClassifierTestCase(c3,
793 EpcTft::DOWNLINK,
794 "3.3.3.4",
795 "4.4.4.1",
796 4,
797 1234,
798 0,
799 2,
800 useIpv6),
801 TestCase::QUICK);
802 AddTestCase(new EpcTftClassifierTestCase(c3,
803 EpcTft::DOWNLINK,
804 "3.3.4.4",
805 "4.4.4.1",
806 4,
807 1234,
808 0,
809 1,
810 useIpv6),
811 TestCase::QUICK);
812 AddTestCase(new EpcTftClassifierTestCase(c3,
813 EpcTft::UPLINK,
814 "3.3.3.4",
815 "4.4.2.1",
816 4,
817 1234,
818 0,
819 1,
820 useIpv6),
821 TestCase::QUICK);
822
823 // test remote port
824 AddTestCase(new EpcTftClassifierTestCase(c3,
825 EpcTft::UPLINK,
826 "9.1.1.1",
827 "8.1.1.1",
828 4,
829 1024,
830 0,
831 3,
832 useIpv6),
833 TestCase::QUICK);
834 AddTestCase(new EpcTftClassifierTestCase(c3,
835 EpcTft::UPLINK,
836 "9.1.1.1",
837 "8.1.1.1",
838 4,
839 1025,
840 0,
841 3,
842 useIpv6),
843 TestCase::QUICK);
844 AddTestCase(new EpcTftClassifierTestCase(c3,
845 EpcTft::UPLINK,
846 "9.1.1.1",
847 "8.1.1.1",
848 4,
849 1035,
850 0,
851 3,
852 useIpv6),
853 TestCase::QUICK);
854 AddTestCase(new EpcTftClassifierTestCase(c3,
855 EpcTft::UPLINK,
856 "9.1.1.1",
857 "8.1.1.1",
858 4,
859 1234,
860 0,
861 1,
862 useIpv6),
863 TestCase::QUICK);
864 AddTestCase(new EpcTftClassifierTestCase(c3,
865 EpcTft::DOWNLINK,
866 "9.1.1.1",
867 "8.1.1.1",
868 4,
869 1024,
870 0,
871 1,
872 useIpv6),
873 TestCase::QUICK);
874 AddTestCase(new EpcTftClassifierTestCase(c3,
875 EpcTft::DOWNLINK,
876 "9.1.1.1",
877 "8.1.1.1",
878 4,
879 1025,
880 0,
881 1,
882 useIpv6),
883 TestCase::QUICK);
884 AddTestCase(new EpcTftClassifierTestCase(c3,
885 EpcTft::DOWNLINK,
886 "9.1.1.1",
887 "8.1.1.1",
888 4,
889 1035,
890 0,
891 1,
892 useIpv6),
893 TestCase::QUICK);
894
895 // test local port
896 AddTestCase(new EpcTftClassifierTestCase(c3,
897 EpcTft::UPLINK,
898 "9.1.1.1",
899 "8.1.1.1",
900 4,
901 3456,
902 0,
903 1,
904 useIpv6),
905 TestCase::QUICK);
906 AddTestCase(new EpcTftClassifierTestCase(c3,
907 EpcTft::UPLINK,
908 "9.1.1.1",
909 "8.1.1.1",
910 4,
911 3457,
912 0,
913 1,
914 useIpv6),
915 TestCase::QUICK);
916 AddTestCase(new EpcTftClassifierTestCase(c3,
917 EpcTft::UPLINK,
918 "9.1.1.1",
919 "8.1.1.1",
920 4,
921 3489,
922 0,
923 1,
924 useIpv6),
925 TestCase::QUICK);
926 AddTestCase(new EpcTftClassifierTestCase(c3,
927 EpcTft::UPLINK,
928 "9.1.1.1",
929 "8.1.1.1",
930 3456,
931 6,
932 0,
933 3,
934 useIpv6),
935 TestCase::QUICK);
936 AddTestCase(new EpcTftClassifierTestCase(c3,
937 EpcTft::DOWNLINK,
938 "9.1.1.1",
939 "8.1.1.1",
940 3461,
941 3461,
942 0,
943 3,
944 useIpv6),
945 TestCase::QUICK);
946 AddTestCase(new EpcTftClassifierTestCase(c3,
947 EpcTft::DOWNLINK,
948 "9.1.1.1",
949 "8.1.1.1",
950 9,
951 3489,
952 0,
953 3,
954 useIpv6),
955 TestCase::QUICK);
956
958 // check two TFTs with different ports
960
961 Ptr<EpcTftClassifier> c4 = Create<EpcTftClassifier>();
962 Ptr<EpcTft> tft4_1 = Create<EpcTft>();
963 tft4_1->Add(pf1_2_3);
964 c4->Add(tft4_1, 1);
965 Ptr<EpcTft> tft4_2 = Create<EpcTft>();
966 tft4_2->Add(pf1_2_4);
967 c4->Add(tft4_2, 2);
968 AddTestCase(new EpcTftClassifierTestCase(c4,
969 EpcTft::DOWNLINK,
970 "9.1.1.1",
971 "8.1.1.1",
972 9,
973 3489,
974 0,
975 0,
976 useIpv6),
977 TestCase::QUICK);
978 AddTestCase(new EpcTftClassifierTestCase(c4,
979 EpcTft::DOWNLINK,
980 "9.1.1.1",
981 "8.1.1.1",
982 9,
983 7895,
984 0,
985 1,
986 useIpv6),
987 TestCase::QUICK);
988 AddTestCase(new EpcTftClassifierTestCase(c4,
989 EpcTft::UPLINK,
990 "9.1.1.1",
991 "8.1.1.1",
992 7895,
993 10,
994 0,
995 1,
996 useIpv6),
997 TestCase::QUICK);
998 AddTestCase(new EpcTftClassifierTestCase(c4,
999 EpcTft::UPLINK,
1000 "9.1.1.1",
1001 "8.1.1.1",
1002 9,
1003 5897,
1004 0,
1005 2,
1006 useIpv6),
1007 TestCase::QUICK);
1008 AddTestCase(new EpcTftClassifierTestCase(c4,
1009 EpcTft::DOWNLINK,
1010 "9.1.1.1",
1011 "8.1.1.1",
1012 5897,
1013 10,
1014 0,
1015 2,
1016 useIpv6),
1017 TestCase::QUICK);
1018 }
1019}
EpcTftClassifierTestCase
Test case to check the functionality of the Tft Classifier.
Definition: test-epc-tft-classifier.cc:50
EpcTftClassifierTestCase::m_ipHeader
Ipv4Header m_ipHeader
the IPv4 header
Definition: test-epc-tft-classifier.cc:83
EpcTftClassifierTestCase::m_tcpHeader
TcpHeader m_tcpHeader
the TCP header
Definition: test-epc-tft-classifier.cc:86
EpcTftClassifierTestCase::m_c
Ptr< EpcTftClassifier > m_c
the EPC TFT classifier
Definition: test-epc-tft-classifier.cc:79
EpcTftClassifierTestCase::BuildNameString
static std::string BuildNameString(Ptr< EpcTftClassifier > c, EpcTft::Direction d, std::string sa, std::string da, uint16_t sp, uint16_t dp, uint8_t tos, uint32_t tftId, bool useIpv6)
Build name string.
Definition: test-epc-tft-classifier.cc:158
EpcTftClassifierTestCase::m_useIpv6
bool m_useIpv6
use IPv4 or IPv6 header/addresses
Definition: test-epc-tft-classifier.cc:82
EpcTftClassifierTestCase::EpcTftClassifierTestCase
EpcTftClassifierTestCase(Ptr< EpcTftClassifier > c, EpcTft::Direction d, std::string sa, std::string da, uint16_t sp, uint16_t dp, uint8_t tos, uint32_t tftId, bool useIpv6)
Constructor.
Definition: test-epc-tft-classifier.cc:115
EpcTftClassifierTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: test-epc-tft-classifier.cc:185
EpcTftClassifierTestCase::m_udpHeader
UdpHeader m_udpHeader
the UDP header
Definition: test-epc-tft-classifier.cc:85
EpcTftClassifierTestCase::m_d
EpcTft::Direction m_d
the EPC TFT direction
Definition: test-epc-tft-classifier.cc:80
EpcTftClassifierTestCase::m_ipv6Header
Ipv6Header m_ipv6Header
the IPv6 header
Definition: test-epc-tft-classifier.cc:84
EpcTftClassifierTestSuite
Epc Tft Classifier Test Suite.
Definition: test-epc-tft-classifier.cc:213
ns3::EpcTftClassifier::Classify
uint32_t Classify(Ptr< Packet > p, EpcTft::Direction direction, uint16_t protocolNumber)
classify an IP packet
Definition: epc-tft-classifier.cc:70
ns3::EpcTft::Default
static Ptr< EpcTft > Default()
creates a TFT matching any traffic
Definition: epc-tft.cc:229
ns3::EpcTft::Direction
Direction
Indicates the direction of the traffic that is to be classified.
Definition: epc-tft.h:51
ns3::EpcTft::DOWNLINK
@ DOWNLINK
Definition: epc-tft.h:52
ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:42
ns3::Ipv4Address::Set
void Set(uint32_t address)
input address is in host order.
Definition: ipv4-address.cc:193
ns3::Ipv4Header
Packet header for IPv4.
Definition: ipv4-header.h:34
ns3::Ipv4Header::SetDestination
void SetDestination(Ipv4Address destination)
Definition: ipv4-header.cc:309
ns3::Ipv4Header::SetPayloadSize
void SetPayloadSize(uint16_t size)
Definition: ipv4-header.cc:57
ns3::Ipv4Header::SetProtocol
void SetProtocol(uint8_t num)
Definition: ipv4-header.cc:288
ns3::Ipv4Header::SetTos
void SetTos(uint8_t tos)
Definition: ipv4-header.cc:85
ns3::Ipv4Header::SetSource
void SetSource(Ipv4Address source)
Definition: ipv4-header.cc:295
ns3::Ipv4L3Protocol::PROT_NUMBER
static const uint16_t PROT_NUMBER
Protocol number (0x0800)
Definition: ipv4-l3-protocol.h:91
ns3::Ipv4Mask::Set
void Set(uint32_t mask)
input mask is in host order.
Definition: ipv4-address.cc:91
ns3::Ipv6Address::Set
void Set(const char *address)
Sets an Ipv6Address by parsing the input C-string.
Definition: ipv6-address.cc:202
ns3::Ipv6Address::MakeIpv4MappedAddress
static Ipv6Address MakeIpv4MappedAddress(Ipv4Address addr)
Make the Ipv4-mapped IPv6 address.
Definition: ipv6-address.cc:241
ns3::Ipv6Header
Packet header for IPv6.
Definition: ipv6-header.h:35
ns3::Ipv6Header::SetDestination
void SetDestination(Ipv6Address dst)
Set the "Destination address" field.
Definition: ipv6-header.cc:118
ns3::Ipv6Header::SetSource
void SetSource(Ipv6Address src)
Set the "Source address" field.
Definition: ipv6-header.cc:106
ns3::Ipv6Header::SetPayloadLength
void SetPayloadLength(uint16_t len)
Set the "Payload length" field.
Definition: ipv6-header.cc:70
ns3::Ipv6Header::SetTrafficClass
void SetTrafficClass(uint8_t traffic)
Set the "Traffic class" field.
Definition: ipv6-header.cc:46
ns3::Ipv6Header::SetNextHeader
void SetNextHeader(uint8_t next)
Set the "Next header" field.
Definition: ipv6-header.cc:82
ns3::Ipv6L3Protocol::PROT_NUMBER
static const uint16_t PROT_NUMBER
The protocol number for IPv6 (0x86DD).
Definition: ipv6-l3-protocol.h:75
ns3::Ipv6Prefix
Describes an IPv6 prefix.
Definition: ipv6-address.h:455
ns3::PacketMetadata::Enable
static void Enable()
Enable the packet metadata.
Definition: packet-metadata.cc:55
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:77
ns3::TcpHeader
Header for the Transmission Control Protocol.
Definition: tcp-header.h:47
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::QUICK
@ QUICK
Fast test.
Definition: test.h:1065
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::UdpHeader
Packet header for UDP packets.
Definition: udp-header.h:41
ns3::UdpHeader::SetSourcePort
void SetSourcePort(uint16_t port)
Definition: udp-header.cc:42
ns3::UdpHeader::SetDestinationPort
void SetDestinationPort(uint16_t port)
Definition: udp-header.cc:36
ns3::UdpL4Protocol::PROT_NUMBER
static const uint8_t PROT_NUMBER
protocol number (0x11)
Definition: udp-l4-protocol.h:71
uint32_t
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:282
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:240
g_lteTftClassifierTestSuite
static EpcTftClassifierTestSuite g_lteTftClassifierTestSuite
Static variable for test initialization.
Definition: test-epc-tft-classifier.cc:222
NS_TEST_ASSERT_MSG_EQ
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:144
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::EpcTft::PacketFilter
Implement the data structure representing a TrafficFlowTemplate Packet Filter.
Definition: epc-tft.h:71
ns3::EpcTft::PacketFilter::localAddress
Ipv4Address localAddress
IPv4 address of the UE.
Definition: epc-tft.h:121
ns3::EpcTft::PacketFilter::localIpv6Prefix
Ipv6Prefix localIpv6Prefix
IPv6 address prefix of the UE.
Definition: epc-tft.h:127
ns3::EpcTft::PacketFilter::localPortEnd
uint16_t localPortEnd
end of the port number range of the UE
Definition: epc-tft.h:132
ns3::EpcTft::PacketFilter::localMask
Ipv4Mask localMask
IPv4 address mask of the UE.
Definition: epc-tft.h:122
ns3::EpcTft::PacketFilter::remotePortEnd
uint16_t remotePortEnd
end of the port number range of the remote host
Definition: epc-tft.h:130
ns3::EpcTft::PacketFilter::remoteIpv6Address
Ipv6Address remoteIpv6Address
IPv6 address of the remote host.
Definition: epc-tft.h:124
ns3::EpcTft::PacketFilter::remoteMask
Ipv4Mask remoteMask
IPv4 address mask of the remote host.
Definition: epc-tft.h:120
ns3::EpcTft::PacketFilter::remotePortStart
uint16_t remotePortStart
start of the port number range of the remote host
Definition: epc-tft.h:129
ns3::EpcTft::PacketFilter::localIpv6Address
Ipv6Address localIpv6Address
IPv6 address of the UE.
Definition: epc-tft.h:126
ns3::EpcTft::PacketFilter::remoteAddress
Ipv4Address remoteAddress
IPv4 address of the remote host.
Definition: epc-tft.h:119
ns3::EpcTft::PacketFilter::remoteIpv6Prefix
Ipv6Prefix remoteIpv6Prefix
IPv6 address prefix of the remote host.
Definition: epc-tft.h:125
ns3::EpcTft::PacketFilter::localPortStart
uint16_t localPortStart
start of the port number range of the UE
Definition: epc-tft.h:131