A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
mac-extension-test-suite.cc
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License version 2 as
4 * published by the Free Software Foundation;
5 *
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 * GNU General Public License for more details.
10 *
11 * You should have received a copy of the GNU General Public License
12 * along with this program; if not, write to the Free Software
13 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
14 *
15 * Author: Junling Bu <linlinjavaer@gmail.com>
16 */
17#include "ns3/config.h"
18#include "ns3/mobility-helper.h"
19#include "ns3/mobility-model.h"
20#include "ns3/node-list.h"
21#include "ns3/string.h"
22#include "ns3/test.h"
23#include "ns3/wave-helper.h"
24#include "ns3/wave-mac-helper.h"
25#include "ns3/wave-net-device.h"
26#include "ns3/yans-wifi-helper.h"
27
28#include <cmath>
29
30using namespace ns3;
31
48class ChannelCoordinationTestCase : public TestCase
49{
50 public:
51 ChannelCoordinationTestCase();
52 ~ChannelCoordinationTestCase() override;
53
54 // below three methods are used in CoordinationTestListener
59 void NotifyCchStartNow(Time duration);
64 void NotifySchStartNow(Time duration);
70 void NotifyGuardStartNow(Time duration, bool inCchInterval);
71
72 private:
79 void TestIntervalAfter(bool cchi, bool schi, bool guardi);
80 void DoRun() override;
81 Ptr<ChannelCoordinator> m_coordinator;
82};
83
90class CoordinationTestListener : public ChannelCoordinationListener
91{
92 public:
98 CoordinationTestListener(ChannelCoordinationTestCase* coordinatorTest)
99 : m_coordinatorTest(coordinatorTest)
100 {
101 }
102
103 ~CoordinationTestListener() override
104 {
105 }
106
107 void NotifyCchSlotStart(Time duration) override
108 {
109 m_coordinatorTest->NotifyCchStartNow(duration);
110 }
111
112 void NotifySchSlotStart(Time duration) override
113 {
114 m_coordinatorTest->NotifySchStartNow(duration);
115 }
116
117 void NotifyGuardSlotStart(Time duration, bool cchi) override
118 {
119 m_coordinatorTest->NotifyGuardStartNow(duration, cchi);
120 }
121
122 ChannelCoordinationTestCase* m_coordinatorTest;
123};
124
125ChannelCoordinationTestCase::ChannelCoordinationTestCase()
126 : TestCase("channel-coordination")
127{
128}
129
130ChannelCoordinationTestCase::~ChannelCoordinationTestCase()
131{
132}
133
134void
135ChannelCoordinationTestCase::TestIntervalAfter(bool cchi, bool schi, bool guardi)
136{
137 uint32_t now = Now().GetMilliSeconds();
138 NS_TEST_EXPECT_MSG_EQ(m_coordinator->IsCchInterval(),
139 cchi,
140 "now is " << now
141 << "ms "
142 "check whether is CCH interval");
143 NS_TEST_EXPECT_MSG_EQ(m_coordinator->IsSchInterval(),
144 schi,
145 "now is " << now
146 << "ms "
147 "check whether is SCH interval");
148 NS_TEST_EXPECT_MSG_EQ(m_coordinator->IsGuardInterval(),
149 guardi,
150 "now is " << now
151 << "ms "
152 "check whether is Guard interval");
153}
154
155void
156ChannelCoordinationTestCase::NotifyCchStartNow(Time duration)
157{
158 // this method shall be called at 4ms, 104ms, ... synci * n + guardi
159 // synci is sync interval with default value 100ms
160 // guardi is guard interval with default value 4ms
161 // n is sequence number
162 int64_t now = Now().GetMilliSeconds();
163 int64_t synci = m_coordinator->GetSyncInterval().GetMilliSeconds();
164 int64_t guardi = m_coordinator->GetGuardInterval().GetMilliSeconds();
165 bool test = (((now - guardi) % synci) == 0);
166 NS_TEST_EXPECT_MSG_EQ(test, true, "the time of now shall be synci * n + guardi");
167
168 // besides that, the argument duration shall be cchi - guardi
169 Time d = m_coordinator->GetCchInterval() - m_coordinator->GetGuardInterval();
170 NS_TEST_EXPECT_MSG_EQ((duration == d), true, "the duration shall be cchi - guardi");
171}
172
173void
174ChannelCoordinationTestCase::NotifySchStartNow(Time duration)
175{
176 // this method shall be called at 54ms, 154ms, ... synci * n + cchi + guardi
177 // synci is sync interval with default value 100ms
178 // cchi is CCH interval with default value 50ms
179 // guardi is guard interval with default value 4ms
180 // n is sequence number
181 int64_t now = Now().GetMilliSeconds();
182 int64_t synci = m_coordinator->GetSyncInterval().GetMilliSeconds();
183 int64_t cchi = m_coordinator->GetCchInterval().GetMilliSeconds();
184 int64_t guardi = m_coordinator->GetGuardInterval().GetMilliSeconds();
185 bool test = ((now - guardi - cchi) % synci == 0);
186 NS_TEST_EXPECT_MSG_EQ(test, true, "the time of now shall be synci * n + cchi + guardi");
187
188 // besides that, the argument duration shall be schi - guardi
189 Time d = m_coordinator->GetSchInterval() - m_coordinator->GetGuardInterval();
190 NS_TEST_EXPECT_MSG_EQ((duration == d), true, "the duration shall be schi - guardi");
191}
192
193void
194ChannelCoordinationTestCase::NotifyGuardStartNow(Time duration, bool inCchInterval)
195{
196 int64_t now = Now().GetMilliSeconds();
197 int64_t sync = m_coordinator->GetSyncInterval().GetMilliSeconds();
198 int64_t cchi = m_coordinator->GetCchInterval().GetMilliSeconds();
199 bool test = false;
200 if (inCchInterval)
201 {
202 // if cchi, this method will be called at 0ms, 100ms, sync * n
203 test = ((now % sync) == 0);
204 NS_TEST_EXPECT_MSG_EQ(test, true, "the time of now shall be sync * n");
205 }
206 else
207 {
208 // if schi, this method will be called at 50ms, 150ms, sync * n + cchi
209 test = (((now - cchi) % sync) == 0);
210 NS_TEST_EXPECT_MSG_EQ(test, true, "the time of now shall be sync * n");
211 }
212 // the duration shall be guardi
213 test = (duration == m_coordinator->GetGuardInterval());
214 NS_TEST_EXPECT_MSG_EQ(test, true, "the duration shall be guard interval");
215}
216
217void
218ChannelCoordinationTestCase::DoRun()
219{
220 // first test configure method
221 m_coordinator = CreateObject<ChannelCoordinator>();
222 NS_TEST_EXPECT_MSG_EQ(m_coordinator->GetCchInterval(),
223 MilliSeconds(50),
224 "normally CCH interval is 50ms");
225 NS_TEST_EXPECT_MSG_EQ(m_coordinator->GetSchInterval(),
226 MilliSeconds(50),
227 "normally SCH interval is 50ms");
228 NS_TEST_EXPECT_MSG_EQ(m_coordinator->GetSyncInterval(),
229 MilliSeconds(100),
230 "normally Sync interval is 50ms");
231 NS_TEST_EXPECT_MSG_EQ(m_coordinator->GetGuardInterval(),
232 MilliSeconds(4),
233 "normally Guard interval is 50ms");
234 m_coordinator->SetCchInterval(MilliSeconds(40));
235 m_coordinator->SetSchInterval(MilliSeconds(60));
236 NS_TEST_EXPECT_MSG_EQ(m_coordinator->IsValidConfig(),
237 true,
238 "valid configuration of channel intervals");
239 m_coordinator->SetCchInterval(MilliSeconds(40));
240 m_coordinator->SetSchInterval(MilliSeconds(50));
241 NS_TEST_EXPECT_MSG_EQ(m_coordinator->IsValidConfig(),
242 false,
243 "invalid configuration of channel intervals");
244 m_coordinator->SetGuardInterval(MilliSeconds(50));
245 m_coordinator->SetCchInterval(MilliSeconds(40));
246 m_coordinator->SetSchInterval(MilliSeconds(50));
247 NS_TEST_EXPECT_MSG_EQ(m_coordinator->IsValidConfig(),
248 false,
249 "invalid configuration of channel intervals");
250
251 // second test member method
252 m_coordinator = CreateObject<ChannelCoordinator>();
253 Simulator::Schedule(MilliSeconds(0),
254 &ChannelCoordinationTestCase::TestIntervalAfter,
255 this,
256 true,
257 false,
258 true);
259 Simulator::Schedule(MilliSeconds(1),
260 &ChannelCoordinationTestCase::TestIntervalAfter,
261 this,
262 true,
263 false,
264 true);
265 Simulator::Schedule(MilliSeconds(3),
266 &ChannelCoordinationTestCase::TestIntervalAfter,
267 this,
268 true,
269 false,
270 true);
271 Simulator::Schedule(MilliSeconds(4),
272 &ChannelCoordinationTestCase::TestIntervalAfter,
273 this,
274 true,
275 false,
276 false);
277 Simulator::Schedule(MilliSeconds(5),
278 &ChannelCoordinationTestCase::TestIntervalAfter,
279 this,
280 true,
281 false,
282 false);
283 Simulator::Schedule(MilliSeconds(50),
284 &ChannelCoordinationTestCase::TestIntervalAfter,
285 this,
286 false,
287 true,
288 true);
289 Simulator::Schedule(MilliSeconds(51),
290 &ChannelCoordinationTestCase::TestIntervalAfter,
291 this,
292 false,
293 true,
294 true);
295 Simulator::Schedule(MilliSeconds(53),
296 &ChannelCoordinationTestCase::TestIntervalAfter,
297 this,
298 false,
299 true,
300 true);
301 Simulator::Schedule(MilliSeconds(54),
302 &ChannelCoordinationTestCase::TestIntervalAfter,
303 this,
304 false,
305 true,
306 false);
307 Simulator::Schedule(MilliSeconds(55),
308 &ChannelCoordinationTestCase::TestIntervalAfter,
309 this,
310 false,
311 true,
312 false);
313 Simulator::Schedule(MilliSeconds(100),
314 &ChannelCoordinationTestCase::TestIntervalAfter,
315 this,
316 true,
317 false,
318 true);
319 Simulator::Schedule(MilliSeconds(200),
320 &ChannelCoordinationTestCase::TestIntervalAfter,
321 this,
322 true,
323 false,
324 true);
325 Simulator::Schedule(MilliSeconds(201),
326 &ChannelCoordinationTestCase::TestIntervalAfter,
327 this,
328 true,
329 false,
330 true);
331 Simulator::Schedule(MilliSeconds(203),
332 &ChannelCoordinationTestCase::TestIntervalAfter,
333 this,
334 true,
335 false,
336 true);
337 Simulator::Schedule(MilliSeconds(204),
338 &ChannelCoordinationTestCase::TestIntervalAfter,
339 this,
340 true,
341 false,
342 false);
343 Simulator::Schedule(MilliSeconds(205),
344 &ChannelCoordinationTestCase::TestIntervalAfter,
345 this,
346 true,
347 false,
348 false);
349 Simulator::Schedule(MilliSeconds(250),
350 &ChannelCoordinationTestCase::TestIntervalAfter,
351 this,
352 false,
353 true,
354 true);
355 Simulator::Schedule(MilliSeconds(251),
356 &ChannelCoordinationTestCase::TestIntervalAfter,
357 this,
358 false,
359 true,
360 true);
361 Simulator::Schedule(MilliSeconds(253),
362 &ChannelCoordinationTestCase::TestIntervalAfter,
363 this,
364 false,
365 true,
366 true);
367 Simulator::Schedule(MilliSeconds(254),
368 &ChannelCoordinationTestCase::TestIntervalAfter,
369 this,
370 false,
371 true,
372 false);
373 Simulator::Schedule(MilliSeconds(255),
374 &ChannelCoordinationTestCase::TestIntervalAfter,
375 this,
376 false,
377 true,
378 false);
379 Simulator::Schedule(MilliSeconds(300),
380 &ChannelCoordinationTestCase::TestIntervalAfter,
381 this,
382 true,
383 false,
384 true);
385 Simulator::Stop(Seconds(1.0));
386 Simulator::Run();
387 Simulator::Destroy();
388
389 m_coordinator = CreateObject<ChannelCoordinator>();
390 // third test channel coordination events
391 Ptr<CoordinationTestListener> ptr = Create<CoordinationTestListener>(this);
392 m_coordinator->RegisterListener(ptr);
393 Simulator::Stop(Seconds(100.0));
394 Simulator::Run();
395 Simulator::Destroy();
396}
397
404class TestCaseHelper
405{
406 public:
412 static NetDeviceContainer CreatWaveDevice(uint32_t nodesNumber = 2);
413};
414
415#define PI 3.14159265
416
417NetDeviceContainer
418TestCaseHelper::CreatWaveDevice(uint32_t nodesNumber)
419{
420 NodeContainer nodes;
421 nodes.Create(nodesNumber);
422
423 MobilityHelper mobility;
424 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
425 mobility.Install(nodes);
426 // this is a circle with radius 10
427 Ptr<MobilityModel> model = NodeList::GetNode(0)->GetObject<MobilityModel>();
428 model->SetPosition(Vector(0, 0, 0));
429 for (uint32_t n = 1; n != nodesNumber; ++n)
430 {
431 double angle = (PI / 180) * (360 / (nodesNumber - 1) * n);
432 double x = cos(angle) * 10;
433 double y = sin(angle) * 10;
434 Ptr<MobilityModel> model = NodeList::GetNode(n)->GetObject<MobilityModel>();
435 model->SetPosition(Vector(x, y, 0));
436 }
437
438 YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default();
439 YansWavePhyHelper wifiPhy = YansWavePhyHelper::Default();
440 wifiPhy.SetChannel(wifiChannel.Create());
441 QosWaveMacHelper waveMac = QosWaveMacHelper::Default();
442 WaveHelper waveHelper = WaveHelper::Default();
443 NetDeviceContainer devices = waveHelper.Install(wifiPhy, waveMac, nodes);
444 return devices;
445}
446
451class ChannelRoutingTestCase : public TestCase
452{
453 public:
454 ChannelRoutingTestCase();
455 ~ChannelRoutingTestCase() override;
456
463 void SendIp(bool shouldSucceed, bool ipv6);
469 void SendWsmp(bool shouldSucceed, const TxInfo& txInfo);
475 void SendWsa(bool shouldSucceed, const VsaInfo& vsaInfo);
476
477 private:
478 void DoRun() override;
487 bool Receive(Ptr<NetDevice> dev, Ptr<const Packet> pkt, uint16_t mode, const Address& sender);
494 bool ReceiveVsa(Ptr<const Packet> pkt, const Address& address, uint32_t, uint32_t);
495
496 Ptr<WaveNetDevice> m_sender;
497};
498
499ChannelRoutingTestCase::ChannelRoutingTestCase()
500 : TestCase("channel-routing")
501{
502}
503
504ChannelRoutingTestCase::~ChannelRoutingTestCase()
505{
506}
507
508void
509ChannelRoutingTestCase::SendWsmp(bool shouldSucceed, const TxInfo& txInfo)
510{
511 Ptr<Packet> packet = Create<Packet>(100);
512 const Address dest = Mac48Address::GetBroadcast();
513 uint16_t protocol = 0x80dd; // any number is OK even ipv4 and ipv6
514 bool result = m_sender->SendX(packet, dest, protocol, txInfo);
515 NS_TEST_EXPECT_MSG_EQ(result, shouldSucceed, "test SendWsmp method error");
516}
517
518void
519ChannelRoutingTestCase::SendIp(bool shouldSucceed, bool ipv6)
520{
521 Ptr<Packet> packet = Create<Packet>(100);
522 const Address dest = Mac48Address::GetBroadcast();
523 const static uint16_t IPv4_PROT_NUMBER = 0x0800;
524 const static uint16_t IPv6_PROT_NUMBER = 0x86DD;
525 uint16_t protocol = ipv6 ? IPv6_PROT_NUMBER : IPv4_PROT_NUMBER;
526 bool result = m_sender->Send(packet, dest, protocol);
527 NS_TEST_EXPECT_MSG_EQ(result, shouldSucceed, "test SendIp method error");
528}
529
530void
531ChannelRoutingTestCase::SendWsa(bool shouldSucceed, const VsaInfo& vsaInfo)
532{
533 bool result = m_sender->StartVsa(vsaInfo);
534 NS_TEST_EXPECT_MSG_EQ(result, shouldSucceed, "test SendWsa method error");
535}
536
537void
538ChannelRoutingTestCase::DoRun()
539{
540 // check SendX method for WSMP packets
541 {
542 NetDeviceContainer devices = TestCaseHelper::CreatWaveDevice(1);
543 m_sender = DynamicCast<WaveNetDevice>(devices.Get(0));
544
545 Simulator::Schedule(Seconds(0.1),
546 &ChannelRoutingTestCase::SendWsmp,
547 this,
548 true,
549 TxInfo(CCH));
550 Simulator::Schedule(Seconds(0.1),
551 &ChannelRoutingTestCase::SendWsmp,
552 this,
553 false,
554 TxInfo(SCH1));
555 Simulator::Schedule(Seconds(0.1),
556 &ChannelRoutingTestCase::SendWsmp,
557 this,
558 false,
559 TxInfo(SCH2));
560
561 const SchInfo schInfo = SchInfo(SCH1, false, EXTENDED_ALTERNATING);
562 Simulator::Schedule(Seconds(0.2), &WaveNetDevice::StartSch, m_sender, schInfo);
563
564 Simulator::Schedule(Seconds(0.3),
565 &ChannelRoutingTestCase::SendWsmp,
566 this,
567 true,
568 TxInfo(CCH));
569 Simulator::Schedule(Seconds(0.3),
570 &ChannelRoutingTestCase::SendWsmp,
571 this,
572 true,
573 TxInfo(SCH1));
574 Simulator::Schedule(Seconds(0.3),
575 &ChannelRoutingTestCase::SendWsmp,
576 this,
577 false,
578 TxInfo(SCH2));
579 Simulator::Schedule(Seconds(0.3),
580 &ChannelRoutingTestCase::SendWsmp,
581 this,
582 false,
583 TxInfo(SCH3));
584 Simulator::Schedule(Seconds(0.3),
585 &ChannelRoutingTestCase::SendWsmp,
586 this,
587 false,
588 TxInfo(SCH4));
589 Simulator::Schedule(Seconds(0.3),
590 &ChannelRoutingTestCase::SendWsmp,
591 this,
592 false,
593 TxInfo(SCH5));
594 Simulator::Schedule(Seconds(0.3),
595 &ChannelRoutingTestCase::SendWsmp,
596 this,
597 false,
598 TxInfo(SCH6));
599
600 // invalid channel number
601 Simulator::Schedule(Seconds(0.4),
602 &ChannelRoutingTestCase::SendWsmp,
603 this,
604 false,
605 TxInfo(0));
606 // invalid user priority
607 Simulator::Schedule(Seconds(0.4),
608 &ChannelRoutingTestCase::SendWsmp,
609 this,
610 false,
611 TxInfo(CCH, 8));
612 // invalid tx parameters
613 Simulator::Schedule(Seconds(0.4),
614 &ChannelRoutingTestCase::SendWsmp,
615 this,
616 false,
617 TxInfo(CCH, 7, WifiMode("OfdmRate6Mbps"), WIFI_PREAMBLE_LONG, 7));
618 Simulator::Schedule(
619 Seconds(0.4),
620 &ChannelRoutingTestCase::SendWsmp,
621 this,
622 false,
623 TxInfo(CCH, 7, WifiMode("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 10));
624 // valid tx parameters
625 Simulator::Schedule(
626 Seconds(0.4),
627 &ChannelRoutingTestCase::SendWsmp,
628 this,
629 true,
630 TxInfo(CCH, 7, WifiMode("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 7));
631 Simulator::Schedule(Seconds(0.4),
632 &ChannelRoutingTestCase::SendWsmp,
633 this,
634 true,
635 TxInfo(CCH, 7, WifiMode(), WIFI_PREAMBLE_LONG, 8));
636
637 // release channel access at 0.6s
638 Simulator::Schedule(Seconds(0.5), &WaveNetDevice::StopSch, m_sender, SCH1);
639
640 // the packet will be dropped because channel access is not assigned again
641 Simulator::Schedule(Seconds(0.6),
642 &ChannelRoutingTestCase::SendWsmp,
643 this,
644 true,
645 TxInfo(CCH));
646 Simulator::Schedule(Seconds(0.6),
647 &ChannelRoutingTestCase::SendWsmp,
648 this,
649 false,
650 TxInfo(SCH1));
651 Simulator::Schedule(Seconds(0.6),
652 &ChannelRoutingTestCase::SendWsmp,
653 this,
654 false,
655 TxInfo(SCH2));
656
657 Simulator::Stop(Seconds(1.0));
658 Simulator::Run();
659 Simulator::Destroy();
660 }
661
662 // check Send method for IP-based packets
663 {
664 NetDeviceContainer devices = TestCaseHelper::CreatWaveDevice(1);
665 m_sender = DynamicCast<WaveNetDevice>(devices.Get(0));
666
667 bool ipv6 = true;
668 bool ipv4 = false;
669 Simulator::Schedule(Seconds(0.1), &ChannelRoutingTestCase::SendIp, this, false, ipv6);
670 Simulator::Schedule(Seconds(0.1), &ChannelRoutingTestCase::SendIp, this, false, ipv4);
671
672 const SchInfo schInfo = SchInfo(SCH1, false, EXTENDED_ALTERNATING);
673 Simulator::Schedule(Seconds(0.2), &WaveNetDevice::StartSch, m_sender, schInfo);
674
675 Simulator::Schedule(Seconds(0.3), &ChannelRoutingTestCase::SendIp, this, false, ipv6);
676 Simulator::Schedule(Seconds(0.3), &ChannelRoutingTestCase::SendIp, this, false, ipv4);
677
678 TxProfile txProfile = TxProfile(SCH1);
679 Simulator::Schedule(Seconds(0.4), &WaveNetDevice::RegisterTxProfile, m_sender, txProfile);
680
681 Simulator::Schedule(Seconds(0.5), &ChannelRoutingTestCase::SendIp, this, true, ipv6);
682 Simulator::Schedule(Seconds(0.5), &ChannelRoutingTestCase::SendIp, this, true, ipv4);
683
684 // unregister txprofile
685 Simulator::Schedule(Seconds(0.5), &WaveNetDevice::DeleteTxProfile, m_sender, SCH1);
686
687 Simulator::Schedule(Seconds(0.6), &ChannelRoutingTestCase::SendIp, this, false, ipv6);
688 Simulator::Schedule(Seconds(0.6), &ChannelRoutingTestCase::SendIp, this, false, ipv4);
689
690 // release channel access
691 // mac entities have no channel resource even phy device has ability to send
692 Simulator::Schedule(Seconds(0.7), &WaveNetDevice::StopSch, m_sender, SCH1);
693
694 Simulator::Schedule(Seconds(0.8), &ChannelRoutingTestCase::SendIp, this, false, ipv6);
695 Simulator::Schedule(Seconds(0.8), &ChannelRoutingTestCase::SendIp, this, false, ipv4);
696
697 Simulator::Stop(Seconds(1.0));
698 Simulator::Run();
699 Simulator::Destroy();
700 }
701
702 // check StartVsa method for WSA management frames
703 {
704 NetDeviceContainer devices = TestCaseHelper::CreatWaveDevice(1);
705 m_sender = DynamicCast<WaveNetDevice>(devices.Get(0));
706
707 Ptr<Packet> packet = Create<Packet>(100);
708 const Mac48Address dest = Mac48Address::GetBroadcast();
709 VsaInfo vsaInfo =
710 VsaInfo(dest, OrganizationIdentifier(), 3, packet, SCH1, 50, VSA_TRANSMIT_IN_BOTHI);
711 Simulator::Schedule(Seconds(0.1), &ChannelRoutingTestCase::SendWsa, this, false, vsaInfo);
712
713 vsaInfo.channelNumber = 0;
714 Simulator::Schedule(Seconds(0.2), &ChannelRoutingTestCase::SendWsa, this, false, vsaInfo);
715
716 vsaInfo.channelNumber = CCH;
717 Simulator::Schedule(Seconds(0.3), &ChannelRoutingTestCase::SendWsa, this, true, vsaInfo);
718 Simulator::Schedule(Seconds(0.39), &WaveNetDevice::StopVsa, m_sender, CCH);
719
720 const SchInfo schInfo = SchInfo(SCH1, false, EXTENDED_ALTERNATING);
721 Simulator::Schedule(Seconds(0.4), &WaveNetDevice::StartSch, m_sender, schInfo);
722 vsaInfo.channelNumber = CCH;
723 Simulator::Schedule(Seconds(0.4), &ChannelRoutingTestCase::SendWsa, this, true, vsaInfo);
724 vsaInfo.channelNumber = SCH1;
725 Simulator::Schedule(Seconds(0.4), &ChannelRoutingTestCase::SendWsa, this, true, vsaInfo);
726 vsaInfo.channelNumber = SCH2;
727 Simulator::Schedule(Seconds(0.4), &ChannelRoutingTestCase::SendWsa, this, false, vsaInfo);
728
729 Simulator::Schedule(Seconds(0.49), &WaveNetDevice::StopVsa, m_sender, CCH);
730 Simulator::Schedule(Seconds(0.49), &WaveNetDevice::StopVsa, m_sender, SCH1);
731 Simulator::Schedule(Seconds(0.49), &WaveNetDevice::StopSch, m_sender, SCH1);
732
733 vsaInfo.channelNumber = CCH;
734 Simulator::Schedule(Seconds(0.5), &ChannelRoutingTestCase::SendWsa, this, true, vsaInfo);
735 vsaInfo.channelNumber = SCH1;
736 Simulator::Schedule(Seconds(0.5), &ChannelRoutingTestCase::SendWsa, this, false, vsaInfo);
737 vsaInfo.channelNumber = SCH2;
738 Simulator::Schedule(Seconds(0.5), &ChannelRoutingTestCase::SendWsa, this, false, vsaInfo);
739
740 Simulator::Stop(Seconds(1.0));
741 Simulator::Run();
742 Simulator::Destroy();
743 }
744}
745
754class ChannelAccessTestCase : public TestCase
755{
756 public:
757 ChannelAccessTestCase();
758 ~ChannelAccessTestCase() override;
759
760 private:
766 void TestContinuous(SchInfo& info, bool shouldSucceed);
772 void TestContinuousAfter(uint32_t channelNumber, bool isAccessAssigned);
778 void TestExtended(SchInfo& info, bool shouldSucceed);
784 void TestExtendedAfter(uint32_t channelNumber, bool isAccessAssigned);
790 void TestAlternating(SchInfo& info, bool shouldSucceed);
796 void TestAlternatingAfter(uint32_t channelNumber, bool isAccessAssigned);
797
803 void SendX(uint32_t channel, uint32_t receiverId);
812 bool Receive(Ptr<NetDevice> dev, Ptr<const Packet> pkt, uint16_t mode, const Address& sender);
813
814 void DoRun() override;
815
816 NetDeviceContainer m_devices;
817 Ptr<WaveNetDevice> m_sender;
818 uint32_t m_received;
819};
820
821ChannelAccessTestCase::ChannelAccessTestCase()
822 : TestCase("channel-access")
823{
824}
825
826ChannelAccessTestCase::~ChannelAccessTestCase()
827{
828}
829
830void
831ChannelAccessTestCase::TestContinuous(SchInfo& info, bool shouldSucceed)
832{
833 bool result = m_sender->StartSch(info);
834 NS_TEST_EXPECT_MSG_EQ(result, shouldSucceed, "TestContinuous fail at " << Now().As(Time::S));
835}
836
837void
838ChannelAccessTestCase::TestContinuousAfter(uint32_t channelNumber, bool isAccessAssigned)
839{
840 bool result = m_sender->GetChannelScheduler()->IsContinuousAccessAssigned(channelNumber);
841 NS_TEST_EXPECT_MSG_EQ(result,
842 isAccessAssigned,
843 "TestContinuousAfter fail at " << Now().As(Time::S));
844}
845
846void
847ChannelAccessTestCase::TestExtended(SchInfo& info, bool shouldSucceed)
848{
849 bool result = m_sender->StartSch(info);
850 NS_TEST_EXPECT_MSG_EQ(result, shouldSucceed, "TestExtended fail at " << Now().As(Time::S));
851}
852
853void
854ChannelAccessTestCase::TestExtendedAfter(uint32_t channelNumber, bool isAccessAssigned)
855{
856 bool result = m_sender->GetChannelScheduler()->IsExtendedAccessAssigned(channelNumber);
857 NS_TEST_EXPECT_MSG_EQ(result,
858 isAccessAssigned,
859 "TestExtendedAfter fail at " << Now().As(Time::S));
860}
861
862void
863ChannelAccessTestCase::TestAlternating(SchInfo& info, bool shouldSucceed)
864{
865 bool result = m_sender->StartSch(info);
866 NS_TEST_EXPECT_MSG_EQ(result, shouldSucceed, "TestAlternating fail at " << Now().As(Time::S));
867}
868
869void
870ChannelAccessTestCase::TestAlternatingAfter(uint32_t channelNumber, bool isAccessAssigned)
871{
872 bool result = m_sender->GetChannelScheduler()->IsAlternatingAccessAssigned(channelNumber);
873 NS_TEST_EXPECT_MSG_EQ(result,
874 isAccessAssigned,
875 "TestAlternating fail at " << Now().As(Time::S));
876}
877
878void
879ChannelAccessTestCase::SendX(uint32_t channel, uint32_t receiverId)
880{
881 const static uint16_t WSMP_PROT_NUMBER = 0x88DC;
882 const Mac48Address dest = Mac48Address::GetBroadcast();
883 const TxInfo txInfo = TxInfo(channel);
884
885 uint8_t* data = new uint8_t[112];
886 data[0] = (receiverId >> 24) & 0xFF;
887 data[1] = (receiverId >> 16) & 0xFF;
888 data[2] = (receiverId >> 8) & 0xFF;
889 data[3] = (receiverId >> 0) & 0xFF;
890
891 uint64_t ts = Simulator::Now().GetTimeStep();
892 data[4] = (ts >> 56) & 0xFF;
893 data[5] = (ts >> 48) & 0xFF;
894 data[6] = (ts >> 40) & 0xFF;
895 data[7] = (ts >> 32) & 0xFF;
896 data[8] = (ts >> 24) & 0xFF;
897 data[9] = (ts >> 16) & 0xFF;
898 data[10] = (ts >> 8) & 0xFF;
899 data[11] = (ts >> 0) & 0xFF;
900
901 Ptr<Packet> p = Create<Packet>(data, 112);
902
903 m_sender->SendX(p, dest, WSMP_PROT_NUMBER, txInfo);
904
905 delete[] data;
906}
907
908bool
909ChannelAccessTestCase::Receive(Ptr<NetDevice> dev,
910 Ptr<const Packet> pkt,
911 uint16_t mode,
912 const Address& sender)
913{
914 uint8_t* data = new uint8_t[pkt->GetSize()];
915 pkt->CopyData(data, pkt->GetSize());
916
917 uint32_t seq = data[0];
918 seq <<= 8;
919 seq |= data[1];
920 seq <<= 8;
921 seq |= data[2];
922 seq <<= 8;
923 seq |= data[3];
924
925 uint64_t ts = data[4];
926 ts <<= 8;
927 ts |= data[5];
928 ts <<= 8;
929 ts |= data[6];
930 ts <<= 8;
931 ts |= data[7];
932 ts <<= 8;
933 ts |= data[8];
934 ts <<= 8;
935 ts |= data[9];
936 ts <<= 8;
937 ts |= data[10];
938 ts <<= 8;
939 ts |= data[11];
940 Time sendTime = TimeStep(ts);
941
942 delete[] data;
943
944 // SeqTsHeader seqTs;
945 // ConstCast<Packet> (pkt)->RemoveHeader (seqTs);
946 uint32_t curNodeId = dev->GetNode()->GetId();
947 NS_TEST_EXPECT_MSG_EQ(curNodeId, seq, "fail to assign channel access");
948 m_received++;
949 return true;
950}
951
952void
953ChannelAccessTestCase::DoRun()
954{
955 // test ContinuousAccess in the sender side
956 {
957 m_devices = TestCaseHelper::CreatWaveDevice(1);
958 m_sender = DynamicCast<WaveNetDevice>(m_devices.Get(0));
959
960 // there is no need for assigning CCH continuous access.
961 SchInfo info = SchInfo(CCH, false, EXTENDED_CONTINUOUS);
962 Simulator::Schedule(Seconds(1), &ChannelAccessTestCase::TestContinuous, this, info, false);
963
964 info = SchInfo(SCH1, false, EXTENDED_CONTINUOUS);
965 Simulator::Schedule(Seconds(2), &ChannelAccessTestCase::TestContinuous, this, info, true);
966
967 // BE ATTENTION !!!
968 // because channel access is assigned in non-immediate mode, the first CCH Interval will be
969 // the wait time with DefaultCchAccess assigned, thus there is no ContinuousAccess assigned.
970 Simulator::Schedule(Seconds(2),
971 &ChannelAccessTestCase::TestContinuousAfter,
972 this,
973 SCH1,
974 false);
975 Simulator::Schedule(Seconds(2.01),
976 &ChannelAccessTestCase::TestContinuousAfter,
977 this,
978 SCH1,
979 false);
980 Simulator::Schedule(Seconds(2.049),
981 &ChannelAccessTestCase::TestContinuousAfter,
982 this,
983 SCH1,
984 false);
985 Simulator::Schedule(Seconds(2.05),
986 &ChannelAccessTestCase::TestContinuousAfter,
987 this,
988 SCH1,
989 false);
990 Simulator::Schedule(Seconds(2.051),
991 &ChannelAccessTestCase::TestContinuousAfter,
992 this,
993 SCH1,
994 true);
995 Simulator::Schedule(Seconds(2.99),
996 &ChannelAccessTestCase::TestContinuousAfter,
997 this,
998 SCH1,
999 true);
1000
1001 // it's OK to assign same access again,
1002 Simulator::Schedule(Seconds(3), &ChannelAccessTestCase::TestContinuous, this, info, true);
1003 // fail to assign continuous access for other SCH if current channel is assigned
1004 info = SchInfo(SCH2, false, EXTENDED_CONTINUOUS);
1005 Simulator::Schedule(Seconds(4), &ChannelAccessTestCase::TestContinuous, this, info, false);
1006
1007 // then we release channel access at 0.5s
1008 Simulator::Schedule(Seconds(5), &WaveNetDevice::StopSch, m_sender, SCH1);
1009
1010 info = SchInfo(SCH2, false, EXTENDED_CONTINUOUS);
1011 // succeed to assign access for other SCH is previous SCH access is released
1012 Simulator::Schedule(Seconds(6), &ChannelAccessTestCase::TestContinuous, this, info, true);
1013
1014 Simulator::Stop(Seconds(7.0));
1015 Simulator::Run();
1016 Simulator::Destroy();
1017 }
1018
1019 // test ContinuousAccess again in the receiver side
1020 {
1021 m_devices = TestCaseHelper::CreatWaveDevice(8);
1022 m_sender = DynamicCast<WaveNetDevice>(m_devices.Get(0));
1023 m_received = 0;
1024
1025 for (uint32_t i = 1; i != 8; ++i)
1026 {
1027 Ptr<WaveNetDevice> device = DynamicCast<WaveNetDevice>(m_devices.Get(i));
1028 device->SetReceiveCallback(MakeCallback(&ChannelAccessTestCase::Receive, this));
1029
1030 // at 0s, receivers are assigned ContinuousAccess from CCH, SCH1 to SCH6
1031 static std::vector<uint32_t> WaveChannels = ChannelManager::GetWaveChannels();
1032 uint32_t channel = WaveChannels[i - 1];
1033 const SchInfo info = SchInfo(channel, false, EXTENDED_CONTINUOUS);
1034 Simulator::Schedule(Seconds(0), &WaveNetDevice::StartSch, device, info);
1035 }
1036
1037 // at 0s, the sender is assigned DefaultCchAccess, so only node-1 can receive packets.
1038 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, CCH, 1);
1039 // if receivers assigned for SCH access can receive packets, there shall be crashed
1040 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH1, 0);
1041 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1042 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1043 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1044 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1045 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1046
1047 // at 1s, the sender is assigned ContinuousAccess for SCH1, so only node-2 can receive
1048 // packets.
1049 SchInfo info = SchInfo(SCH1, false, EXTENDED_CONTINUOUS);
1050 Simulator::Schedule(Seconds(1), &WaveNetDevice::StartSch, m_sender, info);
1051 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH1, 2);
1052 // other channel access cannot receive packets
1053 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, CCH, 0);
1054 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1055 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1056 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1057 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1058 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1059
1060 Simulator::Stop(Seconds(10.0));
1061 Simulator::Run();
1062 Simulator::Destroy();
1063
1064 NS_TEST_EXPECT_MSG_EQ(m_received, 2, "test ContinuousAccess fail in receive side");
1065 }
1066
1067 // test ExtendedAccess in the sender side
1068 {
1069 m_devices = TestCaseHelper::CreatWaveDevice(1);
1070 m_sender = DynamicCast<WaveNetDevice>(m_devices.Get(0));
1071
1072 // there is no need for assigning CCH extended access.
1073 SchInfo info = SchInfo(CCH, false, 10);
1074 Simulator::Schedule(Seconds(1), &ChannelAccessTestCase::TestExtended, this, info, false);
1075
1076 info = SchInfo(SCH1, false, 10);
1077 Simulator::Schedule(Seconds(2), &ChannelAccessTestCase::TestExtended, this, info, true);
1078 // succeed because request for extends 8 can be fulfilled by previous extends 10..
1079 info = SchInfo(SCH1, false, 8);
1080 Simulator::Schedule(Seconds(2), &ChannelAccessTestCase::TestExtended, this, info, true);
1081 // fail because request for extends 12 cannot be fulfilled by previous extends 10..
1082 info = SchInfo(SCH1, false, 12);
1083 Simulator::Schedule(Seconds(2), &ChannelAccessTestCase::TestExtended, this, info, false);
1084
1085 // BE ATTENTION !!!
1086 // because channel access is assigned in non-immediate mode, the first CCH Interval will be
1087 // the wait time with DefaultCchAccess assigned, while there is no ExtendedAccess assigned.
1088 Simulator::Schedule(Seconds(2),
1089 &ChannelAccessTestCase::TestExtendedAfter,
1090 this,
1091 SCH1,
1092 false);
1093 Simulator::Schedule(Seconds(2.01),
1094 &ChannelAccessTestCase::TestExtendedAfter,
1095 this,
1096 SCH1,
1097 false);
1098 Simulator::Schedule(Seconds(2.049),
1099 &ChannelAccessTestCase::TestExtendedAfter,
1100 this,
1101 SCH1,
1102 false);
1103 Simulator::Schedule(Seconds(2.05),
1104 &ChannelAccessTestCase::TestExtendedAfter,
1105 this,
1106 SCH1,
1107 false);
1108 Simulator::Schedule(Seconds(2.051),
1109 &ChannelAccessTestCase::TestExtendedAfter,
1110 this,
1111 SCH1,
1112 true);
1113 Simulator::Schedule(Seconds(2.99),
1114 &ChannelAccessTestCase::TestExtendedAfter,
1115 this,
1116 SCH1,
1117 true);
1118
1119 // the end of extended access is (2s + 100ms + 100ms * 10) = 3.1s
1120 Simulator::Schedule(Seconds(3),
1121 &ChannelAccessTestCase::TestExtendedAfter,
1122 this,
1123 SCH1,
1124 true);
1125 Simulator::Schedule(Seconds(3.1),
1126 &ChannelAccessTestCase::TestExtendedAfter,
1127 this,
1128 SCH1,
1129 true);
1130 Simulator::Schedule(Seconds(3.2),
1131 &ChannelAccessTestCase::TestExtendedAfter,
1132 this,
1133 SCH1,
1134 false);
1135 Simulator::Schedule(Seconds(3.3),
1136 &ChannelAccessTestCase::TestExtendedAfter,
1137 this,
1138 SCH1,
1139 false);
1140
1141 // succeed to assign extended access for other SCH since previous extended access is
1142 // released automatically
1143 info = SchInfo(SCH2, false, 10);
1144 Simulator::Schedule(Seconds(4), &ChannelAccessTestCase::TestExtended, this, info, true);
1145
1146 // stop it at 5s even the end of extended access is (4s + 100ms + 100ms * 10) = 5.1s
1147 Simulator::Schedule(Seconds(5), &WaveNetDevice::StopSch, m_sender, SCH2);
1148
1149 Simulator::Schedule(Seconds(5),
1150 &ChannelAccessTestCase::TestExtendedAfter,
1151 this,
1152 SCH2,
1153 false);
1154 Simulator::Schedule(Seconds(5.1),
1155 &ChannelAccessTestCase::TestExtendedAfter,
1156 this,
1157 SCH2,
1158 false);
1159 Simulator::Schedule(Seconds(5.2),
1160 &ChannelAccessTestCase::TestExtendedAfter,
1161 this,
1162 SCH2,
1163 false);
1164
1165 Simulator::Stop(Seconds(6.0));
1166 Simulator::Run();
1167 Simulator::Destroy();
1168 }
1169
1170 // test ExtendedAccess again in the receiver side
1171 {
1172 m_devices = TestCaseHelper::CreatWaveDevice(8);
1173 m_sender = DynamicCast<WaveNetDevice>(m_devices.Get(0));
1174 m_received = 0;
1175
1176 for (uint32_t i = 1; i != 8; ++i)
1177 {
1178 Ptr<WaveNetDevice> device = DynamicCast<WaveNetDevice>(m_devices.Get(i));
1179 device->SetReceiveCallback(MakeCallback(&ChannelAccessTestCase::Receive, this));
1180
1181 // at 0s, receivers are assigned ContinuosAccess from CCH, SCH1 to SCH6
1182 static std::vector<uint32_t> WaveChannels = ChannelManager::GetWaveChannels();
1183 uint32_t channel = WaveChannels[i - 1];
1184 const SchInfo info = SchInfo(channel, false, EXTENDED_CONTINUOUS);
1185 Simulator::Schedule(Seconds(0), &WaveNetDevice::StartSch, device, info);
1186 }
1187
1188 // at 0s, the sender is assigned DefaultCchAccess, so only node-1 can receive packets.
1189 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, CCH, 1);
1190 // if receivers assigned for SCH access can receive packets, there shall be crashed
1191 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH1, 0);
1192 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1193 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1194 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1195 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1196 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1197
1198 // at 1s, the sender is assigned ExtendedAccess for SCH1 with extends 10,
1199 //, so only node-2 can receive packets from 1s - 2.1s ( 1s + 100ms + 100ms * 10)
1200 SchInfo info = SchInfo(SCH1, false, 10);
1201 Simulator::Schedule(Seconds(1), &WaveNetDevice::StartSch, m_sender, info);
1202 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH1, 2);
1203 // other channel access cannot receive packets
1204 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, CCH, 0);
1205 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1206 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1207 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1208 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1209 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1210 // at 2.2s the node-2 cannot receive this packet because of extended access released in
1211 // node-0 but sended is assigned DefaultCchAccess again, thus node-1 can receive broadcasted
1212 // packets.
1213 Simulator::Schedule(Seconds(2.2), &ChannelAccessTestCase::SendX, this, CCH, 1);
1214 Simulator::Schedule(Seconds(2.2), &ChannelAccessTestCase::SendX, this, SCH1, 0);
1215 Simulator::Schedule(Seconds(2.2), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1216 Simulator::Schedule(Seconds(2.2), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1217 Simulator::Schedule(Seconds(2.2), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1218 Simulator::Schedule(Seconds(2.2), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1219 Simulator::Schedule(Seconds(2.2), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1220
1221 Simulator::Stop(Seconds(10.0));
1222 Simulator::Run();
1223 Simulator::Destroy();
1224
1225 NS_TEST_EXPECT_MSG_EQ(m_received, 3, "test ExtendedAccess fail in receive side");
1226 }
1227
1228 // test AlternatingAccess in the sender side
1229 {
1230 m_devices = TestCaseHelper::CreatWaveDevice(1);
1231 m_sender = DynamicCast<WaveNetDevice>(m_devices.Get(0));
1232
1233 // there is no need for assigning CCH alternating access.
1234 SchInfo info = SchInfo(CCH, false, EXTENDED_ALTERNATING);
1235 Simulator::Schedule(Seconds(1), &ChannelAccessTestCase::TestAlternating, this, info, false);
1236
1237 info = SchInfo(SCH1, false, EXTENDED_ALTERNATING);
1238 Simulator::Schedule(Seconds(2), &ChannelAccessTestCase::TestAlternating, this, info, true);
1239
1240 // BE ATTENTION !!!
1241 // No matter whether channel access is assigned in immediate mode or non-immediate mode,
1242 // the channel access will assigned immediately which is different from the test results in
1243 // ExtendedAccess assignment and ContinuousAccess assignment.
1244 Simulator::Schedule(Seconds(2),
1245 &ChannelAccessTestCase::TestAlternatingAfter,
1246 this,
1247 SCH1,
1248 true);
1249 Simulator::Schedule(Seconds(2.01),
1250 &ChannelAccessTestCase::TestAlternatingAfter,
1251 this,
1252 SCH1,
1253 true);
1254 Simulator::Schedule(Seconds(2.049),
1255 &ChannelAccessTestCase::TestAlternatingAfter,
1256 this,
1257 SCH1,
1258 true);
1259 Simulator::Schedule(Seconds(2.05),
1260 &ChannelAccessTestCase::TestAlternatingAfter,
1261 this,
1262 SCH1,
1263 true);
1264 Simulator::Schedule(Seconds(2.051),
1265 &ChannelAccessTestCase::TestAlternatingAfter,
1266 this,
1267 SCH1,
1268 true);
1269 Simulator::Schedule(Seconds(2.99),
1270 &ChannelAccessTestCase::TestAlternatingAfter,
1271 this,
1272 SCH1,
1273 true);
1274
1275 Simulator::Schedule(Seconds(3), &ChannelAccessTestCase::TestAlternating, this, info, true);
1276 info = SchInfo(SCH2, false, EXTENDED_ALTERNATING);
1277 Simulator::Schedule(Seconds(3), &ChannelAccessTestCase::TestAlternating, this, info, false);
1278 info = SchInfo(0, false, EXTENDED_ALTERNATING);
1279 Simulator::Schedule(Seconds(3), &ChannelAccessTestCase::TestAlternating, this, info, false);
1280
1281 // then we release channel access at 0.5s
1282 Simulator::Schedule(Seconds(4), &WaveNetDevice::StopSch, m_sender, SCH1);
1283
1284 info = SchInfo(SCH2, false, EXTENDED_ALTERNATING);
1285 // succeed to assign access for other SCH is previous SCH access is released
1286 Simulator::Schedule(Seconds(5), &ChannelAccessTestCase::TestAlternating, this, info, true);
1287
1288 Simulator::Stop(Seconds(6.0));
1289 Simulator::Run();
1290 Simulator::Destroy();
1291 }
1292
1293 // test AlternatingAccess again in the receiver side
1294 {
1295 m_devices = TestCaseHelper::CreatWaveDevice(8);
1296 m_sender = DynamicCast<WaveNetDevice>(m_devices.Get(0));
1297 m_received = 0;
1298
1299 for (uint32_t i = 1; i != 8; ++i)
1300 {
1301 Ptr<WaveNetDevice> device = DynamicCast<WaveNetDevice>(m_devices.Get(i));
1302 device->SetReceiveCallback(MakeCallback(&ChannelAccessTestCase::Receive, this));
1303
1304 // at 0s, receivers are assigned ContinuosAccess from CCH, SCH1 to SCH6
1305 static std::vector<uint32_t> WaveChannels = ChannelManager::GetWaveChannels();
1306 uint32_t channel = WaveChannels[i - 1];
1307 const SchInfo info = SchInfo(channel, false, EXTENDED_CONTINUOUS);
1308 Simulator::Schedule(Seconds(0), &WaveNetDevice::StartSch, device, info);
1309 }
1310
1311 // at 0s, the sender is assigned DefaultCchAccess, so only node-1 can receive packets.
1312 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, CCH, 1);
1313 // if receivers assigned for SCH access can receive packets, there shall be crashed
1314 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH1, 0);
1315 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1316 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1317 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1318 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1319 Simulator::Schedule(Seconds(0.1), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1320
1321 // at 1s, the sender is assigned ContinuosAccess for SCH1, so only node-2 can receive
1322 // packets.
1323 SchInfo info = SchInfo(SCH1, false, EXTENDED_ALTERNATING);
1324 Simulator::Schedule(Seconds(1), &WaveNetDevice::StartSch, m_sender, info);
1325 // node-1 (assigned CCH access) and node-2 (assigned SCH1 access) can receive packets
1326 // in different channel interval
1327 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH1, 2);
1328 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, CCH, 1);
1329 // other channel access cannot receive packets
1330 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1331 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1332 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1333 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1334 Simulator::Schedule(Seconds(1.1), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1335
1336 Simulator::Schedule(Seconds(2), &WaveNetDevice::StopSch, m_sender, SCH1);
1337 // if ContinuousAccess for SCH1 is released, node-2 cannot receive packets again
1338 Simulator::Schedule(Seconds(2.1), &ChannelAccessTestCase::SendX, this, CCH, 1);
1339 Simulator::Schedule(Seconds(2.1), &ChannelAccessTestCase::SendX, this, SCH1, 0);
1340 Simulator::Schedule(Seconds(2.1), &ChannelAccessTestCase::SendX, this, SCH2, 0);
1341 Simulator::Schedule(Seconds(2.1), &ChannelAccessTestCase::SendX, this, SCH3, 0);
1342 Simulator::Schedule(Seconds(2.1), &ChannelAccessTestCase::SendX, this, SCH4, 0);
1343 Simulator::Schedule(Seconds(2.1), &ChannelAccessTestCase::SendX, this, SCH5, 0);
1344 Simulator::Schedule(Seconds(2.1), &ChannelAccessTestCase::SendX, this, SCH6, 0);
1345
1346 Simulator::Stop(Seconds(10.0));
1347 Simulator::Run();
1348 Simulator::Destroy();
1349
1350 NS_TEST_EXPECT_MSG_EQ(m_received, 4, "test AlternatingAccess fail in receive side");
1351 }
1352}
1353
1361class AnnexC_TestCase : public TestCase
1362{
1363 public:
1364 AnnexC_TestCase();
1365 ~AnnexC_TestCase() override;
1366
1367 private:
1368 void DoRun() override;
1369
1376 void SendPacket(uint32_t packetSize, const TxInfo& txInfo, uint32_t sequence);
1385 bool Receive(Ptr<NetDevice> dev, Ptr<const Packet> pkt, uint16_t mode, const Address& sender);
1386
1387 NetDeviceContainer m_devices;
1388 Ptr<WaveNetDevice> m_sender;
1389 Ptr<WaveNetDevice> m_receiver;
1390};
1391
1392AnnexC_TestCase::AnnexC_TestCase()
1393 : TestCase("annex-c")
1394{
1395}
1396
1397AnnexC_TestCase::~AnnexC_TestCase()
1398{
1399}
1400
1401void
1402AnnexC_TestCase::SendPacket(uint32_t packetSize, const TxInfo& txInfo, uint32_t sequence)
1403{
1404 const static uint16_t WSMP_PROT_NUMBER = 0x88DC;
1405 const Mac48Address dest = Mac48Address::ConvertFrom(m_receiver->GetAddress());
1406
1407 uint8_t* data = new uint8_t[packetSize];
1408 data[0] = (sequence >> 24) & 0xFF;
1409 data[1] = (sequence >> 16) & 0xFF;
1410 data[2] = (sequence >> 8) & 0xFF;
1411 data[3] = (sequence >> 0) & 0xFF;
1412
1413 uint64_t ts = Simulator::Now().GetTimeStep();
1414 data[4] = (ts >> 56) & 0xFF;
1415 data[5] = (ts >> 48) & 0xFF;
1416 data[6] = (ts >> 40) & 0xFF;
1417 data[7] = (ts >> 32) & 0xFF;
1418 data[8] = (ts >> 24) & 0xFF;
1419 data[9] = (ts >> 16) & 0xFF;
1420 data[10] = (ts >> 8) & 0xFF;
1421 data[11] = (ts >> 0) & 0xFF;
1422
1423 Ptr<Packet> p = Create<Packet>(data, packetSize);
1424
1425 m_sender->SendX(p, dest, WSMP_PROT_NUMBER, txInfo);
1426
1427 delete[] data;
1428}
1429
1430bool
1431AnnexC_TestCase::Receive(Ptr<NetDevice> dev,
1432 Ptr<const Packet> pkt,
1433 uint16_t mode,
1434 const Address& sender)
1435{
1436 uint8_t* data = new uint8_t[pkt->GetSize()];
1437 pkt->CopyData(data, pkt->GetSize());
1438
1439 uint32_t seq = data[0];
1440 seq <<= 8;
1441 seq |= data[1];
1442 seq <<= 8;
1443 seq |= data[2];
1444 seq <<= 8;
1445 seq |= data[3];
1446
1447 uint64_t ts = data[4];
1448 ts <<= 8;
1449 ts |= data[5];
1450 ts <<= 8;
1451 ts |= data[6];
1452 ts <<= 8;
1453 ts |= data[7];
1454 ts <<= 8;
1455 ts |= data[8];
1456 ts <<= 8;
1457 ts |= data[9];
1458 ts <<= 8;
1459 ts |= data[10];
1460 ts <<= 8;
1461 ts |= data[11];
1462 Time sendTime = TimeStep(ts);
1463
1464 delete[] data;
1465
1466 Time curTime = Now();
1467 Time duration = curTime - sendTime;
1468
1469 if (seq == 1)
1470 {
1471 NS_TEST_EXPECT_MSG_GT(duration,
1472 ChannelCoordinator::GetDefaultSchInterval(),
1473 "fail to test Annex C when packet sequence is " << seq);
1474 }
1475 else if (seq == 2)
1476 {
1477 NS_TEST_EXPECT_MSG_LT(duration,
1478 ChannelCoordinator::GetDefaultSchInterval(),
1479 "fail to test Annex C when packet sequence is " << seq);
1480 }
1481 else if (seq == 3)
1482 {
1483 NS_TEST_EXPECT_MSG_GT(duration,
1484 ChannelCoordinator::GetDefaultCchInterval(),
1485 "fail to test Annex C when packet sequence is " << seq);
1486 }
1487 else if (seq == 4)
1488 {
1489 NS_TEST_EXPECT_MSG_LT(duration,
1490 ChannelCoordinator::GetDefaultCchInterval(),
1491 "fail to test Annex C when packet sequence is " << seq);
1492 }
1493 return true;
1494}
1495
1496void
1497AnnexC_TestCase::DoRun()
1498{
1499 m_devices = TestCaseHelper::CreatWaveDevice(2);
1500 m_sender = DynamicCast<WaveNetDevice>(m_devices.Get(0));
1501 m_receiver = DynamicCast<WaveNetDevice>(m_devices.Get(1));
1502 m_receiver->SetReceiveCallback(MakeCallback(&AnnexC_TestCase::Receive, this));
1503
1504 // at 0s, the receiver is assigned AlternatingAccess for SCH1
1505 SchInfo infoReceiver = SchInfo(SCH1, false, EXTENDED_ALTERNATING);
1506 Simulator::Schedule(MilliSeconds(0), &WaveNetDevice::StartSch, m_receiver, infoReceiver);
1507
1508 // at 0s, the sender is assigned AlternatingAccess for SCH1
1509 SchInfo infoSender = SchInfo(SCH1, false, EXTENDED_ALTERNATING);
1510 Simulator::Schedule(MilliSeconds(0), &WaveNetDevice::StartSch, m_sender, infoSender);
1511
1512 TxInfo txInfo = TxInfo(CCH, 0, WifiMode("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 0);
1513 // the packet size with 2312 bytes costs 6.42s, which will cancel this transmission in the CCH
1514 // Interval so the receiver will receive this packet in next CCH Interval
1515 Simulator::Schedule(MilliSeconds(45), &AnnexC_TestCase::SendPacket, this, 2304, txInfo, 1);
1516
1517 // the packet size with 312 bytes costs 1.104ms, which will not cancel transmission in the CCH
1518 // Interval so the receiver can this packet is this CCH Interval
1519 Simulator::Schedule(MilliSeconds(145), &AnnexC_TestCase::SendPacket, this, 312, txInfo, 2);
1520
1521 txInfo = TxInfo(SCH1, 0, WifiMode("OfdmRate3MbpsBW10MHz"), WIFI_PREAMBLE_LONG, 0);
1522 // the packet size with 2312 bytes costs 6.42ms, which will cancel this transmission in the SCH
1523 // Interval so the receiver will receive this packet in next SCH Interval
1524 Simulator::Schedule(MilliSeconds(295), &AnnexC_TestCase::SendPacket, this, 2304, txInfo, 3);
1525
1526 // the packet size with 312 bytes costs 1.104ms, which will not cancel transmission in the SCH
1527 // Interval so the receiver can this packet is this SCH Interval
1528 Simulator::Schedule(MilliSeconds(395), &AnnexC_TestCase::SendPacket, this, 312, txInfo, 4);
1529
1530 Simulator::Stop(Seconds(1.0));
1531 Simulator::Run();
1532 Simulator::Destroy();
1533}
1534
1541class WaveMacTestSuite : public TestSuite
1542{
1543 public:
1544 WaveMacTestSuite();
1545};
1546
1547WaveMacTestSuite::WaveMacTestSuite()
1548 : TestSuite("wave-mac-extension", UNIT)
1549{
1550 // TestDuration for TestCase can be QUICK, EXTENSIVE or TAKES_FOREVER
1551 AddTestCase(new ChannelCoordinationTestCase, TestCase::QUICK);
1552 AddTestCase(new ChannelRoutingTestCase, TestCase::QUICK);
1553 AddTestCase(new ChannelAccessTestCase, TestCase::QUICK);
1554 AddTestCase(new AnnexC_TestCase, TestCase::QUICK);
1555}
1556
1557// Do not forget to allocate an instance of this TestSuite
1558static WaveMacTestSuite waveMacTestSuite;
SCH2
#define SCH2
Definition: channel-manager.h:51
SCH5
#define SCH5
Definition: channel-manager.h:55
SCH1
#define SCH1
Definition: channel-manager.h:50
CCH
#define CCH
Definition: channel-manager.h:53
SCH6
#define SCH6
Definition: channel-manager.h:56
SCH4
#define SCH4
Definition: channel-manager.h:54
SCH3
#define SCH3
Definition: channel-manager.h:52
EXTENDED_ALTERNATING
#define EXTENDED_ALTERNATING
Definition: channel-scheduler.h:53
EXTENDED_CONTINUOUS
#define EXTENDED_CONTINUOUS
Definition: channel-scheduler.h:54
AnnexC_TestCase
The Annex C of IEEE 1609.4 : "Avoiding transmission at scheduled guard intervals" This feature is imp...
Definition: mac-extension-test-suite.cc:1362
AnnexC_TestCase::Receive
bool Receive(Ptr< NetDevice > dev, Ptr< const Packet > pkt, uint16_t mode, const Address &sender)
Receive function.
Definition: mac-extension-test-suite.cc:1431
AnnexC_TestCase::~AnnexC_TestCase
~AnnexC_TestCase() override
Definition: mac-extension-test-suite.cc:1397
AnnexC_TestCase::m_sender
Ptr< WaveNetDevice > m_sender
sender
Definition: mac-extension-test-suite.cc:1388
AnnexC_TestCase::m_receiver
Ptr< WaveNetDevice > m_receiver
receiver
Definition: mac-extension-test-suite.cc:1389
AnnexC_TestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: mac-extension-test-suite.cc:1497
AnnexC_TestCase::SendPacket
void SendPacket(uint32_t packetSize, const TxInfo &txInfo, uint32_t sequence)
Send packet function.
Definition: mac-extension-test-suite.cc:1402
AnnexC_TestCase::m_devices
NetDeviceContainer m_devices
devices
Definition: mac-extension-test-suite.cc:1387
AnnexC_TestCase::AnnexC_TestCase
AnnexC_TestCase()
Definition: mac-extension-test-suite.cc:1392
ChannelAccessTestCase
This test case tests channel access assignments which is done by StartSch and StopSch method of WaveN...
Definition: mac-extension-test-suite.cc:755
ChannelAccessTestCase::TestAlternating
void TestAlternating(SchInfo &info, bool shouldSucceed)
Test aternating function.
Definition: mac-extension-test-suite.cc:863
ChannelAccessTestCase::TestAlternatingAfter
void TestAlternatingAfter(uint32_t channelNumber, bool isAccessAssigned)
Test alternating after function.
Definition: mac-extension-test-suite.cc:870
ChannelAccessTestCase::m_devices
NetDeviceContainer m_devices
the devices
Definition: mac-extension-test-suite.cc:816
ChannelAccessTestCase::SendX
void SendX(uint32_t channel, uint32_t receiverId)
Send X function.
Definition: mac-extension-test-suite.cc:879
ChannelAccessTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: mac-extension-test-suite.cc:953
ChannelAccessTestCase::TestExtendedAfter
void TestExtendedAfter(uint32_t channelNumber, bool isAccessAssigned)
Test extended after function.
Definition: mac-extension-test-suite.cc:854
ChannelAccessTestCase::TestContinuousAfter
void TestContinuousAfter(uint32_t channelNumber, bool isAccessAssigned)
Test continuous after function.
Definition: mac-extension-test-suite.cc:838
ChannelAccessTestCase::Receive
bool Receive(Ptr< NetDevice > dev, Ptr< const Packet > pkt, uint16_t mode, const Address &sender)
Receive function.
Definition: mac-extension-test-suite.cc:909
ChannelAccessTestCase::TestContinuous
void TestContinuous(SchInfo &info, bool shouldSucceed)
Test continuous function.
Definition: mac-extension-test-suite.cc:831
ChannelAccessTestCase::TestExtended
void TestExtended(SchInfo &info, bool shouldSucceed)
Test extended function.
Definition: mac-extension-test-suite.cc:847
ChannelAccessTestCase::m_sender
Ptr< WaveNetDevice > m_sender
sender
Definition: mac-extension-test-suite.cc:817
ChannelCoordinationTestCase
This test case tests the channel coordination.
Definition: mac-extension-test-suite.cc:49
ChannelCoordinationTestCase::NotifySchStartNow
void NotifySchStartNow(Time duration)
Notify SCH start now function.
Definition: mac-extension-test-suite.cc:174
ChannelCoordinationTestCase::TestIntervalAfter
void TestIntervalAfter(bool cchi, bool schi, bool guardi)
Test interval after function.
Definition: mac-extension-test-suite.cc:135
ChannelCoordinationTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: mac-extension-test-suite.cc:218
ChannelCoordinationTestCase::NotifyGuardStartNow
void NotifyGuardStartNow(Time duration, bool inCchInterval)
Notify guard start now function.
Definition: mac-extension-test-suite.cc:194
ChannelCoordinationTestCase::NotifyCchStartNow
void NotifyCchStartNow(Time duration)
Notify CCS start now function.
Definition: mac-extension-test-suite.cc:156
ChannelCoordinationTestCase::m_coordinator
Ptr< ChannelCoordinator > m_coordinator
coordinator
Definition: mac-extension-test-suite.cc:81
ChannelRoutingTestCase
route packets or frames in different approaches see 1609.4-2010 chapter 5.3.4
Definition: mac-extension-test-suite.cc:452
ChannelRoutingTestCase::m_sender
Ptr< WaveNetDevice > m_sender
sender
Definition: mac-extension-test-suite.cc:496
ChannelRoutingTestCase::SendWsa
void SendWsa(bool shouldSucceed, const VsaInfo &vsaInfo)
Send VSA management frames.
Definition: mac-extension-test-suite.cc:531
ChannelRoutingTestCase::SendWsmp
void SendWsmp(bool shouldSucceed, const TxInfo &txInfo)
Send WSMP or other packets.
Definition: mac-extension-test-suite.cc:509
ChannelRoutingTestCase::SendIp
void SendIp(bool shouldSucceed, bool ipv6)
Send IP-based packets.
Definition: mac-extension-test-suite.cc:519
ChannelRoutingTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: mac-extension-test-suite.cc:538
ChannelRoutingTestCase::ReceiveVsa
bool ReceiveVsa(Ptr< const Packet > pkt, const Address &address, uint32_t, uint32_t)
Receive VSA function.
ChannelRoutingTestCase::Receive
bool Receive(Ptr< NetDevice > dev, Ptr< const Packet > pkt, uint16_t mode, const Address &sender)
Receive function.
CoordinationTestListener
CoordinationTestListener is used to test channel coordination events.
Definition: mac-extension-test-suite.cc:91
CoordinationTestListener::NotifyCchSlotStart
void NotifyCchSlotStart(Time duration) override
Definition: mac-extension-test-suite.cc:107
CoordinationTestListener::m_coordinatorTest
ChannelCoordinationTestCase * m_coordinatorTest
coordinator test
Definition: mac-extension-test-suite.cc:122
CoordinationTestListener::NotifySchSlotStart
void NotifySchSlotStart(Time duration) override
Definition: mac-extension-test-suite.cc:112
CoordinationTestListener::CoordinationTestListener
CoordinationTestListener(ChannelCoordinationTestCase *coordinatorTest)
Constructor.
Definition: mac-extension-test-suite.cc:98
CoordinationTestListener::NotifyGuardSlotStart
void NotifyGuardSlotStart(Time duration, bool cchi) override
Definition: mac-extension-test-suite.cc:117
TestCaseHelper::CreatWaveDevice
static NetDeviceContainer CreatWaveDevice(uint32_t nodesNumber=2)
Create WAVE device function.
Definition: mac-extension-test-suite.cc:418
WaveMacTestSuite
Wave Mac Test Suite.
Definition: mac-extension-test-suite.cc:1542
ns3::Address
a polymophic address class
Definition: address.h:100
ns3::ChannelCoordinationListener
receive notifications about channel coordination events.
Definition: channel-coordinator.h:31
ns3::ChannelCoordinator::IsSchInterval
bool IsSchInterval(Time duration=Seconds(0.0)) const
Definition: channel-coordinator.cc:198
ns3::ChannelCoordinator::IsGuardInterval
bool IsGuardInterval(Time duration=Seconds(0.0)) const
Definition: channel-coordinator.cc:205
ns3::ChannelCoordinator::SetGuardInterval
void SetGuardInterval(Time guardi)
Definition: channel-coordinator.cc:162
ns3::ChannelCoordinator::IsCchInterval
bool IsCchInterval(Time duration=Seconds(0.0)) const
Definition: channel-coordinator.cc:190
ns3::ChannelCoordinator::RegisterListener
void RegisterListener(Ptr< ChannelCoordinationListener > listener)
Definition: channel-coordinator.cc:302
ns3::ChannelManager::GetWaveChannels
static std::vector< uint32_t > GetWaveChannels()
Definition: channel-manager.cc:78
ns3::Mac48Address
an EUI-48 address
Definition: mac48-address.h:46
ns3::Mac48Address::ConvertFrom
static Mac48Address ConvertFrom(const Address &address)
Definition: mac48-address.cc:141
ns3::Mac48Address::GetBroadcast
static Mac48Address GetBroadcast()
Definition: mac48-address.cc:201
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:67
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40
ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition: node-container.cc:84
ns3::NodeList::GetNode
static Ptr< Node > GetNode(uint32_t n)
Definition: node-list.cc:251
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
ns3::OrganizationIdentifier
the organization identifier is a public organizationally unique identifier assigned by the IEEE.
Definition: vendor-specific-action.h:55
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
ns3::QosWaveMacHelper
Qos Wave Mac Helper class.
Definition: wave-mac-helper.h:73
ns3::QosWaveMacHelper::Default
static QosWaveMacHelper Default()
Create a mac helper in a default working state.
Definition: wave-mac-helper.cc:60
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:568
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:140
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:176
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:184
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::QUICK
@ QUICK
Fast test.
Definition: test.h:1065
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::Time::GetMilliSeconds
int64_t GetMilliSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:407
ns3::Time::S
@ S
second
Definition: nstime.h:116
ns3::Time::GetTimeStep
int64_t GetTimeStep() const
Get the raw time value, in the current resolution unit.
Definition: nstime.h:444
ns3::WaveHelper
helps to create WaveNetDevice objects
Definition: wave-helper.h:116
ns3::WaveHelper::Install
virtual NetDeviceContainer Install(const WifiPhyHelper &phy, const WifiMacHelper &mac, NodeContainer c) const
Definition: wave-helper.cc:335
ns3::WaveHelper::Default
static WaveHelper Default()
Definition: wave-helper.cc:285
ns3::WaveNetDevice::Send
bool Send(Ptr< Packet > packet, const Address &dest, uint16_t protocolNumber) override
Definition: wave-net-device.cc:639
ns3::WaveNetDevice::StartSch
bool StartSch(const SchInfo &schInfo)
Definition: wave-net-device.cc:295
ns3::WaveNetDevice::DeleteTxProfile
bool DeleteTxProfile(uint32_t channelNumber)
Definition: wave-net-device.cc:363
ns3::WaveNetDevice::GetAddress
Address GetAddress() const override
Definition: wave-net-device.cc:559
ns3::WaveNetDevice::GetChannelScheduler
Ptr< ChannelScheduler > GetChannelScheduler() const
Definition: wave-net-device.cc:501
ns3::WaveNetDevice::SetReceiveCallback
void SetReceiveCallback(NetDevice::ReceiveCallback cb) override
Definition: wave-net-device.cc:691
ns3::WaveNetDevice::StopVsa
bool StopVsa(uint32_t channelNumber)
Definition: wave-net-device.cc:276
ns3::WaveNetDevice::SendX
bool SendX(Ptr< Packet > packet, const Address &dest, uint32_t protocol, const TxInfo &txInfo)
Definition: wave-net-device.cc:385
ns3::WaveNetDevice::RegisterTxProfile
bool RegisterTxProfile(const TxProfile &txprofile)
Definition: wave-net-device.cc:317
ns3::WaveNetDevice::StartVsa
bool StartVsa(const VsaInfo &vsaInfo)
Definition: wave-net-device.cc:247
ns3::WaveNetDevice::StopSch
bool StopSch(uint32_t channelNumber)
Definition: wave-net-device.cc:306
ns3::WifiMode
represent a single transmission mode
Definition: wifi-mode.h:50
ns3::YansWavePhyHelper
To trace WaveNetDevice, we have to overwrite the trace functions of class YansWifiPhyHelper.
Definition: wave-helper.h:42
ns3::YansWavePhyHelper::Default
static YansWavePhyHelper Default()
Create a phy helper in a default working state.
Definition: wave-helper.cc:122
ns3::YansWifiChannelHelper
manage and create wifi channel objects for the YANS model.
Definition: yans-wifi-helper.h:39
ns3::YansWifiChannelHelper::Default
static YansWifiChannelHelper Default()
Create a channel helper in a default working state.
Definition: yans-wifi-helper.cc:44
ns3::YansWifiChannelHelper::Create
Ptr< YansWifiChannel > Create() const
Definition: yans-wifi-helper.cc:53
ns3::YansWifiPhyHelper::SetChannel
void SetChannel(Ptr< YansWifiChannel > channel)
Definition: yans-wifi-helper.cc:93
uint32_t
ns3::Now
Time Now()
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:296
NS_TEST_EXPECT_MSG_LT
#define NS_TEST_EXPECT_MSG_LT(actual, limit, msg)
Test that an actual value is less than a limit and report if not.
Definition: test.h:790
NS_TEST_EXPECT_MSG_GT
#define NS_TEST_EXPECT_MSG_GT(actual, limit, msg)
Test that an actual value is greater than a limit and report if not.
Definition: test.h:956
NS_TEST_EXPECT_MSG_EQ
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:251
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1348
ns3::VSA_TRANSMIT_IN_BOTHI
@ VSA_TRANSMIT_IN_BOTHI
Definition: vsa-manager.h:39
ns3::WIFI_PREAMBLE_LONG
@ WIFI_PREAMBLE_LONG
Definition: wifi-phy-common.h:80
nodes
NodeContainer nodes
Definition: lr-wpan-bootstrap.cc:53
waveMacTestSuite
static WaveMacTestSuite waveMacTestSuite
the test suite
Definition: mac-extension-test-suite.cc:1558
PI
#define PI
Definition: mac-extension-test-suite.cc:415
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::MakeCallback
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:707
test
-ns3 Test suite for the ns3 wrapper script
data
uint8_t data[writeSize]
Definition: socket-bound-tcp-static-routing.cc:52
ns3::VsaInfo::channelNumber
uint32_t channelNumber
channel number
Definition: vsa-manager.h:69
packetSize
static const uint32_t packetSize
Packet size generated at the AP.
Definition: wifi-power-adaptation-distance.cc:111