00001
00002 #ifdef RUN_SELF_TESTS
00003
00004 #include "ns3/test.h"
00005 #include "ns3/simulator.h"
00006 #include "dcf-manager.h"
00007
00008
00009 namespace ns3 {
00010
00011 class DcfManagerTest;
00012
00013 class DcfStateTest : public DcfState
00014 {
00015 public:
00016 DcfStateTest (DcfManagerTest *test, uint32_t i);
00017 void QueueTx (uint64_t txTime, uint64_t expectedGrantTime);
00018 private:
00019 friend class DcfManagerTest;
00020 virtual void DoNotifyAccessGranted (void);
00021 virtual void DoNotifyInternalCollision (void);
00022 virtual void DoNotifyCollision (void);
00023
00024 typedef std::pair<uint64_t,uint64_t> ExpectedGrant;
00025 typedef std::list<ExpectedGrant> ExpectedGrants;
00026 struct ExpectedCollision {
00027 uint64_t at;
00028 uint32_t nSlots;
00029 };
00030 typedef std::list<struct ExpectedCollision> ExpectedCollisions;
00031
00032 ExpectedCollisions m_expectedInternalCollision;
00033 ExpectedCollisions m_expectedCollision;
00034 ExpectedGrants m_expectedGrants;
00035 DcfManagerTest *m_test;
00036 uint32_t m_i;
00037 };
00038
00039
00040 class DcfManagerTest : public Test
00041 {
00042 public:
00043 DcfManagerTest ();
00044 virtual bool RunTests (void);
00045
00046
00047 void NotifyAccessGranted (uint32_t i);
00048 void NotifyInternalCollision (uint32_t i);
00049 void NotifyCollision (uint32_t i);
00050
00051
00052 private:
00053 void StartTest (uint64_t slotTime, uint64_t sifs, uint64_t eifsNoDifsNoSifs);
00054 void AddDcfState (uint32_t aifsn);
00055 void EndTest (void);
00056 void ExpectInternalCollision (uint64_t time, uint32_t from, uint32_t nSlots);
00057 void ExpectCollision (uint64_t time, uint32_t from, uint32_t nSlots);
00058 void AddRxOkEvt (uint64_t at, uint64_t duration);
00059 void AddRxErrorEvt (uint64_t at, uint64_t duration);
00060 void AddNavReset (uint64_t at, uint64_t duration);
00061 void AddNavStart (uint64_t at, uint64_t duration);
00062 void AddAccessRequest (uint64_t at, uint64_t txTime,
00063 uint64_t expectedGrantTime, uint32_t from);
00064 void DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, DcfStateTest *state);
00065
00066 typedef std::vector<DcfStateTest *> DcfStates;
00067
00068 DcfManager *m_dcfManager;
00069 DcfStates m_dcfStates;
00070 bool m_result;
00071 };
00072
00073
00074
00075 DcfStateTest::DcfStateTest (DcfManagerTest *test, uint32_t i)
00076 : m_test (test), m_i(i)
00077 {}
00078 void
00079 DcfStateTest::QueueTx (uint64_t txTime, uint64_t expectedGrantTime)
00080 {
00081 m_expectedGrants.push_back (std::make_pair (txTime, expectedGrantTime));
00082 }
00083 void
00084 DcfStateTest::DoNotifyAccessGranted (void)
00085 {
00086 m_test->NotifyAccessGranted (m_i);
00087 }
00088 void
00089 DcfStateTest::DoNotifyInternalCollision (void)
00090 {
00091 m_test->NotifyInternalCollision (m_i);
00092 }
00093 void
00094 DcfStateTest::DoNotifyCollision (void)
00095 {
00096 m_test->NotifyCollision (m_i);
00097 }
00098
00099
00100
00101 DcfManagerTest::DcfManagerTest ()
00102 : Test ("DcfManager")
00103 {}
00104
00105 void
00106 DcfManagerTest::NotifyAccessGranted (uint32_t i)
00107 {
00108 DcfStateTest *state = m_dcfStates[i];
00109 bool result = true;
00110 NS_TEST_ASSERT (!state->m_expectedGrants.empty ());
00111 std::pair<uint64_t, uint64_t> expected = state->m_expectedGrants.front ();
00112 state->m_expectedGrants.pop_front ();
00113 NS_TEST_ASSERT_EQUAL (Simulator::Now (), MicroSeconds (expected.second));
00114 m_dcfManager->NotifyTxStartNow (MicroSeconds (expected.first));
00115 if (!result)
00116 {
00117 m_result = result;
00118 }
00119 }
00120 void
00121 DcfManagerTest::NotifyInternalCollision (uint32_t i)
00122 {
00123 DcfStateTest *state = m_dcfStates[i];
00124 bool result = true;
00125 NS_TEST_ASSERT (!state->m_expectedInternalCollision.empty ());
00126 struct DcfStateTest::ExpectedCollision expected = state->m_expectedInternalCollision.front ();
00127 state->m_expectedInternalCollision.pop_front ();
00128 NS_TEST_ASSERT_EQUAL (Simulator::Now (), MicroSeconds (expected.at));
00129 state->StartBackoffNow (expected.nSlots);
00130 if (!result)
00131 {
00132 m_result = result;
00133 }
00134 }
00135 void
00136 DcfManagerTest::NotifyCollision (uint32_t i)
00137 {
00138 DcfStateTest *state = m_dcfStates[i];
00139 bool result = true;
00140 NS_TEST_ASSERT (!state->m_expectedCollision.empty ());
00141 struct DcfStateTest::ExpectedCollision expected = state->m_expectedCollision.front ();
00142 state->m_expectedCollision.pop_front ();
00143 NS_TEST_ASSERT_EQUAL (Simulator::Now (), MicroSeconds (expected.at));
00144 state->StartBackoffNow (expected.nSlots);
00145 if (!result)
00146 {
00147 m_result = result;
00148 }
00149 }
00150
00151
00152 void
00153 DcfManagerTest::ExpectInternalCollision (uint64_t time, uint32_t nSlots, uint32_t from)
00154 {
00155 DcfStateTest *state = m_dcfStates[from];
00156 struct DcfStateTest::ExpectedCollision col;
00157 col.at = time;
00158 col.nSlots = nSlots;
00159 state->m_expectedInternalCollision.push_back (col);
00160 }
00161 void
00162 DcfManagerTest::ExpectCollision (uint64_t time, uint32_t nSlots, uint32_t from)
00163 {
00164 DcfStateTest *state = m_dcfStates[from];
00165 struct DcfStateTest::ExpectedCollision col;
00166 col.at = time;
00167 col.nSlots = nSlots;
00168 state->m_expectedCollision.push_back (col);
00169 }
00170
00171 void
00172 DcfManagerTest::StartTest (uint64_t slotTime, uint64_t sifs, uint64_t eifsNoDifsNoSifs)
00173 {
00174 m_dcfManager = new DcfManager ();
00175 m_dcfManager->SetSlot (MicroSeconds (slotTime));
00176 m_dcfManager->SetSifs (MicroSeconds (sifs));
00177 m_dcfManager->SetEifsNoDifs (MicroSeconds (eifsNoDifsNoSifs+sifs));
00178 }
00179
00180 void
00181 DcfManagerTest::AddDcfState (uint32_t aifsn)
00182 {
00183 DcfStateTest *state = new DcfStateTest (this, m_dcfStates.size ());
00184 state->SetAifsn (aifsn);
00185 m_dcfStates.push_back (state);
00186 m_dcfManager->Add (state);
00187 }
00188
00189 void
00190 DcfManagerTest::EndTest (void)
00191 {
00192 bool result = true;
00193 Simulator::Run ();
00194 Simulator::Destroy ();
00195 for (DcfStates::const_iterator i = m_dcfStates.begin (); i != m_dcfStates.end (); i++)
00196 {
00197 DcfStateTest *state = *i;
00198 NS_TEST_ASSERT (state->m_expectedGrants.empty ());
00199 NS_TEST_ASSERT (state->m_expectedInternalCollision.empty ());
00200 NS_TEST_ASSERT (state->m_expectedCollision.empty ());
00201 delete state;
00202 }
00203 m_dcfStates.clear ();
00204 delete m_dcfManager;
00205 if (!result)
00206 {
00207 m_result = result;
00208 }
00209 }
00210
00211 void
00212 DcfManagerTest::AddRxOkEvt (uint64_t at, uint64_t duration)
00213 {
00214 Simulator::Schedule (MicroSeconds (at) - Now (),
00215 &DcfManager::NotifyRxStartNow, m_dcfManager,
00216 MicroSeconds (duration));
00217 Simulator::Schedule (MicroSeconds (at+duration) - Now (),
00218 &DcfManager::NotifyRxEndOkNow, m_dcfManager);
00219 }
00220 void
00221 DcfManagerTest::AddRxErrorEvt (uint64_t at, uint64_t duration)
00222 {
00223 Simulator::Schedule (MicroSeconds (at) - Now (),
00224 &DcfManager::NotifyRxStartNow, m_dcfManager,
00225 MicroSeconds (duration));
00226 Simulator::Schedule (MicroSeconds (at+duration) - Now (),
00227 &DcfManager::NotifyRxEndErrorNow, m_dcfManager);
00228 }
00229
00230 void
00231 DcfManagerTest::AddNavReset (uint64_t at, uint64_t duration)
00232 {
00233 Simulator::Schedule (MicroSeconds (at) - Now (),
00234 &DcfManager::NotifyNavResetNow, m_dcfManager,
00235 MicroSeconds (duration));
00236 }
00237 void
00238 DcfManagerTest::AddNavStart (uint64_t at, uint64_t duration)
00239 {
00240 Simulator::Schedule (MicroSeconds (at) - Now (),
00241 &DcfManager::NotifyNavStartNow, m_dcfManager,
00242 MicroSeconds (duration));
00243 }
00244 void
00245 DcfManagerTest::AddAccessRequest (uint64_t at, uint64_t txTime,
00246 uint64_t expectedGrantTime, uint32_t from)
00247 {
00248 Simulator::Schedule (MicroSeconds (at) - Now (),
00249 &DcfManagerTest::DoAccessRequest, this,
00250 txTime, expectedGrantTime, m_dcfStates[from]);
00251 }
00252
00253 void
00254 DcfManagerTest::DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, DcfStateTest *state)
00255 {
00256 state->QueueTx (txTime, expectedGrantTime);
00257 m_dcfManager->RequestAccess (state);
00258 }
00259
00260
00261
00262
00263 bool
00264 DcfManagerTest::RunTests (void)
00265 {
00266 m_result = true;
00267
00268
00269
00270
00271 StartTest (1, 3, 10);
00272 AddDcfState (1);
00273 AddAccessRequest (1, 1, 4, 0);
00274 AddAccessRequest (10, 2, 10, 0);
00275 EndTest ();
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286 StartTest (4, 6 , 10);
00287 AddDcfState (1);
00288 AddRxOkEvt (20, 40);
00289 AddRxOkEvt (80, 20);
00290 AddAccessRequest (30, 2, 118, 0);
00291 ExpectCollision (30, 4, 0);
00292 EndTest ();
00293
00294
00295
00296
00297
00298
00299
00300 StartTest (4, 6 , 10);
00301 AddDcfState (1);
00302 AddRxOkEvt (20, 40);
00303 AddAccessRequest (30, 2, 70, 0);
00304 ExpectCollision (30, 0, 0);
00305 EndTest ();
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320 StartTest (4, 6 , 10);
00321 AddDcfState (1);
00322 AddRxOkEvt (20, 40);
00323 AddAccessRequest (62, 2, 70, 0);
00324 EndTest ();
00325
00326
00327
00328
00329
00330
00331
00332
00333 StartTest (4, 6, 10);
00334 AddDcfState (1);
00335 AddRxErrorEvt (20, 40);
00336 AddAccessRequest (30, 2, 96, 0);
00337 ExpectCollision (30, 4, 0);
00338 EndTest ();
00339
00340
00341
00342
00343
00344
00345
00346 StartTest (4, 6, 10);
00347 AddDcfState (1);
00348 AddRxErrorEvt (20, 40);
00349 AddAccessRequest (30, 2, 101, 0);
00350 ExpectCollision (30, 4, 0);
00351 AddRxOkEvt (69, 6);
00352 EndTest ();
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362 StartTest (4, 6, 10);
00363 AddDcfState (1);
00364 AddDcfState (3);
00365 AddRxOkEvt (20, 40);
00366 AddAccessRequest (30, 10, 78, 0);
00367 ExpectCollision (30, 2, 0);
00368
00369 AddAccessRequest (40, 2, 110, 1);
00370 ExpectCollision (40, 0, 1);
00371 ExpectInternalCollision (78, 1, 1);
00372 EndTest ();
00373
00374
00375
00376
00377
00378
00379
00380 StartTest (4, 6, 10);
00381 AddDcfState (1);
00382 AddRxOkEvt (20, 40);
00383 AddNavStart (60, 15);
00384 AddRxOkEvt (66, 5);
00385 AddNavStart (71, 0);
00386 AddAccessRequest (30, 10, 93, 0);
00387 ExpectCollision (30, 2, 0);
00388 EndTest ();
00389
00390
00391
00392
00393
00394
00395
00396 StartTest (4, 6, 10);
00397 AddDcfState (1);
00398 AddRxOkEvt (20, 40);
00399 AddNavStart (60, 15);
00400 AddRxOkEvt (66, 5);
00401 AddNavReset (71, 2);
00402 AddAccessRequest (30, 10, 91, 0);
00403 ExpectCollision (30, 2, 0);
00404 EndTest ();
00405
00406
00407 StartTest (4, 6, 10);
00408 AddDcfState (2);
00409 AddRxOkEvt (20, 40);
00410 AddAccessRequest (80, 10, 80, 0);
00411 EndTest ();
00412
00413
00414 StartTest (4, 6, 10);
00415 AddDcfState (2);
00416 AddRxOkEvt (20, 40);
00417 AddRxOkEvt (78, 8);
00418 AddAccessRequest (30, 50, 108, 0);
00419 ExpectCollision (30, 3, 0);
00420 EndTest ();
00421
00422
00423 return m_result;
00424 }
00425
00426
00427
00428 static DcfManagerTest g_dcf_manager_test;
00429
00430 }
00431
00432 #endif