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