A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
buffer-test.cc
1 #include "ns3/buffer.h"
2 #include "ns3/random-variable-stream.h"
3 #include "ns3/double.h"
4 #include "ns3/test.h"
5 
6 using namespace ns3;
7 
8 //-----------------------------------------------------------------------------
9 // Unit tests
10 //-----------------------------------------------------------------------------
11 class BufferTest : public TestCase {
12 private:
13  void EnsureWrittenBytes (Buffer b, uint32_t n, uint8_t array[], const char *file, int line);
14 public:
15  virtual void DoRun (void);
16  BufferTest ();
17 };
18 
19 
20 BufferTest::BufferTest ()
21  : TestCase ("Buffer") {
22 }
23 
24 void
25 BufferTest::EnsureWrittenBytes (Buffer b, uint32_t n, uint8_t array[], const char *file, int line)
26 {
27  bool success = true;
28  uint8_t *expected = array;
29  uint8_t const*got;
30  got = b.PeekData ();
31  for (uint32_t j = 0; j < n; j++)
32  {
33  if (got[j] != expected[j])
34  {
35  success = false;
36  }
37  }
38  if (!success)
39  {
40  std::ostringstream failure;
41  failure << "Buffer -- ";
42  failure << "expected: n=";
43  failure << n << ", ";
44  failure.setf (std::ios::hex, std::ios::basefield);
45  for (uint32_t j = 0; j < n; j++)
46  {
47  failure << (uint16_t)expected[j] << " ";
48  }
49  failure.setf (std::ios::dec, std::ios::basefield);
50  failure << "got: ";
51  failure.setf (std::ios::hex, std::ios::basefield);
52  for (uint32_t j = 0; j < n; j++)
53  {
54  failure << (uint16_t)got[j] << " ";
55  }
56  failure << std::endl;
57  NS_TEST_ASSERT_MSG_EQ_INTERNAL (true, false, failure.str (), file, line);
58  }
59 }
60 
61 /* Note: works only when variadic macros are
62  * available which is the case for gcc.
63  * XXX
64  */
65 #define ENSURE_WRITTEN_BYTES(buffer, n, ...) \
66  { \
67  uint8_t bytes[] = { __VA_ARGS__}; \
68  EnsureWrittenBytes (buffer, n, bytes, __FILE__, __LINE__); \
69  }
70 
71 void
72 BufferTest::DoRun (void)
73 {
74  Buffer buffer;
75  Buffer::Iterator i;
76  buffer.AddAtStart (6);
77  i = buffer.Begin ();
78  i.WriteU8 (0x66);
79  ENSURE_WRITTEN_BYTES (buffer, 1, 0x66);
80  i = buffer.Begin ();
81  i.WriteU8 (0x67);
82  ENSURE_WRITTEN_BYTES (buffer, 1, 0x67);
83  i.WriteHtonU16 (0x6568);
84  i = buffer.Begin ();
85  ENSURE_WRITTEN_BYTES (buffer, 3, 0x67, 0x65, 0x68);
86  i.WriteHtonU16 (0x6369);
87  ENSURE_WRITTEN_BYTES (buffer, 3, 0x63, 0x69, 0x68);
88  i.WriteHtonU32 (0xdeadbeaf);
89  ENSURE_WRITTEN_BYTES (buffer, 6, 0x63, 0x69, 0xde, 0xad, 0xbe, 0xaf);
90  buffer.AddAtStart (2);
91  i = buffer.Begin ();
92  i.WriteU16 (0);
93  ENSURE_WRITTEN_BYTES (buffer, 8, 0, 0, 0x63, 0x69, 0xde, 0xad, 0xbe, 0xaf);
94  buffer.AddAtEnd (2);
95  i = buffer.Begin ();
96  i.Next (8);
97  i.WriteU16 (0);
98  ENSURE_WRITTEN_BYTES (buffer, 10, 0, 0, 0x63, 0x69, 0xde, 0xad, 0xbe, 0xaf, 0, 0);
99  buffer.RemoveAtStart (3);
100  i = buffer.Begin ();
101  ENSURE_WRITTEN_BYTES (buffer, 7, 0x69, 0xde, 0xad, 0xbe, 0xaf, 0, 0);
102  buffer.RemoveAtEnd (4);
103  i = buffer.Begin ();
104  ENSURE_WRITTEN_BYTES (buffer, 3, 0x69, 0xde, 0xad);
105  buffer.AddAtStart (1);
106  i = buffer.Begin ();
107  i.WriteU8 (0xff);
108  ENSURE_WRITTEN_BYTES (buffer, 4, 0xff, 0x69, 0xde, 0xad);
109  buffer.AddAtEnd (1);
110  i = buffer.Begin ();
111  i.Next (4);
112  i.WriteU8 (0xff);
113  i.Prev (2);
114  uint16_t saved = i.ReadU16 ();
115  i.Prev (2);
116  i.WriteHtonU16 (0xff00);
117  i.Prev (2);
118  NS_TEST_ASSERT_MSG_EQ (i.ReadNtohU16 (), 0xff00, "Could not read expected value");
119  i.Prev (2);
120  i.WriteU16 (saved);
121  ENSURE_WRITTEN_BYTES (buffer, 5, 0xff, 0x69, 0xde, 0xad, 0xff);
122  Buffer o = buffer;
123  ENSURE_WRITTEN_BYTES (o, 5, 0xff, 0x69, 0xde, 0xad, 0xff);
124  o.AddAtStart (1);
125  i = o.Begin ();
126  i.WriteU8 (0xfe);
127  ENSURE_WRITTEN_BYTES (o, 6, 0xfe, 0xff, 0x69, 0xde, 0xad, 0xff);
128  buffer.AddAtStart (2);
129  i = buffer.Begin ();
130  i.WriteU8 (0xfd);
131  i.WriteU8 (0xfd);
132  ENSURE_WRITTEN_BYTES (o, 6, 0xfe, 0xff, 0x69, 0xde, 0xad, 0xff);
133  ENSURE_WRITTEN_BYTES (buffer, 7, 0xfd, 0xfd, 0xff, 0x69, 0xde, 0xad, 0xff);
134 
135  // test 64-bit read/write
136  Buffer buff64;
137  buff64.AddAtStart (8);
138  i = buff64.Begin ();
139  i.WriteU64 (0x0123456789ABCDEFllu);
140  ENSURE_WRITTEN_BYTES (buff64, 8, 0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0x01);
141  i = buff64.Begin ();
142  NS_TEST_ASSERT_MSG_EQ (i.ReadLsbtohU64 (), 0x0123456789abcdefllu, "Could not read expected value");
143  i = buff64.Begin ();
144  i.WriteHtolsbU64 (0x0123456789ABCDEFllu);
145  ENSURE_WRITTEN_BYTES (buff64, 8, 0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0x01);
146  i = buff64.Begin ();
147  NS_TEST_ASSERT_MSG_EQ (i.ReadLsbtohU64 (), 0x0123456789abcdefllu, "Could not read expected value");
148  i = buff64.Begin ();
149  i.WriteHtonU64 (0x0123456789ABCDEFllu);
150  ENSURE_WRITTEN_BYTES (buff64, 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef);
151  i = buff64.Begin ();
152  NS_TEST_ASSERT_MSG_EQ (i.ReadNtohU64 (), 0x0123456789abcdefllu, "could not read expected value");
153 
154  // test self-assignment
155  {
156  Buffer a = o;
157  a = a;
158  }
159 
160  // test Remove start.
161  buffer = Buffer (5);
162  ENSURE_WRITTEN_BYTES (buffer, 5, 0, 0, 0, 0, 0);
163  buffer.RemoveAtStart (1);
164  ENSURE_WRITTEN_BYTES (buffer, 4, 0, 0, 0, 0);
165  buffer.AddAtStart (1);
166  buffer.Begin ().WriteU8 (0xff);
167  ENSURE_WRITTEN_BYTES (buffer, 5, 0xff, 0, 0, 0, 0);
168  buffer.RemoveAtStart (3);
169  ENSURE_WRITTEN_BYTES (buffer, 2, 0, 0);
170  buffer.AddAtStart (4);
171  buffer.Begin ().WriteHtonU32 (0xdeadbeaf);
172  ENSURE_WRITTEN_BYTES (buffer, 6, 0xde, 0xad, 0xbe, 0xaf, 0, 0);
173  buffer.RemoveAtStart (2);
174  ENSURE_WRITTEN_BYTES (buffer, 4, 0xbe, 0xaf, 0, 0);
175  buffer.AddAtEnd (4);
176  i = buffer.Begin ();
177  i.Next (4);
178  i.WriteHtonU32 (0xdeadbeaf);
179  ENSURE_WRITTEN_BYTES (buffer, 8, 0xbe, 0xaf, 0, 0, 0xde, 0xad, 0xbe, 0xaf);
180  buffer.RemoveAtStart (5);
181  ENSURE_WRITTEN_BYTES (buffer, 3, 0xad, 0xbe, 0xaf);
182  // test Remove end
183  buffer = Buffer (5);
184  ENSURE_WRITTEN_BYTES (buffer, 5, 0, 0, 0, 0, 0);
185  buffer.RemoveAtEnd (1);
186  ENSURE_WRITTEN_BYTES (buffer, 4, 0, 0, 0, 0);
187  buffer.AddAtEnd (2);
188  i = buffer.Begin ();
189  i.Next (4);
190  i.WriteU8 (0xab);
191  i.WriteU8 (0xac);
192  ENSURE_WRITTEN_BYTES (buffer, 6, 0, 0, 0, 0, 0xab, 0xac);
193  buffer.RemoveAtEnd (1);
194  ENSURE_WRITTEN_BYTES (buffer, 5, 0, 0, 0, 0, 0xab);
195  buffer.RemoveAtEnd (3);
196  ENSURE_WRITTEN_BYTES (buffer, 2, 0, 0);
197  buffer.AddAtEnd (6);
198  i = buffer.Begin ();
199  i.Next (2);
200  i.WriteU8 (0xac);
201  i.WriteU8 (0xad);
202  i.WriteU8 (0xae);
203  i.WriteU8 (0xaf);
204  i.WriteU8 (0xba);
205  i.WriteU8 (0xbb);
206  ENSURE_WRITTEN_BYTES (buffer, 8, 0, 0, 0xac, 0xad, 0xae, 0xaf, 0xba, 0xbb);
207  buffer.AddAtStart (3);
208  i = buffer.Begin ();
209  i.WriteU8 (0x30);
210  i.WriteU8 (0x31);
211  i.WriteU8 (0x32);
212  ENSURE_WRITTEN_BYTES (buffer, 11, 0x30, 0x31, 0x32, 0, 0, 0xac, 0xad, 0xae, 0xaf, 0xba, 0xbb);
213  buffer.RemoveAtEnd (9);
214  ENSURE_WRITTEN_BYTES (buffer, 2, 0x30, 0x31);
215  buffer = Buffer (3);
216  buffer.AddAtEnd (2);
217  i = buffer.Begin ();
218  i.Next (3);
219  i.WriteHtonU16 (0xabcd);
220  buffer.AddAtStart (1);
221  buffer.Begin ().WriteU8 (0x21);
222  ENSURE_WRITTEN_BYTES (buffer, 6, 0x21, 0, 0, 0, 0xab, 0xcd);
223  buffer.RemoveAtEnd (8);
224  NS_TEST_ASSERT_MSG_EQ (buffer.GetSize (), 0, "Buffer size not zero");
225 
226  buffer = Buffer (6);
227  buffer.AddAtStart (9);
228  buffer.AddAtEnd (3);
229  i = buffer.End ();
230  i.Prev (1);
231  i.WriteU8 (1, 1);
232 
233  buffer = Buffer (6);
234  buffer.AddAtStart (3);
235  buffer.RemoveAtEnd (8);
236  buffer.AddAtEnd (4);
237  i = buffer.End ();
238  i.Prev (4);
239  i.WriteU8 (1, 4);
240 
241  buffer = Buffer (1);
242  buffer.AddAtEnd (100);
243  i = buffer.End ();
244  i.Prev (100);
245  i.WriteU8 (1, 100);
246 
247  // Bug #54
248  {
249  const uint32_t actualSize = 72602;
250  const uint32_t chunkSize = 67624;
251  Ptr<UniformRandomVariable> bytesRng = CreateObject<UniformRandomVariable> ();
252  bytesRng->SetAttribute ("Min", DoubleValue (0));
253  bytesRng->SetAttribute ("Max", DoubleValue (256));
254 
255  Buffer inputBuffer;
256  Buffer outputBuffer;
257 
258  inputBuffer.AddAtEnd (actualSize);
259  {
260  Buffer::Iterator iter = inputBuffer.Begin ();
261  for (uint32_t i = 0; i < actualSize; i++)
262  iter.WriteU8 (static_cast<uint8_t> (bytesRng->GetValue ()));
263  }
264 
265  outputBuffer.AddAtEnd (chunkSize);
266  Buffer::Iterator iter = outputBuffer.End ();
267  iter.Prev (chunkSize);
268  iter.Write (inputBuffer.PeekData (), chunkSize);
269 
270  NS_TEST_EXPECT_MSG_EQ (memcmp (inputBuffer.PeekData (), outputBuffer.PeekData (), chunkSize), 0, "memcp works");
271  }
272 
273  buffer = Buffer (5);
274  buffer.AddAtEnd (2);
275  i = buffer.End ();
276  i.Prev (2);
277  i.WriteU8 (0);
278  i.WriteU8 (0x66);
279  ENSURE_WRITTEN_BYTES (buffer, 7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66);
280  Buffer frag0 = buffer.CreateFragment (0, 2);
281  ENSURE_WRITTEN_BYTES (frag0, 2, 0x00, 0x00);
282  Buffer frag1 = buffer.CreateFragment (2, 5);
283  ENSURE_WRITTEN_BYTES (frag1, 5, 0x00, 0x00, 0x00, 0x00, 0x66);
284  frag0.AddAtEnd (frag1);
285  ENSURE_WRITTEN_BYTES (buffer, 7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66);
286  ENSURE_WRITTEN_BYTES (frag0, 7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66);
287 
288  buffer = Buffer (5);
289  buffer.AddAtStart (2);
290  i = buffer.Begin ();
291  i.WriteU8 (0x1);
292  i.WriteU8 (0x2);
293  buffer.AddAtEnd (2);
294  i = buffer.End ();
295  i.Prev (2);
296  i.WriteU8 (0x3);
297  i.WriteU8 (0x4);
298  ENSURE_WRITTEN_BYTES (buffer, 9, 0x1, 0x2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3, 0x4);
299  Buffer other;
300  other.AddAtStart (9);
301  i = other.Begin ();
302  i.Write (buffer.Begin (), buffer.End ());
303  ENSURE_WRITTEN_BYTES (other, 9, 0x1, 0x2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3, 0x4);
304 
305  // BUG #1001
306  std::string ct ("This is the next content of the buffer.");
307  buffer = Buffer ();
308  buffer.AddAtStart (ct.size ());
309  i = buffer.Begin ();
310  i.Write ((const uint8_t*)ct.c_str (), ct.size ());
311  uint32_t sizeBuffer = buffer.GetSize ();
312  NS_TEST_ASSERT_MSG_EQ (sizeBuffer, ct.size(), "Buffer bad size");
313  uint8_t const* evilBuffer = buffer.PeekData ();
314  NS_TEST_ASSERT_MSG_NE( evilBuffer, 0, "Buffer PeekData failed");
315  uint8_t *cBuf = (uint8_t*) malloc ( sizeBuffer );
316  uint32_t copyLen = buffer.CopyData (cBuf, sizeBuffer);
317  NS_TEST_ASSERT_MSG_EQ (copyLen, sizeBuffer, "CopyData return bad size");
318  for (uint8_t i=0; i < sizeBuffer ; i++ )
319  {
320  NS_TEST_ASSERT_MSG_EQ ( cBuf [i], *(((const uint8_t*)ct.c_str ()) + i), "Bad buffer copied data");
321  NS_TEST_ASSERT_MSG_EQ ( evilBuffer [i], cBuf [i] , "Bad buffer peeked");
322  }
323  free (cBuf);
324 }
325 //-----------------------------------------------------------------------------
326 class BufferTestSuite : public TestSuite
327 {
328 public:
329  BufferTestSuite ();
330 };
331 
332 BufferTestSuite::BufferTestSuite ()
333  : TestSuite ("buffer", UNIT)
334 {
335  AddTestCase (new BufferTest, TestCase::QUICK);
336 }
337 
338 static BufferTestSuite g_bufferTestSuite;
ns3::Buffer::Iterator::ReadU16
uint16_t ReadU16(void)
Definition: buffer.h:845
ns3::Buffer::Iterator::WriteHtonU64
void WriteHtonU64(uint64_t data)
Definition: buffer.cc:965
ns3::Buffer::RemoveAtEnd
void RemoveAtEnd(uint32_t end)
Definition: buffer.cc:497
ns3::Buffer::RemoveAtStart
void RemoveAtStart(uint32_t start)
Definition: buffer.cc:452
ns3::TestSuite
A suite of tests to run.
Definition: test.h:962
ns3::Buffer
automatically resized byte buffer
Definition: buffer.h:92
ns3::TestCase
encapsulates test code
Definition: test.h:834
ns3::Buffer::Iterator
iterator in a Buffer instance
Definition: buffer.h:98
ns3::Buffer::Iterator::Prev
void Prev(void)
Definition: buffer.h:672
ns3::Buffer::Iterator::WriteU16
void WriteU16(uint16_t data)
Definition: buffer.cc:895
ns3::Buffer::Iterator::WriteHtonU16
void WriteHtonU16(uint16_t data)
Definition: buffer.h:726
ns3::Buffer::End
Buffer::Iterator End(void) const
Definition: buffer.h:881
ns3::Buffer::PeekData
uint8_t const * PeekData(void) const
Definition: buffer.cc:729
ns3::Buffer::Iterator::Next
void Next(void)
Definition: buffer.h:666
ns3::Buffer::Iterator::WriteU64
void WriteU64(uint64_t data)
Definition: buffer.cc:915
ns3::Buffer::Begin
Buffer::Iterator Begin(void) const
Definition: buffer.h:875
ns3::UniformRandomVariable::GetValue
double GetValue(double min, double max)
Returns a random double from the uniform distribution with the specified range.
Definition: random-variable-stream.cc:172
BufferTest::DoRun
virtual void DoRun(void)
Implementation to actually run this test case.
Definition: buffer-test.cc:72
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase) NS_DEPRECATED
Add an individual test case to this test suite.
Definition: test.cc:172
ns3::Buffer::Iterator::WriteHtonU32
void WriteHtonU32(uint32_t data)
Definition: buffer.h:745
ns3::Buffer::GetSize
uint32_t GetSize(void) const
Definition: buffer.h:869
ns3::Buffer::CreateFragment
Buffer CreateFragment(uint32_t start, uint32_t length) const
Definition: buffer.cc:533
ns3::Buffer::AddAtEnd
bool AddAtEnd(uint32_t end)
Definition: buffer.cc:356
ns3::Buffer::Iterator::WriteU8
void WriteU8(uint8_t data)
Definition: buffer.h:690
ns3::Buffer::Iterator::WriteHtolsbU64
void WriteHtolsbU64(uint64_t data)
Definition: buffer.cc:951
ns3::Buffer::Iterator::Write
void Write(uint8_t const *buffer, uint32_t size)
Definition: buffer.cc:978
ns3::Buffer::AddAtStart
bool AddAtStart(uint32_t start)
Definition: buffer.cc:305
ns3::Buffer::Iterator::ReadLsbtohU64
uint64_t ReadLsbtohU64(void)
Definition: buffer.cc:1118
ns3::Buffer::Iterator::ReadNtohU16
uint16_t ReadNtohU16(void)
Definition: buffer.h:767
ns3::DoubleValue
Hold an floating point type.
Definition: double.h:41
ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Definition: object-base.cc:160