00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifdef RUN_SELF_TESTS
00021
00022 #include <stdarg.h>
00023 #include <iostream>
00024 #include <sstream>
00025 #include "ns3/test.h"
00026 #include "header.h"
00027 #include "trailer.h"
00028 #include "packet.h"
00029 #include "packet-metadata.h"
00030
00031 using namespace ns3;
00032
00033 namespace {
00034
00035 class HistoryHeaderBase : public Header
00036 {
00037 public:
00038 static TypeId GetTypeId (void);
00039 HistoryHeaderBase ();
00040 bool IsOk (void) const;
00041 protected:
00042 void ReportError (void);
00043 private:
00044 bool m_ok;
00045 };
00046
00047 TypeId
00048 HistoryHeaderBase::GetTypeId (void)
00049 {
00050 static TypeId tid = TypeId ("ns3::HistoryHeaderBase")
00051 .SetParent<Header> ()
00052 ;
00053 return tid;
00054 }
00055
00056 HistoryHeaderBase::HistoryHeaderBase ()
00057 : m_ok (true)
00058 {}
00059
00060 bool
00061 HistoryHeaderBase::IsOk (void) const
00062 {
00063 return m_ok;
00064 }
00065 void
00066 HistoryHeaderBase::ReportError (void)
00067 {
00068 m_ok = false;
00069 }
00070
00071
00072 template <int N>
00073 class HistoryHeader : public HistoryHeaderBase
00074 {
00075 public:
00076 HistoryHeader ();
00077 static TypeId GetTypeId (void);
00078 virtual TypeId GetInstanceTypeId (void) const;
00079 virtual void Print (std::ostream &os) const;
00080 virtual uint32_t GetSerializedSize (void) const;
00081 virtual void Serialize (Buffer::Iterator start) const;
00082 virtual uint32_t Deserialize (Buffer::Iterator start);
00083 };
00084
00085 template <int N>
00086 HistoryHeader<N>::HistoryHeader ()
00087 : HistoryHeaderBase ()
00088 {}
00089
00090 template <int N>
00091 TypeId
00092 HistoryHeader<N>::GetTypeId (void)
00093 {
00094 std::ostringstream oss;
00095 oss << "ns3::HistoryHeader<"<<N<<">";
00096 static TypeId tid = TypeId (oss.str ().c_str ())
00097 .SetParent<HistoryHeaderBase> ()
00098 .AddConstructor<HistoryHeader<N> > ()
00099 ;
00100 return tid;
00101 }
00102
00103 template <int N>
00104 TypeId
00105 HistoryHeader<N>::GetInstanceTypeId (void) const
00106 {
00107 return GetTypeId ();
00108 }
00109 template <int N>
00110 void
00111 HistoryHeader<N>::Print (std::ostream &os) const
00112 {
00113 NS_ASSERT (false);
00114 }
00115 template <int N>
00116 uint32_t
00117 HistoryHeader<N>::GetSerializedSize (void) const
00118 {
00119 return N;
00120 }
00121 template <int N>
00122 void
00123 HistoryHeader<N>::Serialize (Buffer::Iterator start) const
00124 {
00125 start.WriteU8 (N, N);
00126 }
00127 template <int N>
00128 uint32_t
00129 HistoryHeader<N>::Deserialize (Buffer::Iterator start)
00130 {
00131 for (int i = 0; i < N; i++)
00132 {
00133 if (start.ReadU8 () != N)
00134 {
00135 ReportError ();
00136 }
00137 }
00138 return N;
00139 }
00140
00141 class HistoryTrailerBase : public Trailer
00142 {
00143 public:
00144 static TypeId GetTypeId (void);
00145 HistoryTrailerBase ();
00146 bool IsOk (void) const;
00147 protected:
00148 void ReportError (void);
00149 private:
00150 bool m_ok;
00151 };
00152
00153 TypeId
00154 HistoryTrailerBase::GetTypeId (void)
00155 {
00156 static TypeId tid = TypeId ("ns3::HistoryTrailerBase")
00157 .SetParent<Trailer> ()
00158 ;
00159 return tid;
00160 }
00161 HistoryTrailerBase::HistoryTrailerBase ()
00162 : m_ok (true)
00163 {}
00164 bool
00165 HistoryTrailerBase::IsOk (void) const
00166 {
00167 return m_ok;
00168 }
00169 void
00170 HistoryTrailerBase::ReportError (void)
00171 {
00172 m_ok = false;
00173 }
00174
00175
00176 template <int N>
00177 class HistoryTrailer : public HistoryTrailerBase
00178 {
00179 public:
00180 HistoryTrailer ();
00181 bool IsOk (void) const;
00182
00183 static TypeId GetTypeId (void);
00184 virtual TypeId GetInstanceTypeId (void) const;
00185 virtual void Print (std::ostream &os) const;
00186 virtual uint32_t GetSerializedSize (void) const;
00187 virtual void Serialize (Buffer::Iterator start) const;
00188 virtual uint32_t Deserialize (Buffer::Iterator start);
00189 private:
00190 bool m_ok;
00191 };
00192
00193 template <int N>
00194 HistoryTrailer<N>::HistoryTrailer ()
00195 {}
00196
00197 template <int N>
00198 TypeId
00199 HistoryTrailer<N>::GetTypeId (void)
00200 {
00201 std::ostringstream oss;
00202 oss << "ns3::HistoryTrailer<"<<N<<">";
00203 static TypeId tid = TypeId (oss.str ().c_str ())
00204 .SetParent<HistoryTrailerBase> ()
00205 .AddConstructor<HistoryTrailer<N> > ()
00206 ;
00207 return tid;
00208 }
00209
00210 template <int N>
00211 TypeId
00212 HistoryTrailer<N>::GetInstanceTypeId (void) const
00213 {
00214 return GetTypeId ();
00215 }
00216 template <int N>
00217 void
00218 HistoryTrailer<N>::Print (std::ostream &os) const
00219 {
00220 NS_ASSERT (false);
00221 }
00222 template <int N>
00223 uint32_t
00224 HistoryTrailer<N>::GetSerializedSize (void) const
00225 {
00226 return N;
00227 }
00228 template <int N>
00229 void
00230 HistoryTrailer<N>::Serialize (Buffer::Iterator start) const
00231 {
00232 start.Prev (N);
00233 start.WriteU8 (N, N);
00234 }
00235 template <int N>
00236 uint32_t
00237 HistoryTrailer<N>::Deserialize (Buffer::Iterator start)
00238 {
00239 start.Prev (N);
00240 for (int i = 0; i < N; i++)
00241 {
00242 if (start.ReadU8 () != N)
00243 {
00244 ReportError ();
00245 }
00246 }
00247 return N;
00248 }
00249
00250 }
00251
00252 namespace ns3 {
00253
00254
00255
00256 class PacketMetadataTest : public Test {
00257 public:
00258 PacketMetadataTest ();
00259 virtual ~PacketMetadataTest ();
00260 bool CheckHistory (Ptr<Packet> p, const char *file, int line, uint32_t n, ...);
00261 virtual bool RunTests (void);
00262 private:
00263 Ptr<Packet> DoAddHeader (Ptr<Packet> p);
00264 };
00265
00266 PacketMetadataTest::PacketMetadataTest ()
00267 : Test ("PacketMetadata")
00268 {}
00269
00270 PacketMetadataTest::~PacketMetadataTest ()
00271 {}
00272
00273 bool
00274 PacketMetadataTest::CheckHistory (Ptr<Packet> p, const char *file, int line, uint32_t n, ...)
00275 {
00276 std::list<int> expected;
00277 va_list ap;
00278 va_start (ap, n);
00279 for (uint32_t j = 0; j < n; j++)
00280 {
00281 int v = va_arg (ap, int);
00282 expected.push_back (v);
00283 }
00284 va_end (ap);
00285
00286 PacketMetadata::ItemIterator k = p->BeginItem ();
00287 std::list<int> got;
00288 while (k.HasNext ())
00289 {
00290 struct PacketMetadata::Item item = k.Next ();
00291 if (item.isFragment || item.type == PacketMetadata::Item::PAYLOAD)
00292 {
00293 got.push_back (item.currentSize);
00294 continue;
00295 }
00296 if (item.type == PacketMetadata::Item::HEADER)
00297 {
00298 Callback<ObjectBase *> constructor = item.tid.GetConstructor ();
00299 HistoryHeaderBase *header = dynamic_cast<HistoryHeaderBase *> (constructor ());
00300 if (header == 0)
00301 {
00302 goto error;
00303 }
00304 header->Deserialize (item.current);
00305 if (!header->IsOk ())
00306 {
00307 delete header;
00308 goto error;
00309 }
00310 delete header;
00311 }
00312 else if (item.type == PacketMetadata::Item::TRAILER)
00313 {
00314 Callback<ObjectBase *> constructor = item.tid.GetConstructor ();
00315 HistoryTrailerBase *trailer = dynamic_cast<HistoryTrailerBase *> (constructor ());
00316 if (trailer == 0)
00317 {
00318 goto error;
00319 }
00320 trailer->Deserialize (item.current);
00321 if (!trailer->IsOk ())
00322 {
00323 delete trailer;
00324 goto error;
00325 }
00326 delete trailer;
00327 }
00328 got.push_back (item.currentSize);
00329 }
00330
00331 for (std::list<int>::iterator i = got.begin (),
00332 j = expected.begin ();
00333 i != got.end (); i++, j++)
00334 {
00335 NS_ASSERT (j != expected.end ());
00336 if (*j != *i)
00337 {
00338 goto error;
00339 }
00340 }
00341 return true;
00342 error:
00343 Failure () << "PacketMetadata error. file="<< file
00344 << ", line=" << line << ", got:\"";
00345 for (std::list<int>::iterator i = got.begin ();
00346 i != got.end (); i++)
00347 {
00348 Failure () << *i << ", ";
00349 }
00350 Failure () << "\", expected: \"";
00351 for (std::list<int>::iterator j = expected.begin ();
00352 j != expected.end (); j++)
00353 {
00354 Failure () << *j << ", ";
00355 }
00356 Failure () << "\"" << std::endl;
00357 return false;
00358 }
00359
00360 #define ADD_HEADER(p, n) \
00361 { \
00362 HistoryHeader<n> header; \
00363 p->AddHeader (header); \
00364 }
00365 #define ADD_TRAILER(p, n) \
00366 { \
00367 HistoryTrailer<n> trailer; \
00368 p->AddTrailer (trailer); \
00369 }
00370 #define REM_HEADER(p, n) \
00371 { \
00372 HistoryHeader<n> header; \
00373 p->RemoveHeader (header); \
00374 }
00375 #define REM_TRAILER(p, n) \
00376 { \
00377 HistoryTrailer<n> trailer; \
00378 p->RemoveTrailer (trailer); \
00379 }
00380 #define CHECK_HISTORY(p, ...) \
00381 { \
00382 if (!CheckHistory (p, __FILE__, \
00383 __LINE__, __VA_ARGS__)) \
00384 { \
00385 result = false; \
00386 } \
00387 Buffer buffer; \
00388 buffer = p->Serialize (); \
00389 Ptr<Packet> otherPacket = Create<Packet> ();\
00390 otherPacket->Deserialize (buffer); \
00391 if (!CheckHistory (otherPacket, __FILE__, \
00392 __LINE__, __VA_ARGS__)) \
00393 { \
00394 result = false; \
00395 } \
00396 }
00397
00398
00399 Ptr<Packet>
00400 PacketMetadataTest::DoAddHeader (Ptr<Packet> p)
00401 {
00402 ADD_HEADER (p, 10);
00403 return p;
00404 }
00405
00406 bool
00407 PacketMetadataTest::RunTests (void)
00408 {
00409 bool result = true;
00410
00411 PacketMetadata::Enable ();
00412
00413 Ptr<Packet> p = Create<Packet> (0);
00414 Ptr<Packet> p1 = Create<Packet> (0);
00415
00416 p = Create<Packet> (10);
00417 ADD_TRAILER (p, 100);
00418 CHECK_HISTORY (p, 2, 10, 100);
00419
00420 p = Create<Packet> (10);
00421 ADD_HEADER (p, 1);
00422 ADD_HEADER (p, 2);
00423 ADD_HEADER (p, 3);
00424 CHECK_HISTORY (p, 4,
00425 3, 2, 1, 10);
00426 ADD_HEADER (p, 5);
00427 CHECK_HISTORY (p, 5,
00428 5, 3, 2, 1, 10);
00429 ADD_HEADER (p, 6);
00430 CHECK_HISTORY (p, 6,
00431 6, 5, 3, 2, 1, 10);
00432
00433 p = Create<Packet> (10);
00434 ADD_HEADER (p, 1);
00435 ADD_HEADER (p, 2);
00436 ADD_HEADER (p, 3);
00437 REM_HEADER (p, 3);
00438 CHECK_HISTORY (p, 3,
00439 2, 1, 10);
00440
00441 p = Create<Packet> (10);
00442 ADD_HEADER (p, 1);
00443 ADD_HEADER (p, 2);
00444 ADD_HEADER (p, 3);
00445 REM_HEADER (p, 3);
00446 REM_HEADER (p, 2);
00447 CHECK_HISTORY (p, 2,
00448 1, 10);
00449
00450 p = Create<Packet> (10);
00451 ADD_HEADER (p, 1);
00452 ADD_HEADER (p, 2);
00453 ADD_HEADER (p, 3);
00454 REM_HEADER (p, 3);
00455 REM_HEADER (p, 2);
00456 REM_HEADER (p, 1);
00457 CHECK_HISTORY (p, 1, 10);
00458
00459 p = Create<Packet> (10);
00460 ADD_HEADER (p, 1);
00461 ADD_HEADER (p, 2);
00462 ADD_HEADER (p, 3);
00463 p1 = p->Copy ();
00464 REM_HEADER (p1, 3);
00465 REM_HEADER (p1, 2);
00466 REM_HEADER (p1, 1);
00467 CHECK_HISTORY (p1, 1, 10);
00468 CHECK_HISTORY (p, 4,
00469 3, 2, 1, 10);
00470 ADD_HEADER (p1, 1);
00471 ADD_HEADER (p1, 2);
00472 CHECK_HISTORY (p1, 3,
00473 2, 1, 10);
00474 CHECK_HISTORY (p, 4,
00475 3, 2, 1, 10);
00476 ADD_HEADER (p, 3);
00477 CHECK_HISTORY (p, 5,
00478 3, 3, 2, 1, 10);
00479 ADD_TRAILER (p, 4);
00480 CHECK_HISTORY (p, 6,
00481 3, 3, 2, 1, 10, 4);
00482 ADD_TRAILER (p, 5);
00483 CHECK_HISTORY (p, 7,
00484 3, 3, 2, 1, 10, 4, 5);
00485 REM_HEADER (p, 3);
00486 CHECK_HISTORY (p, 6,
00487 3, 2, 1, 10, 4, 5);
00488 REM_TRAILER (p, 5);
00489 CHECK_HISTORY (p, 5,
00490 3, 2, 1, 10, 4);
00491 p1 = p->Copy ();
00492 REM_TRAILER (p, 4);
00493 CHECK_HISTORY (p, 4,
00494 3, 2, 1, 10);
00495 CHECK_HISTORY (p1, 5,
00496 3, 2, 1, 10, 4);
00497 p1->RemoveAtStart (3);
00498 CHECK_HISTORY (p1, 4,
00499 2, 1, 10, 4);
00500 p1->RemoveAtStart (1);
00501 CHECK_HISTORY (p1, 4,
00502 1, 1, 10, 4);
00503 p1->RemoveAtStart (1);
00504 CHECK_HISTORY (p1, 3,
00505 1, 10, 4);
00506 p1->RemoveAtEnd (4);
00507 CHECK_HISTORY (p1, 2,
00508 1, 10);
00509 p1->RemoveAtStart (1);
00510 CHECK_HISTORY (p1, 1, 10);
00511
00512 p = Create<Packet> (10);
00513 ADD_HEADER (p, 8);
00514 ADD_TRAILER (p, 8);
00515 ADD_TRAILER (p, 8);
00516 p->RemoveAtStart (8+10+8);
00517 CHECK_HISTORY (p, 1, 8);
00518
00519 p = Create<Packet> (10);
00520 ADD_HEADER (p, 10);
00521 ADD_HEADER (p, 8);
00522 ADD_TRAILER (p, 6);
00523 ADD_TRAILER (p, 7);
00524 ADD_TRAILER (p, 9);
00525 p->RemoveAtStart (5);
00526 p->RemoveAtEnd (12);
00527 CHECK_HISTORY (p, 5, 3, 10, 10, 6, 4);
00528
00529 p = Create<Packet> (10);
00530 ADD_HEADER (p, 10);
00531 ADD_TRAILER (p, 6);
00532 p->RemoveAtEnd (18);
00533 ADD_TRAILER (p, 5);
00534 ADD_HEADER (p, 3);
00535 CHECK_HISTORY (p, 3, 3, 8, 5);
00536 p->RemoveAtStart (12);
00537 CHECK_HISTORY (p, 1, 4);
00538 p->RemoveAtEnd (2);
00539 CHECK_HISTORY (p, 1, 2);
00540 ADD_HEADER (p, 10);
00541 CHECK_HISTORY (p, 2, 10, 2);
00542 p->RemoveAtEnd (5);
00543 CHECK_HISTORY (p, 1, 7);
00544
00545 Ptr<Packet> p2 = Create<Packet> (0);
00546 Ptr<Packet> p3 = Create<Packet> (0);
00547
00548 p = Create<Packet> (40);
00549 ADD_HEADER (p, 5);
00550 ADD_HEADER (p, 8);
00551 CHECK_HISTORY (p, 3, 8, 5, 40);
00552 p1 = p->CreateFragment (0, 5);
00553 p2 = p->CreateFragment (5, 5);
00554 p3 = p->CreateFragment (10, 43);
00555 CHECK_HISTORY (p1, 1, 5);
00556 CHECK_HISTORY (p2, 2, 3, 2);
00557 CHECK_HISTORY (p3, 2, 3, 40);
00558 p1->AddAtEnd (p2);
00559 CHECK_HISTORY (p1, 2, 8, 2);
00560 CHECK_HISTORY (p2, 2, 3, 2);
00561 p1->AddAtEnd (p3);
00562 CHECK_HISTORY (p1, 3, 8, 5, 40);
00563 CHECK_HISTORY (p2, 2, 3, 2);
00564 CHECK_HISTORY (p3, 2, 3, 40);
00565 p1 = p->CreateFragment (0, 5);
00566 CHECK_HISTORY (p1, 1, 5);
00567
00568 p3 = Create<Packet> (50);
00569 ADD_HEADER (p3, 8);
00570 CHECK_HISTORY (p3, 2, 8, 50);
00571 CHECK_HISTORY (p1, 1, 5);
00572 p1->AddAtEnd (p3);
00573 CHECK_HISTORY (p1, 3, 5, 8, 50);
00574 ADD_HEADER (p1, 5);
00575 CHECK_HISTORY (p1, 4, 5, 5, 8, 50);
00576 ADD_TRAILER (p1, 2);
00577 CHECK_HISTORY (p1, 5, 5, 5, 8, 50, 2);
00578 REM_HEADER (p1, 5);
00579 CHECK_HISTORY (p1, 4, 5, 8, 50, 2);
00580 p1->RemoveAtEnd (60);
00581 CHECK_HISTORY (p1, 1, 5);
00582 p1->AddAtEnd (p2);
00583 CHECK_HISTORY (p1, 2, 8, 2);
00584 CHECK_HISTORY (p2, 2, 3, 2);
00585
00586 p3 = Create<Packet> (40);
00587 ADD_HEADER (p3, 5);
00588 ADD_HEADER (p3, 5);
00589 CHECK_HISTORY (p3, 3, 5, 5, 40);
00590 p1 = p3->CreateFragment (0, 5);
00591 p2 = p3->CreateFragment (5, 5);
00592 CHECK_HISTORY (p1, 1, 5);
00593 CHECK_HISTORY (p2, 1, 5);
00594 p1->AddAtEnd (p2);
00595 CHECK_HISTORY (p1, 2, 5, 5);
00596
00597 p = Create<Packet> (0);
00598 CHECK_HISTORY (p, 0);
00599
00600 p3 = Create<Packet> (0);
00601 ADD_HEADER (p3, 5);
00602 ADD_HEADER (p3, 5);
00603 CHECK_HISTORY (p3, 2, 5, 5);
00604 p1 = p3->CreateFragment (0, 4);
00605 p2 = p3->CreateFragment (9, 1);
00606 CHECK_HISTORY (p1, 1, 4);
00607 CHECK_HISTORY (p2, 1, 1);
00608 p1->AddAtEnd (p2);
00609 CHECK_HISTORY (p1, 2, 4, 1);
00610
00611
00612 p = Create<Packet> (2000);
00613 CHECK_HISTORY (p, 1, 2000);
00614
00615 p = Create<Packet> ();
00616 ADD_TRAILER (p, 10);
00617 ADD_HEADER (p, 5);
00618 p1 = p->CreateFragment (0, 8);
00619 p2 = p->CreateFragment (8, 7);
00620 p1->AddAtEnd (p2);
00621 CHECK_HISTORY (p, 2, 5, 10);
00622
00623 p = Create<Packet> ();
00624 ADD_TRAILER (p, 10);
00625 REM_TRAILER (p, 10);
00626 ADD_TRAILER (p, 10);
00627 CHECK_HISTORY (p, 1, 10);
00628
00629 p = Create<Packet> ();
00630 ADD_HEADER (p, 10);
00631 REM_HEADER (p, 10);
00632 ADD_HEADER (p, 10);
00633 CHECK_HISTORY (p, 1, 10);
00634
00635 p = Create<Packet> ();
00636 ADD_HEADER (p, 10);
00637 p = DoAddHeader (p);
00638 CHECK_HISTORY (p, 2, 10, 10);
00639
00640 p = Create<Packet> (10);
00641 ADD_HEADER (p, 8);
00642 ADD_TRAILER (p, 8);
00643 ADD_TRAILER (p, 8);
00644 p->RemoveAtStart (8+10+8);
00645 CHECK_HISTORY (p, 1, 8);
00646
00647 p = Create<Packet> (0);
00648 ADD_HEADER (p, 8);
00649 REM_HEADER (p, 8);
00650 CHECK_HISTORY (p, 0);
00651
00652 p = Create<Packet> (0);
00653 ADD_TRAILER (p, 8);
00654 REM_TRAILER (p, 8);
00655 CHECK_HISTORY (p, 0);
00656
00657 p = Create<Packet> (0);
00658 ADD_HEADER (p, 8);
00659 p->RemoveAtStart (8);
00660 CHECK_HISTORY (p, 0);
00661
00662 p = Create<Packet> (0);
00663 ADD_HEADER (p, 8);
00664 ADD_TRAILER (p, 8);
00665 REM_TRAILER (p, 8);
00666 REM_HEADER (p, 8);
00667 CHECK_HISTORY (p, 0);
00668
00669 p = Create<Packet> (0);
00670 ADD_HEADER (p, 8);
00671 ADD_TRAILER (p, 8);
00672 REM_HEADER (p, 8);
00673 REM_TRAILER (p, 8);
00674 CHECK_HISTORY (p, 0);
00675
00676 p = Create<Packet> (0);
00677 ADD_HEADER (p, 8);
00678 ADD_TRAILER (p, 8);
00679 REM_TRAILER (p, 8);
00680 p->RemoveAtStart (8);
00681 CHECK_HISTORY (p, 0);
00682
00683 p = Create<Packet> (0);
00684 ADD_HEADER (p, 8);
00685 ADD_TRAILER (p, 8);
00686 REM_HEADER (p, 8);
00687 p->RemoveAtEnd (8);
00688 CHECK_HISTORY (p, 0);
00689
00690 p = Create<Packet> (0);
00691 ADD_HEADER (p, 8);
00692 ADD_TRAILER (p, 8);
00693 REM_TRAILER (p, 8);
00694 p->RemoveAtEnd (8);
00695 CHECK_HISTORY (p, 0);
00696
00697 p = Create<Packet> (0);
00698 ADD_HEADER (p, 8);
00699 ADD_TRAILER (p, 8);
00700 REM_HEADER (p, 8);
00701 p->RemoveAtStart (8);
00702 CHECK_HISTORY (p, 0);
00703
00704 p = Create<Packet> (16383);
00705 p = Create<Packet> (16384);
00706
00707
00708
00709 p = Create<Packet> (40);
00710 p2 = p->CreateFragment (5, 5);
00711 p3 = p->CreateFragment (10, 30);
00712 ADD_HEADER (p2, 8);
00713 ADD_HEADER (p3, 8);
00714 REM_HEADER (p2, 8);
00715 REM_HEADER (p3, 8);
00716 p2->AddAtEnd (p3);
00717
00718
00719 p = Create<Packet> (1000);
00720 ADD_HEADER (p, 10);
00721 ADD_TRAILER (p, 5);
00722 p1 = p->Copy ();
00723 ADD_HEADER (p1, 20);
00724 REM_HEADER (p1, 20);
00725 REM_TRAILER (p1, 5);
00726 NS_TEST_ASSERT_EQUAL (p->GetSize (), 1015);
00727
00728
00729 p = Create<Packet> (1510);
00730 ADD_HEADER (p, 8);
00731 ADD_HEADER (p, 25);
00732 REM_HEADER (p, 25);
00733 ADD_HEADER (p, 1);
00734 p1 = p->CreateFragment (0, 1500);
00735 p2 = p1->Copy ();
00736 ADD_HEADER (p2, 24);
00737 NS_TEST_ASSERT_EQUAL (p->GetSize (), 1519);
00738
00739 p = Create<Packet> (1000);
00740 ADD_HEADER (p, 2);
00741 ADD_TRAILER (p, 3);
00742 p1 = p->Copy ();
00743 CHECK_HISTORY (p1, 3, 2, 1000, 3);
00744 REM_HEADER (p, 2);
00745 ADD_HEADER (p, 1);
00746 CHECK_HISTORY (p, 3, 1, 1000, 3);
00747 CHECK_HISTORY (p1, 3, 2, 1000, 3);
00748
00749 p = Create<Packet> (200);
00750 ADD_HEADER (p, 24);
00751 p1 = p->CreateFragment(0, 100);
00752 p2 = p->CreateFragment(100, 100);
00753 p1->AddAtEnd (p2);
00754
00755 p = Create<Packet> ();
00756 ADD_HEADER (p, 10);
00757 p1 = Create<Packet> ();
00758 ADD_HEADER (p1, 11);
00759 REM_HEADER (p1, 11);
00760 p->AddAtEnd (p1);
00761
00762 p = Create<Packet> (500);
00763 CHECK_HISTORY (p, 1, 500);
00764 ADD_HEADER (p, 10);
00765 CHECK_HISTORY (p, 2, 10, 500);
00766 REM_HEADER (p, 10);
00767 CHECK_HISTORY (p, 1, 500);
00768 p->RemoveAtEnd (10);
00769 CHECK_HISTORY (p, 1, 490);
00770
00771 p = Create<Packet> (500);
00772 CHECK_HISTORY (p, 1, 500);
00773 ADD_TRAILER (p, 10);
00774 CHECK_HISTORY (p, 2, 500, 10);
00775 REM_TRAILER (p, 10);
00776 CHECK_HISTORY (p, 1, 500);
00777 p->RemoveAtStart (10);
00778 CHECK_HISTORY (p, 1, 490);
00779
00780
00781 return result;
00782 }
00783
00784 static PacketMetadataTest g_packetHistoryTest;
00785
00786 }
00787
00788 #endif