A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
tx-duration-test.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2009 CTTC
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Authors: Nicola Baldo <nbaldo@cttc.es>
18 * Sébastien Deronne <sebastien.deronne@gmail.com>
19 */
20
21#include "ns3/dsss-phy.h"
22#include "ns3/eht-phy.h" //includes OFDM, HT, VHT and HE
23#include "ns3/eht-ppdu.h" //includes OFDM, HT, VHT and HE
24#include "ns3/erp-ofdm-phy.h"
25#include "ns3/he-ru.h"
26#include "ns3/log.h"
27#include "ns3/packet.h"
28#include "ns3/simulator.h"
29#include "ns3/test.h"
30#include "ns3/wifi-psdu.h"
31#include "ns3/yans-wifi-phy.h"
32
33#include <list>
34#include <numeric>
35
36using namespace ns3;
37
38NS_LOG_COMPONENT_DEFINE("TxDurationTest");
39
46class TxDurationTest : public TestCase
47{
48 public:
49 TxDurationTest();
50 ~TxDurationTest() override;
51 void DoRun() override;
52
53 private:
67 bool CheckPayloadDuration(uint32_t size,
68 WifiMode payloadMode,
69 uint16_t channelWidth,
70 uint16_t guardInterval,
71 WifiPreamble preamble,
72 Time knownDuration);
73
87 bool CheckTxDuration(uint32_t size,
88 WifiMode payloadMode,
89 uint16_t channelWidth,
90 uint16_t guardInterval,
91 WifiPreamble preamble,
92 Time knownDuration);
93
107 static bool CheckMuTxDuration(std::list<uint32_t> sizes,
108 std::list<HeMuUserInfo> userInfos,
109 uint16_t channelWidth,
110 uint16_t guardInterval,
111 WifiPreamble preamble,
112 Time knownDuration);
113
128 static Time CalculateTxDurationUsingList(std::list<uint32_t> sizes,
129 std::list<uint16_t> staIds,
130 WifiTxVector txVector,
131 WifiPhyBand band);
132};
133
134TxDurationTest::TxDurationTest()
135 : TestCase("Wifi TX Duration")
136{
137}
138
139TxDurationTest::~TxDurationTest()
140{
141}
142
143bool
144TxDurationTest::CheckPayloadDuration(uint32_t size,
145 WifiMode payloadMode,
146 uint16_t channelWidth,
147 uint16_t guardInterval,
148 WifiPreamble preamble,
149 Time knownDuration)
150{
151 WifiTxVector txVector;
152 txVector.SetMode(payloadMode);
153 txVector.SetPreambleType(preamble);
154 txVector.SetChannelWidth(channelWidth);
155 txVector.SetGuardInterval(guardInterval);
156 txVector.SetNss(1);
157 txVector.SetStbc(false);
158 txVector.SetNess(0);
159 std::list<WifiPhyBand> testedBands;
160 Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
161 if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM)
162 {
163 testedBands.push_back(WIFI_PHY_BAND_5GHZ);
164 }
165 if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_HE)
166 {
167 testedBands.push_back(WIFI_PHY_BAND_6GHZ);
168 }
169 if (payloadMode.GetModulationClass() != WIFI_MOD_CLASS_VHT)
170 {
171 testedBands.push_back(WIFI_PHY_BAND_2_4GHZ);
172 }
173 for (auto& testedBand : testedBands)
174 {
175 if ((testedBand == WIFI_PHY_BAND_2_4GHZ) &&
176 (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM))
177 {
178 knownDuration +=
179 MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
180 }
181 Time calculatedDuration = phy->GetPayloadDuration(size, txVector, testedBand);
182 if (calculatedDuration != knownDuration)
183 {
184 std::cerr << "size=" << size << " band=" << testedBand << " mode=" << payloadMode
185 << " channelWidth=" << channelWidth << " guardInterval=" << guardInterval
186 << " datarate=" << payloadMode.GetDataRate(channelWidth, guardInterval, 1)
187 << " known=" << knownDuration << " calculated=" << calculatedDuration
188 << std::endl;
189 return false;
190 }
191 }
192 return true;
193}
194
195bool
196TxDurationTest::CheckTxDuration(uint32_t size,
197 WifiMode payloadMode,
198 uint16_t channelWidth,
199 uint16_t guardInterval,
200 WifiPreamble preamble,
201 Time knownDuration)
202{
203 WifiTxVector txVector;
204 txVector.SetMode(payloadMode);
205 txVector.SetPreambleType(preamble);
206 txVector.SetChannelWidth(channelWidth);
207 txVector.SetGuardInterval(guardInterval);
208 txVector.SetNss(1);
209 txVector.SetStbc(false);
210 txVector.SetNess(0);
211 std::list<WifiPhyBand> testedBands;
212 Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
213 if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM)
214 {
215 testedBands.push_back(WIFI_PHY_BAND_5GHZ);
216 }
217 if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_HE)
218 {
219 testedBands.push_back(WIFI_PHY_BAND_6GHZ);
220 }
221 if (payloadMode.GetModulationClass() != WIFI_MOD_CLASS_VHT)
222 {
223 testedBands.push_back(WIFI_PHY_BAND_2_4GHZ);
224 }
225 for (auto& testedBand : testedBands)
226 {
227 if ((testedBand == WIFI_PHY_BAND_2_4GHZ) &&
228 (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM))
229 {
230 knownDuration +=
231 MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
232 }
233 Time calculatedDuration = phy->CalculateTxDuration(size, txVector, testedBand);
234 Time calculatedDurationUsingList =
235 CalculateTxDurationUsingList(std::list<uint32_t>{size},
236 std::list<uint16_t>{SU_STA_ID},
237 txVector,
238 testedBand);
239 if (calculatedDuration != knownDuration ||
240 calculatedDuration != calculatedDurationUsingList)
241 {
242 std::cerr << "size=" << size << " band=" << testedBand << " mode=" << payloadMode
243 << " channelWidth=" << +channelWidth << " guardInterval=" << guardInterval
244 << " datarate=" << payloadMode.GetDataRate(channelWidth, guardInterval, 1)
245 << " preamble=" << preamble << " known=" << knownDuration
246 << " calculated=" << calculatedDuration
247 << " calculatedUsingList=" << calculatedDurationUsingList << std::endl;
248 return false;
249 }
250 }
251 return true;
252}
253
254bool
255TxDurationTest::CheckMuTxDuration(std::list<uint32_t> sizes,
256 std::list<HeMuUserInfo> userInfos,
257 uint16_t channelWidth,
258 uint16_t guardInterval,
259 WifiPreamble preamble,
260 Time knownDuration)
261{
262 NS_ASSERT(sizes.size() == userInfos.size() && sizes.size() > 1);
263 NS_ABORT_MSG_IF(
264 channelWidth < std::accumulate(
265 std::begin(userInfos),
266 std::end(userInfos),
267 0,
268 [](const uint16_t prevBw, const HeMuUserInfo& info) {
269 return prevBw + HeRu::GetBandwidth(info.ru.GetRuType());
270 }),
271 "Cannot accommodate all the RUs in the provided band"); // MU-MIMO (for which allocations
272 // use the same RU) is not supported
273 WifiTxVector txVector;
274 txVector.SetPreambleType(preamble);
275 txVector.SetChannelWidth(channelWidth);
276 txVector.SetGuardInterval(guardInterval);
277 txVector.SetStbc(false);
278 txVector.SetNess(0);
279 if (IsEht(preamble))
280 {
281 txVector.SetEhtPpduType(0);
282 }
283 std::list<uint16_t> staIds;
284
285 uint16_t staId = 1;
286 for (const auto& userInfo : userInfos)
287 {
288 txVector.SetHeMuUserInfo(staId, userInfo);
289 staIds.push_back(staId++);
290 }
291 txVector.SetSigBMode(VhtPhy::GetVhtMcs0());
292 txVector.SetRuAllocation({192, 192}, 0);
293
294 Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
295 std::list<WifiPhyBand> testedBands{
296 WIFI_PHY_BAND_5GHZ,
297 WIFI_PHY_BAND_6GHZ,
298 WIFI_PHY_BAND_2_4GHZ}; // Durations vary depending on frequency; test also 2.4 GHz (bug
299 // 1971)
300 for (auto& testedBand : testedBands)
301 {
302 if (testedBand == WIFI_PHY_BAND_2_4GHZ)
303 {
304 knownDuration +=
305 MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
306 }
307 Time calculatedDuration = NanoSeconds(0);
308 uint32_t longestSize = 0;
309 auto iterStaId = staIds.begin();
310 for (auto& size : sizes)
311 {
312 Time ppduDurationForSta =
313 phy->CalculateTxDuration(size, txVector, testedBand, *iterStaId);
314 if (ppduDurationForSta > calculatedDuration)
315 {
316 calculatedDuration = ppduDurationForSta;
317 staId = *iterStaId;
318 longestSize = size;
319 }
320 ++iterStaId;
321 }
322 Time calculatedDurationUsingList =
323 CalculateTxDurationUsingList(sizes, staIds, txVector, testedBand);
324 if (calculatedDuration != knownDuration ||
325 calculatedDuration != calculatedDurationUsingList)
326 {
327 std::cerr << "size=" << longestSize << " band=" << testedBand << " staId=" << staId
328 << " nss=" << +txVector.GetNss(staId) << " mode=" << txVector.GetMode(staId)
329 << " channelWidth=" << channelWidth << " guardInterval=" << guardInterval
330 << " datarate="
331 << txVector.GetMode(staId).GetDataRate(channelWidth,
332 guardInterval,
333 txVector.GetNss(staId))
334 << " known=" << knownDuration << " calculated=" << calculatedDuration
335 << " calculatedUsingList=" << calculatedDurationUsingList << std::endl;
336 return false;
337 }
338 }
339 return true;
340}
341
342Time
343TxDurationTest::CalculateTxDurationUsingList(std::list<uint32_t> sizes,
344 std::list<uint16_t> staIds,
345 WifiTxVector txVector,
346 WifiPhyBand band)
347{
348 NS_ASSERT(sizes.size() == staIds.size());
349 WifiConstPsduMap psduMap;
350 auto itStaId = staIds.begin();
351 WifiMacHeader hdr;
352 hdr.SetType(WIFI_MAC_CTL_ACK); // so that size may not be empty while being as short as possible
353 for (auto& size : sizes)
354 {
355 // MAC header and FCS are to deduce from size
356 psduMap[*itStaId++] =
357 Create<WifiPsdu>(Create<Packet>(size - hdr.GetSerializedSize() - 4), hdr);
358 }
359 return WifiPhy::CalculateTxDuration(psduMap, txVector, band);
360}
361
362void
363TxDurationTest::DoRun()
364{
365 bool retval = true;
366
367 // IEEE Std 802.11-2007 Table 18-2 "Example of LENGTH calculations for CCK"
368 retval = retval &&
369 CheckPayloadDuration(1023,
370 DsssPhy::GetDsssRate11Mbps(),
371 22,
372 800,
373 WIFI_PREAMBLE_LONG,
374 MicroSeconds(744)) &&
375 CheckPayloadDuration(1024,
376 DsssPhy::GetDsssRate11Mbps(),
377 22,
378 800,
379 WIFI_PREAMBLE_LONG,
380 MicroSeconds(745)) &&
381 CheckPayloadDuration(1025,
382 DsssPhy::GetDsssRate11Mbps(),
383 22,
384 800,
385 WIFI_PREAMBLE_LONG,
386 MicroSeconds(746)) &&
387 CheckPayloadDuration(1026,
388 DsssPhy::GetDsssRate11Mbps(),
389 22,
390 800,
391 WIFI_PREAMBLE_LONG,
392 MicroSeconds(747));
393
394 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11b CCK duration failed");
395
396 // Similar, but we add PHY preamble and header durations
397 // and we test different rates.
398 // The payload durations for modes other than 11mbb have been
399 // calculated by hand according to IEEE Std 802.11-2007 18.2.3.5
400 retval = retval &&
401 CheckTxDuration(1023,
402 DsssPhy::GetDsssRate11Mbps(),
403 22,
404 800,
405 WIFI_PREAMBLE_SHORT,
406 MicroSeconds(744 + 96)) &&
407 CheckTxDuration(1024,
408 DsssPhy::GetDsssRate11Mbps(),
409 22,
410 800,
411 WIFI_PREAMBLE_SHORT,
412 MicroSeconds(745 + 96)) &&
413 CheckTxDuration(1025,
414 DsssPhy::GetDsssRate11Mbps(),
415 22,
416 800,
417 WIFI_PREAMBLE_SHORT,
418 MicroSeconds(746 + 96)) &&
419 CheckTxDuration(1026,
420 DsssPhy::GetDsssRate11Mbps(),
421 22,
422 800,
423 WIFI_PREAMBLE_SHORT,
424 MicroSeconds(747 + 96)) &&
425 CheckTxDuration(1023,
426 DsssPhy::GetDsssRate11Mbps(),
427 22,
428 800,
429 WIFI_PREAMBLE_LONG,
430 MicroSeconds(744 + 192)) &&
431 CheckTxDuration(1024,
432 DsssPhy::GetDsssRate11Mbps(),
433 22,
434 800,
435 WIFI_PREAMBLE_LONG,
436 MicroSeconds(745 + 192)) &&
437 CheckTxDuration(1025,
438 DsssPhy::GetDsssRate11Mbps(),
439 22,
440 800,
441 WIFI_PREAMBLE_LONG,
442 MicroSeconds(746 + 192)) &&
443 CheckTxDuration(1026,
444 DsssPhy::GetDsssRate11Mbps(),
445 22,
446 800,
447 WIFI_PREAMBLE_LONG,
448 MicroSeconds(747 + 192)) &&
449 CheckTxDuration(1023,
450 DsssPhy::GetDsssRate5_5Mbps(),
451 22,
452 800,
453 WIFI_PREAMBLE_SHORT,
454 MicroSeconds(1488 + 96)) &&
455 CheckTxDuration(1024,
456 DsssPhy::GetDsssRate5_5Mbps(),
457 22,
458 800,
459 WIFI_PREAMBLE_SHORT,
460 MicroSeconds(1490 + 96)) &&
461 CheckTxDuration(1025,
462 DsssPhy::GetDsssRate5_5Mbps(),
463 22,
464 800,
465 WIFI_PREAMBLE_SHORT,
466 MicroSeconds(1491 + 96)) &&
467 CheckTxDuration(1026,
468 DsssPhy::GetDsssRate5_5Mbps(),
469 22,
470 800,
471 WIFI_PREAMBLE_SHORT,
472 MicroSeconds(1493 + 96)) &&
473 CheckTxDuration(1023,
474 DsssPhy::GetDsssRate5_5Mbps(),
475 22,
476 800,
477 WIFI_PREAMBLE_LONG,
478 MicroSeconds(1488 + 192)) &&
479 CheckTxDuration(1024,
480 DsssPhy::GetDsssRate5_5Mbps(),
481 22,
482 800,
483 WIFI_PREAMBLE_LONG,
484 MicroSeconds(1490 + 192)) &&
485 CheckTxDuration(1025,
486 DsssPhy::GetDsssRate5_5Mbps(),
487 22,
488 800,
489 WIFI_PREAMBLE_LONG,
490 MicroSeconds(1491 + 192)) &&
491 CheckTxDuration(1026,
492 DsssPhy::GetDsssRate5_5Mbps(),
493 22,
494 800,
495 WIFI_PREAMBLE_LONG,
496 MicroSeconds(1493 + 192)) &&
497 CheckTxDuration(1023,
498 DsssPhy::GetDsssRate2Mbps(),
499 22,
500 800,
501 WIFI_PREAMBLE_SHORT,
502 MicroSeconds(4092 + 96)) &&
503 CheckTxDuration(1024,
504 DsssPhy::GetDsssRate2Mbps(),
505 22,
506 800,
507 WIFI_PREAMBLE_SHORT,
508 MicroSeconds(4096 + 96)) &&
509 CheckTxDuration(1025,
510 DsssPhy::GetDsssRate2Mbps(),
511 22,
512 800,
513 WIFI_PREAMBLE_SHORT,
514 MicroSeconds(4100 + 96)) &&
515 CheckTxDuration(1026,
516 DsssPhy::GetDsssRate2Mbps(),
517 22,
518 800,
519 WIFI_PREAMBLE_SHORT,
520 MicroSeconds(4104 + 96)) &&
521 CheckTxDuration(1023,
522 DsssPhy::GetDsssRate2Mbps(),
523 22,
524 800,
525 WIFI_PREAMBLE_LONG,
526 MicroSeconds(4092 + 192)) &&
527 CheckTxDuration(1024,
528 DsssPhy::GetDsssRate2Mbps(),
529 22,
530 800,
531 WIFI_PREAMBLE_LONG,
532 MicroSeconds(4096 + 192)) &&
533 CheckTxDuration(1025,
534 DsssPhy::GetDsssRate2Mbps(),
535 22,
536 800,
537 WIFI_PREAMBLE_LONG,
538 MicroSeconds(4100 + 192)) &&
539 CheckTxDuration(1026,
540 DsssPhy::GetDsssRate2Mbps(),
541 22,
542 800,
543 WIFI_PREAMBLE_LONG,
544 MicroSeconds(4104 + 192)) &&
545 CheckTxDuration(1023,
546 DsssPhy::GetDsssRate1Mbps(),
547 22,
548 800,
549 WIFI_PREAMBLE_SHORT,
550 MicroSeconds(8184 + 192)) &&
551 CheckTxDuration(1024,
552 DsssPhy::GetDsssRate1Mbps(),
553 22,
554 800,
555 WIFI_PREAMBLE_SHORT,
556 MicroSeconds(8192 + 192)) &&
557 CheckTxDuration(1025,
558 DsssPhy::GetDsssRate1Mbps(),
559 22,
560 800,
561 WIFI_PREAMBLE_SHORT,
562 MicroSeconds(8200 + 192)) &&
563 CheckTxDuration(1026,
564 DsssPhy::GetDsssRate1Mbps(),
565 22,
566 800,
567 WIFI_PREAMBLE_SHORT,
568 MicroSeconds(8208 + 192)) &&
569 CheckTxDuration(1023,
570 DsssPhy::GetDsssRate1Mbps(),
571 22,
572 800,
573 WIFI_PREAMBLE_LONG,
574 MicroSeconds(8184 + 192)) &&
575 CheckTxDuration(1024,
576 DsssPhy::GetDsssRate1Mbps(),
577 22,
578 800,
579 WIFI_PREAMBLE_LONG,
580 MicroSeconds(8192 + 192)) &&
581 CheckTxDuration(1025,
582 DsssPhy::GetDsssRate1Mbps(),
583 22,
584 800,
585 WIFI_PREAMBLE_LONG,
586 MicroSeconds(8200 + 192)) &&
587 CheckTxDuration(1026,
588 DsssPhy::GetDsssRate1Mbps(),
589 22,
590 800,
591 WIFI_PREAMBLE_LONG,
592 MicroSeconds(8208 + 192));
593
594 // values from http://mailman.isi.edu/pipermail/ns-developers/2009-July/006226.html
595 retval = retval && CheckTxDuration(14,
596 DsssPhy::GetDsssRate1Mbps(),
597 22,
598 800,
599 WIFI_PREAMBLE_LONG,
600 MicroSeconds(304));
601
602 // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
603 retval = retval &&
604 CheckTxDuration(1536,
605 DsssPhy::GetDsssRate11Mbps(),
606 22,
607 800,
608 WIFI_PREAMBLE_LONG,
609 MicroSeconds(1310)) &&
610 CheckTxDuration(76,
611 DsssPhy::GetDsssRate11Mbps(),
612 22,
613 800,
614 WIFI_PREAMBLE_LONG,
615 MicroSeconds(248)) &&
616 CheckTxDuration(14,
617 DsssPhy::GetDsssRate11Mbps(),
618 22,
619 800,
620 WIFI_PREAMBLE_LONG,
621 MicroSeconds(203));
622
623 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11b duration failed");
624
625 // 802.11a durations
626 // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
627 retval = retval &&
628 CheckTxDuration(1536,
629 OfdmPhy::GetOfdmRate54Mbps(),
630 20,
631 800,
632 WIFI_PREAMBLE_LONG,
633 MicroSeconds(248)) &&
634 CheckTxDuration(76,
635 OfdmPhy::GetOfdmRate54Mbps(),
636 20,
637 800,
638 WIFI_PREAMBLE_LONG,
639 MicroSeconds(32)) &&
640 CheckTxDuration(14,
641 OfdmPhy::GetOfdmRate54Mbps(),
642 20,
643 800,
644 WIFI_PREAMBLE_LONG,
645 MicroSeconds(24));
646
647 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11a duration failed");
648
649 // 802.11g durations are same as 802.11a durations but with 6 us signal extension
650 retval = retval &&
651 CheckTxDuration(1536,
652 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
653 20,
654 800,
655 WIFI_PREAMBLE_LONG,
656 MicroSeconds(254)) &&
657 CheckTxDuration(76,
658 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
659 20,
660 800,
661 WIFI_PREAMBLE_LONG,
662 MicroSeconds(38)) &&
663 CheckTxDuration(14,
664 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
665 20,
666 800,
667 WIFI_PREAMBLE_LONG,
668 MicroSeconds(30));
669
670 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11g duration failed");
671
672 // 802.11n durations
673 retval =
674 retval &&
675 CheckTxDuration(1536,
676 HtPhy::GetHtMcs7(),
677 20,
678 800,
679 WIFI_PREAMBLE_HT_MF,
680 MicroSeconds(228)) &&
681 CheckTxDuration(76, HtPhy::GetHtMcs7(), 20, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(48)) &&
682 CheckTxDuration(14, HtPhy::GetHtMcs7(), 20, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(40)) &&
683 CheckTxDuration(1536,
684 HtPhy::GetHtMcs0(),
685 20,
686 400,
687 WIFI_PREAMBLE_HT_MF,
688 NanoSeconds(1742400)) &&
689 CheckTxDuration(76, HtPhy::GetHtMcs0(), 20, 400, WIFI_PREAMBLE_HT_MF, MicroSeconds(126)) &&
690 CheckTxDuration(14, HtPhy::GetHtMcs0(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(57600)) &&
691 CheckTxDuration(1536,
692 HtPhy::GetHtMcs6(),
693 20,
694 400,
695 WIFI_PREAMBLE_HT_MF,
696 NanoSeconds(226800)) &&
697 CheckTxDuration(76, HtPhy::GetHtMcs6(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(46800)) &&
698 CheckTxDuration(14, HtPhy::GetHtMcs6(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(39600)) &&
699 CheckTxDuration(1536,
700 HtPhy::GetHtMcs7(),
701 40,
702 800,
703 WIFI_PREAMBLE_HT_MF,
704 MicroSeconds(128)) &&
705 CheckTxDuration(76, HtPhy::GetHtMcs7(), 40, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(44)) &&
706 CheckTxDuration(14, HtPhy::GetHtMcs7(), 40, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(40)) &&
707 CheckTxDuration(1536,
708 HtPhy::GetHtMcs7(),
709 40,
710 400,
711 WIFI_PREAMBLE_HT_MF,
712 NanoSeconds(118800)) &&
713 CheckTxDuration(76, HtPhy::GetHtMcs7(), 40, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(43200)) &&
714 CheckTxDuration(14, HtPhy::GetHtMcs7(), 40, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(39600));
715
716 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11n duration failed");
717
718 // 802.11ac durations
719 retval = retval &&
720 CheckTxDuration(1536,
721 VhtPhy::GetVhtMcs8(),
722 20,
723 800,
724 WIFI_PREAMBLE_VHT_SU,
725 MicroSeconds(196)) &&
726 CheckTxDuration(76,
727 VhtPhy::GetVhtMcs8(),
728 20,
729 800,
730 WIFI_PREAMBLE_VHT_SU,
731 MicroSeconds(48)) &&
732 CheckTxDuration(14,
733 VhtPhy::GetVhtMcs8(),
734 20,
735 800,
736 WIFI_PREAMBLE_VHT_SU,
737 MicroSeconds(40)) &&
738 CheckTxDuration(1536,
739 VhtPhy::GetVhtMcs8(),
740 20,
741 400,
742 WIFI_PREAMBLE_VHT_SU,
743 MicroSeconds(180)) &&
744 CheckTxDuration(76,
745 VhtPhy::GetVhtMcs8(),
746 20,
747 400,
748 WIFI_PREAMBLE_VHT_SU,
749 NanoSeconds(46800)) &&
750 CheckTxDuration(14,
751 VhtPhy::GetVhtMcs8(),
752 20,
753 400,
754 WIFI_PREAMBLE_VHT_SU,
755 NanoSeconds(39600)) &&
756 CheckTxDuration(1536,
757 VhtPhy::GetVhtMcs9(),
758 40,
759 800,
760 WIFI_PREAMBLE_VHT_SU,
761 MicroSeconds(108)) &&
762 CheckTxDuration(76,
763 VhtPhy::GetVhtMcs9(),
764 40,
765 800,
766 WIFI_PREAMBLE_VHT_SU,
767 MicroSeconds(40)) &&
768 CheckTxDuration(14,
769 VhtPhy::GetVhtMcs9(),
770 40,
771 800,
772 WIFI_PREAMBLE_VHT_SU,
773 MicroSeconds(40)) &&
774 CheckTxDuration(1536,
775 VhtPhy::GetVhtMcs9(),
776 40,
777 400,
778 WIFI_PREAMBLE_VHT_SU,
779 NanoSeconds(100800)) &&
780 CheckTxDuration(76,
781 VhtPhy::GetVhtMcs9(),
782 40,
783 400,
784 WIFI_PREAMBLE_VHT_SU,
785 NanoSeconds(39600)) &&
786 CheckTxDuration(14,
787 VhtPhy::GetVhtMcs9(),
788 40,
789 400,
790 WIFI_PREAMBLE_VHT_SU,
791 NanoSeconds(39600)) &&
792 CheckTxDuration(1536,
793 VhtPhy::GetVhtMcs0(),
794 80,
795 800,
796 WIFI_PREAMBLE_VHT_SU,
797 MicroSeconds(460)) &&
798 CheckTxDuration(76,
799 VhtPhy::GetVhtMcs0(),
800 80,
801 800,
802 WIFI_PREAMBLE_VHT_SU,
803 MicroSeconds(60)) &&
804 CheckTxDuration(14,
805 VhtPhy::GetVhtMcs0(),
806 80,
807 800,
808 WIFI_PREAMBLE_VHT_SU,
809 MicroSeconds(44)) &&
810 CheckTxDuration(1536,
811 VhtPhy::GetVhtMcs0(),
812 80,
813 400,
814 WIFI_PREAMBLE_VHT_SU,
815 NanoSeconds(417600)) &&
816 CheckTxDuration(76,
817 VhtPhy::GetVhtMcs0(),
818 80,
819 400,
820 WIFI_PREAMBLE_VHT_SU,
821 NanoSeconds(57600)) &&
822 CheckTxDuration(14,
823 VhtPhy::GetVhtMcs0(),
824 80,
825 400,
826 WIFI_PREAMBLE_VHT_SU,
827 NanoSeconds(43200)) &&
828 CheckTxDuration(1536,
829 VhtPhy::GetVhtMcs9(),
830 80,
831 800,
832 WIFI_PREAMBLE_VHT_SU,
833 MicroSeconds(68)) &&
834 CheckTxDuration(76,
835 VhtPhy::GetVhtMcs9(),
836 80,
837 800,
838 WIFI_PREAMBLE_VHT_SU,
839 MicroSeconds(40)) &&
840 CheckTxDuration(14,
841 VhtPhy::GetVhtMcs9(),
842 80,
843 800,
844 WIFI_PREAMBLE_VHT_SU,
845 MicroSeconds(40)) &&
846 CheckTxDuration(1536,
847 VhtPhy::GetVhtMcs9(),
848 80,
849 400,
850 WIFI_PREAMBLE_VHT_SU,
851 NanoSeconds(64800)) &&
852 CheckTxDuration(76,
853 VhtPhy::GetVhtMcs9(),
854 80,
855 400,
856 WIFI_PREAMBLE_VHT_SU,
857 NanoSeconds(39600)) &&
858 CheckTxDuration(14,
859 VhtPhy::GetVhtMcs9(),
860 80,
861 400,
862 WIFI_PREAMBLE_VHT_SU,
863 NanoSeconds(39600)) &&
864 CheckTxDuration(1536,
865 VhtPhy::GetVhtMcs8(),
866 160,
867 800,
868 WIFI_PREAMBLE_VHT_SU,
869 MicroSeconds(56)) &&
870 CheckTxDuration(76,
871 VhtPhy::GetVhtMcs8(),
872 160,
873 800,
874 WIFI_PREAMBLE_VHT_SU,
875 MicroSeconds(40)) &&
876 CheckTxDuration(14,
877 VhtPhy::GetVhtMcs8(),
878 160,
879 800,
880 WIFI_PREAMBLE_VHT_SU,
881 MicroSeconds(40)) &&
882 CheckTxDuration(1536,
883 VhtPhy::GetVhtMcs8(),
884 160,
885 400,
886 WIFI_PREAMBLE_VHT_SU,
887 MicroSeconds(54)) &&
888 CheckTxDuration(76,
889 VhtPhy::GetVhtMcs8(),
890 160,
891 400,
892 WIFI_PREAMBLE_VHT_SU,
893 NanoSeconds(39600)) &&
894 CheckTxDuration(14,
895 VhtPhy::GetVhtMcs8(),
896 160,
897 400,
898 WIFI_PREAMBLE_VHT_SU,
899 NanoSeconds(39600));
900
901 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ac duration failed");
902
903 // 802.11ax SU durations
904 retval =
905 retval &&
906 CheckTxDuration(1536,
907 HePhy::GetHeMcs0(),
908 20,
909 800,
910 WIFI_PREAMBLE_HE_SU,
911 NanoSeconds(1485600)) &&
912 CheckTxDuration(76,
913 HePhy::GetHeMcs0(),
914 20,
915 800,
916 WIFI_PREAMBLE_HE_SU,
917 NanoSeconds(125600)) &&
918 CheckTxDuration(14, HePhy::GetHeMcs0(), 20, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(71200)) &&
919 CheckTxDuration(1536,
920 HePhy::GetHeMcs0(),
921 40,
922 800,
923 WIFI_PREAMBLE_HE_SU,
924 NanoSeconds(764800)) &&
925 CheckTxDuration(76, HePhy::GetHeMcs0(), 40, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(84800)) &&
926 CheckTxDuration(14, HePhy::GetHeMcs0(), 40, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(57600)) &&
927 CheckTxDuration(1536,
928 HePhy::GetHeMcs0(),
929 80,
930 800,
931 WIFI_PREAMBLE_HE_SU,
932 NanoSeconds(397600)) &&
933 CheckTxDuration(76, HePhy::GetHeMcs0(), 80, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(71200)) &&
934 CheckTxDuration(14, HePhy::GetHeMcs0(), 80, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(57600)) &&
935 CheckTxDuration(1536,
936 HePhy::GetHeMcs0(),
937 160,
938 800,
939 WIFI_PREAMBLE_HE_SU,
940 NanoSeconds(220800)) &&
941 CheckTxDuration(76,
942 HePhy::GetHeMcs0(),
943 160,
944 800,
945 WIFI_PREAMBLE_HE_SU,
946 NanoSeconds(57600)) &&
947 CheckTxDuration(14,
948 HePhy::GetHeMcs0(),
949 160,
950 800,
951 WIFI_PREAMBLE_HE_SU,
952 NanoSeconds(57600)) &&
953 CheckTxDuration(1536,
954 HePhy::GetHeMcs0(),
955 20,
956 1600,
957 WIFI_PREAMBLE_HE_SU,
958 NanoSeconds(1570400)) &&
959 CheckTxDuration(76,
960 HePhy::GetHeMcs0(),
961 20,
962 1600,
963 WIFI_PREAMBLE_HE_SU,
964 NanoSeconds(130400)) &&
965 CheckTxDuration(14,
966 HePhy::GetHeMcs0(),
967 20,
968 1600,
969 WIFI_PREAMBLE_HE_SU,
970 NanoSeconds(72800)) &&
971 CheckTxDuration(1536,
972 HePhy::GetHeMcs0(),
973 40,
974 1600,
975 WIFI_PREAMBLE_HE_SU,
976 NanoSeconds(807200)) &&
977 CheckTxDuration(76,
978 HePhy::GetHeMcs0(),
979 40,
980 1600,
981 WIFI_PREAMBLE_HE_SU,
982 NanoSeconds(87200)) &&
983 CheckTxDuration(14,
984 HePhy::GetHeMcs0(),
985 40,
986 1600,
987 WIFI_PREAMBLE_HE_SU,
988 NanoSeconds(58400)) &&
989 CheckTxDuration(1536,
990 HePhy::GetHeMcs0(),
991 80,
992 1600,
993 WIFI_PREAMBLE_HE_SU,
994 NanoSeconds(418400)) &&
995 CheckTxDuration(76,
996 HePhy::GetHeMcs0(),
997 80,
998 1600,
999 WIFI_PREAMBLE_HE_SU,
1000 NanoSeconds(72800)) &&
1001 CheckTxDuration(14,
1002 HePhy::GetHeMcs0(),
1003 80,
1004 1600,
1005 WIFI_PREAMBLE_HE_SU,
1006 NanoSeconds(58400)) &&
1007 CheckTxDuration(1536,
1008 HePhy::GetHeMcs0(),
1009 160,
1010 1600,
1011 WIFI_PREAMBLE_HE_SU,
1012 NanoSeconds(231200)) &&
1013 CheckTxDuration(76,
1014 HePhy::GetHeMcs0(),
1015 160,
1016 1600,
1017 WIFI_PREAMBLE_HE_SU,
1018 NanoSeconds(58400)) &&
1019 CheckTxDuration(14,
1020 HePhy::GetHeMcs0(),
1021 160,
1022 1600,
1023 WIFI_PREAMBLE_HE_SU,
1024 NanoSeconds(58400)) &&
1025 CheckTxDuration(1536,
1026 HePhy::GetHeMcs0(),
1027 20,
1028 3200,
1029 WIFI_PREAMBLE_HE_SU,
1030 MicroSeconds(1740)) &&
1031 CheckTxDuration(76, HePhy::GetHeMcs0(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(140)) &&
1032 CheckTxDuration(14, HePhy::GetHeMcs0(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(76)) &&
1033 CheckTxDuration(1536,
1034 HePhy::GetHeMcs0(),
1035 40,
1036 3200,
1037 WIFI_PREAMBLE_HE_SU,
1038 MicroSeconds(892)) &&
1039 CheckTxDuration(76, HePhy::GetHeMcs0(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(92)) &&
1040 CheckTxDuration(14, HePhy::GetHeMcs0(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1041 CheckTxDuration(1536,
1042 HePhy::GetHeMcs0(),
1043 80,
1044 3200,
1045 WIFI_PREAMBLE_HE_SU,
1046 MicroSeconds(460)) &&
1047 CheckTxDuration(76, HePhy::GetHeMcs0(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(76)) &&
1048 CheckTxDuration(14, HePhy::GetHeMcs0(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1049 CheckTxDuration(1536,
1050 HePhy::GetHeMcs0(),
1051 160,
1052 3200,
1053 WIFI_PREAMBLE_HE_SU,
1054 MicroSeconds(252)) &&
1055 CheckTxDuration(76, HePhy::GetHeMcs0(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1056 CheckTxDuration(14, HePhy::GetHeMcs0(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1057 CheckTxDuration(1536,
1058 HePhy::GetHeMcs11(),
1059 20,
1060 800,
1061 WIFI_PREAMBLE_HE_SU,
1062 NanoSeconds(139200)) &&
1063 CheckTxDuration(76,
1064 HePhy::GetHeMcs11(),
1065 20,
1066 800,
1067 WIFI_PREAMBLE_HE_SU,
1068 NanoSeconds(57600)) &&
1069 CheckTxDuration(14,
1070 HePhy::GetHeMcs11(),
1071 20,
1072 800,
1073 WIFI_PREAMBLE_HE_SU,
1074 NanoSeconds(57600)) &&
1075 CheckTxDuration(1536,
1076 HePhy::GetHeMcs11(),
1077 40,
1078 800,
1079 WIFI_PREAMBLE_HE_SU,
1080 NanoSeconds(98400)) &&
1081 CheckTxDuration(76,
1082 HePhy::GetHeMcs11(),
1083 40,
1084 800,
1085 WIFI_PREAMBLE_HE_SU,
1086 NanoSeconds(57600)) &&
1087 CheckTxDuration(14,
1088 HePhy::GetHeMcs11(),
1089 40,
1090 800,
1091 WIFI_PREAMBLE_HE_SU,
1092 NanoSeconds(57600)) &&
1093 CheckTxDuration(1536,
1094 HePhy::GetHeMcs11(),
1095 80,
1096 800,
1097 WIFI_PREAMBLE_HE_SU,
1098 NanoSeconds(71200)) &&
1099 CheckTxDuration(76,
1100 HePhy::GetHeMcs11(),
1101 80,
1102 800,
1103 WIFI_PREAMBLE_HE_SU,
1104 NanoSeconds(57600)) &&
1105 CheckTxDuration(14,
1106 HePhy::GetHeMcs11(),
1107 80,
1108 800,
1109 WIFI_PREAMBLE_HE_SU,
1110 NanoSeconds(57600)) &&
1111 CheckTxDuration(1536,
1112 HePhy::GetHeMcs11(),
1113 160,
1114 800,
1115 WIFI_PREAMBLE_HE_SU,
1116 NanoSeconds(57600)) &&
1117 CheckTxDuration(76,
1118 HePhy::GetHeMcs11(),
1119 160,
1120 800,
1121 WIFI_PREAMBLE_HE_SU,
1122 NanoSeconds(57600)) &&
1123 CheckTxDuration(14,
1124 HePhy::GetHeMcs11(),
1125 160,
1126 800,
1127 WIFI_PREAMBLE_HE_SU,
1128 NanoSeconds(57600)) &&
1129 CheckTxDuration(1536,
1130 HePhy::GetHeMcs11(),
1131 20,
1132 1600,
1133 WIFI_PREAMBLE_HE_SU,
1134 NanoSeconds(144800)) &&
1135 CheckTxDuration(76,
1136 HePhy::GetHeMcs11(),
1137 20,
1138 1600,
1139 WIFI_PREAMBLE_HE_SU,
1140 NanoSeconds(58400)) &&
1141 CheckTxDuration(14,
1142 HePhy::GetHeMcs11(),
1143 20,
1144 1600,
1145 WIFI_PREAMBLE_HE_SU,
1146 NanoSeconds(58400)) &&
1147 CheckTxDuration(1536,
1148 HePhy::GetHeMcs11(),
1149 40,
1150 1600,
1151 WIFI_PREAMBLE_HE_SU,
1152 NanoSeconds(101600)) &&
1153 CheckTxDuration(76,
1154 HePhy::GetHeMcs11(),
1155 40,
1156 1600,
1157 WIFI_PREAMBLE_HE_SU,
1158 NanoSeconds(58400)) &&
1159 CheckTxDuration(14,
1160 HePhy::GetHeMcs11(),
1161 40,
1162 1600,
1163 WIFI_PREAMBLE_HE_SU,
1164 NanoSeconds(58400)) &&
1165 CheckTxDuration(1536,
1166 HePhy::GetHeMcs11(),
1167 80,
1168 1600,
1169 WIFI_PREAMBLE_HE_SU,
1170 NanoSeconds(72800)) &&
1171 CheckTxDuration(76,
1172 HePhy::GetHeMcs11(),
1173 80,
1174 1600,
1175 WIFI_PREAMBLE_HE_SU,
1176 NanoSeconds(58400)) &&
1177 CheckTxDuration(14,
1178 HePhy::GetHeMcs11(),
1179 80,
1180 1600,
1181 WIFI_PREAMBLE_HE_SU,
1182 NanoSeconds(58400)) &&
1183 CheckTxDuration(1536,
1184 HePhy::GetHeMcs11(),
1185 160,
1186 1600,
1187 WIFI_PREAMBLE_HE_SU,
1188 NanoSeconds(58400)) &&
1189 CheckTxDuration(76,
1190 HePhy::GetHeMcs11(),
1191 160,
1192 1600,
1193 WIFI_PREAMBLE_HE_SU,
1194 NanoSeconds(58400)) &&
1195 CheckTxDuration(14,
1196 HePhy::GetHeMcs11(),
1197 160,
1198 1600,
1199 WIFI_PREAMBLE_HE_SU,
1200 NanoSeconds(58400)) &&
1201 CheckTxDuration(1536,
1202 HePhy::GetHeMcs11(),
1203 20,
1204 3200,
1205 WIFI_PREAMBLE_HE_SU,
1206 MicroSeconds(156)) &&
1207 CheckTxDuration(76, HePhy::GetHeMcs11(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1208 CheckTxDuration(14, HePhy::GetHeMcs11(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1209 CheckTxDuration(1536,
1210 HePhy::GetHeMcs11(),
1211 40,
1212 3200,
1213 WIFI_PREAMBLE_HE_SU,
1214 MicroSeconds(108)) &&
1215 CheckTxDuration(76, HePhy::GetHeMcs11(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1216 CheckTxDuration(14, HePhy::GetHeMcs11(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1217 CheckTxDuration(1536,
1218 HePhy::GetHeMcs11(),
1219 80,
1220 3200,
1221 WIFI_PREAMBLE_HE_SU,
1222 MicroSeconds(76)) &&
1223 CheckTxDuration(76, HePhy::GetHeMcs11(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1224 CheckTxDuration(14, HePhy::GetHeMcs11(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1225 CheckTxDuration(1536,
1226 HePhy::GetHeMcs11(),
1227 160,
1228 3200,
1229 WIFI_PREAMBLE_HE_SU,
1230 MicroSeconds(60)) &&
1231 CheckTxDuration(76,
1232 HePhy::GetHeMcs11(),
1233 160,
1234 3200,
1235 WIFI_PREAMBLE_HE_SU,
1236 MicroSeconds(60)) &&
1237 CheckTxDuration(14, HePhy::GetHeMcs11(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60));
1238
1239 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax SU duration failed");
1240
1241 // 802.11ax MU durations
1242 retval = retval &&
1243 CheckMuTxDuration(
1244 std::list<uint32_t>{1536, 1536},
1245 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1246 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1247 40,
1248 800,
1249 WIFI_PREAMBLE_HE_MU,
1250 NanoSeconds(
1251 1493600)) // equivalent to HE_SU for 20 MHz with 2 extra HE-SIG-B (i.e. 8 us)
1252 && CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1253 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 1, 1},
1254 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1255 40,
1256 800,
1257 WIFI_PREAMBLE_HE_MU,
1258 NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
1259 && CheckMuTxDuration(std::list<uint32_t>{1536, 76},
1260 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1261 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1262 40,
1263 800,
1264 WIFI_PREAMBLE_HE_MU,
1265 NanoSeconds(1493600));
1266
1267 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax MU duration failed");
1268
1269 // 802.11be MU durations
1270 retval = retval &&
1271 CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1272 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1273 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1274 40,
1275 800,
1276 WIFI_PREAMBLE_EHT_MU,
1277 NanoSeconds(1493600)) // equivalent to 802.11ax MU
1278 && CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1279 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 1, 1},
1280 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1281 40,
1282 800,
1283 WIFI_PREAMBLE_EHT_MU,
1284 NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
1285 && CheckMuTxDuration(std::list<uint32_t>{1536, 76},
1286 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1287 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1288 40,
1289 800,
1290 WIFI_PREAMBLE_EHT_MU,
1291 NanoSeconds(1493600));
1292
1293 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11be MU duration failed");
1294
1295 Simulator::Destroy();
1296}
1297
1304class HeSigBDurationTest : public TestCase
1305{
1306 public:
1310 enum MuType
1311 {
1312 OFDMA = 0,
1313 MU_MIMO
1314 };
1315
1327 HeSigBDurationTest(const std::list<HeMuUserInfo>& userInfos,
1328 const WifiMode& sigBMode,
1329 uint16_t channelWidth,
1330 MuType expectedMuType,
1331 const RuAllocation& expectedRuAllocation,
1332 const std::pair<std::size_t, std::size_t>& expectedNumUsersPerCc,
1333 Time expectedSigBDuration);
1334
1335 private:
1336 void DoRun() override;
1337
1343 WifiTxVector BuildTxVector() const;
1344
1345 std::list<HeMuUserInfo> m_userInfos;
1346 WifiMode m_sigBMode;
1347 uint16_t m_channelWidth;
1348 MuType m_expectedMuType;
1349 RuAllocation m_expectedRuAllocation;
1350 std::pair<std::size_t, std::size_t>
1351 m_expectedNumUsersPerCc;
1352 Time m_expectedSigBDuration;
1353};
1354
1355HeSigBDurationTest::HeSigBDurationTest(
1356 const std::list<HeMuUserInfo>& userInfos,
1357 const WifiMode& sigBMode,
1358 uint16_t channelWidth,
1359 MuType expectedMuType,
1360 const RuAllocation& expectedRuAllocation,
1361 const std::pair<std::size_t, std::size_t>& expectedNumUsersPerCc,
1362 Time expectedSigBDuration)
1363 : TestCase{"Check HE-SIG-B duration computation"},
1364 m_userInfos{userInfos},
1365 m_sigBMode{sigBMode},
1366 m_channelWidth{channelWidth},
1367 m_expectedMuType{expectedMuType},
1368 m_expectedRuAllocation{expectedRuAllocation},
1369 m_expectedNumUsersPerCc{expectedNumUsersPerCc},
1370 m_expectedSigBDuration{expectedSigBDuration}
1371{
1372}
1373
1374WifiTxVector
1375HeSigBDurationTest::BuildTxVector() const
1376{
1377 WifiTxVector txVector;
1378 txVector.SetPreambleType(WIFI_PREAMBLE_HE_MU);
1379 txVector.SetChannelWidth(m_channelWidth);
1380 txVector.SetGuardInterval(3200);
1381 txVector.SetStbc(false);
1382 txVector.SetNess(0);
1383 std::list<uint16_t> staIds;
1384 uint16_t staId = 1;
1385 for (const auto& userInfo : m_userInfos)
1386 {
1387 txVector.SetHeMuUserInfo(staId, userInfo);
1388 staIds.push_back(staId++);
1389 }
1390 txVector.SetSigBMode(m_sigBMode);
1391 NS_ASSERT(m_expectedMuType == OFDMA ? txVector.IsDlOfdma() : txVector.IsDlMuMimo());
1392 return txVector;
1393}
1394
1395void
1396HeSigBDurationTest::DoRun()
1397{
1398 const auto& hePhy = WifiPhy::GetStaticPhyEntity(WIFI_MOD_CLASS_HE);
1399 const auto& txVector = BuildTxVector();
1400
1401 // Verify mode for HE-SIG-B field
1402 NS_TEST_EXPECT_MSG_EQ(hePhy->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
1403 m_sigBMode,
1404 "Incorrect mode used to send HE-SIG-B");
1405
1406 // Verify RU_ALLOCATION in TXVECTOR
1407 NS_TEST_EXPECT_MSG_EQ((txVector.GetRuAllocation(0) == m_expectedRuAllocation),
1408 true,
1409 "Incorrect RU_ALLOCATION");
1410
1411 // Verify number of users for content channels 1 and 2
1412 const auto& numUsersPerCc = HePpdu::GetNumRusPerHeSigBContentChannel(
1413 txVector.GetChannelWidth(),
1414 txVector.GetRuAllocation(0),
1415 txVector.IsSigBCompression(),
1416 txVector.IsSigBCompression() ? txVector.GetHeMuUserInfoMap().size() : 0);
1417 const auto contentChannels = HePpdu::GetHeSigBContentChannels(txVector, 0);
1418 NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
1419 m_expectedNumUsersPerCc.first,
1420 "Incorrect number of users in HE-SIG-B content channel 1");
1421 NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
1422 m_expectedNumUsersPerCc.second,
1423 "Incorrect number of users in HE-SIG-B content channel 2");
1424 NS_TEST_EXPECT_MSG_EQ(contentChannels.at(0).size(),
1425 m_expectedNumUsersPerCc.first,
1426 "Incorrect number of users in HE-SIG-B content channel 1");
1427 NS_TEST_EXPECT_MSG_EQ((contentChannels.size() > 1 ? contentChannels.at(1).size() : 0),
1428 m_expectedNumUsersPerCc.second,
1429 "Incorrect number of users in HE-SIG-B content channel 2");
1430
1431 // Verify total HE-SIG-B duration
1432 NS_TEST_EXPECT_MSG_EQ(hePhy->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
1433 m_expectedSigBDuration,
1434 "Incorrect duration for HE-SIG-B");
1435}
1436
1443class PhyHeaderSectionsTest : public TestCase
1444{
1445 public:
1446 PhyHeaderSectionsTest();
1447 ~PhyHeaderSectionsTest() override;
1448 void DoRun() override;
1449
1450 private:
1458 void CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained,
1459 PhyEntity::PhyHeaderSections expected);
1460};
1461
1462PhyHeaderSectionsTest::PhyHeaderSectionsTest()
1463 : TestCase("PHY header sections consistency")
1464{
1465}
1466
1467PhyHeaderSectionsTest::~PhyHeaderSectionsTest()
1468{
1469}
1470
1471void
1472PhyHeaderSectionsTest::CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained,
1473 PhyEntity::PhyHeaderSections expected)
1474{
1475 NS_ASSERT_MSG(obtained.size() == expected.size(),
1476 "The expected map size (" << expected.size() << ") was not obtained ("
1477 << obtained.size() << ")");
1478
1479 auto itObtained = obtained.begin();
1480 auto itExpected = expected.begin();
1481 for (; itObtained != obtained.end() || itExpected != expected.end();)
1482 {
1483 WifiPpduField field = itObtained->first;
1484 auto window = itObtained->second.first;
1485 auto mode = itObtained->second.second;
1486
1487 WifiPpduField fieldRef = itExpected->first;
1488 auto windowRef = itExpected->second.first;
1489 auto modeRef = itExpected->second.second;
1490
1491 NS_TEST_EXPECT_MSG_EQ(field,
1492 fieldRef,
1493 "The expected PPDU field (" << fieldRef << ") was not obtained ("
1494 << field << ")");
1495 NS_TEST_EXPECT_MSG_EQ(window.first,
1496 windowRef.first,
1497 "The expected start time (" << windowRef.first
1498 << ") was not obtained (" << window.first
1499 << ")");
1500 NS_TEST_EXPECT_MSG_EQ(window.second,
1501 windowRef.second,
1502 "The expected stop time (" << windowRef.second
1503 << ") was not obtained (" << window.second
1504 << ")");
1505 NS_TEST_EXPECT_MSG_EQ(mode,
1506 modeRef,
1507 "The expected mode (" << modeRef << ") was not obtained (" << mode
1508 << ")");
1509 ++itObtained;
1510 ++itExpected;
1511 }
1512}
1513
1514void
1515PhyHeaderSectionsTest::DoRun()
1516{
1517 Time ppduStart = Seconds(1.0);
1518 Ptr<PhyEntity> phyEntity;
1519 PhyEntity::PhyHeaderSections sections;
1520 WifiTxVector txVector;
1521 WifiMode nonHtMode;
1522
1523 // ==================================================================================
1524 // 11b (HR/DSSS)
1525 phyEntity = Create<DsssPhy>();
1526 txVector.SetMode(DsssPhy::GetDsssRate1Mbps());
1527 txVector.SetChannelWidth(22);
1528
1529 // -> long PPDU format
1530 txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
1531 nonHtMode = DsssPhy::GetDsssRate1Mbps();
1532 sections = {
1533 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(144)}, nonHtMode}},
1534 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1535 {{ppduStart + MicroSeconds(144), ppduStart + MicroSeconds(192)}, nonHtMode}},
1536 };
1537 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1538
1539 // -> long PPDU format if data rate is 1 Mbps (even if preamble is tagged short)
1540 txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
1541 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1542
1543 // -> short PPDU format
1544 txVector.SetMode(DsssPhy::GetDsssRate11Mbps());
1545 nonHtMode = DsssPhy::GetDsssRate2Mbps();
1546 txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
1547 sections = {
1548 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(72)}, nonHtMode}},
1549 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1550 {{ppduStart + MicroSeconds(72), ppduStart + MicroSeconds(96)}, nonHtMode}},
1551 };
1552 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1553
1554 // ==================================================================================
1555 // 11a (OFDM)
1556 txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
1557
1558 // -> one iteration per variant: default, 10 MHz, and 5 MHz
1559 std::map<OfdmPhyVariant, std::size_t> variants{
1560 // number to use to deduce rate and BW info for each variant
1561 {OFDM_PHY_DEFAULT, 1},
1562 {OFDM_PHY_10_MHZ, 2},
1563 {OFDM_PHY_5_MHZ, 4},
1564 };
1565 for (auto variant : variants)
1566 {
1567 phyEntity = Create<OfdmPhy>(variant.first);
1568 std::size_t ratio = variant.second;
1569 uint16_t bw = 20 / ratio; // MHz
1570 txVector.SetChannelWidth(bw);
1571 txVector.SetMode(OfdmPhy::GetOfdmRate(12000000 / ratio, bw));
1572 nonHtMode = OfdmPhy::GetOfdmRate(6000000 / ratio, bw);
1573 sections = {
1574 {WIFI_PPDU_FIELD_PREAMBLE,
1575 {{ppduStart, ppduStart + MicroSeconds(16 * ratio)}, nonHtMode}},
1576 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1577 {{ppduStart + MicroSeconds(16 * ratio), ppduStart + MicroSeconds(20 * ratio)},
1578 nonHtMode}},
1579 };
1580 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1581 }
1582
1583 // ==================================================================================
1584 // 11g (ERP-OFDM)
1585 phyEntity = Create<ErpOfdmPhy>();
1586 txVector.SetChannelWidth(20);
1587 txVector.SetMode(ErpOfdmPhy::GetErpOfdmRate(54000000));
1588 nonHtMode = ErpOfdmPhy::GetErpOfdmRate6Mbps();
1589 sections = {
1590 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1591 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1592 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1593 };
1594 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1595
1596 // ==================================================================================
1597 // 11n (HT)
1598 phyEntity = Create<HtPhy>(4);
1599 txVector.SetChannelWidth(20);
1600 txVector.SetMode(HtPhy::GetHtMcs6());
1601 nonHtMode = OfdmPhy::GetOfdmRate6Mbps();
1602 WifiMode htSigMode = nonHtMode;
1603
1604 // -> HT-mixed format for 2 SS and no ESS
1605 txVector.SetPreambleType(WIFI_PREAMBLE_HT_MF);
1606 txVector.SetNss(2);
1607 txVector.SetNess(0);
1608 sections = {
1609 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1610 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1611 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1612 {WIFI_PPDU_FIELD_HT_SIG,
1613 {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, htSigMode}},
1614 {WIFI_PPDU_FIELD_TRAINING,
1615 {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(40)}, // 1 HT-STF + 2 HT-LTFs
1616 htSigMode}},
1617 };
1618 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1619 txVector.SetChannelWidth(20); // shouldn't have any impact
1620 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1621
1622 // -> HT-mixed format for 3 SS and 1 ESS
1623 txVector.SetNss(3);
1624 txVector.SetNess(1);
1625 sections[WIFI_PPDU_FIELD_TRAINING] = {
1626 {ppduStart + MicroSeconds(28),
1627 ppduStart + MicroSeconds(52)}, // 1 HT-STF + 5 HT-LTFs (4 data + 1 extension)
1628 htSigMode};
1629 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1630
1631 // ==================================================================================
1632 // 11ac (VHT)
1633 phyEntity = Create<VhtPhy>();
1634 txVector.SetChannelWidth(20);
1635 txVector.SetNess(0);
1636 txVector.SetMode(VhtPhy::GetVhtMcs7());
1637 WifiMode sigAMode = nonHtMode;
1638 WifiMode sigBMode = VhtPhy::GetVhtMcs0();
1639
1640 // -> VHT SU format for 5 SS
1641 txVector.SetPreambleType(WIFI_PREAMBLE_VHT_SU);
1642 txVector.SetNss(5);
1643 sections = {
1644 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1645 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1646 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1647 {WIFI_PPDU_FIELD_SIG_A,
1648 {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, sigAMode}},
1649 {WIFI_PPDU_FIELD_TRAINING,
1650 {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(56)}, // 1 VHT-STF + 6 VHT-LTFs
1651 sigAMode}},
1652 };
1653 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1654
1655 // -> VHT SU format for 7 SS
1656 txVector.SetNss(7);
1657 sections[WIFI_PPDU_FIELD_TRAINING] = {
1658 {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(64)}, // 1 VHT-STF + 8 VHT-LTFs
1659 sigAMode};
1660 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1661
1662 // -> VHT MU format for 3 SS
1663 txVector.SetPreambleType(WIFI_PREAMBLE_VHT_MU);
1664 txVector.SetNss(3);
1665 sections[WIFI_PPDU_FIELD_TRAINING] = {
1666 {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(48)}, // 1 VHT-STF + 4 VHT-LTFs
1667 sigAMode};
1668 sections[WIFI_PPDU_FIELD_SIG_B] = {{ppduStart + MicroSeconds(48), ppduStart + MicroSeconds(52)},
1669 sigBMode};
1670 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1671 txVector.SetChannelWidth(80); // shouldn't have any impact
1672 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1673
1674 // ==================================================================================
1675 // 11ax (HE)
1676 phyEntity = Create<HePhy>();
1677 txVector.SetChannelWidth(20);
1678 txVector.SetNss(2); // HE-LTF duration assumed to be always 8 us for the time being (see note in
1679 // HePhy::GetTrainingDuration)
1680 txVector.SetMode(HePhy::GetHeMcs9());
1681 std::map<uint16_t, HeMuUserInfo> userInfoMap = {{1, {{HeRu::RU_106_TONE, 1, true}, 4, 2}},
1682 {2, {{HeRu::RU_106_TONE, 1, true}, 9, 1}}};
1683 sigAMode = HePhy::GetVhtMcs0();
1684 sigBMode = HePhy::GetVhtMcs4(); // because of first user info map
1685
1686 // -> HE SU format
1687 txVector.SetPreambleType(WIFI_PREAMBLE_HE_SU);
1688 sections = {
1689 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1690 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1691 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(24)}, // L-SIG + RL-SIG
1692 nonHtMode}},
1693 {WIFI_PPDU_FIELD_SIG_A,
1694 {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)}, sigAMode}},
1695 {WIFI_PPDU_FIELD_TRAINING,
1696 {{ppduStart + MicroSeconds(32),
1697 ppduStart + MicroSeconds(52)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1698 sigAMode}},
1699 };
1700 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1701
1702 // -> HE ER SU format
1703 txVector.SetPreambleType(WIFI_PREAMBLE_HE_ER_SU);
1704 sections[WIFI_PPDU_FIELD_SIG_A] = {
1705 {ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(40)}, // 16 us HE-SIG-A
1706 sigAMode};
1707 sections[WIFI_PPDU_FIELD_TRAINING] = {
1708 {ppduStart + MicroSeconds(40),
1709 ppduStart + MicroSeconds(60)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1710 sigAMode};
1711 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1712
1713 // -> HE TB format
1714 txVector.SetPreambleType(WIFI_PREAMBLE_HE_TB);
1715 txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
1716 txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
1717 sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1718 sigAMode};
1719 sections[WIFI_PPDU_FIELD_TRAINING] = {
1720 {ppduStart + MicroSeconds(32),
1721 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 8 us) + 2 HE-LTFs (@ 8 us)
1722 sigAMode};
1723 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1724
1725 // -> HE MU format
1726 txVector.SetPreambleType(WIFI_PREAMBLE_HE_MU);
1727 txVector.SetSigBMode(sigBMode);
1728 txVector.SetRuAllocation({96}, 0);
1729 sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1730 sigAMode};
1731 sections[WIFI_PPDU_FIELD_SIG_B] = {
1732 {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
1733 sigBMode};
1734 sections[WIFI_PPDU_FIELD_TRAINING] = {
1735 {ppduStart + MicroSeconds(36),
1736 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1737 sigBMode};
1738 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1739 txVector.SetChannelWidth(160); // shouldn't have any impact
1740 txVector.SetRuAllocation({96, 113, 113, 113, 113, 113, 113, 113}, 0);
1741
1742 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1743
1744 // ==================================================================================
1745 // 11be (EHT)
1746 sections.erase(WIFI_PPDU_FIELD_SIG_A); // FIXME: do we keep using separate type for 11be?
1747 sections.erase(WIFI_PPDU_FIELD_SIG_B); // FIXME: do we keep using separate type for 11be?
1748 phyEntity = Create<EhtPhy>();
1749 txVector.SetChannelWidth(20);
1750 txVector.SetNss(2); // EHT-LTF duration assumed to be always 8 us for the time being (see note
1751 // in HePhy::GetTrainingDuration)
1752 txVector.SetMode(EhtPhy::GetEhtMcs9());
1753 userInfoMap = {{1, {{HeRu::RU_106_TONE, 1, true}, 4, 2}},
1754 {2, {{HeRu::RU_106_TONE, 1, true}, 9, 1}}};
1755 WifiMode uSigMode = EhtPhy::GetVhtMcs0();
1756 WifiMode ehtSigMode = EhtPhy::GetVhtMcs4(); // because of first user info map
1757
1758 // -> EHT TB format
1759 txVector.SetPreambleType(WIFI_PREAMBLE_EHT_TB);
1760 txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
1761 txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
1762 sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1763 uSigMode};
1764 sections[WIFI_PPDU_FIELD_TRAINING] = {
1765 {ppduStart + MicroSeconds(32),
1766 ppduStart + MicroSeconds(56)}, // 1 EHT-STF (@ 8 us) + 2 EHT-LTFs (@ 8 us)
1767 uSigMode};
1768 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1769
1770 // -> EHT MU format
1771 txVector.SetPreambleType(WIFI_PREAMBLE_EHT_MU);
1772 txVector.SetEhtPpduType(0); // EHT MU transmission
1773 txVector.SetRuAllocation({96}, 0);
1774 sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1775 uSigMode};
1776 sections[WIFI_PPDU_FIELD_EHT_SIG] = {
1777 {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
1778 ehtSigMode};
1779 sections[WIFI_PPDU_FIELD_TRAINING] = {
1780 {ppduStart + MicroSeconds(36),
1781 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1782 ehtSigMode};
1783 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1784 txVector.SetChannelWidth(160); // shouldn't have any impact
1785 txVector.SetRuAllocation({96, 113, 113, 113, 113, 113, 113, 113}, 0);
1786
1787 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1788}
1789
1796class TxDurationTestSuite : public TestSuite
1797{
1798 public:
1799 TxDurationTestSuite();
1800};
1801
1802TxDurationTestSuite::TxDurationTestSuite()
1803 : TestSuite("wifi-devices-tx-duration", UNIT)
1804{
1805 AddTestCase(new TxDurationTest, TestCase::QUICK);
1806
1807 AddTestCase(new PhyHeaderSectionsTest, TestCase::QUICK);
1808
1809 // 20 MHz band, HeSigBDurationTest::OFDMA, even number of users per HE-SIG-B content channel
1810 AddTestCase(new HeSigBDurationTest(
1811 {{{HeRu::RU_106_TONE, 1, true}, 11, 1}, {{HeRu::RU_106_TONE, 2, true}, 10, 4}},
1812 VhtPhy::GetVhtMcs5(),
1813 20,
1814 HeSigBDurationTest::OFDMA,
1815 {96},
1816 std::make_pair(2, 0), // both users in HE-SIG-B content channel 1
1817 MicroSeconds(4)), // one OFDM symbol;
1818 TestCase::QUICK);
1819
1820 // 40 MHz band, HeSigBDurationTest::OFDMA, even number of users per HE-SIG-B content channel
1821 AddTestCase(
1822 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1823 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1824 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1825 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1826 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1827 {{HeRu::RU_52_TONE, 8, true}, 6, 2}},
1828 VhtPhy::GetVhtMcs4(),
1829 40,
1830 HeSigBDurationTest::OFDMA,
1831 {96, 112},
1832 std::make_pair(2, 4), // two users in HE-SIG-B content channel 1 and
1833 // four users in HE-SIG-B content channel 2
1834 MicroSeconds(4)), // one OFDM symbol;
1835 TestCase::QUICK);
1836
1837 // 40 MHz band, HeSigBDurationTest::OFDMA, odd number of users per HE-SIG-B content channel
1838 AddTestCase(
1839 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1840 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1841 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1842 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1843 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1844 {{HeRu::RU_52_TONE, 8, true}, 6, 2},
1845 {{HeRu::RU_26_TONE, 14, true}, 3, 1}},
1846 VhtPhy::GetVhtMcs3(),
1847 40,
1848 HeSigBDurationTest::OFDMA,
1849 {96, 15},
1850 std::make_pair(2, 5), // two users in HE-SIG-B content channel 1 and
1851 // five users in HE-SIG-B content channel 2
1852 MicroSeconds(8)), // two OFDM symbols
1853 TestCase::QUICK);
1854
1855 // 80 MHz band, OFDMA
1856 AddTestCase(
1857 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1858 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1859 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1860 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1861 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1862 {{HeRu::RU_52_TONE, 8, true}, 6, 2},
1863 {{HeRu::RU_26_TONE, 14, true}, 3, 1},
1864 {{HeRu::RU_242_TONE, 3, true}, 1, 1},
1865 {{HeRu::RU_242_TONE, 4, true}, 4, 1}},
1866 VhtPhy::GetVhtMcs1(),
1867 80,
1868 HeSigBDurationTest::OFDMA,
1869 {96, 15, 192, 192},
1870 std::make_pair(3, 6), // three users in HE-SIG-B content channel 1
1871 // and six users in HE-SIG-B content channel 2
1872 MicroSeconds(16)), // four OFDM symbols
1873 TestCase::QUICK);
1874
1875 // 160 MHz band, OFDMA
1876 AddTestCase(
1877 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1878 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1879 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1880 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1881 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1882 {{HeRu::RU_52_TONE, 8, true}, 6, 2},
1883 {{HeRu::RU_26_TONE, 14, true}, 3, 1},
1884 {{HeRu::RU_242_TONE, 3, true}, 1, 1},
1885 {{HeRu::RU_242_TONE, 4, true}, 4, 1},
1886 {{HeRu::RU_996_TONE, 1, false}, 1, 1}},
1887 VhtPhy::GetVhtMcs1(),
1888 160,
1889 HeSigBDurationTest::OFDMA,
1890 {96, 15, 192, 192, 208, 208, 208, 208},
1891 std::make_pair(4, 7), // four users in HE-SIG-B content channel 1 and
1892 // seven users in HE-SIG-B content channel 2
1893 MicroSeconds(20)), // five OFDM symbols
1894 TestCase::QUICK);
1895
1896 // 20 MHz band, HeSigBDurationTest::OFDMA, one unallocated RU at the middle
1897 AddTestCase(
1898 new HeSigBDurationTest({{{HeRu::RU_26_TONE, 1, true}, 11, 1},
1899 {{HeRu::RU_26_TONE, 2, true}, 11, 1},
1900 {{HeRu::RU_26_TONE, 3, true}, 11, 1},
1901 {{HeRu::RU_26_TONE, 4, true}, 11, 1},
1902 {{HeRu::RU_26_TONE, 6, true}, 11, 1},
1903 {{HeRu::RU_26_TONE, 7, true}, 11, 1},
1904 {{HeRu::RU_26_TONE, 8, true}, 11, 1},
1905 {{HeRu::RU_26_TONE, 9, true}, 11, 1}},
1906 VhtPhy::GetVhtMcs5(),
1907 20,
1908 HeSigBDurationTest::OFDMA,
1909 {0},
1910 std::make_pair(9, 0), // 9 users in HE-SIG-B content channel 1
1911 MicroSeconds(8)), // two OFDM symbols
1912 TestCase::QUICK);
1913
1914 // 40 MHz band, HeSigBDurationTest::OFDMA, unallocated RUs at the begin and at the end of the
1915 // first 20 MHz subband and in the middle of the second 20 MHz subband
1916 AddTestCase(
1917 new HeSigBDurationTest({{{HeRu::RU_52_TONE, 2, true}, 10, 1},
1918 {{HeRu::RU_52_TONE, 3, true}, 10, 2},
1919 {{HeRu::RU_52_TONE, 5, true}, 11, 1},
1920 {{HeRu::RU_52_TONE, 8, true}, 11, 2}},
1921 VhtPhy::GetVhtMcs5(),
1922 40,
1923 HeSigBDurationTest::OFDMA,
1924 {112, 112},
1925 std::make_pair(4, 4), // 4 users in both HE-SIG-B content channels
1926 MicroSeconds(4)), // two OFDM symbols
1927 TestCase::QUICK);
1928
1929 // 40 MHz band, HeSigBDurationTest::OFDMA, one unallocated RUs in the first 20 MHz subband and
1930 // two unallocated RUs in second 20 MHz subband
1931 AddTestCase(
1932 new HeSigBDurationTest({{{HeRu::RU_52_TONE, 1, true}, 10, 1},
1933 {{HeRu::RU_52_TONE, 2, true}, 10, 2},
1934 {{HeRu::RU_52_TONE, 3, true}, 11, 1},
1935 {{HeRu::RU_52_TONE, 5, true}, 11, 2},
1936 {{HeRu::RU_52_TONE, 6, true}, 11, 3}},
1937 VhtPhy::GetVhtMcs5(),
1938 40,
1939 HeSigBDurationTest::OFDMA,
1940 {112, 112},
1941 std::make_pair(4, 4), // 4 users in both HE-SIG-B content channels
1942 MicroSeconds(4)), // two OFDM symbols
1943 TestCase::QUICK);
1944
1945 // 20 MHz band, MU-MIMO, 2 users
1946 AddTestCase(new HeSigBDurationTest(
1947 {{{HeRu::RU_242_TONE, 1, true}, 11, 1}, {{HeRu::RU_242_TONE, 1, true}, 10, 4}},
1948 VhtPhy::GetVhtMcs5(),
1949 20,
1950 HeSigBDurationTest::MU_MIMO,
1951 {192},
1952 std::make_pair(2, 0), // both users in HE-SIG-B content channel 1
1953 MicroSeconds(4)), // one OFDM symbol
1954 TestCase::QUICK);
1955
1956 // 20 MHz band, MU-MIMO, 3 users
1957 AddTestCase(
1958 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 3},
1959 {{HeRu::RU_242_TONE, 1, true}, 5, 2},
1960 {{HeRu::RU_242_TONE, 1, true}, 6, 1}},
1961 VhtPhy::GetVhtMcs4(),
1962 20,
1963 HeSigBDurationTest::MU_MIMO,
1964 {192},
1965 std::make_pair(3, 0), // all users in HE-SIG-B content channel 1
1966 MicroSeconds(4)), // one OFDM symbol
1967 TestCase::QUICK);
1968
1969 // 20 MHz band, MU-MIMO, 4 users
1970 AddTestCase(
1971 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 1},
1972 {{HeRu::RU_242_TONE, 1, true}, 5, 2},
1973 {{HeRu::RU_242_TONE, 1, true}, 6, 3},
1974 {{HeRu::RU_242_TONE, 1, true}, 7, 2}},
1975 VhtPhy::GetVhtMcs4(),
1976 20,
1977 HeSigBDurationTest::MU_MIMO,
1978 {192},
1979 std::make_pair(4, 0), // all users in HE-SIG-B content channel 1
1980 MicroSeconds(4)), // one OFDM symbol
1981 TestCase::QUICK);
1982
1983 // 20 MHz band, MU-MIMO, 6 users
1984 AddTestCase(
1985 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 1},
1986 {{HeRu::RU_242_TONE, 1, true}, 5, 1},
1987 {{HeRu::RU_242_TONE, 1, true}, 6, 2},
1988 {{HeRu::RU_242_TONE, 1, true}, 7, 2},
1989 {{HeRu::RU_242_TONE, 1, true}, 8, 1},
1990 {{HeRu::RU_242_TONE, 1, true}, 9, 1}},
1991 VhtPhy::GetVhtMcs4(),
1992 20,
1993 HeSigBDurationTest::MU_MIMO,
1994 {192},
1995 std::make_pair(6, 0), // all users in HE-SIG-B content channel 1
1996 MicroSeconds(4)), // one OFDM symbol
1997 TestCase::QUICK);
1998
1999 // 20 MHz band, MU-MIMO, 8 users
2000 AddTestCase(
2001 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 1},
2002 {{HeRu::RU_242_TONE, 1, true}, 5, 1},
2003 {{HeRu::RU_242_TONE, 1, true}, 6, 1},
2004 {{HeRu::RU_242_TONE, 1, true}, 7, 1},
2005 {{HeRu::RU_242_TONE, 1, true}, 8, 1},
2006 {{HeRu::RU_242_TONE, 1, true}, 9, 1},
2007 {{HeRu::RU_242_TONE, 1, true}, 10, 1},
2008 {{HeRu::RU_242_TONE, 1, true}, 11, 1}},
2009 VhtPhy::GetVhtMcs4(),
2010 20,
2011 HeSigBDurationTest::MU_MIMO,
2012 {192},
2013 std::make_pair(8, 0), // all users in HE-SIG-B content channel 1
2014 MicroSeconds(8)), // two OFDM symbols
2015 TestCase::QUICK);
2016
2017 // 40 MHz band, MU-MIMO, 2 users
2018 AddTestCase(new HeSigBDurationTest(
2019 {{{HeRu::RU_484_TONE, 1, true}, 11, 1}, {{HeRu::RU_484_TONE, 1, true}, 10, 4}},
2020 VhtPhy::GetVhtMcs5(),
2021 40,
2022 HeSigBDurationTest::MU_MIMO,
2023 {200, 200},
2024 std::make_pair(1, 1), // users equally split between the two content channels
2025 MicroSeconds(4)), // one OFDM symbol
2026 TestCase::QUICK);
2027
2028 // 40 MHz band, MU-MIMO, 3 users
2029 AddTestCase(
2030 new HeSigBDurationTest(
2031 {{{HeRu::RU_484_TONE, 1, true}, 4, 3},
2032 {{HeRu::RU_484_TONE, 1, true}, 5, 2},
2033 {{HeRu::RU_484_TONE, 1, true}, 6, 1}},
2034 VhtPhy::GetVhtMcs4(),
2035 40,
2036 HeSigBDurationTest::MU_MIMO,
2037 {200, 200},
2038 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
2039 MicroSeconds(4)), // one OFDM symbol
2040 TestCase::QUICK);
2041
2042 // 40 MHz band, MU-MIMO, 4 users
2043 AddTestCase(new HeSigBDurationTest(
2044 {{{HeRu::RU_484_TONE, 1, true}, 4, 1},
2045 {{HeRu::RU_484_TONE, 1, true}, 5, 2},
2046 {{HeRu::RU_484_TONE, 1, true}, 6, 3},
2047 {{HeRu::RU_484_TONE, 1, true}, 7, 2}},
2048 VhtPhy::GetVhtMcs4(),
2049 40,
2050 HeSigBDurationTest::MU_MIMO,
2051 {200, 200},
2052 std::make_pair(2, 2), // users equally split between the two content channels
2053 MicroSeconds(4)), // one OFDM symbol
2054 TestCase::QUICK);
2055
2056 // 40 MHz band, MU-MIMO, 6 users
2057 AddTestCase(new HeSigBDurationTest(
2058 {{{HeRu::RU_484_TONE, 1, true}, 4, 1},
2059 {{HeRu::RU_484_TONE, 1, true}, 5, 1},
2060 {{HeRu::RU_484_TONE, 1, true}, 6, 2},
2061 {{HeRu::RU_484_TONE, 1, true}, 7, 2},
2062 {{HeRu::RU_484_TONE, 1, true}, 8, 1},
2063 {{HeRu::RU_484_TONE, 1, true}, 9, 1}},
2064 VhtPhy::GetVhtMcs4(),
2065 40,
2066 HeSigBDurationTest::MU_MIMO,
2067 {200, 200},
2068 std::make_pair(3, 3), // users equally split between the two content channels
2069 MicroSeconds(4)), // one OFDM symbol
2070 TestCase::QUICK);
2071
2072 // 40 MHz band, MU-MIMO, 8 users
2073 AddTestCase(new HeSigBDurationTest(
2074 {{{HeRu::RU_484_TONE, 1, true}, 4, 1},
2075 {{HeRu::RU_484_TONE, 1, true}, 5, 1},
2076 {{HeRu::RU_484_TONE, 1, true}, 6, 1},
2077 {{HeRu::RU_484_TONE, 1, true}, 7, 1},
2078 {{HeRu::RU_484_TONE, 1, true}, 8, 1},
2079 {{HeRu::RU_484_TONE, 1, true}, 9, 1},
2080 {{HeRu::RU_484_TONE, 1, true}, 10, 1},
2081 {{HeRu::RU_484_TONE, 1, true}, 11, 1}},
2082 VhtPhy::GetVhtMcs4(),
2083 40,
2084 HeSigBDurationTest::MU_MIMO,
2085 {200, 200},
2086 std::make_pair(4, 4), // users equally split between the two content channels
2087 MicroSeconds(4)), // one OFDM symbol
2088 TestCase::QUICK);
2089
2090 // 80 MHz band, MU-MIMO, 2 users
2091 AddTestCase(new HeSigBDurationTest(
2092 {{{HeRu::RU_996_TONE, 1, true}, 11, 1}, {{HeRu::RU_996_TONE, 1, true}, 10, 4}},
2093 VhtPhy::GetVhtMcs5(),
2094 80,
2095 HeSigBDurationTest::MU_MIMO,
2096 {208, 208, 208, 208},
2097 std::make_pair(1, 1), // users equally split between the two content channels
2098 MicroSeconds(4)), // one OFDM symbol
2099 TestCase::QUICK);
2100
2101 // 80 MHz band, MU-MIMO, 3 users
2102 AddTestCase(
2103 new HeSigBDurationTest(
2104 {{{HeRu::RU_996_TONE, 1, true}, 4, 3},
2105 {{HeRu::RU_996_TONE, 1, true}, 5, 2},
2106 {{HeRu::RU_996_TONE, 1, true}, 6, 1}},
2107 VhtPhy::GetVhtMcs4(),
2108 80,
2109 HeSigBDurationTest::MU_MIMO,
2110 {208, 208, 208, 208},
2111 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
2112 MicroSeconds(4)), // one OFDM symbol
2113 TestCase::QUICK);
2114
2115 // 80 MHz band, MU-MIMO, 4 users
2116 AddTestCase(new HeSigBDurationTest(
2117 {{{HeRu::RU_996_TONE, 1, true}, 4, 1},
2118 {{HeRu::RU_996_TONE, 1, true}, 5, 2},
2119 {{HeRu::RU_996_TONE, 1, true}, 6, 3},
2120 {{HeRu::RU_996_TONE, 1, true}, 7, 2}},
2121 VhtPhy::GetVhtMcs4(),
2122 80,
2123 HeSigBDurationTest::MU_MIMO,
2124 {208, 208, 208, 208},
2125 std::make_pair(2, 2), // users equally split between the two content channels
2126 MicroSeconds(4)), // one OFDM symbol
2127 TestCase::QUICK);
2128
2129 // 80 MHz band, MU-MIMO, 6 users
2130 AddTestCase(new HeSigBDurationTest(
2131 {{{HeRu::RU_996_TONE, 1, true}, 4, 1},
2132 {{HeRu::RU_996_TONE, 1, true}, 5, 1},
2133 {{HeRu::RU_996_TONE, 1, true}, 6, 2},
2134 {{HeRu::RU_996_TONE, 1, true}, 7, 2},
2135 {{HeRu::RU_996_TONE, 1, true}, 8, 1},
2136 {{HeRu::RU_996_TONE, 1, true}, 9, 1}},
2137 VhtPhy::GetVhtMcs4(),
2138 80,
2139 HeSigBDurationTest::MU_MIMO,
2140 {208, 208, 208, 208},
2141 std::make_pair(3, 3), // users equally split between the two content channels
2142 MicroSeconds(4)), // one OFDM symbol
2143 TestCase::QUICK);
2144
2145 // 80 MHz band, MU-MIMO, 8 users
2146 AddTestCase(new HeSigBDurationTest(
2147 {{{HeRu::RU_996_TONE, 1, true}, 4, 1},
2148 {{HeRu::RU_996_TONE, 1, true}, 5, 1},
2149 {{HeRu::RU_996_TONE, 1, true}, 6, 1},
2150 {{HeRu::RU_996_TONE, 1, true}, 7, 1},
2151 {{HeRu::RU_996_TONE, 1, true}, 8, 1},
2152 {{HeRu::RU_996_TONE, 1, true}, 9, 1},
2153 {{HeRu::RU_996_TONE, 1, true}, 10, 1},
2154 {{HeRu::RU_996_TONE, 1, true}, 11, 1}},
2155 VhtPhy::GetVhtMcs4(),
2156 80,
2157 HeSigBDurationTest::MU_MIMO,
2158 {208, 208, 208, 208},
2159 std::make_pair(4, 4), // users equally split between the two content channels
2160 MicroSeconds(4)), // one OFDM symbol
2161 TestCase::QUICK);
2162
2163 // 160 MHz band, MU-MIMO, 2 users
2164 AddTestCase(
2165 new HeSigBDurationTest(
2166 {{{HeRu::RU_2x996_TONE, 1, true}, 11, 1}, {{HeRu::RU_2x996_TONE, 1, true}, 10, 4}},
2167 VhtPhy::GetVhtMcs5(),
2168 160,
2169 HeSigBDurationTest::MU_MIMO,
2170 {208, 208, 208, 208, 208, 208, 208, 208},
2171 std::make_pair(1, 1), // users equally split between the two content channels
2172 MicroSeconds(4)), // one OFDM symbol
2173 TestCase::QUICK);
2174
2175 // 160 MHz band, MU-MIMO, 3 users
2176 AddTestCase(
2177 new HeSigBDurationTest(
2178 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 3},
2179 {{HeRu::RU_2x996_TONE, 1, true}, 5, 2},
2180 {{HeRu::RU_2x996_TONE, 1, true}, 6, 1}},
2181 VhtPhy::GetVhtMcs4(),
2182 160,
2183 HeSigBDurationTest::MU_MIMO,
2184 {208, 208, 208, 208, 208, 208, 208, 208},
2185 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
2186 MicroSeconds(4)), // one OFDM symbol
2187 TestCase::QUICK);
2188
2189 // 160 MHz band, MU-MIMO, 4 users
2190 AddTestCase(new HeSigBDurationTest(
2191 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 1},
2192 {{HeRu::RU_2x996_TONE, 1, true}, 5, 2},
2193 {{HeRu::RU_2x996_TONE, 1, true}, 6, 3},
2194 {{HeRu::RU_2x996_TONE, 1, true}, 7, 2}},
2195 VhtPhy::GetVhtMcs4(),
2196 160,
2197 HeSigBDurationTest::MU_MIMO,
2198 {208, 208, 208, 208, 208, 208, 208, 208},
2199 std::make_pair(2, 2), // users equally split between the two content channels
2200 MicroSeconds(4)), // one OFDM symbol
2201 TestCase::QUICK);
2202
2203 // 160 MHz band, MU-MIMO, 6 users
2204 AddTestCase(new HeSigBDurationTest(
2205 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 1},
2206 {{HeRu::RU_2x996_TONE, 1, true}, 5, 1},
2207 {{HeRu::RU_2x996_TONE, 1, true}, 6, 2},
2208 {{HeRu::RU_2x996_TONE, 1, true}, 7, 2},
2209 {{HeRu::RU_2x996_TONE, 1, true}, 8, 1},
2210 {{HeRu::RU_2x996_TONE, 1, true}, 9, 1}},
2211 VhtPhy::GetVhtMcs4(),
2212 160,
2213 HeSigBDurationTest::MU_MIMO,
2214 {208, 208, 208, 208, 208, 208, 208, 208},
2215 std::make_pair(3, 3), // users equally split between the two content channels
2216 MicroSeconds(4)), // one OFDM symbol
2217 TestCase::QUICK);
2218
2219 // 160 MHz band, MU-MIMO, 8 users
2220 AddTestCase(new HeSigBDurationTest(
2221 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 1},
2222 {{HeRu::RU_2x996_TONE, 1, true}, 5, 1},
2223 {{HeRu::RU_2x996_TONE, 1, true}, 6, 1},
2224 {{HeRu::RU_2x996_TONE, 1, true}, 7, 1},
2225 {{HeRu::RU_2x996_TONE, 1, true}, 8, 1},
2226 {{HeRu::RU_2x996_TONE, 1, true}, 9, 1},
2227 {{HeRu::RU_2x996_TONE, 1, true}, 10, 1},
2228 {{HeRu::RU_2x996_TONE, 1, true}, 11, 1}},
2229 VhtPhy::GetVhtMcs4(),
2230 160,
2231 HeSigBDurationTest::MU_MIMO,
2232 {208, 208, 208, 208, 208, 208, 208, 208},
2233 std::make_pair(4, 4), // users equally split between the two content channels
2234 MicroSeconds(4)), // one OFDM symbol
2235 TestCase::QUICK);
2236}
2237
2238static TxDurationTestSuite g_txDurationTestSuite;
HeSigBDurationTest
HE-SIG-B duration test.
Definition: tx-duration-test.cc:1305
HeSigBDurationTest::m_userInfos
std::list< HeMuUserInfo > m_userInfos
HE MU specific per-user information.
Definition: tx-duration-test.cc:1345
HeSigBDurationTest::MuType
MuType
OFDMA or MU-MIMO.
Definition: tx-duration-test.cc:1311
HeSigBDurationTest::m_expectedMuType
MuType m_expectedMuType
Expected MU type (OFDMA or MU-MIMO)
Definition: tx-duration-test.cc:1348
HeSigBDurationTest::HeSigBDurationTest
HeSigBDurationTest(const std::list< HeMuUserInfo > &userInfos, const WifiMode &sigBMode, uint16_t channelWidth, MuType expectedMuType, const RuAllocation &expectedRuAllocation, const std::pair< std::size_t, std::size_t > &expectedNumUsersPerCc, Time expectedSigBDuration)
Constructor.
Definition: tx-duration-test.cc:1355
HeSigBDurationTest::m_expectedRuAllocation
RuAllocation m_expectedRuAllocation
Expected RU_ALLOCATION.
Definition: tx-duration-test.cc:1349
HeSigBDurationTest::m_expectedSigBDuration
Time m_expectedSigBDuration
Expected duration of the HE-SIG-B header.
Definition: tx-duration-test.cc:1352
HeSigBDurationTest::m_sigBMode
WifiMode m_sigBMode
Mode used to transmit HE-SIG-B.
Definition: tx-duration-test.cc:1346
HeSigBDurationTest::BuildTxVector
WifiTxVector BuildTxVector() const
Build a TXVECTOR for HE MU.
Definition: tx-duration-test.cc:1375
HeSigBDurationTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:1396
HeSigBDurationTest::m_expectedNumUsersPerCc
std::pair< std::size_t, std::size_t > m_expectedNumUsersPerCc
Expected number of users per content channel.
Definition: tx-duration-test.cc:1351
HeSigBDurationTest::m_channelWidth
uint16_t m_channelWidth
Channel width in MHz.
Definition: tx-duration-test.cc:1347
PhyHeaderSectionsTest
PHY header sections consistency test.
Definition: tx-duration-test.cc:1444
PhyHeaderSectionsTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:1515
PhyHeaderSectionsTest::CheckPhyHeaderSections
void CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained, PhyEntity::PhyHeaderSections expected)
Check if map of PHY header sections returned by a given PHY entity corresponds to a known value.
Definition: tx-duration-test.cc:1472
TxDurationTest
Tx Duration Test.
Definition: tx-duration-test.cc:47
TxDurationTest::~TxDurationTest
~TxDurationTest() override
Definition: tx-duration-test.cc:139
TxDurationTest::CalculateTxDurationUsingList
static Time CalculateTxDurationUsingList(std::list< uint32_t > sizes, std::list< uint16_t > staIds, WifiTxVector txVector, WifiPhyBand band)
Calculate the overall Tx duration returned by WifiPhy for list of sizes.
Definition: tx-duration-test.cc:343
TxDurationTest::CheckMuTxDuration
static bool CheckMuTxDuration(std::list< uint32_t > sizes, std::list< HeMuUserInfo > userInfos, uint16_t channelWidth, uint16_t guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the overall Tx duration returned by WifiPhy for a MU PPDU corresponds to a known value.
Definition: tx-duration-test.cc:255
TxDurationTest::CheckTxDuration
bool CheckTxDuration(uint32_t size, WifiMode payloadMode, uint16_t channelWidth, uint16_t guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the overall tx duration returned by InterferenceHelper corresponds to a known value.
Definition: tx-duration-test.cc:196
TxDurationTest::CheckPayloadDuration
bool CheckPayloadDuration(uint32_t size, WifiMode payloadMode, uint16_t channelWidth, uint16_t guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the payload tx duration returned by InterferenceHelper corresponds to a known value.
Definition: tx-duration-test.cc:144
TxDurationTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:363
TxDurationTestSuite
Tx Duration Test Suite.
Definition: tx-duration-test.cc:1797
ns3::DsssPhy::GetDsssRate5_5Mbps
static WifiMode GetDsssRate5_5Mbps()
Return a WifiMode for HR/DSSS at 5.5 Mbps.
ns3::DsssPhy::GetDsssRate1Mbps
static WifiMode GetDsssRate1Mbps()
Return a WifiMode for DSSS at 1 Mbps.
ns3::DsssPhy::GetDsssRate11Mbps
static WifiMode GetDsssRate11Mbps()
Return a WifiMode for HR/DSSS at 11 Mbps.
ns3::DsssPhy::GetDsssRate2Mbps
static WifiMode GetDsssRate2Mbps()
Return a WifiMode for DSSS at 2 Mbps.
ns3::EhtPhy::GetEhtMcs9
static WifiMode GetEhtMcs9()
Return MCS 9 from EHT MCS values.
ns3::ErpOfdmPhy::GetErpOfdmRate
static WifiMode GetErpOfdmRate(uint64_t rate)
Return a WifiMode for ERP-OFDM corresponding to the provided rate.
Definition: erp-ofdm-phy.cc:134
ns3::ErpOfdmPhy::GetErpOfdmRate6Mbps
static WifiMode GetErpOfdmRate6Mbps()
Return a WifiMode for ERP-OFDM at 6 Mbps.
ns3::ErpOfdmPhy::GetErpOfdmRate54Mbps
static WifiMode GetErpOfdmRate54Mbps()
Return a WifiMode for ERP-OFDM at 54 Mbps.
ns3::HePhy::GetHeMcs9
static WifiMode GetHeMcs9()
Return MCS 9 from HE MCS values.
ns3::HePhy::GetHeMcs11
static WifiMode GetHeMcs11()
Return MCS 11 from HE MCS values.
ns3::HePhy::GetHeMcs0
static WifiMode GetHeMcs0()
Return MCS 0 from HE MCS values.
ns3::HePpdu::GetNumRusPerHeSigBContentChannel
static std::pair< std::size_t, std::size_t > GetNumRusPerHeSigBContentChannel(uint16_t channelWidth, const RuAllocation &ruAllocation, bool sigBCompression, uint8_t numMuMimoUsers)
Get the number of STAs per HE-SIG-B content channel.
Definition: he-ppdu.cc:486
ns3::HePpdu::GetHeSigBContentChannels
static HeSigBContentChannels GetHeSigBContentChannels(const WifiTxVector &txVector, uint8_t p20Index)
Get the HE SIG-B content channels for a given PPDU IEEE 802.11ax-2021 27.3.11.8.2 HE-SIG-B content ch...
Definition: he-ppdu.cc:554
ns3::HeRu::RuSpec::GetRuType
RuType GetRuType() const
Get the RU type.
Definition: he-ru.cc:454
ns3::HeRu::GetBandwidth
static uint16_t GetBandwidth(RuType ruType)
Get the approximate bandwidth occupied by a RU.
Definition: he-ru.cc:763
ns3::HeRu::RU_26_TONE
@ RU_26_TONE
Definition: he-ru.h:42
ns3::HeRu::RU_484_TONE
@ RU_484_TONE
Definition: he-ru.h:46
ns3::HeRu::RU_996_TONE
@ RU_996_TONE
Definition: he-ru.h:47
ns3::HeRu::RU_106_TONE
@ RU_106_TONE
Definition: he-ru.h:44
ns3::HeRu::RU_52_TONE
@ RU_52_TONE
Definition: he-ru.h:43
ns3::HeRu::RU_242_TONE
@ RU_242_TONE
Definition: he-ru.h:45
ns3::HeRu::RU_2x996_TONE
@ RU_2x996_TONE
Definition: he-ru.h:48
ns3::HtPhy::GetHtMcs0
static WifiMode GetHtMcs0()
Return MCS 0 from HT MCS values.
ns3::HtPhy::GetHtMcs6
static WifiMode GetHtMcs6()
Return MCS 6 from HT MCS values.
ns3::HtPhy::GetHtMcs7
static WifiMode GetHtMcs7()
Return MCS 7 from HT MCS values.
ns3::OfdmPhy::GetOfdmRate6Mbps
static WifiMode GetOfdmRate6Mbps()
Return a WifiMode for OFDM at 6 Mbps.
ns3::OfdmPhy::GetOfdmRate54Mbps
static WifiMode GetOfdmRate54Mbps()
Return a WifiMode for OFDM at 54 Mbps.
ns3::OfdmPhy::GetOfdmRate
static WifiMode GetOfdmRate(uint64_t rate, uint16_t bw=20)
Return a WifiMode for OFDM corresponding to the provided rate and the channel bandwidth (20,...
Definition: ofdm-phy.cc:411
ns3::PhyEntity::PhyHeaderSections
std::map< WifiPpduField, PhyHeaderChunkInfo > PhyHeaderSections
A map of PhyHeaderChunkInfo elements per PPDU field.
Definition: phy-entity.h:326
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:140
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:301
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::VhtPhy::GetVhtMcs0
static WifiMode GetVhtMcs0()
Return MCS 0 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs5
static WifiMode GetVhtMcs5()
Return MCS 5 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs3
static WifiMode GetVhtMcs3()
Return MCS 3 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs1
static WifiMode GetVhtMcs1()
Return MCS 1 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs4
static WifiMode GetVhtMcs4()
Return MCS 4 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs9
static WifiMode GetVhtMcs9()
Return MCS 9 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs8
static WifiMode GetVhtMcs8()
Return MCS 8 from VHT MCS values.
ns3::VhtPhy::GetVhtMcs7
static WifiMode GetVhtMcs7()
Return MCS 7 from VHT MCS values.
ns3::WifiMacHeader
Implements the IEEE 802.11 MAC header.
Definition: wifi-mac-header.h:98
ns3::WifiMacHeader::GetSerializedSize
uint32_t GetSerializedSize() const override
Definition: wifi-mac-header.cc:1231
ns3::WifiMacHeader::SetType
virtual void SetType(WifiMacType type, bool resetToDsFromDs=true)
Set Type/Subtype values with the correct values depending on the given type.
Definition: wifi-mac-header.cc:135
ns3::WifiMode
represent a single transmission mode
Definition: wifi-mode.h:51
ns3::WifiMode::GetModulationClass
WifiModulationClass GetModulationClass() const
Definition: wifi-mode.cc:185
ns3::WifiMode::GetDataRate
uint64_t GetDataRate(uint16_t channelWidth, uint16_t guardInterval, uint8_t nss) const
Definition: wifi-mode.cc:122
ns3::WifiPhy::CalculateTxDuration
static Time CalculateTxDuration(uint32_t size, const WifiTxVector &txVector, WifiPhyBand band, uint16_t staId=SU_STA_ID)
Definition: wifi-phy.cc:1496
ns3::WifiPhy::GetStaticPhyEntity
static const Ptr< const PhyEntity > GetStaticPhyEntity(WifiModulationClass modulation)
Get the implemented PHY entity corresponding to the modulation class.
Definition: wifi-phy.cc:704
ns3::WifiTxVector
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
Definition: wifi-tx-vector.h:110
ns3::WifiTxVector::SetRuAllocation
void SetRuAllocation(const RuAllocation &ruAlloc, uint8_t p20Index)
Set RU_ALLOCATION field.
Definition: wifi-tx-vector.cc:421
ns3::WifiTxVector::SetStbc
void SetStbc(bool stbc)
Sets if STBC is being used.
Definition: wifi-tx-vector.cc:361
ns3::WifiTxVector::SetNess
void SetNess(uint8_t ness)
Sets the Ness number.
Definition: wifi-tx-vector.cc:349
ns3::WifiTxVector::SetEhtPpduType
void SetEhtPpduType(uint8_t type)
Set the EHT_PPDU_TYPE parameter.
Definition: wifi-tx-vector.cc:441
ns3::WifiTxVector::SetChannelWidth
void SetChannelWidth(uint16_t channelWidth)
Sets the selected channelWidth (in MHz)
Definition: wifi-tx-vector.cc:317
ns3::WifiTxVector::SetGuardInterval
void SetGuardInterval(uint16_t guardInterval)
Sets the guard interval duration (in nanoseconds)
Definition: wifi-tx-vector.cc:323
ns3::WifiTxVector::GetMode
WifiMode GetMode(uint16_t staId=SU_STA_ID) const
If this TX vector is associated with an SU PPDU, return the selected payload transmission mode.
Definition: wifi-tx-vector.cc:138
ns3::WifiTxVector::SetHeMuUserInfo
void SetHeMuUserInfo(uint16_t staId, HeMuUserInfo userInfo)
Set the HE MU user-specific transmission information for the given STA-ID.
Definition: wifi-tx-vector.cc:630
ns3::WifiTxVector::IsDlOfdma
bool IsDlOfdma() const
Return true if this TX vector is used for a downlink multi-user transmission using OFDMA.
Definition: wifi-tx-vector.cc:547
ns3::WifiTxVector::GetNss
uint8_t GetNss(uint16_t staId=SU_STA_ID) const
If this TX vector is associated with an SU PPDU, return the number of spatial streams.
Definition: wifi-tx-vector.cc:208
ns3::WifiTxVector::SetSigBMode
void SetSigBMode(const WifiMode &mode)
Set the MCS used for SIG-B.
Definition: wifi-tx-vector.cc:409
ns3::WifiTxVector::IsDlMuMimo
bool IsDlMuMimo() const
Return true if this TX vector is used for a downlink multi-user transmission using MU-MIMO.
Definition: wifi-tx-vector.cc:574
ns3::WifiTxVector::SetMode
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
Definition: wifi-tx-vector.cc:289
ns3::WifiTxVector::SetNss
void SetNss(uint8_t nss)
Sets the number of Nss.
Definition: wifi-tx-vector.cc:335
ns3::WifiTxVector::SetPreambleType
void SetPreambleType(WifiPreamble preamble)
Sets the preamble type.
Definition: wifi-tx-vector.cc:311
uint32_t
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:86
NS_ABORT_MSG_IF
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
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::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1349
ns3::NanoSeconds
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1361
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1325
ns3::WifiPreamble
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-phy-common.h:169
ns3::WifiPhyBand
WifiPhyBand
Identifies the PHY band.
Definition: wifi-phy-band.h:33
ns3::WifiPpduField
WifiPpduField
The type of PPDU field (grouped for convenience)
Definition: wifi-phy-common.h:304
ns3::WIFI_PREAMBLE_LONG
@ WIFI_PREAMBLE_LONG
Definition: wifi-phy-common.h:170
ns3::WIFI_PREAMBLE_EHT_TB
@ WIFI_PREAMBLE_EHT_TB
Definition: wifi-phy-common.h:183
ns3::WIFI_PREAMBLE_HE_ER_SU
@ WIFI_PREAMBLE_HE_ER_SU
Definition: wifi-phy-common.h:179
ns3::WIFI_PREAMBLE_HE_TB
@ WIFI_PREAMBLE_HE_TB
Definition: wifi-phy-common.h:181
ns3::WIFI_PREAMBLE_EHT_MU
@ WIFI_PREAMBLE_EHT_MU
Definition: wifi-phy-common.h:182
ns3::WIFI_PREAMBLE_HE_MU
@ WIFI_PREAMBLE_HE_MU
Definition: wifi-phy-common.h:180
ns3::WIFI_PREAMBLE_HE_SU
@ WIFI_PREAMBLE_HE_SU
Definition: wifi-phy-common.h:178
ns3::WIFI_PREAMBLE_VHT_MU
@ WIFI_PREAMBLE_VHT_MU
Definition: wifi-phy-common.h:174
ns3::WIFI_PREAMBLE_VHT_SU
@ WIFI_PREAMBLE_VHT_SU
Definition: wifi-phy-common.h:173
ns3::WIFI_PREAMBLE_SHORT
@ WIFI_PREAMBLE_SHORT
Definition: wifi-phy-common.h:171
ns3::WIFI_PREAMBLE_HT_MF
@ WIFI_PREAMBLE_HT_MF
Definition: wifi-phy-common.h:172
ns3::WIFI_PHY_BAND_6GHZ
@ WIFI_PHY_BAND_6GHZ
The 6 GHz band.
Definition: wifi-phy-band.h:39
ns3::WIFI_PHY_BAND_2_4GHZ
@ WIFI_PHY_BAND_2_4GHZ
The 2.4 GHz band.
Definition: wifi-phy-band.h:35
ns3::WIFI_PHY_BAND_5GHZ
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
Definition: wifi-phy-band.h:37
ns3::WIFI_MOD_CLASS_OFDM
@ WIFI_MOD_CLASS_OFDM
OFDM (Clause 17)
Definition: wifi-phy-common.h:246
ns3::WIFI_MOD_CLASS_VHT
@ WIFI_MOD_CLASS_VHT
VHT (Clause 22)
Definition: wifi-phy-common.h:248
ns3::WIFI_MOD_CLASS_HE
@ WIFI_MOD_CLASS_HE
HE (Clause 27)
Definition: wifi-phy-common.h:253
ns3::OFDM_PHY_10_MHZ
@ OFDM_PHY_10_MHZ
Definition: ofdm-phy.h:46
ns3::OFDM_PHY_DEFAULT
@ OFDM_PHY_DEFAULT
Definition: ofdm-phy.h:45
ns3::OFDM_PHY_5_MHZ
@ OFDM_PHY_5_MHZ
Definition: ofdm-phy.h:47
ns3::WIFI_PPDU_FIELD_SIG_B
@ WIFI_PPDU_FIELD_SIG_B
SIG-B field.
Definition: wifi-phy-common.h:322
ns3::WIFI_PPDU_FIELD_TRAINING
@ WIFI_PPDU_FIELD_TRAINING
STF + LTF fields (excluding those in preamble for HT-GF)
Definition: wifi-phy-common.h:320
ns3::WIFI_PPDU_FIELD_NON_HT_HEADER
@ WIFI_PPDU_FIELD_NON_HT_HEADER
PHY header field for DSSS or ERP, short PHY header field for HR/DSSS or ERP, field not present for HT...
Definition: wifi-phy-common.h:318
ns3::WIFI_PPDU_FIELD_EHT_SIG
@ WIFI_PPDU_FIELD_EHT_SIG
EHT-SIG field.
Definition: wifi-phy-common.h:324
ns3::WIFI_PPDU_FIELD_HT_SIG
@ WIFI_PPDU_FIELD_HT_SIG
HT-SIG field.
Definition: wifi-phy-common.h:319
ns3::WIFI_PPDU_FIELD_PREAMBLE
@ WIFI_PPDU_FIELD_PREAMBLE
SYNC + SFD fields for DSSS or ERP, shortSYNC + shortSFD fields for HR/DSSS or ERP,...
Definition: wifi-phy-common.h:311
ns3::WIFI_PPDU_FIELD_U_SIG
@ WIFI_PPDU_FIELD_U_SIG
U-SIG field.
Definition: wifi-phy-common.h:323
ns3::WIFI_PPDU_FIELD_SIG_A
@ WIFI_PPDU_FIELD_SIG_A
SIG-A field.
Definition: wifi-phy-common.h:321
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::WifiConstPsduMap
std::unordered_map< uint16_t, Ptr< const WifiPsdu > > WifiConstPsduMap
Map of const PSDUs indexed by STA-ID.
Definition: he-frame-exchange-manager.h:45
ns3::IsEht
bool IsEht(WifiPreamble preamble)
Return true if a preamble corresponds to an EHT transmission.
Definition: wifi-phy-common.cc:272
ns3::WIFI_MAC_CTL_ACK
@ WIFI_MAC_CTL_ACK
Definition: wifi-mac-header.h:43
ns3::RuAllocation
std::vector< uint8_t > RuAllocation
8 bit RU_ALLOCATION per 20 MHz
Definition: wifi-tx-vector.h:64
ns3::SU_STA_ID
static constexpr uint16_t SU_STA_ID
STA_ID to identify a single user (SU)
Definition: wifi-mode.h:35
ns3::HeMuUserInfo
HE MU specific user transmission parameters.
Definition: wifi-tx-vector.h:42
ns3::HeMuUserInfo::ru
HeRu::RuSpec ru
RU specification.
Definition: wifi-tx-vector.h:43
g_txDurationTestSuite
static TxDurationTestSuite g_txDurationTestSuite
the test suite
Definition: tx-duration-test.cc:2238