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
595 // https://web.archive.org/web/20100711002639/http://mailman.isi.edu/pipermail/ns-developers/2009-July/006226.html
596 retval = retval && CheckTxDuration(14,
597 DsssPhy::GetDsssRate1Mbps(),
598 22,
599 800,
600 WIFI_PREAMBLE_LONG,
601 MicroSeconds(304));
602
603 // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
604 retval = retval &&
605 CheckTxDuration(1536,
606 DsssPhy::GetDsssRate11Mbps(),
607 22,
608 800,
609 WIFI_PREAMBLE_LONG,
610 MicroSeconds(1310)) &&
611 CheckTxDuration(76,
612 DsssPhy::GetDsssRate11Mbps(),
613 22,
614 800,
615 WIFI_PREAMBLE_LONG,
616 MicroSeconds(248)) &&
617 CheckTxDuration(14,
618 DsssPhy::GetDsssRate11Mbps(),
619 22,
620 800,
621 WIFI_PREAMBLE_LONG,
622 MicroSeconds(203));
623
624 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11b duration failed");
625
626 // 802.11a durations
627 // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
628 retval = retval &&
629 CheckTxDuration(1536,
630 OfdmPhy::GetOfdmRate54Mbps(),
631 20,
632 800,
633 WIFI_PREAMBLE_LONG,
634 MicroSeconds(248)) &&
635 CheckTxDuration(76,
636 OfdmPhy::GetOfdmRate54Mbps(),
637 20,
638 800,
639 WIFI_PREAMBLE_LONG,
640 MicroSeconds(32)) &&
641 CheckTxDuration(14,
642 OfdmPhy::GetOfdmRate54Mbps(),
643 20,
644 800,
645 WIFI_PREAMBLE_LONG,
646 MicroSeconds(24));
647
648 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11a duration failed");
649
650 // 802.11g durations are same as 802.11a durations but with 6 us signal extension
651 retval = retval &&
652 CheckTxDuration(1536,
653 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
654 20,
655 800,
656 WIFI_PREAMBLE_LONG,
657 MicroSeconds(254)) &&
658 CheckTxDuration(76,
659 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
660 20,
661 800,
662 WIFI_PREAMBLE_LONG,
663 MicroSeconds(38)) &&
664 CheckTxDuration(14,
665 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
666 20,
667 800,
668 WIFI_PREAMBLE_LONG,
669 MicroSeconds(30));
670
671 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11g duration failed");
672
673 // 802.11n durations
674 retval =
675 retval &&
676 CheckTxDuration(1536,
677 HtPhy::GetHtMcs7(),
678 20,
679 800,
680 WIFI_PREAMBLE_HT_MF,
681 MicroSeconds(228)) &&
682 CheckTxDuration(76, HtPhy::GetHtMcs7(), 20, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(48)) &&
683 CheckTxDuration(14, HtPhy::GetHtMcs7(), 20, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(40)) &&
684 CheckTxDuration(1536,
685 HtPhy::GetHtMcs0(),
686 20,
687 400,
688 WIFI_PREAMBLE_HT_MF,
689 NanoSeconds(1742400)) &&
690 CheckTxDuration(76, HtPhy::GetHtMcs0(), 20, 400, WIFI_PREAMBLE_HT_MF, MicroSeconds(126)) &&
691 CheckTxDuration(14, HtPhy::GetHtMcs0(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(57600)) &&
692 CheckTxDuration(1536,
693 HtPhy::GetHtMcs6(),
694 20,
695 400,
696 WIFI_PREAMBLE_HT_MF,
697 NanoSeconds(226800)) &&
698 CheckTxDuration(76, HtPhy::GetHtMcs6(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(46800)) &&
699 CheckTxDuration(14, HtPhy::GetHtMcs6(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(39600)) &&
700 CheckTxDuration(1536,
701 HtPhy::GetHtMcs7(),
702 40,
703 800,
704 WIFI_PREAMBLE_HT_MF,
705 MicroSeconds(128)) &&
706 CheckTxDuration(76, HtPhy::GetHtMcs7(), 40, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(44)) &&
707 CheckTxDuration(14, HtPhy::GetHtMcs7(), 40, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(40)) &&
708 CheckTxDuration(1536,
709 HtPhy::GetHtMcs7(),
710 40,
711 400,
712 WIFI_PREAMBLE_HT_MF,
713 NanoSeconds(118800)) &&
714 CheckTxDuration(76, HtPhy::GetHtMcs7(), 40, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(43200)) &&
715 CheckTxDuration(14, HtPhy::GetHtMcs7(), 40, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(39600));
716
717 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11n duration failed");
718
719 // 802.11ac durations
720 retval = retval &&
721 CheckTxDuration(1536,
722 VhtPhy::GetVhtMcs8(),
723 20,
724 800,
725 WIFI_PREAMBLE_VHT_SU,
726 MicroSeconds(196)) &&
727 CheckTxDuration(76,
728 VhtPhy::GetVhtMcs8(),
729 20,
730 800,
731 WIFI_PREAMBLE_VHT_SU,
732 MicroSeconds(48)) &&
733 CheckTxDuration(14,
734 VhtPhy::GetVhtMcs8(),
735 20,
736 800,
737 WIFI_PREAMBLE_VHT_SU,
738 MicroSeconds(40)) &&
739 CheckTxDuration(1536,
740 VhtPhy::GetVhtMcs8(),
741 20,
742 400,
743 WIFI_PREAMBLE_VHT_SU,
744 MicroSeconds(180)) &&
745 CheckTxDuration(76,
746 VhtPhy::GetVhtMcs8(),
747 20,
748 400,
749 WIFI_PREAMBLE_VHT_SU,
750 NanoSeconds(46800)) &&
751 CheckTxDuration(14,
752 VhtPhy::GetVhtMcs8(),
753 20,
754 400,
755 WIFI_PREAMBLE_VHT_SU,
756 NanoSeconds(39600)) &&
757 CheckTxDuration(1536,
758 VhtPhy::GetVhtMcs9(),
759 40,
760 800,
761 WIFI_PREAMBLE_VHT_SU,
762 MicroSeconds(108)) &&
763 CheckTxDuration(76,
764 VhtPhy::GetVhtMcs9(),
765 40,
766 800,
767 WIFI_PREAMBLE_VHT_SU,
768 MicroSeconds(40)) &&
769 CheckTxDuration(14,
770 VhtPhy::GetVhtMcs9(),
771 40,
772 800,
773 WIFI_PREAMBLE_VHT_SU,
774 MicroSeconds(40)) &&
775 CheckTxDuration(1536,
776 VhtPhy::GetVhtMcs9(),
777 40,
778 400,
779 WIFI_PREAMBLE_VHT_SU,
780 NanoSeconds(100800)) &&
781 CheckTxDuration(76,
782 VhtPhy::GetVhtMcs9(),
783 40,
784 400,
785 WIFI_PREAMBLE_VHT_SU,
786 NanoSeconds(39600)) &&
787 CheckTxDuration(14,
788 VhtPhy::GetVhtMcs9(),
789 40,
790 400,
791 WIFI_PREAMBLE_VHT_SU,
792 NanoSeconds(39600)) &&
793 CheckTxDuration(1536,
794 VhtPhy::GetVhtMcs0(),
795 80,
796 800,
797 WIFI_PREAMBLE_VHT_SU,
798 MicroSeconds(460)) &&
799 CheckTxDuration(76,
800 VhtPhy::GetVhtMcs0(),
801 80,
802 800,
803 WIFI_PREAMBLE_VHT_SU,
804 MicroSeconds(60)) &&
805 CheckTxDuration(14,
806 VhtPhy::GetVhtMcs0(),
807 80,
808 800,
809 WIFI_PREAMBLE_VHT_SU,
810 MicroSeconds(44)) &&
811 CheckTxDuration(1536,
812 VhtPhy::GetVhtMcs0(),
813 80,
814 400,
815 WIFI_PREAMBLE_VHT_SU,
816 NanoSeconds(417600)) &&
817 CheckTxDuration(76,
818 VhtPhy::GetVhtMcs0(),
819 80,
820 400,
821 WIFI_PREAMBLE_VHT_SU,
822 NanoSeconds(57600)) &&
823 CheckTxDuration(14,
824 VhtPhy::GetVhtMcs0(),
825 80,
826 400,
827 WIFI_PREAMBLE_VHT_SU,
828 NanoSeconds(43200)) &&
829 CheckTxDuration(1536,
830 VhtPhy::GetVhtMcs9(),
831 80,
832 800,
833 WIFI_PREAMBLE_VHT_SU,
834 MicroSeconds(68)) &&
835 CheckTxDuration(76,
836 VhtPhy::GetVhtMcs9(),
837 80,
838 800,
839 WIFI_PREAMBLE_VHT_SU,
840 MicroSeconds(40)) &&
841 CheckTxDuration(14,
842 VhtPhy::GetVhtMcs9(),
843 80,
844 800,
845 WIFI_PREAMBLE_VHT_SU,
846 MicroSeconds(40)) &&
847 CheckTxDuration(1536,
848 VhtPhy::GetVhtMcs9(),
849 80,
850 400,
851 WIFI_PREAMBLE_VHT_SU,
852 NanoSeconds(64800)) &&
853 CheckTxDuration(76,
854 VhtPhy::GetVhtMcs9(),
855 80,
856 400,
857 WIFI_PREAMBLE_VHT_SU,
858 NanoSeconds(39600)) &&
859 CheckTxDuration(14,
860 VhtPhy::GetVhtMcs9(),
861 80,
862 400,
863 WIFI_PREAMBLE_VHT_SU,
864 NanoSeconds(39600)) &&
865 CheckTxDuration(1536,
866 VhtPhy::GetVhtMcs8(),
867 160,
868 800,
869 WIFI_PREAMBLE_VHT_SU,
870 MicroSeconds(56)) &&
871 CheckTxDuration(76,
872 VhtPhy::GetVhtMcs8(),
873 160,
874 800,
875 WIFI_PREAMBLE_VHT_SU,
876 MicroSeconds(40)) &&
877 CheckTxDuration(14,
878 VhtPhy::GetVhtMcs8(),
879 160,
880 800,
881 WIFI_PREAMBLE_VHT_SU,
882 MicroSeconds(40)) &&
883 CheckTxDuration(1536,
884 VhtPhy::GetVhtMcs8(),
885 160,
886 400,
887 WIFI_PREAMBLE_VHT_SU,
888 MicroSeconds(54)) &&
889 CheckTxDuration(76,
890 VhtPhy::GetVhtMcs8(),
891 160,
892 400,
893 WIFI_PREAMBLE_VHT_SU,
894 NanoSeconds(39600)) &&
895 CheckTxDuration(14,
896 VhtPhy::GetVhtMcs8(),
897 160,
898 400,
899 WIFI_PREAMBLE_VHT_SU,
900 NanoSeconds(39600));
901
902 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ac duration failed");
903
904 // 802.11ax SU durations
905 retval =
906 retval &&
907 CheckTxDuration(1536,
908 HePhy::GetHeMcs0(),
909 20,
910 800,
911 WIFI_PREAMBLE_HE_SU,
912 NanoSeconds(1485600)) &&
913 CheckTxDuration(76,
914 HePhy::GetHeMcs0(),
915 20,
916 800,
917 WIFI_PREAMBLE_HE_SU,
918 NanoSeconds(125600)) &&
919 CheckTxDuration(14, HePhy::GetHeMcs0(), 20, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(71200)) &&
920 CheckTxDuration(1536,
921 HePhy::GetHeMcs0(),
922 40,
923 800,
924 WIFI_PREAMBLE_HE_SU,
925 NanoSeconds(764800)) &&
926 CheckTxDuration(76, HePhy::GetHeMcs0(), 40, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(84800)) &&
927 CheckTxDuration(14, HePhy::GetHeMcs0(), 40, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(57600)) &&
928 CheckTxDuration(1536,
929 HePhy::GetHeMcs0(),
930 80,
931 800,
932 WIFI_PREAMBLE_HE_SU,
933 NanoSeconds(397600)) &&
934 CheckTxDuration(76, HePhy::GetHeMcs0(), 80, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(71200)) &&
935 CheckTxDuration(14, HePhy::GetHeMcs0(), 80, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(57600)) &&
936 CheckTxDuration(1536,
937 HePhy::GetHeMcs0(),
938 160,
939 800,
940 WIFI_PREAMBLE_HE_SU,
941 NanoSeconds(220800)) &&
942 CheckTxDuration(76,
943 HePhy::GetHeMcs0(),
944 160,
945 800,
946 WIFI_PREAMBLE_HE_SU,
947 NanoSeconds(57600)) &&
948 CheckTxDuration(14,
949 HePhy::GetHeMcs0(),
950 160,
951 800,
952 WIFI_PREAMBLE_HE_SU,
953 NanoSeconds(57600)) &&
954 CheckTxDuration(1536,
955 HePhy::GetHeMcs0(),
956 20,
957 1600,
958 WIFI_PREAMBLE_HE_SU,
959 NanoSeconds(1570400)) &&
960 CheckTxDuration(76,
961 HePhy::GetHeMcs0(),
962 20,
963 1600,
964 WIFI_PREAMBLE_HE_SU,
965 NanoSeconds(130400)) &&
966 CheckTxDuration(14,
967 HePhy::GetHeMcs0(),
968 20,
969 1600,
970 WIFI_PREAMBLE_HE_SU,
971 NanoSeconds(72800)) &&
972 CheckTxDuration(1536,
973 HePhy::GetHeMcs0(),
974 40,
975 1600,
976 WIFI_PREAMBLE_HE_SU,
977 NanoSeconds(807200)) &&
978 CheckTxDuration(76,
979 HePhy::GetHeMcs0(),
980 40,
981 1600,
982 WIFI_PREAMBLE_HE_SU,
983 NanoSeconds(87200)) &&
984 CheckTxDuration(14,
985 HePhy::GetHeMcs0(),
986 40,
987 1600,
988 WIFI_PREAMBLE_HE_SU,
989 NanoSeconds(58400)) &&
990 CheckTxDuration(1536,
991 HePhy::GetHeMcs0(),
992 80,
993 1600,
994 WIFI_PREAMBLE_HE_SU,
995 NanoSeconds(418400)) &&
996 CheckTxDuration(76,
997 HePhy::GetHeMcs0(),
998 80,
999 1600,
1000 WIFI_PREAMBLE_HE_SU,
1001 NanoSeconds(72800)) &&
1002 CheckTxDuration(14,
1003 HePhy::GetHeMcs0(),
1004 80,
1005 1600,
1006 WIFI_PREAMBLE_HE_SU,
1007 NanoSeconds(58400)) &&
1008 CheckTxDuration(1536,
1009 HePhy::GetHeMcs0(),
1010 160,
1011 1600,
1012 WIFI_PREAMBLE_HE_SU,
1013 NanoSeconds(231200)) &&
1014 CheckTxDuration(76,
1015 HePhy::GetHeMcs0(),
1016 160,
1017 1600,
1018 WIFI_PREAMBLE_HE_SU,
1019 NanoSeconds(58400)) &&
1020 CheckTxDuration(14,
1021 HePhy::GetHeMcs0(),
1022 160,
1023 1600,
1024 WIFI_PREAMBLE_HE_SU,
1025 NanoSeconds(58400)) &&
1026 CheckTxDuration(1536,
1027 HePhy::GetHeMcs0(),
1028 20,
1029 3200,
1030 WIFI_PREAMBLE_HE_SU,
1031 MicroSeconds(1740)) &&
1032 CheckTxDuration(76, HePhy::GetHeMcs0(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(140)) &&
1033 CheckTxDuration(14, HePhy::GetHeMcs0(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(76)) &&
1034 CheckTxDuration(1536,
1035 HePhy::GetHeMcs0(),
1036 40,
1037 3200,
1038 WIFI_PREAMBLE_HE_SU,
1039 MicroSeconds(892)) &&
1040 CheckTxDuration(76, HePhy::GetHeMcs0(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(92)) &&
1041 CheckTxDuration(14, HePhy::GetHeMcs0(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1042 CheckTxDuration(1536,
1043 HePhy::GetHeMcs0(),
1044 80,
1045 3200,
1046 WIFI_PREAMBLE_HE_SU,
1047 MicroSeconds(460)) &&
1048 CheckTxDuration(76, HePhy::GetHeMcs0(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(76)) &&
1049 CheckTxDuration(14, HePhy::GetHeMcs0(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1050 CheckTxDuration(1536,
1051 HePhy::GetHeMcs0(),
1052 160,
1053 3200,
1054 WIFI_PREAMBLE_HE_SU,
1055 MicroSeconds(252)) &&
1056 CheckTxDuration(76, HePhy::GetHeMcs0(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1057 CheckTxDuration(14, HePhy::GetHeMcs0(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1058 CheckTxDuration(1536,
1059 HePhy::GetHeMcs11(),
1060 20,
1061 800,
1062 WIFI_PREAMBLE_HE_SU,
1063 NanoSeconds(139200)) &&
1064 CheckTxDuration(76,
1065 HePhy::GetHeMcs11(),
1066 20,
1067 800,
1068 WIFI_PREAMBLE_HE_SU,
1069 NanoSeconds(57600)) &&
1070 CheckTxDuration(14,
1071 HePhy::GetHeMcs11(),
1072 20,
1073 800,
1074 WIFI_PREAMBLE_HE_SU,
1075 NanoSeconds(57600)) &&
1076 CheckTxDuration(1536,
1077 HePhy::GetHeMcs11(),
1078 40,
1079 800,
1080 WIFI_PREAMBLE_HE_SU,
1081 NanoSeconds(98400)) &&
1082 CheckTxDuration(76,
1083 HePhy::GetHeMcs11(),
1084 40,
1085 800,
1086 WIFI_PREAMBLE_HE_SU,
1087 NanoSeconds(57600)) &&
1088 CheckTxDuration(14,
1089 HePhy::GetHeMcs11(),
1090 40,
1091 800,
1092 WIFI_PREAMBLE_HE_SU,
1093 NanoSeconds(57600)) &&
1094 CheckTxDuration(1536,
1095 HePhy::GetHeMcs11(),
1096 80,
1097 800,
1098 WIFI_PREAMBLE_HE_SU,
1099 NanoSeconds(71200)) &&
1100 CheckTxDuration(76,
1101 HePhy::GetHeMcs11(),
1102 80,
1103 800,
1104 WIFI_PREAMBLE_HE_SU,
1105 NanoSeconds(57600)) &&
1106 CheckTxDuration(14,
1107 HePhy::GetHeMcs11(),
1108 80,
1109 800,
1110 WIFI_PREAMBLE_HE_SU,
1111 NanoSeconds(57600)) &&
1112 CheckTxDuration(1536,
1113 HePhy::GetHeMcs11(),
1114 160,
1115 800,
1116 WIFI_PREAMBLE_HE_SU,
1117 NanoSeconds(57600)) &&
1118 CheckTxDuration(76,
1119 HePhy::GetHeMcs11(),
1120 160,
1121 800,
1122 WIFI_PREAMBLE_HE_SU,
1123 NanoSeconds(57600)) &&
1124 CheckTxDuration(14,
1125 HePhy::GetHeMcs11(),
1126 160,
1127 800,
1128 WIFI_PREAMBLE_HE_SU,
1129 NanoSeconds(57600)) &&
1130 CheckTxDuration(1536,
1131 HePhy::GetHeMcs11(),
1132 20,
1133 1600,
1134 WIFI_PREAMBLE_HE_SU,
1135 NanoSeconds(144800)) &&
1136 CheckTxDuration(76,
1137 HePhy::GetHeMcs11(),
1138 20,
1139 1600,
1140 WIFI_PREAMBLE_HE_SU,
1141 NanoSeconds(58400)) &&
1142 CheckTxDuration(14,
1143 HePhy::GetHeMcs11(),
1144 20,
1145 1600,
1146 WIFI_PREAMBLE_HE_SU,
1147 NanoSeconds(58400)) &&
1148 CheckTxDuration(1536,
1149 HePhy::GetHeMcs11(),
1150 40,
1151 1600,
1152 WIFI_PREAMBLE_HE_SU,
1153 NanoSeconds(101600)) &&
1154 CheckTxDuration(76,
1155 HePhy::GetHeMcs11(),
1156 40,
1157 1600,
1158 WIFI_PREAMBLE_HE_SU,
1159 NanoSeconds(58400)) &&
1160 CheckTxDuration(14,
1161 HePhy::GetHeMcs11(),
1162 40,
1163 1600,
1164 WIFI_PREAMBLE_HE_SU,
1165 NanoSeconds(58400)) &&
1166 CheckTxDuration(1536,
1167 HePhy::GetHeMcs11(),
1168 80,
1169 1600,
1170 WIFI_PREAMBLE_HE_SU,
1171 NanoSeconds(72800)) &&
1172 CheckTxDuration(76,
1173 HePhy::GetHeMcs11(),
1174 80,
1175 1600,
1176 WIFI_PREAMBLE_HE_SU,
1177 NanoSeconds(58400)) &&
1178 CheckTxDuration(14,
1179 HePhy::GetHeMcs11(),
1180 80,
1181 1600,
1182 WIFI_PREAMBLE_HE_SU,
1183 NanoSeconds(58400)) &&
1184 CheckTxDuration(1536,
1185 HePhy::GetHeMcs11(),
1186 160,
1187 1600,
1188 WIFI_PREAMBLE_HE_SU,
1189 NanoSeconds(58400)) &&
1190 CheckTxDuration(76,
1191 HePhy::GetHeMcs11(),
1192 160,
1193 1600,
1194 WIFI_PREAMBLE_HE_SU,
1195 NanoSeconds(58400)) &&
1196 CheckTxDuration(14,
1197 HePhy::GetHeMcs11(),
1198 160,
1199 1600,
1200 WIFI_PREAMBLE_HE_SU,
1201 NanoSeconds(58400)) &&
1202 CheckTxDuration(1536,
1203 HePhy::GetHeMcs11(),
1204 20,
1205 3200,
1206 WIFI_PREAMBLE_HE_SU,
1207 MicroSeconds(156)) &&
1208 CheckTxDuration(76, HePhy::GetHeMcs11(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1209 CheckTxDuration(14, HePhy::GetHeMcs11(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1210 CheckTxDuration(1536,
1211 HePhy::GetHeMcs11(),
1212 40,
1213 3200,
1214 WIFI_PREAMBLE_HE_SU,
1215 MicroSeconds(108)) &&
1216 CheckTxDuration(76, HePhy::GetHeMcs11(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1217 CheckTxDuration(14, HePhy::GetHeMcs11(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1218 CheckTxDuration(1536,
1219 HePhy::GetHeMcs11(),
1220 80,
1221 3200,
1222 WIFI_PREAMBLE_HE_SU,
1223 MicroSeconds(76)) &&
1224 CheckTxDuration(76, HePhy::GetHeMcs11(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1225 CheckTxDuration(14, HePhy::GetHeMcs11(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1226 CheckTxDuration(1536,
1227 HePhy::GetHeMcs11(),
1228 160,
1229 3200,
1230 WIFI_PREAMBLE_HE_SU,
1231 MicroSeconds(60)) &&
1232 CheckTxDuration(76,
1233 HePhy::GetHeMcs11(),
1234 160,
1235 3200,
1236 WIFI_PREAMBLE_HE_SU,
1237 MicroSeconds(60)) &&
1238 CheckTxDuration(14, HePhy::GetHeMcs11(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60));
1239
1240 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax SU duration failed");
1241
1242 // 802.11ax MU durations
1243 retval = retval &&
1244 CheckMuTxDuration(
1245 std::list<uint32_t>{1536, 1536},
1246 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1247 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1248 40,
1249 800,
1250 WIFI_PREAMBLE_HE_MU,
1251 NanoSeconds(
1252 1493600)) // equivalent to HE_SU for 20 MHz with 2 extra HE-SIG-B (i.e. 8 us)
1253 && CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1254 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 1, 1},
1255 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1256 40,
1257 800,
1258 WIFI_PREAMBLE_HE_MU,
1259 NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
1260 && CheckMuTxDuration(std::list<uint32_t>{1536, 76},
1261 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1262 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1263 40,
1264 800,
1265 WIFI_PREAMBLE_HE_MU,
1266 NanoSeconds(1493600));
1267
1268 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax MU duration failed");
1269
1270 // 802.11be MU durations
1271 retval = retval &&
1272 CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1273 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1274 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1275 40,
1276 800,
1277 WIFI_PREAMBLE_EHT_MU,
1278 NanoSeconds(1493600)) // equivalent to 802.11ax MU
1279 && CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1280 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 1, 1},
1281 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1282 40,
1283 800,
1284 WIFI_PREAMBLE_EHT_MU,
1285 NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
1286 && CheckMuTxDuration(std::list<uint32_t>{1536, 76},
1287 std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1288 {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1289 40,
1290 800,
1291 WIFI_PREAMBLE_EHT_MU,
1292 NanoSeconds(1493600));
1293
1294 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11be MU duration failed");
1295
1296 Simulator::Destroy();
1297}
1298
1305class HeSigBDurationTest : public TestCase
1306{
1307 public:
1311 enum MuType
1312 {
1313 OFDMA = 0,
1314 MU_MIMO
1315 };
1316
1328 HeSigBDurationTest(const std::list<HeMuUserInfo>& userInfos,
1329 const WifiMode& sigBMode,
1330 uint16_t channelWidth,
1331 MuType expectedMuType,
1332 const RuAllocation& expectedRuAllocation,
1333 const std::pair<std::size_t, std::size_t>& expectedNumUsersPerCc,
1334 Time expectedSigBDuration);
1335
1336 private:
1337 void DoRun() override;
1338
1344 WifiTxVector BuildTxVector() const;
1345
1346 std::list<HeMuUserInfo> m_userInfos;
1347 WifiMode m_sigBMode;
1348 uint16_t m_channelWidth;
1349 MuType m_expectedMuType;
1350 RuAllocation m_expectedRuAllocation;
1351 std::pair<std::size_t, std::size_t>
1352 m_expectedNumUsersPerCc;
1353 Time m_expectedSigBDuration;
1354};
1355
1356HeSigBDurationTest::HeSigBDurationTest(
1357 const std::list<HeMuUserInfo>& userInfos,
1358 const WifiMode& sigBMode,
1359 uint16_t channelWidth,
1360 MuType expectedMuType,
1361 const RuAllocation& expectedRuAllocation,
1362 const std::pair<std::size_t, std::size_t>& expectedNumUsersPerCc,
1363 Time expectedSigBDuration)
1364 : TestCase{"Check HE-SIG-B duration computation"},
1365 m_userInfos{userInfos},
1366 m_sigBMode{sigBMode},
1367 m_channelWidth{channelWidth},
1368 m_expectedMuType{expectedMuType},
1369 m_expectedRuAllocation{expectedRuAllocation},
1370 m_expectedNumUsersPerCc{expectedNumUsersPerCc},
1371 m_expectedSigBDuration{expectedSigBDuration}
1372{
1373}
1374
1375WifiTxVector
1376HeSigBDurationTest::BuildTxVector() const
1377{
1378 WifiTxVector txVector;
1379 txVector.SetPreambleType(WIFI_PREAMBLE_HE_MU);
1380 txVector.SetChannelWidth(m_channelWidth);
1381 txVector.SetGuardInterval(3200);
1382 txVector.SetStbc(false);
1383 txVector.SetNess(0);
1384 std::list<uint16_t> staIds;
1385 uint16_t staId = 1;
1386 for (const auto& userInfo : m_userInfos)
1387 {
1388 txVector.SetHeMuUserInfo(staId, userInfo);
1389 staIds.push_back(staId++);
1390 }
1391 txVector.SetSigBMode(m_sigBMode);
1392 NS_ASSERT(m_expectedMuType == OFDMA ? txVector.IsDlOfdma() : txVector.IsDlMuMimo());
1393 return txVector;
1394}
1395
1396void
1397HeSigBDurationTest::DoRun()
1398{
1399 const auto& hePhy = WifiPhy::GetStaticPhyEntity(WIFI_MOD_CLASS_HE);
1400 const auto& txVector = BuildTxVector();
1401
1402 // Verify mode for HE-SIG-B field
1403 NS_TEST_EXPECT_MSG_EQ(hePhy->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
1404 m_sigBMode,
1405 "Incorrect mode used to send HE-SIG-B");
1406
1407 // Verify RU_ALLOCATION in TXVECTOR
1408 NS_TEST_EXPECT_MSG_EQ((txVector.GetRuAllocation(0) == m_expectedRuAllocation),
1409 true,
1410 "Incorrect RU_ALLOCATION");
1411
1412 // Verify number of users for content channels 1 and 2
1413 const auto& numUsersPerCc = HePpdu::GetNumRusPerHeSigBContentChannel(
1414 txVector.GetChannelWidth(),
1415 txVector.GetRuAllocation(0),
1416 txVector.IsSigBCompression(),
1417 txVector.IsSigBCompression() ? txVector.GetHeMuUserInfoMap().size() : 0);
1418 const auto contentChannels = HePpdu::GetHeSigBContentChannels(txVector, 0);
1419 NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
1420 m_expectedNumUsersPerCc.first,
1421 "Incorrect number of users in HE-SIG-B content channel 1");
1422 NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
1423 m_expectedNumUsersPerCc.second,
1424 "Incorrect number of users in HE-SIG-B content channel 2");
1425 NS_TEST_EXPECT_MSG_EQ(contentChannels.at(0).size(),
1426 m_expectedNumUsersPerCc.first,
1427 "Incorrect number of users in HE-SIG-B content channel 1");
1428 NS_TEST_EXPECT_MSG_EQ((contentChannels.size() > 1 ? contentChannels.at(1).size() : 0),
1429 m_expectedNumUsersPerCc.second,
1430 "Incorrect number of users in HE-SIG-B content channel 2");
1431
1432 // Verify total HE-SIG-B duration
1433 NS_TEST_EXPECT_MSG_EQ(hePhy->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
1434 m_expectedSigBDuration,
1435 "Incorrect duration for HE-SIG-B");
1436}
1437
1444class PhyHeaderSectionsTest : public TestCase
1445{
1446 public:
1447 PhyHeaderSectionsTest();
1448 ~PhyHeaderSectionsTest() override;
1449 void DoRun() override;
1450
1451 private:
1459 void CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained,
1460 PhyEntity::PhyHeaderSections expected);
1461};
1462
1463PhyHeaderSectionsTest::PhyHeaderSectionsTest()
1464 : TestCase("PHY header sections consistency")
1465{
1466}
1467
1468PhyHeaderSectionsTest::~PhyHeaderSectionsTest()
1469{
1470}
1471
1472void
1473PhyHeaderSectionsTest::CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained,
1474 PhyEntity::PhyHeaderSections expected)
1475{
1476 NS_ASSERT_MSG(obtained.size() == expected.size(),
1477 "The expected map size (" << expected.size() << ") was not obtained ("
1478 << obtained.size() << ")");
1479
1480 auto itObtained = obtained.begin();
1481 auto itExpected = expected.begin();
1482 for (; itObtained != obtained.end() || itExpected != expected.end();)
1483 {
1484 WifiPpduField field = itObtained->first;
1485 auto window = itObtained->second.first;
1486 auto mode = itObtained->second.second;
1487
1488 WifiPpduField fieldRef = itExpected->first;
1489 auto windowRef = itExpected->second.first;
1490 auto modeRef = itExpected->second.second;
1491
1492 NS_TEST_EXPECT_MSG_EQ(field,
1493 fieldRef,
1494 "The expected PPDU field (" << fieldRef << ") was not obtained ("
1495 << field << ")");
1496 NS_TEST_EXPECT_MSG_EQ(window.first,
1497 windowRef.first,
1498 "The expected start time (" << windowRef.first
1499 << ") was not obtained (" << window.first
1500 << ")");
1501 NS_TEST_EXPECT_MSG_EQ(window.second,
1502 windowRef.second,
1503 "The expected stop time (" << windowRef.second
1504 << ") was not obtained (" << window.second
1505 << ")");
1506 NS_TEST_EXPECT_MSG_EQ(mode,
1507 modeRef,
1508 "The expected mode (" << modeRef << ") was not obtained (" << mode
1509 << ")");
1510 ++itObtained;
1511 ++itExpected;
1512 }
1513}
1514
1515void
1516PhyHeaderSectionsTest::DoRun()
1517{
1518 Time ppduStart = Seconds(1.0);
1519 Ptr<PhyEntity> phyEntity;
1520 PhyEntity::PhyHeaderSections sections;
1521 WifiTxVector txVector;
1522 WifiMode nonHtMode;
1523
1524 // ==================================================================================
1525 // 11b (HR/DSSS)
1526 phyEntity = Create<DsssPhy>();
1527 txVector.SetMode(DsssPhy::GetDsssRate1Mbps());
1528 txVector.SetChannelWidth(22);
1529
1530 // -> long PPDU format
1531 txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
1532 nonHtMode = DsssPhy::GetDsssRate1Mbps();
1533 sections = {
1534 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(144)}, nonHtMode}},
1535 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1536 {{ppduStart + MicroSeconds(144), ppduStart + MicroSeconds(192)}, nonHtMode}},
1537 };
1538 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1539
1540 // -> long PPDU format if data rate is 1 Mbps (even if preamble is tagged short)
1541 txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
1542 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1543
1544 // -> short PPDU format
1545 txVector.SetMode(DsssPhy::GetDsssRate11Mbps());
1546 nonHtMode = DsssPhy::GetDsssRate2Mbps();
1547 txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
1548 sections = {
1549 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(72)}, nonHtMode}},
1550 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1551 {{ppduStart + MicroSeconds(72), ppduStart + MicroSeconds(96)}, nonHtMode}},
1552 };
1553 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1554
1555 // ==================================================================================
1556 // 11a (OFDM)
1557 txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
1558
1559 // -> one iteration per variant: default, 10 MHz, and 5 MHz
1560 std::map<OfdmPhyVariant, std::size_t> variants{
1561 // number to use to deduce rate and BW info for each variant
1562 {OFDM_PHY_DEFAULT, 1},
1563 {OFDM_PHY_10_MHZ, 2},
1564 {OFDM_PHY_5_MHZ, 4},
1565 };
1566 for (auto variant : variants)
1567 {
1568 phyEntity = Create<OfdmPhy>(variant.first);
1569 std::size_t ratio = variant.second;
1570 uint16_t bw = 20 / ratio; // MHz
1571 txVector.SetChannelWidth(bw);
1572 txVector.SetMode(OfdmPhy::GetOfdmRate(12000000 / ratio, bw));
1573 nonHtMode = OfdmPhy::GetOfdmRate(6000000 / ratio, bw);
1574 sections = {
1575 {WIFI_PPDU_FIELD_PREAMBLE,
1576 {{ppduStart, ppduStart + MicroSeconds(16 * ratio)}, nonHtMode}},
1577 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1578 {{ppduStart + MicroSeconds(16 * ratio), ppduStart + MicroSeconds(20 * ratio)},
1579 nonHtMode}},
1580 };
1581 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1582 }
1583
1584 // ==================================================================================
1585 // 11g (ERP-OFDM)
1586 phyEntity = Create<ErpOfdmPhy>();
1587 txVector.SetChannelWidth(20);
1588 txVector.SetMode(ErpOfdmPhy::GetErpOfdmRate(54000000));
1589 nonHtMode = ErpOfdmPhy::GetErpOfdmRate6Mbps();
1590 sections = {
1591 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1592 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1593 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1594 };
1595 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1596
1597 // ==================================================================================
1598 // 11n (HT)
1599 phyEntity = Create<HtPhy>(4);
1600 txVector.SetChannelWidth(20);
1601 txVector.SetMode(HtPhy::GetHtMcs6());
1602 nonHtMode = OfdmPhy::GetOfdmRate6Mbps();
1603 WifiMode htSigMode = nonHtMode;
1604
1605 // -> HT-mixed format for 2 SS and no ESS
1606 txVector.SetPreambleType(WIFI_PREAMBLE_HT_MF);
1607 txVector.SetNss(2);
1608 txVector.SetNess(0);
1609 sections = {
1610 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1611 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1612 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1613 {WIFI_PPDU_FIELD_HT_SIG,
1614 {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, htSigMode}},
1615 {WIFI_PPDU_FIELD_TRAINING,
1616 {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(40)}, // 1 HT-STF + 2 HT-LTFs
1617 htSigMode}},
1618 };
1619 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1620 txVector.SetChannelWidth(20); // shouldn't have any impact
1621 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1622
1623 // -> HT-mixed format for 3 SS and 1 ESS
1624 txVector.SetNss(3);
1625 txVector.SetNess(1);
1626 sections[WIFI_PPDU_FIELD_TRAINING] = {
1627 {ppduStart + MicroSeconds(28),
1628 ppduStart + MicroSeconds(52)}, // 1 HT-STF + 5 HT-LTFs (4 data + 1 extension)
1629 htSigMode};
1630 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1631
1632 // ==================================================================================
1633 // 11ac (VHT)
1634 phyEntity = Create<VhtPhy>();
1635 txVector.SetChannelWidth(20);
1636 txVector.SetNess(0);
1637 txVector.SetMode(VhtPhy::GetVhtMcs7());
1638 WifiMode sigAMode = nonHtMode;
1639 WifiMode sigBMode = VhtPhy::GetVhtMcs0();
1640
1641 // -> VHT SU format for 5 SS
1642 txVector.SetPreambleType(WIFI_PREAMBLE_VHT_SU);
1643 txVector.SetNss(5);
1644 sections = {
1645 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1646 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1647 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1648 {WIFI_PPDU_FIELD_SIG_A,
1649 {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, sigAMode}},
1650 {WIFI_PPDU_FIELD_TRAINING,
1651 {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(56)}, // 1 VHT-STF + 6 VHT-LTFs
1652 sigAMode}},
1653 };
1654 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1655
1656 // -> VHT SU format for 7 SS
1657 txVector.SetNss(7);
1658 sections[WIFI_PPDU_FIELD_TRAINING] = {
1659 {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(64)}, // 1 VHT-STF + 8 VHT-LTFs
1660 sigAMode};
1661 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1662
1663 // -> VHT MU format for 3 SS
1664 txVector.SetPreambleType(WIFI_PREAMBLE_VHT_MU);
1665 txVector.SetNss(3);
1666 sections[WIFI_PPDU_FIELD_TRAINING] = {
1667 {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(48)}, // 1 VHT-STF + 4 VHT-LTFs
1668 sigAMode};
1669 sections[WIFI_PPDU_FIELD_SIG_B] = {{ppduStart + MicroSeconds(48), ppduStart + MicroSeconds(52)},
1670 sigBMode};
1671 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1672 txVector.SetChannelWidth(80); // shouldn't have any impact
1673 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1674
1675 // ==================================================================================
1676 // 11ax (HE)
1677 phyEntity = Create<HePhy>();
1678 txVector.SetChannelWidth(20);
1679 txVector.SetNss(2); // HE-LTF duration assumed to be always 8 us for the time being (see note in
1680 // HePhy::GetTrainingDuration)
1681 txVector.SetMode(HePhy::GetHeMcs9());
1682 std::map<uint16_t, HeMuUserInfo> userInfoMap = {{1, {{HeRu::RU_106_TONE, 1, true}, 4, 2}},
1683 {2, {{HeRu::RU_106_TONE, 1, true}, 9, 1}}};
1684 sigAMode = HePhy::GetVhtMcs0();
1685 sigBMode = HePhy::GetVhtMcs4(); // because of first user info map
1686
1687 // -> HE SU format
1688 txVector.SetPreambleType(WIFI_PREAMBLE_HE_SU);
1689 sections = {
1690 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1691 {WIFI_PPDU_FIELD_NON_HT_HEADER,
1692 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(24)}, // L-SIG + RL-SIG
1693 nonHtMode}},
1694 {WIFI_PPDU_FIELD_SIG_A,
1695 {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)}, sigAMode}},
1696 {WIFI_PPDU_FIELD_TRAINING,
1697 {{ppduStart + MicroSeconds(32),
1698 ppduStart + MicroSeconds(52)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1699 sigAMode}},
1700 };
1701 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1702
1703 // -> HE ER SU format
1704 txVector.SetPreambleType(WIFI_PREAMBLE_HE_ER_SU);
1705 sections[WIFI_PPDU_FIELD_SIG_A] = {
1706 {ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(40)}, // 16 us HE-SIG-A
1707 sigAMode};
1708 sections[WIFI_PPDU_FIELD_TRAINING] = {
1709 {ppduStart + MicroSeconds(40),
1710 ppduStart + MicroSeconds(60)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1711 sigAMode};
1712 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1713
1714 // -> HE TB format
1715 txVector.SetPreambleType(WIFI_PREAMBLE_HE_TB);
1716 txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
1717 txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
1718 sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1719 sigAMode};
1720 sections[WIFI_PPDU_FIELD_TRAINING] = {
1721 {ppduStart + MicroSeconds(32),
1722 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 8 us) + 2 HE-LTFs (@ 8 us)
1723 sigAMode};
1724 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1725
1726 // -> HE MU format
1727 txVector.SetPreambleType(WIFI_PREAMBLE_HE_MU);
1728 txVector.SetSigBMode(sigBMode);
1729 txVector.SetRuAllocation({96}, 0);
1730 sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1731 sigAMode};
1732 sections[WIFI_PPDU_FIELD_SIG_B] = {
1733 {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
1734 sigBMode};
1735 sections[WIFI_PPDU_FIELD_TRAINING] = {
1736 {ppduStart + MicroSeconds(36),
1737 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1738 sigBMode};
1739 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1740 txVector.SetChannelWidth(160); // shouldn't have any impact
1741 txVector.SetRuAllocation({96, 113, 113, 113, 113, 113, 113, 113}, 0);
1742
1743 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1744
1745 // ==================================================================================
1746 // 11be (EHT)
1747 sections.erase(WIFI_PPDU_FIELD_SIG_A); // FIXME: do we keep using separate type for 11be?
1748 sections.erase(WIFI_PPDU_FIELD_SIG_B); // FIXME: do we keep using separate type for 11be?
1749 phyEntity = Create<EhtPhy>();
1750 txVector.SetChannelWidth(20);
1751 txVector.SetNss(2); // EHT-LTF duration assumed to be always 8 us for the time being (see note
1752 // in HePhy::GetTrainingDuration)
1753 txVector.SetMode(EhtPhy::GetEhtMcs9());
1754 userInfoMap = {{1, {{HeRu::RU_106_TONE, 1, true}, 4, 2}},
1755 {2, {{HeRu::RU_106_TONE, 1, true}, 9, 1}}};
1756 WifiMode uSigMode = EhtPhy::GetVhtMcs0();
1757 WifiMode ehtSigMode = EhtPhy::GetVhtMcs4(); // because of first user info map
1758
1759 // -> EHT TB format
1760 txVector.SetPreambleType(WIFI_PREAMBLE_EHT_TB);
1761 txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
1762 txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
1763 sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1764 uSigMode};
1765 sections[WIFI_PPDU_FIELD_TRAINING] = {
1766 {ppduStart + MicroSeconds(32),
1767 ppduStart + MicroSeconds(56)}, // 1 EHT-STF (@ 8 us) + 2 EHT-LTFs (@ 8 us)
1768 uSigMode};
1769 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1770
1771 // -> EHT MU format
1772 txVector.SetPreambleType(WIFI_PREAMBLE_EHT_MU);
1773 txVector.SetEhtPpduType(0); // EHT MU transmission
1774 txVector.SetRuAllocation({96}, 0);
1775 sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1776 uSigMode};
1777 sections[WIFI_PPDU_FIELD_EHT_SIG] = {
1778 {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
1779 ehtSigMode};
1780 sections[WIFI_PPDU_FIELD_TRAINING] = {
1781 {ppduStart + MicroSeconds(36),
1782 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1783 ehtSigMode};
1784 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1785 txVector.SetChannelWidth(160); // shouldn't have any impact
1786 txVector.SetRuAllocation({96, 113, 113, 113, 113, 113, 113, 113}, 0);
1787
1788 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1789}
1790
1797class TxDurationTestSuite : public TestSuite
1798{
1799 public:
1800 TxDurationTestSuite();
1801};
1802
1803TxDurationTestSuite::TxDurationTestSuite()
1804 : TestSuite("wifi-devices-tx-duration", UNIT)
1805{
1806 AddTestCase(new TxDurationTest, TestCase::QUICK);
1807
1808 AddTestCase(new PhyHeaderSectionsTest, TestCase::QUICK);
1809
1810 // 20 MHz band, HeSigBDurationTest::OFDMA, even number of users per HE-SIG-B content channel
1811 AddTestCase(new HeSigBDurationTest(
1812 {{{HeRu::RU_106_TONE, 1, true}, 11, 1}, {{HeRu::RU_106_TONE, 2, true}, 10, 4}},
1813 VhtPhy::GetVhtMcs5(),
1814 20,
1815 HeSigBDurationTest::OFDMA,
1816 {96},
1817 std::make_pair(2, 0), // both users in HE-SIG-B content channel 1
1818 MicroSeconds(4)), // one OFDM symbol;
1819 TestCase::QUICK);
1820
1821 // 40 MHz band, HeSigBDurationTest::OFDMA, even number of users per HE-SIG-B content channel
1822 AddTestCase(
1823 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1824 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1825 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1826 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1827 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1828 {{HeRu::RU_52_TONE, 8, true}, 6, 2}},
1829 VhtPhy::GetVhtMcs4(),
1830 40,
1831 HeSigBDurationTest::OFDMA,
1832 {96, 112},
1833 std::make_pair(2, 4), // two users in HE-SIG-B content channel 1 and
1834 // four users in HE-SIG-B content channel 2
1835 MicroSeconds(4)), // one OFDM symbol;
1836 TestCase::QUICK);
1837
1838 // 40 MHz band, HeSigBDurationTest::OFDMA, odd number of users per HE-SIG-B content channel
1839 AddTestCase(
1840 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1841 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1842 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1843 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1844 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1845 {{HeRu::RU_52_TONE, 8, true}, 6, 2},
1846 {{HeRu::RU_26_TONE, 14, true}, 3, 1}},
1847 VhtPhy::GetVhtMcs3(),
1848 40,
1849 HeSigBDurationTest::OFDMA,
1850 {96, 15},
1851 std::make_pair(2, 5), // two users in HE-SIG-B content channel 1 and
1852 // five users in HE-SIG-B content channel 2
1853 MicroSeconds(8)), // two OFDM symbols
1854 TestCase::QUICK);
1855
1856 // 80 MHz band, OFDMA
1857 AddTestCase(
1858 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1859 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1860 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1861 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1862 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1863 {{HeRu::RU_52_TONE, 8, true}, 6, 2},
1864 {{HeRu::RU_26_TONE, 14, true}, 3, 1},
1865 {{HeRu::RU_242_TONE, 3, true}, 1, 1},
1866 {{HeRu::RU_242_TONE, 4, true}, 4, 1}},
1867 VhtPhy::GetVhtMcs1(),
1868 80,
1869 HeSigBDurationTest::OFDMA,
1870 {96, 15, 192, 192},
1871 std::make_pair(3, 6), // three users in HE-SIG-B content channel 1
1872 // and six users in HE-SIG-B content channel 2
1873 MicroSeconds(16)), // four OFDM symbols
1874 TestCase::QUICK);
1875
1876 // 160 MHz band, OFDMA
1877 AddTestCase(
1878 new HeSigBDurationTest({{{HeRu::RU_106_TONE, 1, true}, 11, 1},
1879 {{HeRu::RU_106_TONE, 2, true}, 10, 4},
1880 {{HeRu::RU_52_TONE, 5, true}, 4, 1},
1881 {{HeRu::RU_52_TONE, 6, true}, 6, 2},
1882 {{HeRu::RU_52_TONE, 7, true}, 5, 3},
1883 {{HeRu::RU_52_TONE, 8, true}, 6, 2},
1884 {{HeRu::RU_26_TONE, 14, true}, 3, 1},
1885 {{HeRu::RU_242_TONE, 3, true}, 1, 1},
1886 {{HeRu::RU_242_TONE, 4, true}, 4, 1},
1887 {{HeRu::RU_996_TONE, 1, false}, 1, 1}},
1888 VhtPhy::GetVhtMcs1(),
1889 160,
1890 HeSigBDurationTest::OFDMA,
1891 {96, 15, 192, 192, 208, 208, 208, 208},
1892 std::make_pair(4, 7), // four users in HE-SIG-B content channel 1 and
1893 // seven users in HE-SIG-B content channel 2
1894 MicroSeconds(20)), // five OFDM symbols
1895 TestCase::QUICK);
1896
1897 // 20 MHz band, HeSigBDurationTest::OFDMA, one unallocated RU at the middle
1898 AddTestCase(
1899 new HeSigBDurationTest({{{HeRu::RU_26_TONE, 1, true}, 11, 1},
1900 {{HeRu::RU_26_TONE, 2, true}, 11, 1},
1901 {{HeRu::RU_26_TONE, 3, true}, 11, 1},
1902 {{HeRu::RU_26_TONE, 4, true}, 11, 1},
1903 {{HeRu::RU_26_TONE, 6, true}, 11, 1},
1904 {{HeRu::RU_26_TONE, 7, true}, 11, 1},
1905 {{HeRu::RU_26_TONE, 8, true}, 11, 1},
1906 {{HeRu::RU_26_TONE, 9, true}, 11, 1}},
1907 VhtPhy::GetVhtMcs5(),
1908 20,
1909 HeSigBDurationTest::OFDMA,
1910 {0},
1911 std::make_pair(9, 0), // 9 users in HE-SIG-B content channel 1
1912 MicroSeconds(8)), // two OFDM symbols
1913 TestCase::QUICK);
1914
1915 // 40 MHz band, HeSigBDurationTest::OFDMA, unallocated RUs at the begin and at the end of the
1916 // first 20 MHz subband and in the middle of the second 20 MHz subband
1917 AddTestCase(
1918 new HeSigBDurationTest({{{HeRu::RU_52_TONE, 2, true}, 10, 1},
1919 {{HeRu::RU_52_TONE, 3, true}, 10, 2},
1920 {{HeRu::RU_52_TONE, 5, true}, 11, 1},
1921 {{HeRu::RU_52_TONE, 8, true}, 11, 2}},
1922 VhtPhy::GetVhtMcs5(),
1923 40,
1924 HeSigBDurationTest::OFDMA,
1925 {112, 112},
1926 std::make_pair(4, 4), // 4 users in both HE-SIG-B content channels
1927 MicroSeconds(4)), // two OFDM symbols
1928 TestCase::QUICK);
1929
1930 // 40 MHz band, HeSigBDurationTest::OFDMA, one unallocated RUs in the first 20 MHz subband and
1931 // two unallocated RUs in second 20 MHz subband
1932 AddTestCase(
1933 new HeSigBDurationTest({{{HeRu::RU_52_TONE, 1, true}, 10, 1},
1934 {{HeRu::RU_52_TONE, 2, true}, 10, 2},
1935 {{HeRu::RU_52_TONE, 3, true}, 11, 1},
1936 {{HeRu::RU_52_TONE, 5, true}, 11, 2},
1937 {{HeRu::RU_52_TONE, 6, true}, 11, 3}},
1938 VhtPhy::GetVhtMcs5(),
1939 40,
1940 HeSigBDurationTest::OFDMA,
1941 {112, 112},
1942 std::make_pair(4, 4), // 4 users in both HE-SIG-B content channels
1943 MicroSeconds(4)), // two OFDM symbols
1944 TestCase::QUICK);
1945
1946 // 20 MHz band, MU-MIMO, 2 users
1947 AddTestCase(new HeSigBDurationTest(
1948 {{{HeRu::RU_242_TONE, 1, true}, 11, 1}, {{HeRu::RU_242_TONE, 1, true}, 10, 4}},
1949 VhtPhy::GetVhtMcs5(),
1950 20,
1951 HeSigBDurationTest::MU_MIMO,
1952 {192},
1953 std::make_pair(2, 0), // both users in HE-SIG-B content channel 1
1954 MicroSeconds(4)), // one OFDM symbol
1955 TestCase::QUICK);
1956
1957 // 20 MHz band, MU-MIMO, 3 users
1958 AddTestCase(
1959 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 3},
1960 {{HeRu::RU_242_TONE, 1, true}, 5, 2},
1961 {{HeRu::RU_242_TONE, 1, true}, 6, 1}},
1962 VhtPhy::GetVhtMcs4(),
1963 20,
1964 HeSigBDurationTest::MU_MIMO,
1965 {192},
1966 std::make_pair(3, 0), // all users in HE-SIG-B content channel 1
1967 MicroSeconds(4)), // one OFDM symbol
1968 TestCase::QUICK);
1969
1970 // 20 MHz band, MU-MIMO, 4 users
1971 AddTestCase(
1972 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 1},
1973 {{HeRu::RU_242_TONE, 1, true}, 5, 2},
1974 {{HeRu::RU_242_TONE, 1, true}, 6, 3},
1975 {{HeRu::RU_242_TONE, 1, true}, 7, 2}},
1976 VhtPhy::GetVhtMcs4(),
1977 20,
1978 HeSigBDurationTest::MU_MIMO,
1979 {192},
1980 std::make_pair(4, 0), // all users in HE-SIG-B content channel 1
1981 MicroSeconds(4)), // one OFDM symbol
1982 TestCase::QUICK);
1983
1984 // 20 MHz band, MU-MIMO, 6 users
1985 AddTestCase(
1986 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 1},
1987 {{HeRu::RU_242_TONE, 1, true}, 5, 1},
1988 {{HeRu::RU_242_TONE, 1, true}, 6, 2},
1989 {{HeRu::RU_242_TONE, 1, true}, 7, 2},
1990 {{HeRu::RU_242_TONE, 1, true}, 8, 1},
1991 {{HeRu::RU_242_TONE, 1, true}, 9, 1}},
1992 VhtPhy::GetVhtMcs4(),
1993 20,
1994 HeSigBDurationTest::MU_MIMO,
1995 {192},
1996 std::make_pair(6, 0), // all users in HE-SIG-B content channel 1
1997 MicroSeconds(4)), // one OFDM symbol
1998 TestCase::QUICK);
1999
2000 // 20 MHz band, MU-MIMO, 8 users
2001 AddTestCase(
2002 new HeSigBDurationTest({{{HeRu::RU_242_TONE, 1, true}, 4, 1},
2003 {{HeRu::RU_242_TONE, 1, true}, 5, 1},
2004 {{HeRu::RU_242_TONE, 1, true}, 6, 1},
2005 {{HeRu::RU_242_TONE, 1, true}, 7, 1},
2006 {{HeRu::RU_242_TONE, 1, true}, 8, 1},
2007 {{HeRu::RU_242_TONE, 1, true}, 9, 1},
2008 {{HeRu::RU_242_TONE, 1, true}, 10, 1},
2009 {{HeRu::RU_242_TONE, 1, true}, 11, 1}},
2010 VhtPhy::GetVhtMcs4(),
2011 20,
2012 HeSigBDurationTest::MU_MIMO,
2013 {192},
2014 std::make_pair(8, 0), // all users in HE-SIG-B content channel 1
2015 MicroSeconds(8)), // two OFDM symbols
2016 TestCase::QUICK);
2017
2018 // 40 MHz band, MU-MIMO, 2 users
2019 AddTestCase(new HeSigBDurationTest(
2020 {{{HeRu::RU_484_TONE, 1, true}, 11, 1}, {{HeRu::RU_484_TONE, 1, true}, 10, 4}},
2021 VhtPhy::GetVhtMcs5(),
2022 40,
2023 HeSigBDurationTest::MU_MIMO,
2024 {200, 200},
2025 std::make_pair(1, 1), // users equally split between the two content channels
2026 MicroSeconds(4)), // one OFDM symbol
2027 TestCase::QUICK);
2028
2029 // 40 MHz band, MU-MIMO, 3 users
2030 AddTestCase(
2031 new HeSigBDurationTest(
2032 {{{HeRu::RU_484_TONE, 1, true}, 4, 3},
2033 {{HeRu::RU_484_TONE, 1, true}, 5, 2},
2034 {{HeRu::RU_484_TONE, 1, true}, 6, 1}},
2035 VhtPhy::GetVhtMcs4(),
2036 40,
2037 HeSigBDurationTest::MU_MIMO,
2038 {200, 200},
2039 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
2040 MicroSeconds(4)), // one OFDM symbol
2041 TestCase::QUICK);
2042
2043 // 40 MHz band, MU-MIMO, 4 users
2044 AddTestCase(new HeSigBDurationTest(
2045 {{{HeRu::RU_484_TONE, 1, true}, 4, 1},
2046 {{HeRu::RU_484_TONE, 1, true}, 5, 2},
2047 {{HeRu::RU_484_TONE, 1, true}, 6, 3},
2048 {{HeRu::RU_484_TONE, 1, true}, 7, 2}},
2049 VhtPhy::GetVhtMcs4(),
2050 40,
2051 HeSigBDurationTest::MU_MIMO,
2052 {200, 200},
2053 std::make_pair(2, 2), // users equally split between the two content channels
2054 MicroSeconds(4)), // one OFDM symbol
2055 TestCase::QUICK);
2056
2057 // 40 MHz band, MU-MIMO, 6 users
2058 AddTestCase(new HeSigBDurationTest(
2059 {{{HeRu::RU_484_TONE, 1, true}, 4, 1},
2060 {{HeRu::RU_484_TONE, 1, true}, 5, 1},
2061 {{HeRu::RU_484_TONE, 1, true}, 6, 2},
2062 {{HeRu::RU_484_TONE, 1, true}, 7, 2},
2063 {{HeRu::RU_484_TONE, 1, true}, 8, 1},
2064 {{HeRu::RU_484_TONE, 1, true}, 9, 1}},
2065 VhtPhy::GetVhtMcs4(),
2066 40,
2067 HeSigBDurationTest::MU_MIMO,
2068 {200, 200},
2069 std::make_pair(3, 3), // users equally split between the two content channels
2070 MicroSeconds(4)), // one OFDM symbol
2071 TestCase::QUICK);
2072
2073 // 40 MHz band, MU-MIMO, 8 users
2074 AddTestCase(new HeSigBDurationTest(
2075 {{{HeRu::RU_484_TONE, 1, true}, 4, 1},
2076 {{HeRu::RU_484_TONE, 1, true}, 5, 1},
2077 {{HeRu::RU_484_TONE, 1, true}, 6, 1},
2078 {{HeRu::RU_484_TONE, 1, true}, 7, 1},
2079 {{HeRu::RU_484_TONE, 1, true}, 8, 1},
2080 {{HeRu::RU_484_TONE, 1, true}, 9, 1},
2081 {{HeRu::RU_484_TONE, 1, true}, 10, 1},
2082 {{HeRu::RU_484_TONE, 1, true}, 11, 1}},
2083 VhtPhy::GetVhtMcs4(),
2084 40,
2085 HeSigBDurationTest::MU_MIMO,
2086 {200, 200},
2087 std::make_pair(4, 4), // users equally split between the two content channels
2088 MicroSeconds(4)), // one OFDM symbol
2089 TestCase::QUICK);
2090
2091 // 80 MHz band, MU-MIMO, 2 users
2092 AddTestCase(new HeSigBDurationTest(
2093 {{{HeRu::RU_996_TONE, 1, true}, 11, 1}, {{HeRu::RU_996_TONE, 1, true}, 10, 4}},
2094 VhtPhy::GetVhtMcs5(),
2095 80,
2096 HeSigBDurationTest::MU_MIMO,
2097 {208, 208, 208, 208},
2098 std::make_pair(1, 1), // users equally split between the two content channels
2099 MicroSeconds(4)), // one OFDM symbol
2100 TestCase::QUICK);
2101
2102 // 80 MHz band, MU-MIMO, 3 users
2103 AddTestCase(
2104 new HeSigBDurationTest(
2105 {{{HeRu::RU_996_TONE, 1, true}, 4, 3},
2106 {{HeRu::RU_996_TONE, 1, true}, 5, 2},
2107 {{HeRu::RU_996_TONE, 1, true}, 6, 1}},
2108 VhtPhy::GetVhtMcs4(),
2109 80,
2110 HeSigBDurationTest::MU_MIMO,
2111 {208, 208, 208, 208},
2112 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
2113 MicroSeconds(4)), // one OFDM symbol
2114 TestCase::QUICK);
2115
2116 // 80 MHz band, MU-MIMO, 4 users
2117 AddTestCase(new HeSigBDurationTest(
2118 {{{HeRu::RU_996_TONE, 1, true}, 4, 1},
2119 {{HeRu::RU_996_TONE, 1, true}, 5, 2},
2120 {{HeRu::RU_996_TONE, 1, true}, 6, 3},
2121 {{HeRu::RU_996_TONE, 1, true}, 7, 2}},
2122 VhtPhy::GetVhtMcs4(),
2123 80,
2124 HeSigBDurationTest::MU_MIMO,
2125 {208, 208, 208, 208},
2126 std::make_pair(2, 2), // users equally split between the two content channels
2127 MicroSeconds(4)), // one OFDM symbol
2128 TestCase::QUICK);
2129
2130 // 80 MHz band, MU-MIMO, 6 users
2131 AddTestCase(new HeSigBDurationTest(
2132 {{{HeRu::RU_996_TONE, 1, true}, 4, 1},
2133 {{HeRu::RU_996_TONE, 1, true}, 5, 1},
2134 {{HeRu::RU_996_TONE, 1, true}, 6, 2},
2135 {{HeRu::RU_996_TONE, 1, true}, 7, 2},
2136 {{HeRu::RU_996_TONE, 1, true}, 8, 1},
2137 {{HeRu::RU_996_TONE, 1, true}, 9, 1}},
2138 VhtPhy::GetVhtMcs4(),
2139 80,
2140 HeSigBDurationTest::MU_MIMO,
2141 {208, 208, 208, 208},
2142 std::make_pair(3, 3), // users equally split between the two content channels
2143 MicroSeconds(4)), // one OFDM symbol
2144 TestCase::QUICK);
2145
2146 // 80 MHz band, MU-MIMO, 8 users
2147 AddTestCase(new HeSigBDurationTest(
2148 {{{HeRu::RU_996_TONE, 1, true}, 4, 1},
2149 {{HeRu::RU_996_TONE, 1, true}, 5, 1},
2150 {{HeRu::RU_996_TONE, 1, true}, 6, 1},
2151 {{HeRu::RU_996_TONE, 1, true}, 7, 1},
2152 {{HeRu::RU_996_TONE, 1, true}, 8, 1},
2153 {{HeRu::RU_996_TONE, 1, true}, 9, 1},
2154 {{HeRu::RU_996_TONE, 1, true}, 10, 1},
2155 {{HeRu::RU_996_TONE, 1, true}, 11, 1}},
2156 VhtPhy::GetVhtMcs4(),
2157 80,
2158 HeSigBDurationTest::MU_MIMO,
2159 {208, 208, 208, 208},
2160 std::make_pair(4, 4), // users equally split between the two content channels
2161 MicroSeconds(4)), // one OFDM symbol
2162 TestCase::QUICK);
2163
2164 // 160 MHz band, MU-MIMO, 2 users
2165 AddTestCase(
2166 new HeSigBDurationTest(
2167 {{{HeRu::RU_2x996_TONE, 1, true}, 11, 1}, {{HeRu::RU_2x996_TONE, 1, true}, 10, 4}},
2168 VhtPhy::GetVhtMcs5(),
2169 160,
2170 HeSigBDurationTest::MU_MIMO,
2171 {208, 208, 208, 208, 208, 208, 208, 208},
2172 std::make_pair(1, 1), // users equally split between the two content channels
2173 MicroSeconds(4)), // one OFDM symbol
2174 TestCase::QUICK);
2175
2176 // 160 MHz band, MU-MIMO, 3 users
2177 AddTestCase(
2178 new HeSigBDurationTest(
2179 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 3},
2180 {{HeRu::RU_2x996_TONE, 1, true}, 5, 2},
2181 {{HeRu::RU_2x996_TONE, 1, true}, 6, 1}},
2182 VhtPhy::GetVhtMcs4(),
2183 160,
2184 HeSigBDurationTest::MU_MIMO,
2185 {208, 208, 208, 208, 208, 208, 208, 208},
2186 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
2187 MicroSeconds(4)), // one OFDM symbol
2188 TestCase::QUICK);
2189
2190 // 160 MHz band, MU-MIMO, 4 users
2191 AddTestCase(new HeSigBDurationTest(
2192 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 1},
2193 {{HeRu::RU_2x996_TONE, 1, true}, 5, 2},
2194 {{HeRu::RU_2x996_TONE, 1, true}, 6, 3},
2195 {{HeRu::RU_2x996_TONE, 1, true}, 7, 2}},
2196 VhtPhy::GetVhtMcs4(),
2197 160,
2198 HeSigBDurationTest::MU_MIMO,
2199 {208, 208, 208, 208, 208, 208, 208, 208},
2200 std::make_pair(2, 2), // users equally split between the two content channels
2201 MicroSeconds(4)), // one OFDM symbol
2202 TestCase::QUICK);
2203
2204 // 160 MHz band, MU-MIMO, 6 users
2205 AddTestCase(new HeSigBDurationTest(
2206 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 1},
2207 {{HeRu::RU_2x996_TONE, 1, true}, 5, 1},
2208 {{HeRu::RU_2x996_TONE, 1, true}, 6, 2},
2209 {{HeRu::RU_2x996_TONE, 1, true}, 7, 2},
2210 {{HeRu::RU_2x996_TONE, 1, true}, 8, 1},
2211 {{HeRu::RU_2x996_TONE, 1, true}, 9, 1}},
2212 VhtPhy::GetVhtMcs4(),
2213 160,
2214 HeSigBDurationTest::MU_MIMO,
2215 {208, 208, 208, 208, 208, 208, 208, 208},
2216 std::make_pair(3, 3), // users equally split between the two content channels
2217 MicroSeconds(4)), // one OFDM symbol
2218 TestCase::QUICK);
2219
2220 // 160 MHz band, MU-MIMO, 8 users
2221 AddTestCase(new HeSigBDurationTest(
2222 {{{HeRu::RU_2x996_TONE, 1, true}, 4, 1},
2223 {{HeRu::RU_2x996_TONE, 1, true}, 5, 1},
2224 {{HeRu::RU_2x996_TONE, 1, true}, 6, 1},
2225 {{HeRu::RU_2x996_TONE, 1, true}, 7, 1},
2226 {{HeRu::RU_2x996_TONE, 1, true}, 8, 1},
2227 {{HeRu::RU_2x996_TONE, 1, true}, 9, 1},
2228 {{HeRu::RU_2x996_TONE, 1, true}, 10, 1},
2229 {{HeRu::RU_2x996_TONE, 1, true}, 11, 1}},
2230 VhtPhy::GetVhtMcs4(),
2231 160,
2232 HeSigBDurationTest::MU_MIMO,
2233 {208, 208, 208, 208, 208, 208, 208, 208},
2234 std::make_pair(4, 4), // users equally split between the two content channels
2235 MicroSeconds(4)), // one OFDM symbol
2236 TestCase::QUICK);
2237}
2238
2239static TxDurationTestSuite g_txDurationTestSuite;
HeSigBDurationTest
HE-SIG-B duration test.
Definition: tx-duration-test.cc:1306
HeSigBDurationTest::m_userInfos
std::list< HeMuUserInfo > m_userInfos
HE MU specific per-user information.
Definition: tx-duration-test.cc:1346
HeSigBDurationTest::MuType
MuType
OFDMA or MU-MIMO.
Definition: tx-duration-test.cc:1312
HeSigBDurationTest::m_expectedMuType
MuType m_expectedMuType
Expected MU type (OFDMA or MU-MIMO)
Definition: tx-duration-test.cc:1349
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:1356
HeSigBDurationTest::m_expectedRuAllocation
RuAllocation m_expectedRuAllocation
Expected RU_ALLOCATION.
Definition: tx-duration-test.cc:1350
HeSigBDurationTest::m_expectedSigBDuration
Time m_expectedSigBDuration
Expected duration of the HE-SIG-B header.
Definition: tx-duration-test.cc:1353
HeSigBDurationTest::m_sigBMode
WifiMode m_sigBMode
Mode used to transmit HE-SIG-B.
Definition: tx-duration-test.cc:1347
HeSigBDurationTest::BuildTxVector
WifiTxVector BuildTxVector() const
Build a TXVECTOR for HE MU.
Definition: tx-duration-test.cc:1376
HeSigBDurationTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:1397
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:1352
HeSigBDurationTest::m_channelWidth
uint16_t m_channelWidth
Channel width in MHz.
Definition: tx-duration-test.cc:1348
PhyHeaderSectionsTest
PHY header sections consistency test.
Definition: tx-duration-test.cc:1445
PhyHeaderSectionsTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:1516
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:1473
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:1798
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:77
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142
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:1507
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:702
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:111
ns3::WifiTxVector::SetRuAllocation
void SetRuAllocation(const RuAllocation &ruAlloc, uint8_t p20Index)
Set RU_ALLOCATION field.
Definition: wifi-tx-vector.cc:416
ns3::WifiTxVector::SetStbc
void SetStbc(bool stbc)
Sets if STBC is being used.
Definition: wifi-tx-vector.cc:356
ns3::WifiTxVector::SetNess
void SetNess(uint8_t ness)
Sets the Ness number.
Definition: wifi-tx-vector.cc:344
ns3::WifiTxVector::SetEhtPpduType
void SetEhtPpduType(uint8_t type)
Set the EHT_PPDU_TYPE parameter.
Definition: wifi-tx-vector.cc:436
ns3::WifiTxVector::SetChannelWidth
void SetChannelWidth(uint16_t channelWidth)
Sets the selected channelWidth (in MHz)
Definition: wifi-tx-vector.cc:312
ns3::WifiTxVector::SetGuardInterval
void SetGuardInterval(uint16_t guardInterval)
Sets the guard interval duration (in nanoseconds)
Definition: wifi-tx-vector.cc:318
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:133
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:635
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:552
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:203
ns3::WifiTxVector::SetSigBMode
void SetSigBMode(const WifiMode &mode)
Set the MCS used for SIG-B.
Definition: wifi-tx-vector.cc:404
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:579
ns3::WifiTxVector::SetMode
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
Definition: wifi-tx-vector.cc:284
ns3::WifiTxVector::SetNss
void SetNss(uint8_t nss)
Sets the number of Nss.
Definition: wifi-tx-vector.cc:330
ns3::WifiTxVector::SetPreambleType
void SetPreambleType(WifiPreamble preamble)
Sets the preamble type.
Definition: wifi-tx-vector.cc:306
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:1350
ns3::NanoSeconds
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1362
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1326
ns3::WifiPreamble
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-phy-common.h:172
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:307
ns3::WIFI_PREAMBLE_LONG
@ WIFI_PREAMBLE_LONG
Definition: wifi-phy-common.h:173
ns3::WIFI_PREAMBLE_EHT_TB
@ WIFI_PREAMBLE_EHT_TB
Definition: wifi-phy-common.h:186
ns3::WIFI_PREAMBLE_HE_ER_SU
@ WIFI_PREAMBLE_HE_ER_SU
Definition: wifi-phy-common.h:182
ns3::WIFI_PREAMBLE_HE_TB
@ WIFI_PREAMBLE_HE_TB
Definition: wifi-phy-common.h:184
ns3::WIFI_PREAMBLE_EHT_MU
@ WIFI_PREAMBLE_EHT_MU
Definition: wifi-phy-common.h:185
ns3::WIFI_PREAMBLE_HE_MU
@ WIFI_PREAMBLE_HE_MU
Definition: wifi-phy-common.h:183
ns3::WIFI_PREAMBLE_HE_SU
@ WIFI_PREAMBLE_HE_SU
Definition: wifi-phy-common.h:181
ns3::WIFI_PREAMBLE_VHT_MU
@ WIFI_PREAMBLE_VHT_MU
Definition: wifi-phy-common.h:177
ns3::WIFI_PREAMBLE_VHT_SU
@ WIFI_PREAMBLE_VHT_SU
Definition: wifi-phy-common.h:176
ns3::WIFI_PREAMBLE_SHORT
@ WIFI_PREAMBLE_SHORT
Definition: wifi-phy-common.h:174
ns3::WIFI_PREAMBLE_HT_MF
@ WIFI_PREAMBLE_HT_MF
Definition: wifi-phy-common.h:175
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:249
ns3::WIFI_MOD_CLASS_VHT
@ WIFI_MOD_CLASS_VHT
VHT (Clause 22)
Definition: wifi-phy-common.h:251
ns3::WIFI_MOD_CLASS_HE
@ WIFI_MOD_CLASS_HE
HE (Clause 27)
Definition: wifi-phy-common.h:256
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:325
ns3::WIFI_PPDU_FIELD_TRAINING
@ WIFI_PPDU_FIELD_TRAINING
STF + LTF fields (excluding those in preamble for HT-GF)
Definition: wifi-phy-common.h:323
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:321
ns3::WIFI_PPDU_FIELD_EHT_SIG
@ WIFI_PPDU_FIELD_EHT_SIG
EHT-SIG field.
Definition: wifi-phy-common.h:327
ns3::WIFI_PPDU_FIELD_HT_SIG
@ WIFI_PPDU_FIELD_HT_SIG
HT-SIG field.
Definition: wifi-phy-common.h:322
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:314
ns3::WIFI_PPDU_FIELD_U_SIG
@ WIFI_PPDU_FIELD_U_SIG
U-SIG field.
Definition: wifi-phy-common.h:326
ns3::WIFI_PPDU_FIELD_SIG_A
@ WIFI_PPDU_FIELD_SIG_A
SIG-A field.
Definition: wifi-phy-common.h:324
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:65
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:43
ns3::HeMuUserInfo::ru
HeRu::RuSpec ru
RU specification.
Definition: wifi-tx-vector.h:44
g_txDurationTestSuite
static TxDurationTestSuite g_txDurationTestSuite
the test suite
Definition: tx-duration-test.cc:2239