A Discrete-Event Network Simulator
API
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 
37 using namespace ns3;
38 
39 NS_LOG_COMPONENT_DEFINE("TestEpcTftClassifier");
40 
49 class 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 
115 EpcTftClassifierTestCase::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 
153 EpcTftClassifierTestCase::~EpcTftClassifierTestCase()
154 {
155 }
156 
157 std::string
158 EpcTftClassifierTestCase::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 
184 void
185 EpcTftClassifierTestCase::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 
212 class EpcTftClassifierTestSuite : public TestSuite
213 {
214  public:
215  EpcTftClassifierTestSuite();
216 };
217 
222 static EpcTftClassifierTestSuite g_lteTftClassifierTestSuite;
223 
224 EpcTftClassifierTestSuite::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::EpcTftClassifier::Add
void Add(Ptr< EpcTft > tft, uint32_t id)
add a TFT to the Classifier
Definition: epc-tft-classifier.cc:53
ns3::EpcTft::Direction
Direction
Indicates the direction of the traffic that is to be classified.
Definition: epc-tft.h:51
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::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::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::Ipv6Prefix
Describes an IPv6 prefix.
Definition: ipv6-address.h:455
ns3::Packet::AddHeader
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:268
ns3::PacketMetadata::Enable
static void Enable()
Enable the packet metadata.
Definition: packet-metadata.cc:55
ns3::TcpHeader
Header for the Transmission Control Protocol.
Definition: tcp-header.h:47
ns3::TestCase
encapsulates test code
Definition: test.h:1060
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
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