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 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Authors: Nicola Baldo <nbaldo@cttc.es>
7 * Sébastien Deronne <sebastien.deronne@gmail.com>
8 */
9
10#include "ns3/dsss-phy.h"
11#include "ns3/eht-phy.h" //includes OFDM, HT, VHT and HE
12#include "ns3/eht-ppdu.h" //includes OFDM, HT, VHT and HE
13#include "ns3/erp-ofdm-phy.h"
14#include "ns3/he-ru.h"
15#include "ns3/log.h"
16#include "ns3/packet.h"
17#include "ns3/simulator.h"
18#include "ns3/test.h"
19#include "ns3/wifi-psdu.h"
20#include "ns3/yans-wifi-phy.h"
21
22#include <list>
23#include <numeric>
24
25using namespace ns3;
26
27NS_LOG_COMPONENT_DEFINE("TxDurationTest");
28
29namespace
30{
31/**
32 * Create an HE or an EHT RU Specification.
33 * If a primary80 is provided, an HE RU Specification is created, other it is an EHT RU
34 * Specification.
35 *
36 * @param ruType the RU type
37 * @param index the RU index (starting at 1)
38 * @param primaryOrLow80MHz whether the RU is allocated in the primary 80MHz channel or in the low
39 * 80 MHz if the RU is allocated in the secondary 160 MHz
40 * @param primary160MHz whether the RU is allocated in the primary 160MHz channel (only for EHT)
41 * @return the created RU Specification.
42 */
43WifiRu::RuSpec
44MakeRuSpec(RuType ruType,
45 std::size_t index,
46 bool primaryOrLow80MHz,
47 std::optional<bool> primary160MHz = std::nullopt)
48{
49 if (!primary160MHz)
50 {
51 return HeRu::RuSpec{ruType, index, primaryOrLow80MHz};
52 }
53 return EhtRu::RuSpec{ruType, index, *primary160MHz, primaryOrLow80MHz};
54}
55
56} // namespace
57
58/**
59 * @ingroup wifi-test
60 * @ingroup tests
61 *
62 * @brief Tx Duration Test
63 */
64class TxDurationTest : public TestCase
65{
66 public:
67 TxDurationTest();
68 ~TxDurationTest() override;
69 void DoRun() override;
70
71 private:
72 /**
73 * Check if the payload tx duration returned by the PHY corresponds to a known value
74 *
75 * @param size size of payload in octets (includes everything after the PHY header)
76 * @param payloadMode the WifiMode used for the transmission
77 * @param channelWidth the channel width used for the transmission
78 * @param guardInterval the guard interval duration used for the transmission
79 * @param preamble the WifiPreamble used for the transmission
80 * @param knownDuration the known duration value of the transmission
81 *
82 * @return true if values correspond, false otherwise
83 */
84 bool CheckPayloadDuration(uint32_t size,
85 WifiMode payloadMode,
86 MHz_u channelWidth,
87 Time guardInterval,
88 WifiPreamble preamble,
89 Time knownDuration);
90
91 /**
92 * Check if the overall tx duration returned by the PHY corresponds to a known value
93 *
94 * @param size size of payload in octets (includes everything after the PHY header)
95 * @param payloadMode the WifiMode used for the transmission
96 * @param channelWidth the channel width used for the transmission
97 * @param guardInterval the guard interval duration used for the transmission
98 * @param preamble the WifiPreamble used for the transmission
99 * @param knownDuration the known duration value of the transmission
100 *
101 * @return true if values correspond, false otherwise
102 */
103 bool CheckTxDuration(uint32_t size,
104 WifiMode payloadMode,
105 MHz_u channelWidth,
106 Time guardInterval,
107 WifiPreamble preamble,
108 Time knownDuration);
109
110 /**
111 * Check if the overall Tx duration returned by WifiPhy for a MU PPDU
112 * corresponds to a known value
113 *
114 * @param sizes the list of PSDU sizes for each station in octets
115 * @param userInfos the list of HE MU specific user transmission parameters
116 * @param channelWidth the channel width used for the transmission
117 * @param guardInterval the guard interval duration used for the transmission
118 * @param preamble the WifiPreamble used for the transmission
119 * @param knownDuration the known duration value of the transmission
120 *
121 * @return true if values correspond, false otherwise
122 */
123 static bool CheckMuTxDuration(std::list<uint32_t> sizes,
124 std::list<HeMuUserInfo> userInfos,
125 MHz_u channelWidth,
126 Time guardInterval,
127 WifiPreamble preamble,
128 Time knownDuration);
129
130 /**
131 * Calculate the overall Tx duration returned by WifiPhy for list of sizes.
132 * A map of WifiPsdu indexed by STA-ID is built using the provided lists
133 * and handed over to the corresponding SU/MU WifiPhy Tx duration computing
134 * method.
135 * Note that provided lists should be of same size.
136 *
137 * @param sizes the list of PSDU sizes for each station in octets
138 * @param staIds the list of STA-IDs of each station
139 * @param txVector the TXVECTOR used for the transmission of the PPDU
140 * @param band the selected wifi PHY band
141 *
142 * @return the overall Tx duration for the list of sizes (SU or MU PPDU)
143 */
144 static Time CalculateTxDurationUsingList(std::list<uint32_t> sizes,
145 std::list<uint16_t> staIds,
146 WifiTxVector txVector,
147 WifiPhyBand band);
148};
149
150TxDurationTest::TxDurationTest()
151 : TestCase("Wifi TX Duration")
152{
153}
154
158
159bool
160TxDurationTest::CheckPayloadDuration(uint32_t size,
161 WifiMode payloadMode,
162 MHz_u channelWidth,
163 Time guardInterval,
164 WifiPreamble preamble,
165 Time knownDuration)
166{
167 WifiTxVector txVector;
168 txVector.SetMode(payloadMode);
169 txVector.SetPreambleType(preamble);
170 txVector.SetChannelWidth(channelWidth);
171 txVector.SetGuardInterval(guardInterval);
172 std::list<WifiPhyBand> testedBands;
173 Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
174 if ((payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM) && (channelWidth <= 160))
175 {
176 testedBands.push_back(WIFI_PHY_BAND_5GHZ);
177 }
178 if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_HE)
179 {
180 testedBands.push_back(WIFI_PHY_BAND_6GHZ);
181 }
182 if ((payloadMode.GetModulationClass() != WIFI_MOD_CLASS_OFDM) &&
183 (payloadMode.GetModulationClass() != WIFI_MOD_CLASS_VHT) && (channelWidth < 80))
184 {
185 testedBands.push_back(WIFI_PHY_BAND_2_4GHZ);
186 }
187 for (auto& testedBand : testedBands)
188 {
189 if ((testedBand == WIFI_PHY_BAND_2_4GHZ) &&
190 (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM))
191 {
192 knownDuration +=
193 MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
194 }
195 Time calculatedDuration = YansWifiPhy::GetPayloadDuration(size, txVector, testedBand);
196 if (calculatedDuration != knownDuration)
197 {
198 std::cerr << "size=" << size << " band=" << testedBand << " mode=" << payloadMode
199 << " channelWidth=" << channelWidth << " guardInterval=" << guardInterval
200 << " datarate=" << payloadMode.GetDataRate(channelWidth, guardInterval, 1)
201 << " known=" << knownDuration << " calculated=" << calculatedDuration
202 << std::endl;
203 return false;
204 }
205 }
206 return true;
207}
208
209bool
210TxDurationTest::CheckTxDuration(uint32_t size,
211 WifiMode payloadMode,
212 MHz_u channelWidth,
213 Time guardInterval,
214 WifiPreamble preamble,
215 Time knownDuration)
216{
217 WifiTxVector txVector{};
218 txVector.SetMode(payloadMode);
219 txVector.SetPreambleType(preamble);
220 txVector.SetChannelWidth(channelWidth);
221 txVector.SetGuardInterval(guardInterval);
222 std::list<WifiPhyBand> testedBands;
223 Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
224 if ((payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM) && (channelWidth <= 160))
225 {
226 testedBands.push_back(WIFI_PHY_BAND_5GHZ);
227 }
228 if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_HE)
229 {
230 testedBands.push_back(WIFI_PHY_BAND_6GHZ);
231 }
232 if ((payloadMode.GetModulationClass() != WIFI_MOD_CLASS_OFDM) &&
233 (payloadMode.GetModulationClass() != WIFI_MOD_CLASS_VHT) && (channelWidth < 80))
234 {
235 testedBands.push_back(WIFI_PHY_BAND_2_4GHZ);
236 }
237 for (auto& testedBand : testedBands)
238 {
239 if ((testedBand == WIFI_PHY_BAND_2_4GHZ) &&
240 (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM))
241 {
242 knownDuration +=
243 MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
244 }
245 Time calculatedDuration = YansWifiPhy::CalculateTxDuration(size, txVector, testedBand);
246 Time calculatedDurationUsingList =
247 CalculateTxDurationUsingList(std::list<uint32_t>{size},
248 std::list<uint16_t>{SU_STA_ID},
249 txVector,
250 testedBand);
251 if (calculatedDuration != knownDuration ||
252 calculatedDuration != calculatedDurationUsingList)
253 {
254 std::cerr << "size=" << size << " band=" << testedBand << " mode=" << payloadMode
255 << " channelWidth=" << +channelWidth << " guardInterval=" << guardInterval
256 << " datarate=" << payloadMode.GetDataRate(channelWidth, guardInterval, 1)
257 << " preamble=" << preamble << " known=" << knownDuration
258 << " calculated=" << calculatedDuration
259 << " calculatedUsingList=" << calculatedDurationUsingList << std::endl;
260 return false;
261 }
262 }
263 return true;
264}
265
266bool
267TxDurationTest::CheckMuTxDuration(std::list<uint32_t> sizes,
268 std::list<HeMuUserInfo> userInfos,
269 MHz_u channelWidth,
270 Time guardInterval,
271 WifiPreamble preamble,
272 Time knownDuration)
273{
274 NS_ASSERT(sizes.size() == userInfos.size() && sizes.size() > 1);
275 NS_ABORT_MSG_IF(
276 channelWidth < std::accumulate(
277 std::begin(userInfos),
278 std::end(userInfos),
279 MHz_u{0},
280 [](const MHz_u prevBw, const HeMuUserInfo& info) {
281 return prevBw + WifiRu::GetBandwidth(WifiRu::GetRuType(info.ru));
282 }),
283 "Cannot accommodate all the RUs in the provided band"); // MU-MIMO (for which allocations
284 // use the same RU) is not supported
285 WifiTxVector txVector;
286 txVector.SetPreambleType(preamble);
287 txVector.SetChannelWidth(channelWidth);
288 txVector.SetGuardInterval(guardInterval);
289 if (IsEht(preamble))
290 {
291 txVector.SetEhtPpduType(0);
292 }
293 std::list<uint16_t> staIds;
294
295 uint16_t staId = 1;
296 for (const auto& userInfo : userInfos)
297 {
298 txVector.SetHeMuUserInfo(staId, userInfo);
299 staIds.push_back(staId++);
300 }
301 txVector.SetSigBMode(VhtPhy::GetVhtMcs0());
302 const uint16_t ruAllocPer20 = IsEht(preamble) ? 64 : 192;
303 txVector.SetRuAllocation({ruAllocPer20, ruAllocPer20}, 0);
304
305 Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
306 std::list<WifiPhyBand> testedBands;
307 if (channelWidth <= 160)
308 {
309 testedBands.push_back(WIFI_PHY_BAND_5GHZ);
310 }
311 testedBands.push_back(WIFI_PHY_BAND_6GHZ);
312 if (channelWidth < 80)
313 {
314 // Durations vary depending on frequency; test also 2.4 GHz (bug 1971)
315 testedBands.push_back(WIFI_PHY_BAND_2_4GHZ);
316 }
317 for (auto& testedBand : testedBands)
318 {
319 if (testedBand == WIFI_PHY_BAND_2_4GHZ)
320 {
321 knownDuration +=
322 MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
323 }
324 Time calculatedDuration;
325 uint32_t longestSize = 0;
326 auto iterStaId = staIds.begin();
327 for (auto& size : sizes)
328 {
329 Time ppduDurationForSta =
330 YansWifiPhy::CalculateTxDuration(size, txVector, testedBand, *iterStaId);
331 if (ppduDurationForSta > calculatedDuration)
332 {
333 calculatedDuration = ppduDurationForSta;
334 staId = *iterStaId;
335 longestSize = size;
336 }
337 ++iterStaId;
338 }
339 Time calculatedDurationUsingList =
340 CalculateTxDurationUsingList(sizes, staIds, txVector, testedBand);
341 if (calculatedDuration != knownDuration ||
342 calculatedDuration != calculatedDurationUsingList)
343 {
344 std::cerr << "size=" << longestSize << " band=" << testedBand << " staId=" << staId
345 << " nss=" << +txVector.GetNss(staId) << " mode=" << txVector.GetMode(staId)
346 << " channelWidth=" << channelWidth << " guardInterval=" << guardInterval
347 << " datarate="
348 << txVector.GetMode(staId).GetDataRate(channelWidth,
349 guardInterval,
350 txVector.GetNss(staId))
351 << " known=" << knownDuration << " calculated=" << calculatedDuration
352 << " calculatedUsingList=" << calculatedDurationUsingList << std::endl;
353 return false;
354 }
355 }
356 return true;
357}
358
359Time
360TxDurationTest::CalculateTxDurationUsingList(std::list<uint32_t> sizes,
361 std::list<uint16_t> staIds,
362 WifiTxVector txVector,
363 WifiPhyBand band)
364{
365 NS_ASSERT(sizes.size() == staIds.size());
366 WifiConstPsduMap psduMap;
367 auto itStaId = staIds.begin();
368 WifiMacHeader hdr;
369 hdr.SetType(WIFI_MAC_CTL_ACK); // so that size may not be empty while being as short as possible
370 for (auto& size : sizes)
371 {
372 // MAC header and FCS are to deduce from size
373 psduMap[*itStaId++] =
374 Create<WifiPsdu>(Create<Packet>(size - hdr.GetSerializedSize() - 4), hdr);
375 }
376 return WifiPhy::CalculateTxDuration(psduMap, txVector, band);
377}
378
379void
380TxDurationTest::DoRun()
381{
382 bool retval = true;
383
384 // IEEE Std 802.11-2007 Table 18-2 "Example of LENGTH calculations for CCK"
385 retval = retval &&
386 CheckPayloadDuration(1023,
387 DsssPhy::GetDsssRate11Mbps(),
388 MHz_u{22},
389 NanoSeconds(800),
390 WIFI_PREAMBLE_LONG,
391 MicroSeconds(744)) &&
392 CheckPayloadDuration(1024,
393 DsssPhy::GetDsssRate11Mbps(),
394 MHz_u{22},
395 NanoSeconds(800),
396 WIFI_PREAMBLE_LONG,
397 MicroSeconds(745)) &&
398 CheckPayloadDuration(1025,
399 DsssPhy::GetDsssRate11Mbps(),
400 MHz_u{22},
401 NanoSeconds(800),
402 WIFI_PREAMBLE_LONG,
403 MicroSeconds(746)) &&
404 CheckPayloadDuration(1026,
405 DsssPhy::GetDsssRate11Mbps(),
406 MHz_u{22},
407 NanoSeconds(800),
408 WIFI_PREAMBLE_LONG,
409 MicroSeconds(747));
410
411 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11b CCK duration failed");
412
413 // Similar, but we add PHY preamble and header durations
414 // and we test different rates.
415 // The payload durations for modes other than 11mbb have been
416 // calculated by hand according to IEEE Std 802.11-2007 18.2.3.5
417 retval = retval &&
418 CheckTxDuration(1023,
419 DsssPhy::GetDsssRate11Mbps(),
420 MHz_u{22},
421 NanoSeconds(800),
422 WIFI_PREAMBLE_SHORT,
423 MicroSeconds(744 + 96)) &&
424 CheckTxDuration(1024,
425 DsssPhy::GetDsssRate11Mbps(),
426 MHz_u{22},
427 NanoSeconds(800),
428 WIFI_PREAMBLE_SHORT,
429 MicroSeconds(745 + 96)) &&
430 CheckTxDuration(1025,
431 DsssPhy::GetDsssRate11Mbps(),
432 MHz_u{22},
433 NanoSeconds(800),
434 WIFI_PREAMBLE_SHORT,
435 MicroSeconds(746 + 96)) &&
436 CheckTxDuration(1026,
437 DsssPhy::GetDsssRate11Mbps(),
438 MHz_u{22},
439 NanoSeconds(800),
440 WIFI_PREAMBLE_SHORT,
441 MicroSeconds(747 + 96)) &&
442 CheckTxDuration(1023,
443 DsssPhy::GetDsssRate11Mbps(),
444 MHz_u{22},
445 NanoSeconds(800),
446 WIFI_PREAMBLE_LONG,
447 MicroSeconds(744 + 192)) &&
448 CheckTxDuration(1024,
449 DsssPhy::GetDsssRate11Mbps(),
450 MHz_u{22},
451 NanoSeconds(800),
452 WIFI_PREAMBLE_LONG,
453 MicroSeconds(745 + 192)) &&
454 CheckTxDuration(1025,
455 DsssPhy::GetDsssRate11Mbps(),
456 MHz_u{22},
457 NanoSeconds(800),
458 WIFI_PREAMBLE_LONG,
459 MicroSeconds(746 + 192)) &&
460 CheckTxDuration(1026,
461 DsssPhy::GetDsssRate11Mbps(),
462 MHz_u{22},
463 NanoSeconds(800),
464 WIFI_PREAMBLE_LONG,
465 MicroSeconds(747 + 192)) &&
466 CheckTxDuration(1023,
467 DsssPhy::GetDsssRate5_5Mbps(),
468 MHz_u{22},
469 NanoSeconds(800),
470 WIFI_PREAMBLE_SHORT,
471 MicroSeconds(1488 + 96)) &&
472 CheckTxDuration(1024,
473 DsssPhy::GetDsssRate5_5Mbps(),
474 MHz_u{22},
475 NanoSeconds(800),
476 WIFI_PREAMBLE_SHORT,
477 MicroSeconds(1490 + 96)) &&
478 CheckTxDuration(1025,
479 DsssPhy::GetDsssRate5_5Mbps(),
480 MHz_u{22},
481 NanoSeconds(800),
482 WIFI_PREAMBLE_SHORT,
483 MicroSeconds(1491 + 96)) &&
484 CheckTxDuration(1026,
485 DsssPhy::GetDsssRate5_5Mbps(),
486 MHz_u{22},
487 NanoSeconds(800),
488 WIFI_PREAMBLE_SHORT,
489 MicroSeconds(1493 + 96)) &&
490 CheckTxDuration(1023,
491 DsssPhy::GetDsssRate5_5Mbps(),
492 MHz_u{22},
493 NanoSeconds(800),
494 WIFI_PREAMBLE_LONG,
495 MicroSeconds(1488 + 192)) &&
496 CheckTxDuration(1024,
497 DsssPhy::GetDsssRate5_5Mbps(),
498 MHz_u{22},
499 NanoSeconds(800),
500 WIFI_PREAMBLE_LONG,
501 MicroSeconds(1490 + 192)) &&
502 CheckTxDuration(1025,
503 DsssPhy::GetDsssRate5_5Mbps(),
504 MHz_u{22},
505 NanoSeconds(800),
506 WIFI_PREAMBLE_LONG,
507 MicroSeconds(1491 + 192)) &&
508 CheckTxDuration(1026,
509 DsssPhy::GetDsssRate5_5Mbps(),
510 MHz_u{22},
511 NanoSeconds(800),
512 WIFI_PREAMBLE_LONG,
513 MicroSeconds(1493 + 192)) &&
514 CheckTxDuration(1023,
515 DsssPhy::GetDsssRate2Mbps(),
516 MHz_u{22},
517 NanoSeconds(800),
518 WIFI_PREAMBLE_SHORT,
519 MicroSeconds(4092 + 96)) &&
520 CheckTxDuration(1024,
521 DsssPhy::GetDsssRate2Mbps(),
522 MHz_u{22},
523 NanoSeconds(800),
524 WIFI_PREAMBLE_SHORT,
525 MicroSeconds(4096 + 96)) &&
526 CheckTxDuration(1025,
527 DsssPhy::GetDsssRate2Mbps(),
528 MHz_u{22},
529 NanoSeconds(800),
530 WIFI_PREAMBLE_SHORT,
531 MicroSeconds(4100 + 96)) &&
532 CheckTxDuration(1026,
533 DsssPhy::GetDsssRate2Mbps(),
534 MHz_u{22},
535 NanoSeconds(800),
536 WIFI_PREAMBLE_SHORT,
537 MicroSeconds(4104 + 96)) &&
538 CheckTxDuration(1023,
539 DsssPhy::GetDsssRate2Mbps(),
540 MHz_u{22},
541 NanoSeconds(800),
542 WIFI_PREAMBLE_LONG,
543 MicroSeconds(4092 + 192)) &&
544 CheckTxDuration(1024,
545 DsssPhy::GetDsssRate2Mbps(),
546 MHz_u{22},
547 NanoSeconds(800),
548 WIFI_PREAMBLE_LONG,
549 MicroSeconds(4096 + 192)) &&
550 CheckTxDuration(1025,
551 DsssPhy::GetDsssRate2Mbps(),
552 MHz_u{22},
553 NanoSeconds(800),
554 WIFI_PREAMBLE_LONG,
555 MicroSeconds(4100 + 192)) &&
556 CheckTxDuration(1026,
557 DsssPhy::GetDsssRate2Mbps(),
558 MHz_u{22},
559 NanoSeconds(800),
560 WIFI_PREAMBLE_LONG,
561 MicroSeconds(4104 + 192)) &&
562 CheckTxDuration(1023,
563 DsssPhy::GetDsssRate1Mbps(),
564 MHz_u{22},
565 NanoSeconds(800),
566 WIFI_PREAMBLE_SHORT,
567 MicroSeconds(8184 + 192)) &&
568 CheckTxDuration(1024,
569 DsssPhy::GetDsssRate1Mbps(),
570 MHz_u{22},
571 NanoSeconds(800),
572 WIFI_PREAMBLE_SHORT,
573 MicroSeconds(8192 + 192)) &&
574 CheckTxDuration(1025,
575 DsssPhy::GetDsssRate1Mbps(),
576 MHz_u{22},
577 NanoSeconds(800),
578 WIFI_PREAMBLE_SHORT,
579 MicroSeconds(8200 + 192)) &&
580 CheckTxDuration(1026,
581 DsssPhy::GetDsssRate1Mbps(),
582 MHz_u{22},
583 NanoSeconds(800),
584 WIFI_PREAMBLE_SHORT,
585 MicroSeconds(8208 + 192)) &&
586 CheckTxDuration(1023,
587 DsssPhy::GetDsssRate1Mbps(),
588 MHz_u{22},
589 NanoSeconds(800),
590 WIFI_PREAMBLE_LONG,
591 MicroSeconds(8184 + 192)) &&
592 CheckTxDuration(1024,
593 DsssPhy::GetDsssRate1Mbps(),
594 MHz_u{22},
595 NanoSeconds(800),
596 WIFI_PREAMBLE_LONG,
597 MicroSeconds(8192 + 192)) &&
598 CheckTxDuration(1025,
599 DsssPhy::GetDsssRate1Mbps(),
600 MHz_u{22},
601 NanoSeconds(800),
602 WIFI_PREAMBLE_LONG,
603 MicroSeconds(8200 + 192)) &&
604 CheckTxDuration(1026,
605 DsssPhy::GetDsssRate1Mbps(),
606 MHz_u{22},
607 NanoSeconds(800),
608 WIFI_PREAMBLE_LONG,
609 MicroSeconds(8208 + 192));
610
611 // values from
612 // https://web.archive.org/web/20100711002639/http://mailman.isi.edu/pipermail/ns-developers/2009-July/006226.html
613 retval = retval && CheckTxDuration(14,
614 DsssPhy::GetDsssRate1Mbps(),
615 MHz_u{22},
616 NanoSeconds(800),
617 WIFI_PREAMBLE_LONG,
618 MicroSeconds(304));
619
620 // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
621 retval = retval &&
622 CheckTxDuration(1536,
623 DsssPhy::GetDsssRate11Mbps(),
624 MHz_u{22},
625 NanoSeconds(800),
626 WIFI_PREAMBLE_LONG,
627 MicroSeconds(1310)) &&
628 CheckTxDuration(76,
629 DsssPhy::GetDsssRate11Mbps(),
630 MHz_u{22},
631 NanoSeconds(800),
632 WIFI_PREAMBLE_LONG,
633 MicroSeconds(248)) &&
634 CheckTxDuration(14,
635 DsssPhy::GetDsssRate11Mbps(),
636 MHz_u{22},
637 NanoSeconds(800),
638 WIFI_PREAMBLE_LONG,
639 MicroSeconds(203));
640
641 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11b duration failed");
642
643 // 802.11a durations
644 // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
645 retval = retval &&
646 CheckTxDuration(1536,
647 OfdmPhy::GetOfdmRate54Mbps(),
648 MHz_u{20},
649 NanoSeconds(800),
650 WIFI_PREAMBLE_LONG,
651 MicroSeconds(248)) &&
652 CheckTxDuration(76,
653 OfdmPhy::GetOfdmRate54Mbps(),
654 MHz_u{20},
655 NanoSeconds(800),
656 WIFI_PREAMBLE_LONG,
657 MicroSeconds(32)) &&
658 CheckTxDuration(14,
659 OfdmPhy::GetOfdmRate54Mbps(),
660 MHz_u{20},
661 NanoSeconds(800),
662 WIFI_PREAMBLE_LONG,
663 MicroSeconds(24));
664
665 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11a duration failed");
666
667 // 802.11g durations are same as 802.11a durations but with 6 us signal extension
668 retval = retval &&
669 CheckTxDuration(1536,
670 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
671 MHz_u{20},
672 NanoSeconds(800),
673 WIFI_PREAMBLE_LONG,
674 MicroSeconds(254)) &&
675 CheckTxDuration(76,
676 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
677 MHz_u{20},
678 NanoSeconds(800),
679 WIFI_PREAMBLE_LONG,
680 MicroSeconds(38)) &&
681 CheckTxDuration(14,
682 ErpOfdmPhy::GetErpOfdmRate54Mbps(),
683 MHz_u{20},
684 NanoSeconds(800),
685 WIFI_PREAMBLE_LONG,
686 MicroSeconds(30));
687
688 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11g duration failed");
689
690 // 802.11n durations
691 retval = retval &&
692 CheckTxDuration(1536,
693 HtPhy::GetHtMcs7(),
694 MHz_u{20},
695 NanoSeconds(800),
696 WIFI_PREAMBLE_HT_MF,
697 MicroSeconds(228)) &&
698 CheckTxDuration(76,
699 HtPhy::GetHtMcs7(),
700 MHz_u{20},
701 NanoSeconds(800),
702 WIFI_PREAMBLE_HT_MF,
703 MicroSeconds(48)) &&
704 CheckTxDuration(14,
705 HtPhy::GetHtMcs7(),
706 MHz_u{20},
707 NanoSeconds(800),
708 WIFI_PREAMBLE_HT_MF,
709 MicroSeconds(40)) &&
710 CheckTxDuration(1536,
711 HtPhy::GetHtMcs0(),
712 MHz_u{20},
713 NanoSeconds(400),
714 WIFI_PREAMBLE_HT_MF,
715 NanoSeconds(1742400)) &&
716 CheckTxDuration(76,
717 HtPhy::GetHtMcs0(),
718 MHz_u{20},
719 NanoSeconds(400),
720 WIFI_PREAMBLE_HT_MF,
721 MicroSeconds(126)) &&
722 CheckTxDuration(14,
723 HtPhy::GetHtMcs0(),
724 MHz_u{20},
725 NanoSeconds(400),
726 WIFI_PREAMBLE_HT_MF,
727 NanoSeconds(57600)) &&
728 CheckTxDuration(1536,
729 HtPhy::GetHtMcs6(),
730 MHz_u{20},
731 NanoSeconds(400),
732 WIFI_PREAMBLE_HT_MF,
733 NanoSeconds(226800)) &&
734 CheckTxDuration(76,
735 HtPhy::GetHtMcs6(),
736 MHz_u{20},
737 NanoSeconds(400),
738 WIFI_PREAMBLE_HT_MF,
739 NanoSeconds(46800)) &&
740 CheckTxDuration(14,
741 HtPhy::GetHtMcs6(),
742 MHz_u{20},
743 NanoSeconds(400),
744 WIFI_PREAMBLE_HT_MF,
745 NanoSeconds(39600)) &&
746 CheckTxDuration(1536,
747 HtPhy::GetHtMcs7(),
748 MHz_u{40},
749 NanoSeconds(800),
750 WIFI_PREAMBLE_HT_MF,
751 MicroSeconds(128)) &&
752 CheckTxDuration(76,
753 HtPhy::GetHtMcs7(),
754 MHz_u{40},
755 NanoSeconds(800),
756 WIFI_PREAMBLE_HT_MF,
757 MicroSeconds(44)) &&
758 CheckTxDuration(14,
759 HtPhy::GetHtMcs7(),
760 MHz_u{40},
761 NanoSeconds(800),
762 WIFI_PREAMBLE_HT_MF,
763 MicroSeconds(40)) &&
764 CheckTxDuration(1536,
765 HtPhy::GetHtMcs7(),
766 MHz_u{40},
767 NanoSeconds(400),
768 WIFI_PREAMBLE_HT_MF,
769 NanoSeconds(118800)) &&
770 CheckTxDuration(76,
771 HtPhy::GetHtMcs7(),
772 MHz_u{40},
773 NanoSeconds(400),
774 WIFI_PREAMBLE_HT_MF,
775 NanoSeconds(43200)) &&
776 CheckTxDuration(14,
777 HtPhy::GetHtMcs7(),
778 MHz_u{40},
779 NanoSeconds(400),
780 WIFI_PREAMBLE_HT_MF,
781 NanoSeconds(39600));
782
783 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11n duration failed");
784
785 // 802.11ac durations
786 retval = retval &&
787 CheckTxDuration(1536,
788 VhtPhy::GetVhtMcs8(),
789 MHz_u{20},
790 NanoSeconds(800),
791 WIFI_PREAMBLE_VHT_SU,
792 MicroSeconds(196)) &&
793 CheckTxDuration(76,
794 VhtPhy::GetVhtMcs8(),
795 MHz_u{20},
796 NanoSeconds(800),
797 WIFI_PREAMBLE_VHT_SU,
798 MicroSeconds(48)) &&
799 CheckTxDuration(14,
800 VhtPhy::GetVhtMcs8(),
801 MHz_u{20},
802 NanoSeconds(800),
803 WIFI_PREAMBLE_VHT_SU,
804 MicroSeconds(40)) &&
805 CheckTxDuration(1536,
806 VhtPhy::GetVhtMcs8(),
807 MHz_u{20},
808 NanoSeconds(400),
809 WIFI_PREAMBLE_VHT_SU,
810 MicroSeconds(180)) &&
811 CheckTxDuration(76,
812 VhtPhy::GetVhtMcs8(),
813 MHz_u{20},
814 NanoSeconds(400),
815 WIFI_PREAMBLE_VHT_SU,
816 NanoSeconds(46800)) &&
817 CheckTxDuration(14,
818 VhtPhy::GetVhtMcs8(),
819 MHz_u{20},
820 NanoSeconds(400),
821 WIFI_PREAMBLE_VHT_SU,
822 NanoSeconds(39600)) &&
823 CheckTxDuration(1536,
824 VhtPhy::GetVhtMcs9(),
825 MHz_u{40},
826 NanoSeconds(800),
827 WIFI_PREAMBLE_VHT_SU,
828 MicroSeconds(108)) &&
829 CheckTxDuration(76,
830 VhtPhy::GetVhtMcs9(),
831 MHz_u{40},
832 NanoSeconds(800),
833 WIFI_PREAMBLE_VHT_SU,
834 MicroSeconds(40)) &&
835 CheckTxDuration(14,
836 VhtPhy::GetVhtMcs9(),
837 MHz_u{40},
838 NanoSeconds(800),
839 WIFI_PREAMBLE_VHT_SU,
840 MicroSeconds(40)) &&
841 CheckTxDuration(1536,
842 VhtPhy::GetVhtMcs9(),
843 MHz_u{40},
844 NanoSeconds(400),
845 WIFI_PREAMBLE_VHT_SU,
846 NanoSeconds(100800)) &&
847 CheckTxDuration(76,
848 VhtPhy::GetVhtMcs9(),
849 MHz_u{40},
850 NanoSeconds(400),
851 WIFI_PREAMBLE_VHT_SU,
852 NanoSeconds(39600)) &&
853 CheckTxDuration(14,
854 VhtPhy::GetVhtMcs9(),
855 MHz_u{40},
856 NanoSeconds(400),
857 WIFI_PREAMBLE_VHT_SU,
858 NanoSeconds(39600)) &&
859 CheckTxDuration(1536,
860 VhtPhy::GetVhtMcs0(),
861 MHz_u{80},
862 NanoSeconds(800),
863 WIFI_PREAMBLE_VHT_SU,
864 MicroSeconds(460)) &&
865 CheckTxDuration(76,
866 VhtPhy::GetVhtMcs0(),
867 MHz_u{80},
868 NanoSeconds(800),
869 WIFI_PREAMBLE_VHT_SU,
870 MicroSeconds(60)) &&
871 CheckTxDuration(14,
872 VhtPhy::GetVhtMcs0(),
873 MHz_u{80},
874 NanoSeconds(800),
875 WIFI_PREAMBLE_VHT_SU,
876 MicroSeconds(44)) &&
877 CheckTxDuration(1536,
878 VhtPhy::GetVhtMcs0(),
879 MHz_u{80},
880 NanoSeconds(400),
881 WIFI_PREAMBLE_VHT_SU,
882 NanoSeconds(417600)) &&
883 CheckTxDuration(76,
884 VhtPhy::GetVhtMcs0(),
885 MHz_u{80},
886 NanoSeconds(400),
887 WIFI_PREAMBLE_VHT_SU,
888 NanoSeconds(57600)) &&
889 CheckTxDuration(14,
890 VhtPhy::GetVhtMcs0(),
891 MHz_u{80},
892 NanoSeconds(400),
893 WIFI_PREAMBLE_VHT_SU,
894 NanoSeconds(43200)) &&
895 CheckTxDuration(1536,
896 VhtPhy::GetVhtMcs9(),
897 MHz_u{80},
898 NanoSeconds(800),
899 WIFI_PREAMBLE_VHT_SU,
900 MicroSeconds(68)) &&
901 CheckTxDuration(76,
902 VhtPhy::GetVhtMcs9(),
903 MHz_u{80},
904 NanoSeconds(800),
905 WIFI_PREAMBLE_VHT_SU,
906 MicroSeconds(40)) &&
907 CheckTxDuration(14,
908 VhtPhy::GetVhtMcs9(),
909 MHz_u{80},
910 NanoSeconds(800),
911 WIFI_PREAMBLE_VHT_SU,
912 MicroSeconds(40)) &&
913 CheckTxDuration(1536,
914 VhtPhy::GetVhtMcs9(),
915 MHz_u{80},
916 NanoSeconds(400),
917 WIFI_PREAMBLE_VHT_SU,
918 NanoSeconds(64800)) &&
919 CheckTxDuration(76,
920 VhtPhy::GetVhtMcs9(),
921 MHz_u{80},
922 NanoSeconds(400),
923 WIFI_PREAMBLE_VHT_SU,
924 NanoSeconds(39600)) &&
925 CheckTxDuration(14,
926 VhtPhy::GetVhtMcs9(),
927 MHz_u{80},
928 NanoSeconds(400),
929 WIFI_PREAMBLE_VHT_SU,
930 NanoSeconds(39600)) &&
931 CheckTxDuration(1536,
932 VhtPhy::GetVhtMcs8(),
933 MHz_u{160},
934 NanoSeconds(800),
935 WIFI_PREAMBLE_VHT_SU,
936 MicroSeconds(56)) &&
937 CheckTxDuration(76,
938 VhtPhy::GetVhtMcs8(),
939 MHz_u{160},
940 NanoSeconds(800),
941 WIFI_PREAMBLE_VHT_SU,
942 MicroSeconds(40)) &&
943 CheckTxDuration(14,
944 VhtPhy::GetVhtMcs8(),
945 MHz_u{160},
946 NanoSeconds(800),
947 WIFI_PREAMBLE_VHT_SU,
948 MicroSeconds(40)) &&
949 CheckTxDuration(1536,
950 VhtPhy::GetVhtMcs8(),
951 MHz_u{160},
952 NanoSeconds(400),
953 WIFI_PREAMBLE_VHT_SU,
954 MicroSeconds(54)) &&
955 CheckTxDuration(76,
956 VhtPhy::GetVhtMcs8(),
957 MHz_u{160},
958 NanoSeconds(400),
959 WIFI_PREAMBLE_VHT_SU,
960 NanoSeconds(39600)) &&
961 CheckTxDuration(14,
962 VhtPhy::GetVhtMcs8(),
963 MHz_u{160},
964 NanoSeconds(400),
965 WIFI_PREAMBLE_VHT_SU,
966 NanoSeconds(39600));
967
968 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ac duration failed");
969
970 // 802.11ax SU durations
971 retval = retval &&
972 CheckTxDuration(1536,
973 HePhy::GetHeMcs0(),
974 MHz_u{20},
975 NanoSeconds(800),
976 WIFI_PREAMBLE_HE_SU,
977 NanoSeconds(1485600)) &&
978 CheckTxDuration(76,
979 HePhy::GetHeMcs0(),
980 MHz_u{20},
981 NanoSeconds(800),
982 WIFI_PREAMBLE_HE_SU,
983 NanoSeconds(125600)) &&
984 CheckTxDuration(14,
985 HePhy::GetHeMcs0(),
986 MHz_u{20},
987 NanoSeconds(800),
988 WIFI_PREAMBLE_HE_SU,
989 NanoSeconds(71200)) &&
990 CheckTxDuration(1536,
991 HePhy::GetHeMcs0(),
992 MHz_u{40},
993 NanoSeconds(800),
994 WIFI_PREAMBLE_HE_SU,
995 NanoSeconds(764800)) &&
996 CheckTxDuration(76,
997 HePhy::GetHeMcs0(),
998 MHz_u{40},
999 NanoSeconds(800),
1000 WIFI_PREAMBLE_HE_SU,
1001 NanoSeconds(84800)) &&
1002 CheckTxDuration(14,
1003 HePhy::GetHeMcs0(),
1004 MHz_u{40},
1005 NanoSeconds(800),
1006 WIFI_PREAMBLE_HE_SU,
1007 NanoSeconds(57600)) &&
1008 CheckTxDuration(1536,
1009 HePhy::GetHeMcs0(),
1010 MHz_u{80},
1011 NanoSeconds(800),
1012 WIFI_PREAMBLE_HE_SU,
1013 NanoSeconds(397600)) &&
1014 CheckTxDuration(76,
1015 HePhy::GetHeMcs0(),
1016 MHz_u{80},
1017 NanoSeconds(800),
1018 WIFI_PREAMBLE_HE_SU,
1019 NanoSeconds(71200)) &&
1020 CheckTxDuration(14,
1021 HePhy::GetHeMcs0(),
1022 MHz_u{80},
1023 NanoSeconds(800),
1024 WIFI_PREAMBLE_HE_SU,
1025 NanoSeconds(57600)) &&
1026 CheckTxDuration(1536,
1027 HePhy::GetHeMcs0(),
1028 MHz_u{160},
1029 NanoSeconds(800),
1030 WIFI_PREAMBLE_HE_SU,
1031 NanoSeconds(220800)) &&
1032 CheckTxDuration(76,
1033 HePhy::GetHeMcs0(),
1034 MHz_u{160},
1035 NanoSeconds(800),
1036 WIFI_PREAMBLE_HE_SU,
1037 NanoSeconds(57600)) &&
1038 CheckTxDuration(14,
1039 HePhy::GetHeMcs0(),
1040 MHz_u{160},
1041 NanoSeconds(800),
1042 WIFI_PREAMBLE_HE_SU,
1043 NanoSeconds(57600)) &&
1044 CheckTxDuration(1536,
1045 HePhy::GetHeMcs0(),
1046 MHz_u{20},
1047 NanoSeconds(1600),
1048 WIFI_PREAMBLE_HE_SU,
1049 NanoSeconds(1570400)) &&
1050 CheckTxDuration(76,
1051 HePhy::GetHeMcs0(),
1052 MHz_u{20},
1053 NanoSeconds(1600),
1054 WIFI_PREAMBLE_HE_SU,
1055 NanoSeconds(130400)) &&
1056 CheckTxDuration(14,
1057 HePhy::GetHeMcs0(),
1058 MHz_u{20},
1059 NanoSeconds(1600),
1060 WIFI_PREAMBLE_HE_SU,
1061 NanoSeconds(72800)) &&
1062 CheckTxDuration(1536,
1063 HePhy::GetHeMcs0(),
1064 MHz_u{40},
1065 NanoSeconds(1600),
1066 WIFI_PREAMBLE_HE_SU,
1067 NanoSeconds(807200)) &&
1068 CheckTxDuration(76,
1069 HePhy::GetHeMcs0(),
1070 MHz_u{40},
1071 NanoSeconds(1600),
1072 WIFI_PREAMBLE_HE_SU,
1073 NanoSeconds(87200)) &&
1074 CheckTxDuration(14,
1075 HePhy::GetHeMcs0(),
1076 MHz_u{40},
1077 NanoSeconds(1600),
1078 WIFI_PREAMBLE_HE_SU,
1079 NanoSeconds(58400)) &&
1080 CheckTxDuration(1536,
1081 HePhy::GetHeMcs0(),
1082 MHz_u{80},
1083 NanoSeconds(1600),
1084 WIFI_PREAMBLE_HE_SU,
1085 NanoSeconds(418400)) &&
1086 CheckTxDuration(76,
1087 HePhy::GetHeMcs0(),
1088 MHz_u{80},
1089 NanoSeconds(1600),
1090 WIFI_PREAMBLE_HE_SU,
1091 NanoSeconds(72800)) &&
1092 CheckTxDuration(14,
1093 HePhy::GetHeMcs0(),
1094 MHz_u{80},
1095 NanoSeconds(1600),
1096 WIFI_PREAMBLE_HE_SU,
1097 NanoSeconds(58400)) &&
1098 CheckTxDuration(1536,
1099 HePhy::GetHeMcs0(),
1100 MHz_u{160},
1101 NanoSeconds(1600),
1102 WIFI_PREAMBLE_HE_SU,
1103 NanoSeconds(231200)) &&
1104 CheckTxDuration(76,
1105 HePhy::GetHeMcs0(),
1106 MHz_u{160},
1107 NanoSeconds(1600),
1108 WIFI_PREAMBLE_HE_SU,
1109 NanoSeconds(58400)) &&
1110 CheckTxDuration(14,
1111 HePhy::GetHeMcs0(),
1112 MHz_u{160},
1113 NanoSeconds(1600),
1114 WIFI_PREAMBLE_HE_SU,
1115 NanoSeconds(58400)) &&
1116 CheckTxDuration(1536,
1117 HePhy::GetHeMcs0(),
1118 MHz_u{20},
1119 NanoSeconds(3200),
1120 WIFI_PREAMBLE_HE_SU,
1121 MicroSeconds(1740)) &&
1122 CheckTxDuration(76,
1123 HePhy::GetHeMcs0(),
1124 MHz_u{20},
1125 NanoSeconds(3200),
1126 WIFI_PREAMBLE_HE_SU,
1127 MicroSeconds(140)) &&
1128 CheckTxDuration(14,
1129 HePhy::GetHeMcs0(),
1130 MHz_u{20},
1131 NanoSeconds(3200),
1132 WIFI_PREAMBLE_HE_SU,
1133 MicroSeconds(76)) &&
1134 CheckTxDuration(1536,
1135 HePhy::GetHeMcs0(),
1136 MHz_u{40},
1137 NanoSeconds(3200),
1138 WIFI_PREAMBLE_HE_SU,
1139 MicroSeconds(892)) &&
1140 CheckTxDuration(76,
1141 HePhy::GetHeMcs0(),
1142 MHz_u{40},
1143 NanoSeconds(3200),
1144 WIFI_PREAMBLE_HE_SU,
1145 MicroSeconds(92)) &&
1146 CheckTxDuration(14,
1147 HePhy::GetHeMcs0(),
1148 MHz_u{40},
1149 NanoSeconds(3200),
1150 WIFI_PREAMBLE_HE_SU,
1151 MicroSeconds(60)) &&
1152 CheckTxDuration(1536,
1153 HePhy::GetHeMcs0(),
1154 MHz_u{80},
1155 NanoSeconds(3200),
1156 WIFI_PREAMBLE_HE_SU,
1157 MicroSeconds(460)) &&
1158 CheckTxDuration(76,
1159 HePhy::GetHeMcs0(),
1160 MHz_u{80},
1161 NanoSeconds(3200),
1162 WIFI_PREAMBLE_HE_SU,
1163 MicroSeconds(76)) &&
1164 CheckTxDuration(14,
1165 HePhy::GetHeMcs0(),
1166 MHz_u{80},
1167 NanoSeconds(3200),
1168 WIFI_PREAMBLE_HE_SU,
1169 MicroSeconds(60)) &&
1170 CheckTxDuration(1536,
1171 HePhy::GetHeMcs0(),
1172 MHz_u{160},
1173 NanoSeconds(3200),
1174 WIFI_PREAMBLE_HE_SU,
1175 MicroSeconds(252)) &&
1176 CheckTxDuration(76,
1177 HePhy::GetHeMcs0(),
1178 MHz_u{160},
1179 NanoSeconds(3200),
1180 WIFI_PREAMBLE_HE_SU,
1181 MicroSeconds(60)) &&
1182 CheckTxDuration(14,
1183 HePhy::GetHeMcs0(),
1184 MHz_u{160},
1185 NanoSeconds(3200),
1186 WIFI_PREAMBLE_HE_SU,
1187 MicroSeconds(60)) &&
1188 CheckTxDuration(1536,
1189 HePhy::GetHeMcs11(),
1190 MHz_u{20},
1191 NanoSeconds(800),
1192 WIFI_PREAMBLE_HE_SU,
1193 NanoSeconds(139200)) &&
1194 CheckTxDuration(76,
1195 HePhy::GetHeMcs11(),
1196 MHz_u{20},
1197 NanoSeconds(800),
1198 WIFI_PREAMBLE_HE_SU,
1199 NanoSeconds(57600)) &&
1200 CheckTxDuration(14,
1201 HePhy::GetHeMcs11(),
1202 MHz_u{20},
1203 NanoSeconds(800),
1204 WIFI_PREAMBLE_HE_SU,
1205 NanoSeconds(57600)) &&
1206 CheckTxDuration(1536,
1207 HePhy::GetHeMcs11(),
1208 MHz_u{40},
1209 NanoSeconds(800),
1210 WIFI_PREAMBLE_HE_SU,
1211 NanoSeconds(98400)) &&
1212 CheckTxDuration(76,
1213 HePhy::GetHeMcs11(),
1214 MHz_u{40},
1215 NanoSeconds(800),
1216 WIFI_PREAMBLE_HE_SU,
1217 NanoSeconds(57600)) &&
1218 CheckTxDuration(14,
1219 HePhy::GetHeMcs11(),
1220 MHz_u{40},
1221 NanoSeconds(800),
1222 WIFI_PREAMBLE_HE_SU,
1223 NanoSeconds(57600)) &&
1224 CheckTxDuration(1536,
1225 HePhy::GetHeMcs11(),
1226 MHz_u{80},
1227 NanoSeconds(800),
1228 WIFI_PREAMBLE_HE_SU,
1229 NanoSeconds(71200)) &&
1230 CheckTxDuration(76,
1231 HePhy::GetHeMcs11(),
1232 MHz_u{80},
1233 NanoSeconds(800),
1234 WIFI_PREAMBLE_HE_SU,
1235 NanoSeconds(57600)) &&
1236 CheckTxDuration(14,
1237 HePhy::GetHeMcs11(),
1238 MHz_u{80},
1239 NanoSeconds(800),
1240 WIFI_PREAMBLE_HE_SU,
1241 NanoSeconds(57600)) &&
1242 CheckTxDuration(1536,
1243 HePhy::GetHeMcs11(),
1244 MHz_u{160},
1245 NanoSeconds(800),
1246 WIFI_PREAMBLE_HE_SU,
1247 NanoSeconds(57600)) &&
1248 CheckTxDuration(76,
1249 HePhy::GetHeMcs11(),
1250 MHz_u{160},
1251 NanoSeconds(800),
1252 WIFI_PREAMBLE_HE_SU,
1253 NanoSeconds(57600)) &&
1254 CheckTxDuration(14,
1255 HePhy::GetHeMcs11(),
1256 MHz_u{160},
1257 NanoSeconds(800),
1258 WIFI_PREAMBLE_HE_SU,
1259 NanoSeconds(57600)) &&
1260 CheckTxDuration(1536,
1261 HePhy::GetHeMcs11(),
1262 MHz_u{20},
1263 NanoSeconds(1600),
1264 WIFI_PREAMBLE_HE_SU,
1265 NanoSeconds(144800)) &&
1266 CheckTxDuration(76,
1267 HePhy::GetHeMcs11(),
1268 MHz_u{20},
1269 NanoSeconds(1600),
1270 WIFI_PREAMBLE_HE_SU,
1271 NanoSeconds(58400)) &&
1272 CheckTxDuration(14,
1273 HePhy::GetHeMcs11(),
1274 MHz_u{20},
1275 NanoSeconds(1600),
1276 WIFI_PREAMBLE_HE_SU,
1277 NanoSeconds(58400)) &&
1278 CheckTxDuration(1536,
1279 HePhy::GetHeMcs11(),
1280 MHz_u{40},
1281 NanoSeconds(1600),
1282 WIFI_PREAMBLE_HE_SU,
1283 NanoSeconds(101600)) &&
1284 CheckTxDuration(76,
1285 HePhy::GetHeMcs11(),
1286 MHz_u{40},
1287 NanoSeconds(1600),
1288 WIFI_PREAMBLE_HE_SU,
1289 NanoSeconds(58400)) &&
1290 CheckTxDuration(14,
1291 HePhy::GetHeMcs11(),
1292 MHz_u{40},
1293 NanoSeconds(1600),
1294 WIFI_PREAMBLE_HE_SU,
1295 NanoSeconds(58400)) &&
1296 CheckTxDuration(1536,
1297 HePhy::GetHeMcs11(),
1298 MHz_u{80},
1299 NanoSeconds(1600),
1300 WIFI_PREAMBLE_HE_SU,
1301 NanoSeconds(72800)) &&
1302 CheckTxDuration(76,
1303 HePhy::GetHeMcs11(),
1304 MHz_u{80},
1305 NanoSeconds(1600),
1306 WIFI_PREAMBLE_HE_SU,
1307 NanoSeconds(58400)) &&
1308 CheckTxDuration(14,
1309 HePhy::GetHeMcs11(),
1310 MHz_u{80},
1311 NanoSeconds(1600),
1312 WIFI_PREAMBLE_HE_SU,
1313 NanoSeconds(58400)) &&
1314 CheckTxDuration(1536,
1315 HePhy::GetHeMcs11(),
1316 MHz_u{160},
1317 NanoSeconds(1600),
1318 WIFI_PREAMBLE_HE_SU,
1319 NanoSeconds(58400)) &&
1320 CheckTxDuration(76,
1321 HePhy::GetHeMcs11(),
1322 MHz_u{160},
1323 NanoSeconds(1600),
1324 WIFI_PREAMBLE_HE_SU,
1325 NanoSeconds(58400)) &&
1326 CheckTxDuration(14,
1327 HePhy::GetHeMcs11(),
1328 MHz_u{160},
1329 NanoSeconds(1600),
1330 WIFI_PREAMBLE_HE_SU,
1331 NanoSeconds(58400)) &&
1332 CheckTxDuration(1536,
1333 HePhy::GetHeMcs11(),
1334 MHz_u{20},
1335 NanoSeconds(3200),
1336 WIFI_PREAMBLE_HE_SU,
1337 MicroSeconds(156)) &&
1338 CheckTxDuration(76,
1339 HePhy::GetHeMcs11(),
1340 MHz_u{20},
1341 NanoSeconds(3200),
1342 WIFI_PREAMBLE_HE_SU,
1343 MicroSeconds(60)) &&
1344 CheckTxDuration(14,
1345 HePhy::GetHeMcs11(),
1346 MHz_u{20},
1347 NanoSeconds(3200),
1348 WIFI_PREAMBLE_HE_SU,
1349 MicroSeconds(60)) &&
1350 CheckTxDuration(1536,
1351 HePhy::GetHeMcs11(),
1352 MHz_u{40},
1353 NanoSeconds(3200),
1354 WIFI_PREAMBLE_HE_SU,
1355 MicroSeconds(108)) &&
1356 CheckTxDuration(76,
1357 HePhy::GetHeMcs11(),
1358 MHz_u{40},
1359 NanoSeconds(3200),
1360 WIFI_PREAMBLE_HE_SU,
1361 MicroSeconds(60)) &&
1362 CheckTxDuration(14,
1363 HePhy::GetHeMcs11(),
1364 MHz_u{40},
1365 NanoSeconds(3200),
1366 WIFI_PREAMBLE_HE_SU,
1367 MicroSeconds(60)) &&
1368 CheckTxDuration(1536,
1369 HePhy::GetHeMcs11(),
1370 MHz_u{80},
1371 NanoSeconds(3200),
1372 WIFI_PREAMBLE_HE_SU,
1373 MicroSeconds(76)) &&
1374 CheckTxDuration(76,
1375 HePhy::GetHeMcs11(),
1376 MHz_u{80},
1377 NanoSeconds(3200),
1378 WIFI_PREAMBLE_HE_SU,
1379 MicroSeconds(60)) &&
1380 CheckTxDuration(14,
1381 HePhy::GetHeMcs11(),
1382 MHz_u{80},
1383 NanoSeconds(3200),
1384 WIFI_PREAMBLE_HE_SU,
1385 MicroSeconds(60)) &&
1386 CheckTxDuration(1536,
1387 HePhy::GetHeMcs11(),
1388 MHz_u{160},
1389 NanoSeconds(3200),
1390 WIFI_PREAMBLE_HE_SU,
1391 MicroSeconds(60)) &&
1392 CheckTxDuration(76,
1393 HePhy::GetHeMcs11(),
1394 MHz_u{160},
1395 NanoSeconds(3200),
1396 WIFI_PREAMBLE_HE_SU,
1397 MicroSeconds(60)) &&
1398 CheckTxDuration(14,
1399 HePhy::GetHeMcs11(),
1400 MHz_u{160},
1401 NanoSeconds(3200),
1402 WIFI_PREAMBLE_HE_SU,
1403 MicroSeconds(60));
1404
1405 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax SU duration failed");
1406
1407 // 802.11ax MU durations
1408 retval = retval &&
1409 CheckMuTxDuration(
1410 std::list<uint32_t>{1536, 1536},
1411 std::list<HeMuUserInfo>{{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 0, 1},
1412 {HeRu::RuSpec{RuType::RU_242_TONE, 2, true}, 0, 1}},
1413 MHz_u{40},
1414 NanoSeconds(800),
1415 WIFI_PREAMBLE_HE_MU,
1416 NanoSeconds(
1417 1493600)) // equivalent to HE_SU for 20 MHz with 2 extra HE-SIG-B (i.e. 8 us)
1418 && CheckMuTxDuration(
1419 std::list<uint32_t>{1536, 1536},
1420 std::list<HeMuUserInfo>{{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 1, 1},
1421 {HeRu::RuSpec{RuType::RU_242_TONE, 2, true}, 0, 1}},
1422 MHz_u{40},
1423 NanoSeconds(800),
1424 WIFI_PREAMBLE_HE_MU,
1425 NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
1426 && CheckMuTxDuration(
1427 std::list<uint32_t>{1536, 76},
1428 std::list<HeMuUserInfo>{{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 0, 1},
1429 {HeRu::RuSpec{RuType::RU_242_TONE, 2, true}, 0, 1}},
1430 MHz_u{40},
1431 NanoSeconds(800),
1432 WIFI_PREAMBLE_HE_MU,
1433 NanoSeconds(1493600));
1434
1435 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax MU duration failed");
1436
1437 // 802.11be SU durations
1438 retval = retval &&
1439 CheckTxDuration(1536,
1440 EhtPhy::GetEhtMcs0(),
1441 MHz_u{20},
1442 NanoSeconds(800),
1443 WIFI_PREAMBLE_EHT_MU,
1444 NanoSeconds(1493600)) &&
1445 CheckTxDuration(76,
1446 EhtPhy::GetEhtMcs0(),
1447 MHz_u{20},
1448 NanoSeconds(800),
1449 WIFI_PREAMBLE_EHT_MU,
1450 NanoSeconds(133600)) &&
1451 CheckTxDuration(14,
1452 EhtPhy::GetEhtMcs0(),
1453 MHz_u{20},
1454 NanoSeconds(800),
1455 WIFI_PREAMBLE_EHT_MU,
1456 NanoSeconds(79200)) &&
1457 CheckTxDuration(1536,
1458 EhtPhy::GetEhtMcs0(),
1459 MHz_u{40},
1460 NanoSeconds(800),
1461 WIFI_PREAMBLE_EHT_MU,
1462 NanoSeconds(772800)) &&
1463 CheckTxDuration(76,
1464 EhtPhy::GetEhtMcs0(),
1465 MHz_u{40},
1466 NanoSeconds(800),
1467 WIFI_PREAMBLE_EHT_MU,
1468 NanoSeconds(92800)) &&
1469 CheckTxDuration(14,
1470 EhtPhy::GetEhtMcs0(),
1471 MHz_u{40},
1472 NanoSeconds(800),
1473 WIFI_PREAMBLE_EHT_MU,
1474 NanoSeconds(65600)) &&
1475 CheckTxDuration(1536,
1476 EhtPhy::GetEhtMcs0(),
1477 MHz_u{80},
1478 NanoSeconds(800),
1479 WIFI_PREAMBLE_EHT_MU,
1480 NanoSeconds(409600)) &&
1481 CheckTxDuration(76,
1482 EhtPhy::GetEhtMcs0(),
1483 MHz_u{80},
1484 NanoSeconds(800),
1485 WIFI_PREAMBLE_EHT_MU,
1486 NanoSeconds(83200)) &&
1487 CheckTxDuration(14,
1488 EhtPhy::GetEhtMcs0(),
1489 MHz_u{80},
1490 NanoSeconds(800),
1491 WIFI_PREAMBLE_EHT_MU,
1492 NanoSeconds(69600)) &&
1493 CheckTxDuration(1536,
1494 EhtPhy::GetEhtMcs0(),
1495 MHz_u{160},
1496 NanoSeconds(800),
1497 WIFI_PREAMBLE_EHT_MU,
1498 NanoSeconds(232800)) &&
1499 CheckTxDuration(76,
1500 EhtPhy::GetEhtMcs0(),
1501 MHz_u{160},
1502 NanoSeconds(800),
1503 WIFI_PREAMBLE_EHT_MU,
1504 NanoSeconds(69600)) &&
1505 CheckTxDuration(14,
1506 EhtPhy::GetEhtMcs0(),
1507 MHz_u{160},
1508 NanoSeconds(800),
1509 WIFI_PREAMBLE_EHT_MU,
1510 NanoSeconds(69600)) &&
1511 CheckTxDuration(1536,
1512 EhtPhy::GetEhtMcs0(),
1513 MHz_u{320},
1514 NanoSeconds(800),
1515 WIFI_PREAMBLE_EHT_MU,
1516 NanoSeconds(159200)) &&
1517 CheckTxDuration(76,
1518 EhtPhy::GetEhtMcs0(),
1519 MHz_u{320},
1520 NanoSeconds(800),
1521 WIFI_PREAMBLE_EHT_MU,
1522 NanoSeconds(77600)) &&
1523 CheckTxDuration(14,
1524 EhtPhy::GetEhtMcs0(),
1525 MHz_u{320},
1526 NanoSeconds(800),
1527 WIFI_PREAMBLE_EHT_MU,
1528 NanoSeconds(77600)) &&
1529 CheckTxDuration(1536,
1530 EhtPhy::GetEhtMcs0(),
1531 MHz_u{20},
1532 NanoSeconds(1600),
1533 WIFI_PREAMBLE_EHT_MU,
1534 NanoSeconds(1578400)) &&
1535 CheckTxDuration(76,
1536 EhtPhy::GetEhtMcs0(),
1537 MHz_u{20},
1538 NanoSeconds(1600),
1539 WIFI_PREAMBLE_EHT_MU,
1540 NanoSeconds(138400)) &&
1541 CheckTxDuration(14,
1542 EhtPhy::GetEhtMcs0(),
1543 MHz_u{20},
1544 NanoSeconds(1600),
1545 WIFI_PREAMBLE_EHT_MU,
1546 NanoSeconds(80800)) &&
1547 CheckTxDuration(1536,
1548 EhtPhy::GetEhtMcs0(),
1549 MHz_u{40},
1550 NanoSeconds(1600),
1551 WIFI_PREAMBLE_EHT_MU,
1552 NanoSeconds(815200)) &&
1553 CheckTxDuration(76,
1554 EhtPhy::GetEhtMcs0(),
1555 MHz_u{40},
1556 NanoSeconds(1600),
1557 WIFI_PREAMBLE_EHT_MU,
1558 NanoSeconds(95200)) &&
1559 CheckTxDuration(14,
1560 EhtPhy::GetEhtMcs0(),
1561 MHz_u{40},
1562 NanoSeconds(1600),
1563 WIFI_PREAMBLE_EHT_MU,
1564 NanoSeconds(66400)) &&
1565 CheckTxDuration(1536,
1566 EhtPhy::GetEhtMcs0(),
1567 MHz_u{80},
1568 NanoSeconds(1600),
1569 WIFI_PREAMBLE_EHT_MU,
1570 NanoSeconds(430400)) &&
1571 CheckTxDuration(76,
1572 EhtPhy::GetEhtMcs0(),
1573 MHz_u{80},
1574 NanoSeconds(1600),
1575 WIFI_PREAMBLE_EHT_MU,
1576 NanoSeconds(84800)) &&
1577 CheckTxDuration(14,
1578 EhtPhy::GetEhtMcs0(),
1579 MHz_u{80},
1580 NanoSeconds(1600),
1581 WIFI_PREAMBLE_EHT_MU,
1582 NanoSeconds(70400)) &&
1583 CheckTxDuration(1536,
1584 EhtPhy::GetEhtMcs0(),
1585 MHz_u{160},
1586 NanoSeconds(1600),
1587 WIFI_PREAMBLE_EHT_MU,
1588 NanoSeconds(243200)) &&
1589 CheckTxDuration(76,
1590 EhtPhy::GetEhtMcs0(),
1591 MHz_u{160},
1592 NanoSeconds(1600),
1593 WIFI_PREAMBLE_EHT_MU,
1594 NanoSeconds(70400)) &&
1595 CheckTxDuration(14,
1596 EhtPhy::GetEhtMcs0(),
1597 MHz_u{160},
1598 NanoSeconds(1600),
1599 WIFI_PREAMBLE_EHT_MU,
1600 NanoSeconds(70400)) &&
1601 CheckTxDuration(1536,
1602 EhtPhy::GetEhtMcs0(),
1603 MHz_u{320},
1604 NanoSeconds(1600),
1605 WIFI_PREAMBLE_EHT_MU,
1606 NanoSeconds(164800)) &&
1607 CheckTxDuration(76,
1608 EhtPhy::GetEhtMcs0(),
1609 MHz_u{320},
1610 NanoSeconds(1600),
1611 WIFI_PREAMBLE_EHT_MU,
1612 NanoSeconds(78400)) &&
1613 CheckTxDuration(14,
1614 EhtPhy::GetEhtMcs0(),
1615 MHz_u{320},
1616 NanoSeconds(1600),
1617 WIFI_PREAMBLE_EHT_MU,
1618 NanoSeconds(78400)) &&
1619 CheckTxDuration(1536,
1620 EhtPhy::GetEhtMcs0(),
1621 MHz_u{20},
1622 NanoSeconds(3200),
1623 WIFI_PREAMBLE_EHT_MU,
1624 MicroSeconds(1748)) &&
1625 CheckTxDuration(76,
1626 EhtPhy::GetEhtMcs0(),
1627 MHz_u{20},
1628 NanoSeconds(3200),
1629 WIFI_PREAMBLE_EHT_MU,
1630 MicroSeconds(148)) &&
1631 CheckTxDuration(14,
1632 EhtPhy::GetEhtMcs0(),
1633 MHz_u{20},
1634 NanoSeconds(3200),
1635 WIFI_PREAMBLE_EHT_MU,
1636 MicroSeconds(84)) &&
1637 CheckTxDuration(1536,
1638 EhtPhy::GetEhtMcs0(),
1639 MHz_u{40},
1640 NanoSeconds(3200),
1641 WIFI_PREAMBLE_EHT_MU,
1642 MicroSeconds(900)) &&
1643 CheckTxDuration(76,
1644 EhtPhy::GetEhtMcs0(),
1645 MHz_u{40},
1646 NanoSeconds(3200),
1647 WIFI_PREAMBLE_EHT_MU,
1648 MicroSeconds(100)) &&
1649 CheckTxDuration(14,
1650 EhtPhy::GetEhtMcs0(),
1651 MHz_u{40},
1652 NanoSeconds(3200),
1653 WIFI_PREAMBLE_EHT_MU,
1654 MicroSeconds(68)) &&
1655 CheckTxDuration(1536,
1656 EhtPhy::GetEhtMcs0(),
1657 MHz_u{80},
1658 NanoSeconds(3200),
1659 WIFI_PREAMBLE_EHT_MU,
1660 MicroSeconds(472)) &&
1661 CheckTxDuration(76,
1662 EhtPhy::GetEhtMcs0(),
1663 MHz_u{80},
1664 NanoSeconds(3200),
1665 WIFI_PREAMBLE_EHT_MU,
1666 MicroSeconds(88)) &&
1667 CheckTxDuration(14,
1668 EhtPhy::GetEhtMcs0(),
1669 MHz_u{80},
1670 NanoSeconds(3200),
1671 WIFI_PREAMBLE_EHT_MU,
1672 MicroSeconds(72)) &&
1673 CheckTxDuration(1536,
1674 EhtPhy::GetEhtMcs0(),
1675 MHz_u{160},
1676 NanoSeconds(3200),
1677 WIFI_PREAMBLE_EHT_MU,
1678 MicroSeconds(264)) &&
1679 CheckTxDuration(76,
1680 EhtPhy::GetEhtMcs0(),
1681 MHz_u{160},
1682 NanoSeconds(3200),
1683 WIFI_PREAMBLE_EHT_MU,
1684 MicroSeconds(72)) &&
1685 CheckTxDuration(14,
1686 EhtPhy::GetEhtMcs0(),
1687 MHz_u{160},
1688 NanoSeconds(3200),
1689 WIFI_PREAMBLE_EHT_MU,
1690 MicroSeconds(72)) &&
1691 CheckTxDuration(1536,
1692 EhtPhy::GetEhtMcs0(),
1693 MHz_u{320},
1694 NanoSeconds(3200),
1695 WIFI_PREAMBLE_EHT_MU,
1696 MicroSeconds(176)) &&
1697 CheckTxDuration(76,
1698 EhtPhy::GetEhtMcs0(),
1699 MHz_u{320},
1700 NanoSeconds(3200),
1701 WIFI_PREAMBLE_EHT_MU,
1702 MicroSeconds(80)) &&
1703 CheckTxDuration(14,
1704 EhtPhy::GetEhtMcs0(),
1705 MHz_u{320},
1706 NanoSeconds(3200),
1707 WIFI_PREAMBLE_EHT_MU,
1708 MicroSeconds(80)) &&
1709 CheckTxDuration(1536,
1710 EhtPhy::GetEhtMcs13(),
1711 MHz_u{20},
1712 NanoSeconds(800),
1713 WIFI_PREAMBLE_EHT_MU,
1714 NanoSeconds(129600)) &&
1715 CheckTxDuration(76,
1716 EhtPhy::GetEhtMcs13(),
1717 MHz_u{20},
1718 NanoSeconds(800),
1719 WIFI_PREAMBLE_EHT_MU,
1720 NanoSeconds(61600)) &&
1721 CheckTxDuration(14,
1722 EhtPhy::GetEhtMcs13(),
1723 MHz_u{20},
1724 NanoSeconds(800),
1725 WIFI_PREAMBLE_EHT_MU,
1726 NanoSeconds(61600)) &&
1727 CheckTxDuration(1536,
1728 EhtPhy::GetEhtMcs13(),
1729 MHz_u{40},
1730 NanoSeconds(800),
1731 WIFI_PREAMBLE_EHT_MU,
1732 NanoSeconds(88800)) &&
1733 CheckTxDuration(76,
1734 EhtPhy::GetEhtMcs13(),
1735 MHz_u{40},
1736 NanoSeconds(800),
1737 WIFI_PREAMBLE_EHT_MU,
1738 NanoSeconds(61600)) &&
1739 CheckTxDuration(14,
1740 EhtPhy::GetEhtMcs13(),
1741 MHz_u{40},
1742 NanoSeconds(800),
1743 WIFI_PREAMBLE_EHT_MU,
1744 NanoSeconds(61600)) &&
1745 CheckTxDuration(1536,
1746 EhtPhy::GetEhtMcs13(),
1747 MHz_u{80},
1748 NanoSeconds(800),
1749 WIFI_PREAMBLE_EHT_MU,
1750 NanoSeconds(75200)) &&
1751 CheckTxDuration(76,
1752 EhtPhy::GetEhtMcs13(),
1753 MHz_u{80},
1754 NanoSeconds(800),
1755 WIFI_PREAMBLE_EHT_MU,
1756 NanoSeconds(61600)) &&
1757 CheckTxDuration(14,
1758 EhtPhy::GetEhtMcs13(),
1759 MHz_u{80},
1760 NanoSeconds(800),
1761 WIFI_PREAMBLE_EHT_MU,
1762 NanoSeconds(61600)) &&
1763 CheckTxDuration(1536,
1764 EhtPhy::GetEhtMcs13(),
1765 MHz_u{160},
1766 NanoSeconds(800),
1767 WIFI_PREAMBLE_EHT_MU,
1768 NanoSeconds(61600)) &&
1769 CheckTxDuration(76,
1770 EhtPhy::GetEhtMcs13(),
1771 MHz_u{160},
1772 NanoSeconds(800),
1773 WIFI_PREAMBLE_EHT_MU,
1774 NanoSeconds(61600)) &&
1775 CheckTxDuration(14,
1776 EhtPhy::GetEhtMcs13(),
1777 MHz_u{160},
1778 NanoSeconds(800),
1779 WIFI_PREAMBLE_EHT_MU,
1780 NanoSeconds(61600)) &&
1781 CheckTxDuration(1536,
1782 EhtPhy::GetEhtMcs13(),
1783 MHz_u{320},
1784 NanoSeconds(800),
1785 WIFI_PREAMBLE_EHT_MU,
1786 NanoSeconds(61600)) &&
1787 CheckTxDuration(76,
1788 EhtPhy::GetEhtMcs13(),
1789 MHz_u{320},
1790 NanoSeconds(800),
1791 WIFI_PREAMBLE_EHT_MU,
1792 NanoSeconds(61600)) &&
1793 CheckTxDuration(14,
1794 EhtPhy::GetEhtMcs13(),
1795 MHz_u{320},
1796 NanoSeconds(800),
1797 WIFI_PREAMBLE_EHT_MU,
1798 NanoSeconds(61600)) &&
1799 CheckTxDuration(1536,
1800 EhtPhy::GetEhtMcs13(),
1801 MHz_u{20},
1802 NanoSeconds(1600),
1803 WIFI_PREAMBLE_EHT_MU,
1804 NanoSeconds(134400)) &&
1805 CheckTxDuration(76,
1806 EhtPhy::GetEhtMcs13(),
1807 MHz_u{20},
1808 NanoSeconds(1600),
1809 WIFI_PREAMBLE_EHT_MU,
1810 NanoSeconds(62400)) &&
1811 CheckTxDuration(14,
1812 EhtPhy::GetEhtMcs13(),
1813 MHz_u{20},
1814 NanoSeconds(1600),
1815 WIFI_PREAMBLE_EHT_MU,
1816 NanoSeconds(62400)) &&
1817 CheckTxDuration(1536,
1818 EhtPhy::GetEhtMcs13(),
1819 MHz_u{40},
1820 NanoSeconds(1600),
1821 WIFI_PREAMBLE_EHT_MU,
1822 NanoSeconds(91200)) &&
1823 CheckTxDuration(76,
1824 EhtPhy::GetEhtMcs13(),
1825 MHz_u{40},
1826 NanoSeconds(1600),
1827 WIFI_PREAMBLE_EHT_MU,
1828 NanoSeconds(62400)) &&
1829 CheckTxDuration(14,
1830 EhtPhy::GetEhtMcs13(),
1831 MHz_u{40},
1832 NanoSeconds(1600),
1833 WIFI_PREAMBLE_EHT_MU,
1834 NanoSeconds(62400)) &&
1835 CheckTxDuration(1536,
1836 EhtPhy::GetEhtMcs13(),
1837 MHz_u{80},
1838 NanoSeconds(1600),
1839 WIFI_PREAMBLE_EHT_MU,
1840 NanoSeconds(76800)) &&
1841 CheckTxDuration(76,
1842 EhtPhy::GetEhtMcs13(),
1843 MHz_u{80},
1844 NanoSeconds(1600),
1845 WIFI_PREAMBLE_EHT_MU,
1846 NanoSeconds(62400)) &&
1847 CheckTxDuration(14,
1848 EhtPhy::GetEhtMcs13(),
1849 MHz_u{80},
1850 NanoSeconds(1600),
1851 WIFI_PREAMBLE_EHT_MU,
1852 NanoSeconds(62400)) &&
1853 CheckTxDuration(1536,
1854 EhtPhy::GetEhtMcs13(),
1855 MHz_u{160},
1856 NanoSeconds(1600),
1857 WIFI_PREAMBLE_EHT_MU,
1858 NanoSeconds(62400)) &&
1859 CheckTxDuration(76,
1860 EhtPhy::GetEhtMcs13(),
1861 MHz_u{160},
1862 NanoSeconds(1600),
1863 WIFI_PREAMBLE_EHT_MU,
1864 NanoSeconds(62400)) &&
1865 CheckTxDuration(14,
1866 EhtPhy::GetEhtMcs13(),
1867 MHz_u{160},
1868 NanoSeconds(1600),
1869 WIFI_PREAMBLE_EHT_MU,
1870 NanoSeconds(62400)) &&
1871 CheckTxDuration(1536,
1872 EhtPhy::GetEhtMcs13(),
1873 MHz_u{320},
1874 NanoSeconds(1600),
1875 WIFI_PREAMBLE_EHT_MU,
1876 NanoSeconds(62400)) &&
1877 CheckTxDuration(76,
1878 EhtPhy::GetEhtMcs13(),
1879 MHz_u{320},
1880 NanoSeconds(1600),
1881 WIFI_PREAMBLE_EHT_MU,
1882 NanoSeconds(62400)) &&
1883 CheckTxDuration(14,
1884 EhtPhy::GetEhtMcs13(),
1885 MHz_u{320},
1886 NanoSeconds(1600),
1887 WIFI_PREAMBLE_EHT_MU,
1888 NanoSeconds(62400)) &&
1889 CheckTxDuration(1536,
1890 EhtPhy::GetEhtMcs13(),
1891 MHz_u{20},
1892 NanoSeconds(3200),
1893 WIFI_PREAMBLE_EHT_MU,
1894 MicroSeconds(144)) &&
1895 CheckTxDuration(76,
1896 EhtPhy::GetEhtMcs13(),
1897 MHz_u{20},
1898 NanoSeconds(3200),
1899 WIFI_PREAMBLE_EHT_MU,
1900 MicroSeconds(64)) &&
1901 CheckTxDuration(14,
1902 EhtPhy::GetEhtMcs13(),
1903 MHz_u{20},
1904 NanoSeconds(3200),
1905 WIFI_PREAMBLE_EHT_MU,
1906 MicroSeconds(64)) &&
1907 CheckTxDuration(1536,
1908 EhtPhy::GetEhtMcs13(),
1909 MHz_u{40},
1910 NanoSeconds(3200),
1911 WIFI_PREAMBLE_EHT_MU,
1912 MicroSeconds(96)) &&
1913 CheckTxDuration(76,
1914 EhtPhy::GetEhtMcs13(),
1915 MHz_u{40},
1916 NanoSeconds(3200),
1917 WIFI_PREAMBLE_EHT_MU,
1918 MicroSeconds(64)) &&
1919 CheckTxDuration(14,
1920 EhtPhy::GetEhtMcs13(),
1921 MHz_u{40},
1922 NanoSeconds(3200),
1923 WIFI_PREAMBLE_EHT_MU,
1924 MicroSeconds(64)) &&
1925 CheckTxDuration(1536,
1926 EhtPhy::GetEhtMcs13(),
1927 MHz_u{80},
1928 NanoSeconds(3200),
1929 WIFI_PREAMBLE_EHT_MU,
1930 MicroSeconds(80)) &&
1931 CheckTxDuration(76,
1932 EhtPhy::GetEhtMcs13(),
1933 MHz_u{80},
1934 NanoSeconds(3200),
1935 WIFI_PREAMBLE_EHT_MU,
1936 MicroSeconds(64)) &&
1937 CheckTxDuration(14,
1938 EhtPhy::GetEhtMcs13(),
1939 MHz_u{80},
1940 NanoSeconds(3200),
1941 WIFI_PREAMBLE_EHT_MU,
1942 MicroSeconds(64)) &&
1943 CheckTxDuration(1536,
1944 EhtPhy::GetEhtMcs13(),
1945 MHz_u{160},
1946 NanoSeconds(3200),
1947 WIFI_PREAMBLE_EHT_MU,
1948 MicroSeconds(64)) &&
1949 CheckTxDuration(76,
1950 EhtPhy::GetEhtMcs13(),
1951 MHz_u{160},
1952 NanoSeconds(3200),
1953 WIFI_PREAMBLE_EHT_MU,
1954 MicroSeconds(64)) &&
1955 CheckTxDuration(14,
1956 EhtPhy::GetEhtMcs13(),
1957 MHz_u{160},
1958 NanoSeconds(3200),
1959 WIFI_PREAMBLE_EHT_MU,
1960 MicroSeconds(64)) &&
1961 CheckTxDuration(1536,
1962 EhtPhy::GetEhtMcs13(),
1963 MHz_u{320},
1964 NanoSeconds(3200),
1965 WIFI_PREAMBLE_EHT_MU,
1966 MicroSeconds(64)) &&
1967 CheckTxDuration(76,
1968 EhtPhy::GetEhtMcs13(),
1969 MHz_u{320},
1970 NanoSeconds(3200),
1971 WIFI_PREAMBLE_EHT_MU,
1972 MicroSeconds(64)) &&
1973 CheckTxDuration(14,
1974 EhtPhy::GetEhtMcs13(),
1975 MHz_u{320},
1976 NanoSeconds(3200),
1977 WIFI_PREAMBLE_EHT_MU,
1978 MicroSeconds(64));
1979
1980 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11be SU duration failed");
1981
1982 // 802.11be MU durations
1983 retval =
1984 retval &&
1985 CheckMuTxDuration(
1986 std::list<uint32_t>{1536, 1536},
1987 std::list<HeMuUserInfo>{{EhtRu::RuSpec{RuType::RU_242_TONE, 1, true, true}, 0, 1},
1988 {EhtRu::RuSpec{RuType::RU_242_TONE, 2, true, true}, 0, 1}},
1989 MHz_u{40},
1990 NanoSeconds(800),
1991 WIFI_PREAMBLE_EHT_MU,
1992 NanoSeconds(1493600)) // equivalent to 802.11ax MU
1993 && CheckMuTxDuration(
1994 std::list<uint32_t>{1536, 1536},
1995 std::list<HeMuUserInfo>{{EhtRu::RuSpec{RuType::RU_242_TONE, 1, true, true}, 1, 1},
1996 {EhtRu::RuSpec{RuType::RU_242_TONE, 2, true, true}, 0, 1}},
1997 MHz_u{40},
1998 NanoSeconds(800),
1999 WIFI_PREAMBLE_EHT_MU,
2000 NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
2001 && CheckMuTxDuration(
2002 std::list<uint32_t>{1536, 76},
2003 std::list<HeMuUserInfo>{{EhtRu::RuSpec{RuType::RU_242_TONE, 1, true, true}, 0, 1},
2004 {EhtRu::RuSpec{RuType::RU_242_TONE, 2, true, true}, 0, 1}},
2005 MHz_u{40},
2006 NanoSeconds(800),
2007 WIFI_PREAMBLE_EHT_MU,
2008 NanoSeconds(1493600));
2009
2010 NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11be MU duration failed");
2011
2012 Simulator::Destroy();
2013}
2014
2015/**
2016 * @ingroup wifi-test
2017 * @ingroup tests
2018 *
2019 * @brief HE-SIG-B/EHT-SIG duration test
2020 */
2021class MuSigDurationTest : public TestCase
2022{
2023 public:
2024 /**
2025 * OFDMA or MU-MIMO
2026 */
2027 enum MuType
2028 {
2029 OFDMA = 0,
2030 MU_MIMO
2031 };
2032
2033 /**
2034 * Constructor
2035 *
2036 * @param userInfos the HE MU specific per-user information to use for the test
2037 * @param sigBMode the mode to transmit HE-SIG-B for the test
2038 * @param channelWidth the channel width to select for the test
2039 * @param p20Index the index of the primary20 channel
2040 * @param expectedMuType the expected MU type (OFDMA or MU-MIMO)
2041 * @param expectedRuAllocation the expected RuType::RU_ALLOCATION
2042 * @param expectedNumUsersPerCc the expected number of users per content channel
2043 * @param expectedSigBDuration the expected duration of the HE-SIG-B header
2044 */
2045 MuSigDurationTest(const std::list<HeMuUserInfo>& userInfos,
2046 const WifiMode& sigBMode,
2047 MHz_u channelWidth,
2048 uint8_t p20Index,
2049 MuType expectedMuType,
2050 const RuAllocation& expectedRuAllocation,
2051 const std::pair<std::size_t, std::size_t>& expectedNumUsersPerCc,
2052 Time expectedSigBDuration);
2053
2054 private:
2055 void DoRun() override;
2056 void DoTeardown() override;
2057
2058 /**
2059 * Build a TXVECTOR for HE MU or EHT MU.
2060 *
2061 * @return the configured TXVECTOR for HE MU or EHT MU
2062 */
2063 WifiTxVector BuildTxVector() const;
2064
2065 Ptr<YansWifiPhy> m_phy; ///< the PHY under test
2066
2067 std::list<HeMuUserInfo> m_userInfos; ///< HE MU specific per-user information
2068 WifiMode m_sigBMode; ///< Mode used to transmit HE-SIG-B
2069 MHz_u m_channelWidth; ///< Channel width
2070 uint8_t m_p20Index; ///< index of the primary20 channel
2071 MuType m_expectedMuType; ///< Expected MU type (OFDMA or MU-MIMO)
2072 RuAllocation m_expectedRuAllocation; ///< Expected RuType::RU_ALLOCATION
2073 std::pair<std::size_t, std::size_t>
2074 m_expectedNumUsersPerCc; ///< Expected number of users per content channel
2075 Time m_expectedSigBDuration; ///< Expected duration of the HE-SIG-B/EHT-SIG header
2076};
2077
2078MuSigDurationTest::MuSigDurationTest(
2079 const std::list<HeMuUserInfo>& userInfos,
2080 const WifiMode& sigBMode,
2081 MHz_u channelWidth,
2082 uint8_t p20Index,
2083 MuType expectedMuType,
2084 const RuAllocation& expectedRuAllocation,
2085 const std::pair<std::size_t, std::size_t>& expectedNumUsersPerCc,
2086 Time expectedSigBDuration)
2087 : TestCase{"Check HE-SIG-B or EHT-SIG duration computation"},
2088 m_userInfos{userInfos},
2089 m_sigBMode{sigBMode},
2090 m_channelWidth{channelWidth},
2091 m_p20Index{p20Index},
2092 m_expectedMuType{expectedMuType},
2093 m_expectedRuAllocation{expectedRuAllocation},
2094 m_expectedNumUsersPerCc{expectedNumUsersPerCc},
2095 m_expectedSigBDuration{expectedSigBDuration}
2096{
2097}
2098
2099WifiTxVector
2100MuSigDurationTest::BuildTxVector() const
2101{
2102 const auto isHe = WifiRu::IsHe(m_userInfos.begin()->ru);
2103 WifiTxVector txVector;
2104 txVector.SetPreambleType(isHe ? WIFI_PREAMBLE_HE_MU : WIFI_PREAMBLE_EHT_MU);
2105 txVector.SetChannelWidth(m_channelWidth);
2106 txVector.SetGuardInterval(NanoSeconds(3200));
2107 txVector.SetStbc(false);
2108 txVector.SetNess(0);
2109 std::list<uint16_t> staIds;
2110 uint16_t staId = 1;
2111 if (!isHe)
2112 {
2113 txVector.SetEhtPpduType(0);
2114 }
2115 for (const auto& userInfo : m_userInfos)
2116 {
2117 txVector.SetHeMuUserInfo(staId, userInfo);
2118 staIds.push_back(staId++);
2119 }
2120 txVector.SetSigBMode(m_sigBMode);
2121 NS_ASSERT(m_expectedMuType == OFDMA ? txVector.IsDlOfdma() : txVector.IsDlMuMimo());
2122 return txVector;
2123}
2124
2125void
2126MuSigDurationTest::DoRun()
2127{
2128 m_phy = CreateObject<YansWifiPhy>();
2129 auto channelNum = WifiPhyOperatingChannel::FindFirst(0,
2130 MHz_u{0},
2131 MHz_u{320},
2132 WIFI_STANDARD_80211be,
2133 WIFI_PHY_BAND_6GHZ)
2134 ->number;
2135 m_phy->SetOperatingChannel(
2136 WifiPhy::ChannelTuple{channelNum, 320, WIFI_PHY_BAND_6GHZ, m_p20Index});
2137 m_phy->ConfigureStandard(WIFI_STANDARD_80211be);
2138
2139 const auto& txVector = BuildTxVector();
2140 auto phyEntity = m_phy->GetPhyEntity(txVector.GetModulationClass());
2141
2142 // Verify mode for HE-SIG-B/EHT-SIG field
2143 NS_TEST_EXPECT_MSG_EQ(phyEntity->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
2144 m_sigBMode,
2145 "Incorrect mode used to send HE-SIG-B/EHT-SIG");
2146
2147 // Verify RuType::RU_ALLOCATION in TXVECTOR
2148 NS_TEST_EXPECT_MSG_EQ((txVector.GetRuAllocation(0) == m_expectedRuAllocation),
2149 true,
2150 "Incorrect RuType::RU_ALLOCATION");
2151
2152 // Verify number of users for content channels 1 and 2
2153 const auto& numUsersPerCc = HePpdu::GetNumRusPerHeSigBContentChannel(
2154 txVector.GetChannelWidth(),
2155 txVector.GetModulationClass(),
2156 txVector.GetRuAllocation(m_p20Index),
2157 txVector.GetCenter26ToneRuIndication(),
2158 txVector.IsSigBCompression(),
2159 txVector.IsSigBCompression() ? txVector.GetHeMuUserInfoMap().size() : 0);
2160 const auto contentChannels = HePpdu::GetHeSigBContentChannels(txVector, 0);
2161 NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
2162 m_expectedNumUsersPerCc.first,
2163 "Incorrect number of users in content channel 1");
2164 NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
2165 m_expectedNumUsersPerCc.second,
2166 "Incorrect number of users in content channel 2");
2167 NS_TEST_EXPECT_MSG_EQ(contentChannels.at(0).size(),
2168 m_expectedNumUsersPerCc.first,
2169 "Incorrect number of users in content channel 1");
2170 NS_TEST_EXPECT_MSG_EQ((contentChannels.size() > 1 ? contentChannels.at(1).size() : 0),
2171 m_expectedNumUsersPerCc.second,
2172 "Incorrect number of users in content channel 2");
2173
2174 // Verify total HE-SIG-B/EHT-SIG duration
2175 if (txVector.GetModulationClass() == WIFI_MOD_CLASS_HE)
2176 {
2177 NS_TEST_EXPECT_MSG_EQ(phyEntity->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
2178 m_expectedSigBDuration,
2179 "Incorrect duration for HE-SIG-B");
2180 }
2181 else // EHT
2182 {
2183 NS_TEST_EXPECT_MSG_EQ(phyEntity->GetDuration(WIFI_PPDU_FIELD_EHT_SIG, txVector),
2184 m_expectedSigBDuration,
2185 "Incorrect duration for EHT-SIG");
2186 }
2187
2188 // Verify user infos in reconstructed TX vector
2189 WifiConstPsduMap psdus;
2190 Time ppduDuration;
2191 for (std::size_t i = 0; i < m_userInfos.size(); ++i)
2192 {
2193 WifiMacHeader hdr;
2194 auto psdu = Create<WifiPsdu>(Create<Packet>(1000), hdr);
2195 ppduDuration = std::max(
2196 ppduDuration,
2197 WifiPhy::CalculateTxDuration(psdu->GetSize(), txVector, m_phy->GetPhyBand(), i + 1));
2198 psdus.insert(std::make_pair(i, psdu));
2199 }
2200 auto ppdu = phyEntity->BuildPpdu(psdus, txVector, ppduDuration);
2201 ppdu->ResetTxVector();
2202 const auto& rxVector = ppdu->GetTxVector();
2203 NS_TEST_EXPECT_MSG_EQ((txVector.GetHeMuUserInfoMap() == rxVector.GetHeMuUserInfoMap()),
2204 true,
2205 "Incorrect user infos in reconstructed TXVECTOR");
2206
2207 Simulator::Destroy();
2208}
2209
2210void
2211MuSigDurationTest::DoTeardown()
2212{
2213 m_phy->Dispose();
2214 m_phy = nullptr;
2215}
2216
2217/**
2218 * @ingroup wifi-test
2219 * @ingroup tests
2220 *
2221 * @brief PHY header sections consistency test
2222 */
2223class PhyHeaderSectionsTest : public TestCase
2224{
2225 public:
2226 PhyHeaderSectionsTest();
2227 ~PhyHeaderSectionsTest() override;
2228 void DoRun() override;
2229
2230 private:
2231 /**
2232 * Check if map of PHY header sections returned by a given PHY entity
2233 * corresponds to a known value
2234 *
2235 * @param obtained the map of PHY header sections to check
2236 * @param expected the expected map of PHY header sections
2237 */
2238 void CheckPhyHeaderSections(PhyHeaderSections obtained, PhyHeaderSections expected);
2239};
2240
2241PhyHeaderSectionsTest::PhyHeaderSectionsTest()
2242 : TestCase("PHY header sections consistency")
2243{
2244}
2245
2249
2250void
2251PhyHeaderSectionsTest::CheckPhyHeaderSections(PhyHeaderSections obtained,
2252 PhyHeaderSections expected)
2253{
2254 NS_ASSERT_MSG(obtained.size() == expected.size(),
2255 "The expected map size (" << expected.size() << ") was not obtained ("
2256 << obtained.size() << ")");
2257
2258 auto itObtained = obtained.begin();
2259 auto itExpected = expected.begin();
2260 for (; itObtained != obtained.end() || itExpected != expected.end();)
2261 {
2262 WifiPpduField field = itObtained->first;
2263 auto window = itObtained->second.first;
2264 auto mode = itObtained->second.second;
2265
2266 WifiPpduField fieldRef = itExpected->first;
2267 auto windowRef = itExpected->second.first;
2268 auto modeRef = itExpected->second.second;
2269
2270 NS_TEST_EXPECT_MSG_EQ(field,
2271 fieldRef,
2272 "The expected PPDU field (" << fieldRef << ") was not obtained ("
2273 << field << ")");
2274 NS_TEST_EXPECT_MSG_EQ(window.first,
2275 windowRef.first,
2276 "The expected start time (" << windowRef.first
2277 << ") was not obtained (" << window.first
2278 << ")");
2279 NS_TEST_EXPECT_MSG_EQ(window.second,
2280 windowRef.second,
2281 "The expected stop time (" << windowRef.second
2282 << ") was not obtained (" << window.second
2283 << ")");
2284 NS_TEST_EXPECT_MSG_EQ(mode,
2285 modeRef,
2286 "The expected mode (" << modeRef << ") was not obtained (" << mode
2287 << ")");
2288 ++itObtained;
2289 ++itExpected;
2290 }
2291}
2292
2293void
2294PhyHeaderSectionsTest::DoRun()
2295{
2296 Time ppduStart = Seconds(1);
2297 std::shared_ptr<PhyEntity> phyEntity;
2298 PhyHeaderSections sections;
2299 WifiTxVector txVector;
2300 WifiMode nonHtMode;
2301
2302 // ==================================================================================
2303 // 11b (HR/DSSS)
2304 phyEntity = std::make_shared<DsssPhy>();
2305 txVector.SetMode(DsssPhy::GetDsssRate1Mbps());
2306 txVector.SetChannelWidth(MHz_u{22});
2307
2308 // -> long PPDU format
2309 txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
2310 nonHtMode = DsssPhy::GetDsssRate1Mbps();
2311 sections = {
2312 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(144)}, nonHtMode}},
2313 {WIFI_PPDU_FIELD_NON_HT_HEADER,
2314 {{ppduStart + MicroSeconds(144), ppduStart + MicroSeconds(192)}, nonHtMode}},
2315 };
2316 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2317
2318 // -> long PPDU format if data rate is 1 Mbps (even if preamble is tagged short)
2319 txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
2320 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2321
2322 // -> short PPDU format
2323 txVector.SetMode(DsssPhy::GetDsssRate11Mbps());
2324 nonHtMode = DsssPhy::GetDsssRate2Mbps();
2325 txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
2326 sections = {
2327 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(72)}, nonHtMode}},
2328 {WIFI_PPDU_FIELD_NON_HT_HEADER,
2329 {{ppduStart + MicroSeconds(72), ppduStart + MicroSeconds(96)}, nonHtMode}},
2330 };
2331 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2332
2333 // ==================================================================================
2334 // 11a (OFDM)
2335 txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
2336
2337 // -> one iteration per variant: default, 10 MHz, and 5 MHz
2338 std::map<OfdmPhyVariant, std::size_t> variants{
2339 // number to use to deduce rate and BW info for each variant
2340 {OFDM_PHY_DEFAULT, 1},
2341 {OFDM_PHY_10_MHZ, 2},
2342 {OFDM_PHY_5_MHZ, 4},
2343 };
2344 for (auto variant : variants)
2345 {
2346 phyEntity = std::make_shared<OfdmPhy>(variant.first);
2347 std::size_t ratio = variant.second;
2348 const auto bw = MHz_u{20} / ratio;
2349 txVector.SetChannelWidth(bw);
2350 txVector.SetMode(OfdmPhy::GetOfdmRate(12000000 / ratio, bw));
2351 nonHtMode = OfdmPhy::GetOfdmRate(6000000 / ratio, bw);
2352 sections = {
2353 {WIFI_PPDU_FIELD_PREAMBLE,
2354 {{ppduStart, ppduStart + MicroSeconds(16 * ratio)}, nonHtMode}},
2355 {WIFI_PPDU_FIELD_NON_HT_HEADER,
2356 {{ppduStart + MicroSeconds(16 * ratio), ppduStart + MicroSeconds(20 * ratio)},
2357 nonHtMode}},
2358 };
2359 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2360 }
2361
2362 // ==================================================================================
2363 // 11g (ERP-OFDM)
2364 phyEntity = std::make_shared<ErpOfdmPhy>();
2365 txVector.SetChannelWidth(MHz_u{20});
2366 txVector.SetMode(ErpOfdmPhy::GetErpOfdmRate(54000000));
2367 nonHtMode = ErpOfdmPhy::GetErpOfdmRate6Mbps();
2368 sections = {
2369 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
2370 {WIFI_PPDU_FIELD_NON_HT_HEADER,
2371 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
2372 };
2373 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2374
2375 // ==================================================================================
2376 // 11n (HT)
2377 phyEntity = std::make_shared<HtPhy>(4);
2378 txVector.SetChannelWidth(MHz_u{20});
2379 txVector.SetMode(HtPhy::GetHtMcs6());
2380 nonHtMode = OfdmPhy::GetOfdmRate6Mbps();
2381 WifiMode htSigMode = nonHtMode;
2382
2383 // -> HT-mixed format for 2 SS and no ESS
2384 txVector.SetPreambleType(WIFI_PREAMBLE_HT_MF);
2385 txVector.SetNss(2);
2386 txVector.SetNess(0);
2387 sections = {
2388 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
2389 {WIFI_PPDU_FIELD_NON_HT_HEADER,
2390 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
2391 {WIFI_PPDU_FIELD_HT_SIG,
2392 {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, htSigMode}},
2393 {WIFI_PPDU_FIELD_TRAINING,
2394 {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(40)}, // 1 HT-STF + 2 HT-LTFs
2395 htSigMode}},
2396 };
2397 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2398 txVector.SetChannelWidth(MHz_u{20}); // shouldn't have any impact
2399 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2400
2401 // -> HT-mixed format for 3 SS and 1 ESS
2402 txVector.SetNss(3);
2403 txVector.SetNess(1);
2404 sections[WIFI_PPDU_FIELD_TRAINING] = {
2405 {ppduStart + MicroSeconds(28),
2406 ppduStart + MicroSeconds(52)}, // 1 HT-STF + 5 HT-LTFs (4 data + 1 extension)
2407 htSigMode};
2408 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2409
2410 // ==================================================================================
2411 // 11ac (VHT)
2412 phyEntity = std::make_shared<VhtPhy>();
2413 txVector.SetChannelWidth(MHz_u{20});
2414 txVector.SetNess(0);
2415 txVector.SetMode(VhtPhy::GetVhtMcs7());
2416 WifiMode sigAMode = nonHtMode;
2417 WifiMode sigBMode = VhtPhy::GetVhtMcs0();
2418
2419 // -> VHT SU format for 5 SS
2420 txVector.SetPreambleType(WIFI_PREAMBLE_VHT_SU);
2421 txVector.SetNss(5);
2422 sections = {
2423 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
2424 {WIFI_PPDU_FIELD_NON_HT_HEADER,
2425 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
2426 {WIFI_PPDU_FIELD_SIG_A,
2427 {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, sigAMode}},
2428 {WIFI_PPDU_FIELD_TRAINING,
2429 {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(56)}, // 1 VHT-STF + 6 VHT-LTFs
2430 sigAMode}},
2431 };
2432 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2433
2434 // -> VHT SU format for 7 SS
2435 txVector.SetNss(7);
2436 sections[WIFI_PPDU_FIELD_TRAINING] = {
2437 {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(64)}, // 1 VHT-STF + 8 VHT-LTFs
2438 sigAMode};
2439 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2440
2441 // -> VHT MU format for 3 SS
2442 txVector.SetPreambleType(WIFI_PREAMBLE_VHT_MU);
2443 txVector.SetNss(3);
2444 sections[WIFI_PPDU_FIELD_TRAINING] = {
2445 {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(48)}, // 1 VHT-STF + 4 VHT-LTFs
2446 sigAMode};
2447 sections[WIFI_PPDU_FIELD_SIG_B] = {{ppduStart + MicroSeconds(48), ppduStart + MicroSeconds(52)},
2448 sigBMode};
2449 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2450 txVector.SetChannelWidth(MHz_u{80}); // shouldn't have any impact
2451 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2452
2453 // ==================================================================================
2454 // 11ax (HE)
2455 phyEntity = std::make_shared<HePhy>();
2456 txVector.SetChannelWidth(MHz_u{20});
2457 txVector.SetNss(2); // HE-LTF duration assumed to be always 8 us for the time being (see note in
2458 // HePhy::GetTrainingDuration)
2459 txVector.SetMode(HePhy::GetHeMcs9());
2460 std::map<uint16_t, HeMuUserInfo> userInfoMap = {
2461 {1, {HeRu::RuSpec{RuType::RU_106_TONE, 1, true}, 4, 2}},
2462 {2, {HeRu::RuSpec{RuType::RU_106_TONE, 1, true}, 9, 1}}};
2463 sigAMode = HePhy::GetVhtMcs0();
2464 sigBMode = HePhy::GetVhtMcs4(); // because of first user info map
2465
2466 // -> HE SU format
2467 txVector.SetPreambleType(WIFI_PREAMBLE_HE_SU);
2468 sections = {
2469 {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
2470 {WIFI_PPDU_FIELD_NON_HT_HEADER,
2471 {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(24)}, // L-SIG + RL-SIG
2472 nonHtMode}},
2473 {WIFI_PPDU_FIELD_SIG_A,
2474 {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)}, sigAMode}},
2475 {WIFI_PPDU_FIELD_TRAINING,
2476 {{ppduStart + MicroSeconds(32),
2477 ppduStart + MicroSeconds(52)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
2478 sigAMode}},
2479 };
2480 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2481
2482 // -> HE ER SU format
2483 txVector.SetPreambleType(WIFI_PREAMBLE_HE_ER_SU);
2484 sections[WIFI_PPDU_FIELD_SIG_A] = {
2485 {ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(40)}, // 16 us HE-SIG-A
2486 sigAMode};
2487 sections[WIFI_PPDU_FIELD_TRAINING] = {
2488 {ppduStart + MicroSeconds(40),
2489 ppduStart + MicroSeconds(60)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
2490 sigAMode};
2491 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2492
2493 // -> HE TB format
2494 txVector.SetPreambleType(WIFI_PREAMBLE_HE_TB);
2495 txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
2496 txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
2497 sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
2498 sigAMode};
2499 sections[WIFI_PPDU_FIELD_TRAINING] = {
2500 {ppduStart + MicroSeconds(32),
2501 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 8 us) + 2 HE-LTFs (@ 8 us)
2502 sigAMode};
2503 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2504
2505 // -> HE MU format
2506 txVector.SetPreambleType(WIFI_PREAMBLE_HE_MU);
2507 txVector.SetSigBMode(sigBMode);
2508 txVector.SetRuAllocation({96}, 0);
2509 sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
2510 sigAMode};
2511 sections[WIFI_PPDU_FIELD_SIG_B] = {
2512 {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
2513 sigBMode};
2514 sections[WIFI_PPDU_FIELD_TRAINING] = {
2515 {ppduStart + MicroSeconds(36),
2516 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
2517 sigBMode};
2518 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2519 txVector.SetChannelWidth(MHz_u{160}); // shouldn't have any impact
2520 txVector.SetRuAllocation({96, 113, 113, 113, 113, 113, 113, 113}, 0);
2521
2522 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2523
2524 // ==================================================================================
2525 // 11be (EHT)
2526 sections.erase(WIFI_PPDU_FIELD_SIG_A); // FIXME: do we keep using separate type for 11be?
2527 sections.erase(WIFI_PPDU_FIELD_SIG_B); // FIXME: do we keep using separate type for 11be?
2528 phyEntity = std::make_shared<EhtPhy>();
2529 txVector.SetChannelWidth(MHz_u{20});
2530 txVector.SetNss(2); // EHT-LTF duration assumed to be always 8 us for the time being (see note
2531 // in HePhy::GetTrainingDuration)
2532 txVector.SetMode(EhtPhy::GetEhtMcs9());
2533 userInfoMap = {{1, {EhtRu::RuSpec{RuType::RU_52_TONE, 1, true, true}, 4, 2}},
2534 {2, {EhtRu::RuSpec{RuType::RU_52_TONE, 2, true, true}, 9, 1}},
2535 {3, {EhtRu::RuSpec{RuType::RU_52_TONE, 3, true, true}, 4, 2}},
2536 {4, {EhtRu::RuSpec{RuType::RU_52_TONE, 4, true, true}, 9, 1}}};
2537 WifiMode uSigMode = EhtPhy::GetVhtMcs0();
2538 WifiMode ehtSigMode = EhtPhy::GetVhtMcs4(); // because of first user info map
2539
2540 // -> EHT TB format
2541 txVector.SetPreambleType(WIFI_PREAMBLE_EHT_TB);
2542 txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
2543 txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
2544 sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
2545 uSigMode};
2546 sections[WIFI_PPDU_FIELD_TRAINING] = {
2547 {ppduStart + MicroSeconds(32),
2548 ppduStart + MicroSeconds(56)}, // 1 EHT-STF (@ 8 us) + 2 EHT-LTFs (@ 8 us)
2549 uSigMode};
2550 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2551
2552 // -> EHT MU format
2553 txVector.SetPreambleType(WIFI_PREAMBLE_EHT_MU);
2554 txVector.SetEhtPpduType(0); // EHT MU transmission
2555 txVector.SetRuAllocation({24}, 0);
2556 sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
2557 uSigMode};
2558 sections[WIFI_PPDU_FIELD_EHT_SIG] = {
2559 {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
2560 ehtSigMode};
2561 sections[WIFI_PPDU_FIELD_TRAINING] = {
2562 {ppduStart + MicroSeconds(36),
2563 ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
2564 ehtSigMode};
2565 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2566 txVector.SetChannelWidth(MHz_u{160}); // shouldn't have any impact
2567 txVector.SetRuAllocation({24, 27, 27, 27, 27, 27, 27, 27}, 0);
2568
2569 CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
2570}
2571
2572/**
2573 * @ingroup wifi-test
2574 * @ingroup tests
2575 *
2576 * @brief Tx Duration Test Suite
2577 */
2578class TxDurationTestSuite : public TestSuite
2579{
2580 public:
2581 TxDurationTestSuite();
2582};
2583
2584TxDurationTestSuite::TxDurationTestSuite()
2585 : TestSuite("wifi-devices-tx-duration", Type::UNIT)
2586{
2587 AddTestCase(new TxDurationTest, TestCase::Duration::QUICK);
2588
2589 AddTestCase(new PhyHeaderSectionsTest, TestCase::Duration::QUICK);
2590
2591 const auto p80OrLow80 = true;
2592 const auto s80OrHigh80 = false;
2593 for (const auto p160 :
2594 std::initializer_list<std::optional<bool>>{std::nullopt /* HE-SIG-B */,
2595 std::optional(true) /* EHT-SIG */})
2596 {
2597 // 20 MHz band, OFDMA, even number of users in content channel
2598 AddTestCase(
2599 new MuSigDurationTest({{MakeRuSpec(RuType::RU_106_TONE, 1, p80OrLow80, p160), 11, 1},
2600 {MakeRuSpec(RuType::RU_106_TONE, 2, p80OrLow80, p160), 10, 4}},
2601 VhtPhy::GetVhtMcs5(),
2602 MHz_u{20},
2603 0,
2604 MuSigDurationTest::OFDMA,
2605 (p160 == std::nullopt) ? RuAllocation{96} : RuAllocation{48},
2606 std::make_pair(2, 0), // both users in content channel 1
2607 MicroSeconds(4)), // one OFDM symbol;
2608 TestCase::Duration::QUICK);
2609
2610 // 40 MHz band, OFDMA, even number of users per content channel
2611 AddTestCase(new MuSigDurationTest(
2612 {{MakeRuSpec(RuType::RU_106_TONE, 1, p80OrLow80, p160), 11, 1}, // CC1
2613 {MakeRuSpec(RuType::RU_106_TONE, 2, p80OrLow80, p160), 10, 4}, // CC1
2614 {MakeRuSpec(RuType::RU_52_TONE, 5, p80OrLow80, p160), 4, 1}, // CC2
2615 {MakeRuSpec(RuType::RU_52_TONE, 6, p80OrLow80, p160), 6, 2}, // CC2
2616 {MakeRuSpec(RuType::RU_52_TONE, 7, p80OrLow80, p160), 5, 3}, // CC2
2617 {MakeRuSpec(RuType::RU_52_TONE, 8, p80OrLow80, p160), 6, 2}}, // CC2
2618 VhtPhy::GetVhtMcs4(),
2619 MHz_u{40},
2620 0,
2621 MuSigDurationTest::OFDMA,
2622 (p160 == std::nullopt) ? RuAllocation{96, 112} : RuAllocation{48, 24},
2623 std::make_pair(2, 4), // two users in content channel 1 and
2624 // four users in content channel 2
2625 MicroSeconds(4)), // one OFDM symbol;
2626 TestCase::Duration::QUICK);
2627
2628 // 40 MHz band, OFDMA, odd number of users in second content channel
2629 AddTestCase(new MuSigDurationTest(
2630 {{MakeRuSpec(RuType::RU_106_TONE, 1, p80OrLow80, p160), 11, 1}, // CC1
2631 {MakeRuSpec(RuType::RU_106_TONE, 2, p80OrLow80, p160), 10, 4}, // CC1
2632 {MakeRuSpec(RuType::RU_52_TONE, 5, p80OrLow80, p160), 4, 1}, // CC2
2633 {MakeRuSpec(RuType::RU_52_TONE, 6, p80OrLow80, p160), 6, 2}, // CC2
2634 {MakeRuSpec(RuType::RU_52_TONE, 7, p80OrLow80, p160), 5, 3}, // CC2
2635 {MakeRuSpec(RuType::RU_52_TONE, 8, p80OrLow80, p160), 6, 2}, // CC2
2636 {MakeRuSpec(RuType::RU_26_TONE, 14, p80OrLow80, p160), 3, 1}}, // CC2
2637 VhtPhy::GetVhtMcs3(),
2638 MHz_u{40},
2639 0,
2640 MuSigDurationTest::OFDMA,
2641 (p160 == std::nullopt) ? RuAllocation{96, 15} : RuAllocation{48, 15},
2642 std::make_pair(2, 5), // two users in content channel 1 and
2643 // five users in content channel 2
2644 MicroSeconds(8)), // two OFDM symbols
2645 TestCase::Duration::QUICK);
2646
2647 // 80 MHz band, OFDMA
2648 AddTestCase(new MuSigDurationTest(
2649 {{MakeRuSpec(RuType::RU_106_TONE, 1, p80OrLow80, p160), 11, 1}, // CC1
2650 {MakeRuSpec(RuType::RU_106_TONE, 2, p80OrLow80, p160), 10, 4}, // CC1
2651 {MakeRuSpec(RuType::RU_52_TONE, 5, p80OrLow80, p160), 4, 1}, // CC2
2652 {MakeRuSpec(RuType::RU_52_TONE, 6, p80OrLow80, p160), 6, 2}, // CC2
2653 {MakeRuSpec(RuType::RU_52_TONE, 7, p80OrLow80, p160), 5, 3}, // CC2
2654 {MakeRuSpec(RuType::RU_52_TONE, 8, p80OrLow80, p160), 6, 2}, // CC2
2655 {MakeRuSpec(RuType::RU_26_TONE, 14, p80OrLow80, p160), 3, 1}, // CC2
2656 {MakeRuSpec(RuType::RU_242_TONE, 3, p80OrLow80, p160), 1, 1}, // CC1
2657 {MakeRuSpec(RuType::RU_242_TONE, 4, p80OrLow80, p160), 4, 1}}, // CC2
2658 VhtPhy::GetVhtMcs1(),
2659 MHz_u{80},
2660 0,
2661 MuSigDurationTest::OFDMA,
2662 (p160 == std::nullopt) ? RuAllocation{96, 15, 192, 192}
2663 : RuAllocation{48, 15, 64, 64},
2664 std::make_pair(3, 6), // three users in content channel 1
2665 // and six users in content channel 2
2666 MicroSeconds(16)), // four OFDM symbols
2667 TestCase::Duration::QUICK);
2668
2669 // 80 MHz band, OFDMA, no central 26-tones RU
2670 AddTestCase(new MuSigDurationTest(
2671 {{MakeRuSpec(RuType::RU_26_TONE, 1, p80OrLow80, p160), 8, 1}, // CC1
2672 {MakeRuSpec(RuType::RU_26_TONE, 2, p80OrLow80, p160), 8, 1}, // CC1
2673 {MakeRuSpec(RuType::RU_26_TONE, 3, p80OrLow80, p160), 8, 1}, // CC1
2674 {MakeRuSpec(RuType::RU_26_TONE, 4, p80OrLow80, p160), 8, 1}, // CC1
2675 {MakeRuSpec(RuType::RU_26_TONE, 5, p80OrLow80, p160), 8, 1}, // CC1
2676 {MakeRuSpec(RuType::RU_26_TONE, 6, p80OrLow80, p160), 8, 1}, // CC1
2677 {MakeRuSpec(RuType::RU_26_TONE, 7, p80OrLow80, p160), 8, 1}, // CC1
2678 {MakeRuSpec(RuType::RU_26_TONE, 8, p80OrLow80, p160), 8, 1}, // CC1
2679 {MakeRuSpec(RuType::RU_26_TONE, 9, p80OrLow80, p160), 8, 1}, // CC1
2680 {MakeRuSpec(RuType::RU_26_TONE, 10, p80OrLow80, p160), 8, 1}, // CC2
2681 {MakeRuSpec(RuType::RU_26_TONE, 11, p80OrLow80, p160), 8, 1}, // CC2
2682 {MakeRuSpec(RuType::RU_26_TONE, 12, p80OrLow80, p160), 8, 1}, // CC2
2683 {MakeRuSpec(RuType::RU_26_TONE, 13, p80OrLow80, p160), 8, 1}, // CC2
2684 {MakeRuSpec(RuType::RU_26_TONE, 14, p80OrLow80, p160), 8, 1}, // CC2
2685 {MakeRuSpec(RuType::RU_26_TONE, 15, p80OrLow80, p160), 8, 1}, // CC2
2686 {MakeRuSpec(RuType::RU_26_TONE, 16, p80OrLow80, p160), 8, 1}, // CC2
2687 {MakeRuSpec(RuType::RU_26_TONE, 17, p80OrLow80, p160), 8, 1}, // CC2
2688 {MakeRuSpec(RuType::RU_26_TONE, 18, p80OrLow80, p160), 8, 1}, // CC2
2689 {MakeRuSpec(RuType::RU_26_TONE, 20, p80OrLow80, p160), 8, 1}, // CC1
2690 {MakeRuSpec(RuType::RU_26_TONE, 21, p80OrLow80, p160), 8, 1}, // CC1
2691 {MakeRuSpec(RuType::RU_26_TONE, 22, p80OrLow80, p160), 8, 1}, // CC1
2692 {MakeRuSpec(RuType::RU_26_TONE, 23, p80OrLow80, p160), 8, 1}, // CC1
2693 {MakeRuSpec(RuType::RU_26_TONE, 24, p80OrLow80, p160), 8, 1}, // CC1
2694 {MakeRuSpec(RuType::RU_26_TONE, 25, p80OrLow80, p160), 8, 1}, // CC1
2695 {MakeRuSpec(RuType::RU_26_TONE, 26, p80OrLow80, p160), 8, 1}, // CC1
2696 {MakeRuSpec(RuType::RU_26_TONE, 27, p80OrLow80, p160), 8, 1}, // CC1
2697 {MakeRuSpec(RuType::RU_26_TONE, 28, p80OrLow80, p160), 8, 1}, // CC2
2698 {MakeRuSpec(RuType::RU_26_TONE, 29, p80OrLow80, p160), 8, 1}, // CC2
2699 {MakeRuSpec(RuType::RU_26_TONE, 30, p80OrLow80, p160), 8, 1}, // CC2
2700 {MakeRuSpec(RuType::RU_26_TONE, 31, p80OrLow80, p160), 8, 1}, // CC2
2701 {MakeRuSpec(RuType::RU_26_TONE, 32, p80OrLow80, p160), 8, 1}, // CC2
2702 {MakeRuSpec(RuType::RU_26_TONE, 33, p80OrLow80, p160), 8, 1}, // CC2
2703 {MakeRuSpec(RuType::RU_26_TONE, 34, p80OrLow80, p160), 8, 1}, // CC2
2704 {MakeRuSpec(RuType::RU_26_TONE, 35, p80OrLow80, p160), 8, 1}, // CC2
2705 {MakeRuSpec(RuType::RU_26_TONE, 36, p80OrLow80, p160), 8, 1}, // CC2
2706 {MakeRuSpec(RuType::RU_26_TONE, 37, p80OrLow80, p160), 8, 1}}, // CC2
2707 VhtPhy::GetVhtMcs5(),
2708 MHz_u{80},
2709 0,
2710 MuSigDurationTest::OFDMA,
2711 {0, 0, 0, 0},
2712 std::make_pair(18, 18), // 18 users users in each content channel
2713 MicroSeconds(12)), // three OFDM symbols
2714 TestCase::Duration::QUICK);
2715
2716 // 160 MHz band, OFDMA, no central 26-tones RU
2717 AddTestCase(new MuSigDurationTest(
2718 {{MakeRuSpec(RuType::RU_106_TONE, 1, p80OrLow80, p160), 11, 1}, // CC1
2719 {MakeRuSpec(RuType::RU_106_TONE, 2, p80OrLow80, p160), 10, 4}, // CC1
2720 {MakeRuSpec(RuType::RU_52_TONE, 5, p80OrLow80, p160), 4, 1}, // CC2
2721 {MakeRuSpec(RuType::RU_52_TONE, 6, p80OrLow80, p160), 6, 2}, // CC2
2722 {MakeRuSpec(RuType::RU_52_TONE, 7, p80OrLow80, p160), 5, 3}, // CC2
2723 {MakeRuSpec(RuType::RU_52_TONE, 8, p80OrLow80, p160), 6, 2}, // CC2
2724 {MakeRuSpec(RuType::RU_26_TONE, 14, p80OrLow80, p160), 3, 1}, // CC2
2725 {MakeRuSpec(RuType::RU_242_TONE, 3, p80OrLow80, p160), 1, 1}, // CC1
2726 {MakeRuSpec(RuType::RU_242_TONE, 4, p80OrLow80, p160), 4, 1}, // CC2
2727 {MakeRuSpec(RuType::RU_996_TONE, 1, s80OrHigh80, p160),
2728 1,
2729 1}}, // CC1 or CC2 => CC1 for better split
2730 VhtPhy::GetVhtMcs1(),
2731 MHz_u{160},
2732 0,
2733 MuSigDurationTest::OFDMA,
2734 (p160 == std::nullopt) ? RuAllocation{96, 15, 192, 192, 208, 115, 208, 115}
2735 : RuAllocation{48, 15, 64, 64, 80, 30, 80, 30},
2736 std::make_pair(4, 6), // four users in content channel 1 and
2737 // seven users in content channel 2
2738 MicroSeconds(16)), // four OFDM symbols
2739 TestCase::Duration::QUICK);
2740
2741 // 20 MHz band, OFDMA, one unallocated RU at the middle
2742 AddTestCase(
2743 new MuSigDurationTest(
2744 {{MakeRuSpec(RuType::RU_26_TONE, 1, p80OrLow80, p160), 11, 1}, // CC1
2745 {MakeRuSpec(RuType::RU_26_TONE, 2, p80OrLow80, p160), 11, 1}, // CC1
2746 {MakeRuSpec(RuType::RU_26_TONE, 3, p80OrLow80, p160), 11, 1}, // CC1
2747 {MakeRuSpec(RuType::RU_26_TONE, 4, p80OrLow80, p160), 11, 1}, // CC1
2748 {MakeRuSpec(RuType::RU_26_TONE, 6, p80OrLow80, p160), 11, 1}, // CC1
2749 {MakeRuSpec(RuType::RU_26_TONE, 7, p80OrLow80, p160), 11, 1}, // CC1
2750 {MakeRuSpec(RuType::RU_26_TONE, 8, p80OrLow80, p160), 11, 1}, // CC1
2751 {MakeRuSpec(RuType::RU_26_TONE, 9, p80OrLow80, p160), 11, 1}}, // CC1
2752 VhtPhy::GetVhtMcs5(),
2753 MHz_u{20},
2754 0,
2755 MuSigDurationTest::OFDMA,
2756 {0},
2757 std::make_pair(9, 0), // 9 users (8 users + 1 empty user) in content channel 1
2758 MicroSeconds(8)), // two OFDM symbols
2759 TestCase::Duration::QUICK);
2760
2761 // 40 MHz band, OFDMA, unallocated RUs at the begin and at the end of the
2762 // first 20 MHz subband and in the middle of the second 20 MHz subband
2763 AddTestCase(
2764 new MuSigDurationTest(
2765 {{MakeRuSpec(RuType::RU_52_TONE, 2, p80OrLow80, p160), 10, 1}, // CC1
2766 {MakeRuSpec(RuType::RU_52_TONE, 3, p80OrLow80, p160), 10, 2}, // CC1
2767 {MakeRuSpec(RuType::RU_52_TONE, 5, p80OrLow80, p160), 11, 1}, // CC2
2768 {MakeRuSpec(RuType::RU_52_TONE, 8, p80OrLow80, p160), 11, 2}}, // CC2
2769 VhtPhy::GetVhtMcs5(),
2770 MHz_u{40},
2771 0,
2772 MuSigDurationTest::OFDMA,
2773 (p160 == std::nullopt) ? RuAllocation{112, 112} : RuAllocation{24, 24},
2774 std::make_pair(4,
2775 4), // 4 users (2 users + 2 empty users) in each content channel
2776 MicroSeconds(4)), // one OFDM symbol
2777 TestCase::Duration::QUICK);
2778
2779 // 40 MHz band, OFDMA, one unallocated RUs in the first 20 MHz subband and
2780 // two unallocated RUs in second 20 MHz subband
2781 AddTestCase(
2782 new MuSigDurationTest(
2783 {{MakeRuSpec(RuType::RU_52_TONE, 1, p80OrLow80, p160), 10, 1}, // CC1
2784 {MakeRuSpec(RuType::RU_52_TONE, 2, p80OrLow80, p160), 10, 2}, // CC1
2785 {MakeRuSpec(RuType::RU_52_TONE, 3, p80OrLow80, p160), 11, 1}, // CC1
2786 {MakeRuSpec(RuType::RU_52_TONE, 5, p80OrLow80, p160), 11, 2}, // CC2
2787 {MakeRuSpec(RuType::RU_52_TONE, 6, p80OrLow80, p160), 11, 3}}, // CC2
2788 VhtPhy::GetVhtMcs5(),
2789 MHz_u{40},
2790 0,
2791 MuSigDurationTest::OFDMA,
2792 (p160 == std::nullopt) ? RuAllocation{112, 112} : RuAllocation{24, 24},
2793 std::make_pair(4,
2794 4), // 4 users (3 users + 1 empty user) in content channel 1 and
2795 // 4 users (2 users + 2 empty users) in content channel 2
2796 MicroSeconds(4)), // one OFDM symbol
2797 TestCase::Duration::QUICK);
2798 }
2799
2800 // 80 MHz band, OFDMA, central 26-tones RU (11ax only)
2801 AddTestCase(new MuSigDurationTest(
2802 {{HeRu::RuSpec{RuType::RU_26_TONE, 1, true}, 8, 1}, // CC1
2803 {HeRu::RuSpec{RuType::RU_26_TONE, 2, true}, 8, 1}, // CC1
2804 {HeRu::RuSpec{RuType::RU_26_TONE, 3, true}, 8, 1}, // CC1
2805 {HeRu::RuSpec{RuType::RU_26_TONE, 4, true}, 8, 1}, // CC1
2806 {HeRu::RuSpec{RuType::RU_26_TONE, 5, true}, 8, 1}, // CC1
2807 {HeRu::RuSpec{RuType::RU_26_TONE, 6, true}, 8, 1}, // CC1
2808 {HeRu::RuSpec{RuType::RU_26_TONE, 7, true}, 8, 1}, // CC1
2809 {HeRu::RuSpec{RuType::RU_26_TONE, 8, true}, 8, 1}, // CC1
2810 {HeRu::RuSpec{RuType::RU_26_TONE, 9, true}, 8, 1}, // CC1
2811 {HeRu::RuSpec{RuType::RU_26_TONE, 10, true}, 8, 1}, // CC2
2812 {HeRu::RuSpec{RuType::RU_26_TONE, 11, true}, 8, 1}, // CC2
2813 {HeRu::RuSpec{RuType::RU_26_TONE, 12, true}, 8, 1}, // CC2
2814 {HeRu::RuSpec{RuType::RU_26_TONE, 13, true}, 8, 1}, // CC2
2815 {HeRu::RuSpec{RuType::RU_26_TONE, 14, true}, 8, 1}, // CC2
2816 {HeRu::RuSpec{RuType::RU_26_TONE, 15, true}, 8, 1}, // CC2
2817 {HeRu::RuSpec{RuType::RU_26_TONE, 16, true}, 8, 1}, // CC2
2818 {HeRu::RuSpec{RuType::RU_26_TONE, 17, true}, 8, 1}, // CC2
2819 {HeRu::RuSpec{RuType::RU_26_TONE, 18, true}, 8, 1}, // CC2
2820 {HeRu::RuSpec{RuType::RU_26_TONE, 19, true}, 8, 1}, // CC1
2821 {HeRu::RuSpec{RuType::RU_26_TONE, 20, true}, 8, 1}, // CC1
2822 {HeRu::RuSpec{RuType::RU_26_TONE, 21, true}, 8, 1}, // CC1
2823 {HeRu::RuSpec{RuType::RU_26_TONE, 22, true}, 8, 1}, // CC1
2824 {HeRu::RuSpec{RuType::RU_26_TONE, 23, true}, 8, 1}, // CC1
2825 {HeRu::RuSpec{RuType::RU_26_TONE, 24, true}, 8, 1}, // CC1
2826 {HeRu::RuSpec{RuType::RU_26_TONE, 25, true}, 8, 1}, // CC1
2827 {HeRu::RuSpec{RuType::RU_26_TONE, 26, true}, 8, 1}, // CC1
2828 {HeRu::RuSpec{RuType::RU_26_TONE, 27, true}, 8, 1}, // CC1
2829 {HeRu::RuSpec{RuType::RU_26_TONE, 28, true}, 8, 1}, // CC2
2830 {HeRu::RuSpec{RuType::RU_26_TONE, 29, true}, 8, 1}, // CC2
2831 {HeRu::RuSpec{RuType::RU_26_TONE, 30, true}, 8, 1}, // CC2
2832 {HeRu::RuSpec{RuType::RU_26_TONE, 31, true}, 8, 1}, // CC2
2833 {HeRu::RuSpec{RuType::RU_26_TONE, 32, true}, 8, 1}, // CC2
2834 {HeRu::RuSpec{RuType::RU_26_TONE, 33, true}, 8, 1}, // CC2
2835 {HeRu::RuSpec{RuType::RU_26_TONE, 34, true}, 8, 1}, // CC2
2836 {HeRu::RuSpec{RuType::RU_26_TONE, 35, true}, 8, 1}, // CC2
2837 {HeRu::RuSpec{RuType::RU_26_TONE, 36, true}, 8, 1}, // CC2
2838 {HeRu::RuSpec{RuType::RU_26_TONE, 37, true}, 8, 1}}, // CC2
2839 VhtPhy::GetVhtMcs5(),
2840 MHz_u{80},
2841 0,
2842 MuSigDurationTest::OFDMA,
2843 {0, 0, 0, 0},
2844 std::make_pair(19,
2845 18), // 19 users (18 users + 1 central tones-RU user) in content
2846 // channel 1 and 18 users user in content channel 2
2847 MicroSeconds(12)), // three OFDM symbols
2848 TestCase::Duration::QUICK);
2849
2850 // 160 MHz band, OFDMA, central 26-tones RU in low 80 MHz (11ax only)
2851 AddTestCase(new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_106_TONE, 1, true}, 11, 1}, // CC1
2852 {HeRu::RuSpec{RuType::RU_106_TONE, 2, true}, 10, 4}, // CC1
2853 {HeRu::RuSpec{RuType::RU_52_TONE, 5, true}, 4, 1}, // CC2
2854 {HeRu::RuSpec{RuType::RU_52_TONE, 6, true}, 6, 2}, // CC2
2855 {HeRu::RuSpec{RuType::RU_52_TONE, 7, true}, 5, 3}, // CC2
2856 {HeRu::RuSpec{RuType::RU_52_TONE, 8, true}, 6, 2}, // CC2
2857 {HeRu::RuSpec{RuType::RU_26_TONE, 14, true}, 3, 1}, // CC2
2858 {HeRu::RuSpec{RuType::RU_26_TONE, 19, true}, 8, 2}, // CC1
2859 {HeRu::RuSpec{RuType::RU_242_TONE, 3, true}, 1, 1}, // CC1
2860 {HeRu::RuSpec{RuType::RU_242_TONE, 4, true}, 4, 1}, // CC2
2861 {HeRu::RuSpec{RuType::RU_996_TONE, 1, false},
2862 1,
2863 1}}, // CC1 or CC2 => CC1 for better split
2864 VhtPhy::GetVhtMcs1(),
2865 MHz_u{160},
2866 0,
2867 MuSigDurationTest::OFDMA,
2868 {96, 15, 192, 192, 208, 115, 208, 115},
2869 std::make_pair(5, 6), // five users in content channel 1 and
2870 // seven users in content channel 2
2871 MicroSeconds(16)), // four OFDM symbols
2872 TestCase::Duration::QUICK);
2873
2874 // 160 MHz band, OFDMA, central 26-tones RU in high 80 MHz (11ax only)
2875 AddTestCase(
2876 new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_106_TONE, 1, true}, 11, 1}, // CC1
2877 {HeRu::RuSpec{RuType::RU_106_TONE, 2, true}, 10, 4}, // CC1
2878 {HeRu::RuSpec{RuType::RU_106_TONE, 3, true}, 11, 1}, // CC2
2879 {HeRu::RuSpec{RuType::RU_106_TONE, 4, true}, 10, 4}, // CC2
2880 {HeRu::RuSpec{RuType::RU_242_TONE, 3, true}, 10, 1}, // CC1
2881 {HeRu::RuSpec{RuType::RU_242_TONE, 4, true}, 11, 1}, // CC2
2882 {HeRu::RuSpec{RuType::RU_484_TONE, 1, false}, 7, 1}, // CC1 or CC2
2883 {HeRu::RuSpec{RuType::RU_26_TONE, 19, false}, 8, 2}, // CC2
2884 {HeRu::RuSpec{RuType::RU_484_TONE, 2, false}, 9, 1}}, // CC1 or CC2
2885 VhtPhy::GetVhtMcs5(),
2886 MHz_u{160},
2887 0,
2888 MuSigDurationTest::OFDMA,
2889 {96, 96, 192, 192, 200, 114, 114, 200},
2890 std::make_pair(4, 5), // two users in content channel 1 and
2891 // one user in content channel 2
2892 MicroSeconds(4)), // two OFDM symbols
2893 TestCase::Duration::QUICK);
2894
2895 // 160 MHz band, OFDMA, central 26-tones RU in both 80 MHz (11ax only)
2896 AddTestCase(
2897 new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_106_TONE, 1, true}, 11, 1}, // CC1
2898 {HeRu::RuSpec{RuType::RU_106_TONE, 2, true}, 10, 4}, // CC1
2899 {HeRu::RuSpec{RuType::RU_106_TONE, 3, true}, 11, 1}, // CC2
2900 {HeRu::RuSpec{RuType::RU_106_TONE, 4, true}, 10, 4}, // CC2
2901 {HeRu::RuSpec{RuType::RU_26_TONE, 19, true}, 8, 2}, // CC1
2902 {HeRu::RuSpec{RuType::RU_242_TONE, 3, true}, 10, 1}, // CC1
2903 {HeRu::RuSpec{RuType::RU_242_TONE, 4, true}, 11, 1}, // CC2
2904 {HeRu::RuSpec{RuType::RU_484_TONE, 1, false}, 7, 1}, // CC1 or CC2
2905 {HeRu::RuSpec{RuType::RU_26_TONE, 19, false}, 8, 2}, // CC2
2906 {HeRu::RuSpec{RuType::RU_484_TONE, 2, false}, 9, 1}}, // CC1 or CC2
2907 VhtPhy::GetVhtMcs5(),
2908 MHz_u{160},
2909 0,
2910 MuSigDurationTest::OFDMA,
2911 {96, 96, 192, 192, 200, 114, 114, 200},
2912 std::make_pair(5, 5), // two users in content channel 1 and
2913 // one user in content channel 2
2914 MicroSeconds(4)), // two OFDM symbols
2915 TestCase::Duration::QUICK);
2916
2917 // 160 MHz band, OFDMA, 11ax maximum number of users
2918 AddTestCase(new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_26_TONE, 1, true}, 8, 1}, // CC1
2919 {HeRu::RuSpec{RuType::RU_26_TONE, 2, true}, 8, 1}, // CC1
2920 {HeRu::RuSpec{RuType::RU_26_TONE, 3, true}, 8, 1}, // CC1
2921 {HeRu::RuSpec{RuType::RU_26_TONE, 4, true}, 8, 1}, // CC1
2922 {HeRu::RuSpec{RuType::RU_26_TONE, 5, true}, 8, 1}, // CC1
2923 {HeRu::RuSpec{RuType::RU_26_TONE, 6, true}, 8, 1}, // CC1
2924 {HeRu::RuSpec{RuType::RU_26_TONE, 7, true}, 8, 1}, // CC1
2925 {HeRu::RuSpec{RuType::RU_26_TONE, 8, true}, 8, 1}, // CC1
2926 {HeRu::RuSpec{RuType::RU_26_TONE, 9, true}, 8, 1}, // CC1
2927 {HeRu::RuSpec{RuType::RU_26_TONE, 10, true}, 8, 1}, // CC2
2928 {HeRu::RuSpec{RuType::RU_26_TONE, 11, true}, 8, 1}, // CC2
2929 {HeRu::RuSpec{RuType::RU_26_TONE, 12, true}, 8, 1}, // CC2
2930 {HeRu::RuSpec{RuType::RU_26_TONE, 13, true}, 8, 1}, // CC2
2931 {HeRu::RuSpec{RuType::RU_26_TONE, 14, true}, 8, 1}, // CC2
2932 {HeRu::RuSpec{RuType::RU_26_TONE, 15, true}, 8, 1}, // CC2
2933 {HeRu::RuSpec{RuType::RU_26_TONE, 16, true}, 8, 1}, // CC2
2934 {HeRu::RuSpec{RuType::RU_26_TONE, 17, true}, 8, 1}, // CC2
2935 {HeRu::RuSpec{RuType::RU_26_TONE, 18, true}, 8, 1}, // CC2
2936 {HeRu::RuSpec{RuType::RU_26_TONE, 19, true}, 8, 1}, // CC1
2937 {HeRu::RuSpec{RuType::RU_26_TONE, 20, true}, 8, 1}, // CC1
2938 {HeRu::RuSpec{RuType::RU_26_TONE, 21, true}, 8, 1}, // CC1
2939 {HeRu::RuSpec{RuType::RU_26_TONE, 22, true}, 8, 1}, // CC1
2940 {HeRu::RuSpec{RuType::RU_26_TONE, 23, true}, 8, 1}, // CC1
2941 {HeRu::RuSpec{RuType::RU_26_TONE, 24, true}, 8, 1}, // CC1
2942 {HeRu::RuSpec{RuType::RU_26_TONE, 25, true}, 8, 1}, // CC1
2943 {HeRu::RuSpec{RuType::RU_26_TONE, 26, true}, 8, 1}, // CC1
2944 {HeRu::RuSpec{RuType::RU_26_TONE, 27, true}, 8, 1}, // CC1
2945 {HeRu::RuSpec{RuType::RU_26_TONE, 28, true}, 8, 1}, // CC2
2946 {HeRu::RuSpec{RuType::RU_26_TONE, 29, true}, 8, 1}, // CC2
2947 {HeRu::RuSpec{RuType::RU_26_TONE, 30, true}, 8, 1}, // CC2
2948 {HeRu::RuSpec{RuType::RU_26_TONE, 31, true}, 8, 1}, // CC2
2949 {HeRu::RuSpec{RuType::RU_26_TONE, 32, true}, 8, 1}, // CC2
2950 {HeRu::RuSpec{RuType::RU_26_TONE, 33, true}, 8, 1}, // CC2
2951 {HeRu::RuSpec{RuType::RU_26_TONE, 34, true}, 8, 1}, // CC2
2952 {HeRu::RuSpec{RuType::RU_26_TONE, 35, true}, 8, 1}, // CC2
2953 {HeRu::RuSpec{RuType::RU_26_TONE, 36, true}, 8, 1}, // CC2
2954 {HeRu::RuSpec{RuType::RU_26_TONE, 37, true}, 8, 1}, // CC2
2955 {HeRu::RuSpec{RuType::RU_26_TONE, 1, false}, 8, 1}, // CC1
2956 {HeRu::RuSpec{RuType::RU_26_TONE, 2, false}, 8, 1}, // CC1
2957 {HeRu::RuSpec{RuType::RU_26_TONE, 3, false}, 8, 1}, // CC1
2958 {HeRu::RuSpec{RuType::RU_26_TONE, 4, false}, 8, 1}, // CC1
2959 {HeRu::RuSpec{RuType::RU_26_TONE, 5, false}, 8, 1}, // CC1
2960 {HeRu::RuSpec{RuType::RU_26_TONE, 6, false}, 8, 1}, // CC1
2961 {HeRu::RuSpec{RuType::RU_26_TONE, 7, false}, 8, 1}, // CC1
2962 {HeRu::RuSpec{RuType::RU_26_TONE, 8, false}, 8, 1}, // CC1
2963 {HeRu::RuSpec{RuType::RU_26_TONE, 9, false}, 8, 1}, // CC1
2964 {HeRu::RuSpec{RuType::RU_26_TONE, 10, false}, 8, 1}, // CC2
2965 {HeRu::RuSpec{RuType::RU_26_TONE, 11, false}, 8, 1}, // CC2
2966 {HeRu::RuSpec{RuType::RU_26_TONE, 12, false}, 8, 1}, // CC2
2967 {HeRu::RuSpec{RuType::RU_26_TONE, 13, false}, 8, 1}, // CC2
2968 {HeRu::RuSpec{RuType::RU_26_TONE, 14, false}, 8, 1}, // CC2
2969 {HeRu::RuSpec{RuType::RU_26_TONE, 15, false}, 8, 1}, // CC2
2970 {HeRu::RuSpec{RuType::RU_26_TONE, 16, false}, 8, 1}, // CC2
2971 {HeRu::RuSpec{RuType::RU_26_TONE, 17, false}, 8, 1}, // CC2
2972 {HeRu::RuSpec{RuType::RU_26_TONE, 18, false}, 8, 1}, // CC2
2973 {HeRu::RuSpec{RuType::RU_26_TONE, 19, false}, 8, 1}, // CC1
2974 {HeRu::RuSpec{RuType::RU_26_TONE, 20, false}, 8, 1}, // CC1
2975 {HeRu::RuSpec{RuType::RU_26_TONE, 21, false}, 8, 1}, // CC1
2976 {HeRu::RuSpec{RuType::RU_26_TONE, 22, false}, 8, 1}, // CC1
2977 {HeRu::RuSpec{RuType::RU_26_TONE, 23, false}, 8, 1}, // CC1
2978 {HeRu::RuSpec{RuType::RU_26_TONE, 24, false}, 8, 1}, // CC1
2979 {HeRu::RuSpec{RuType::RU_26_TONE, 25, false}, 8, 1}, // CC1
2980 {HeRu::RuSpec{RuType::RU_26_TONE, 26, false}, 8, 1}, // CC1
2981 {HeRu::RuSpec{RuType::RU_26_TONE, 27, false}, 8, 1}, // CC1
2982 {HeRu::RuSpec{RuType::RU_26_TONE, 28, false}, 8, 1}, // CC2
2983 {HeRu::RuSpec{RuType::RU_26_TONE, 29, false}, 8, 1}, // CC2
2984 {HeRu::RuSpec{RuType::RU_26_TONE, 30, false}, 8, 1}, // CC2
2985 {HeRu::RuSpec{RuType::RU_26_TONE, 31, false}, 8, 1}, // CC2
2986 {HeRu::RuSpec{RuType::RU_26_TONE, 32, false}, 8, 1}, // CC2
2987 {HeRu::RuSpec{RuType::RU_26_TONE, 33, false}, 8, 1}, // CC2
2988 {HeRu::RuSpec{RuType::RU_26_TONE, 34, false}, 8, 1}, // CC2
2989 {HeRu::RuSpec{RuType::RU_26_TONE, 35, false}, 8, 1}, // CC2
2990 {HeRu::RuSpec{RuType::RU_26_TONE, 36, false}, 8, 1}, // CC2
2991 {HeRu::RuSpec{RuType::RU_26_TONE, 37, false}, 8, 1}}, // CC2
2992 VhtPhy::GetVhtMcs5(),
2993 MHz_u{160},
2994 0,
2995 MuSigDurationTest::OFDMA,
2996 {0, 0, 0, 0, 0, 0, 0, 0},
2997 std::make_pair(37,
2998 37), // 37 users (36 users + 1 central tones-RU
2999 // user) in each content channel
3000 MicroSeconds(20)), // five OFDM symbols
3001 TestCase::Duration::QUICK);
3002
3003 // 320 MHz band, OFDMA, 11be maximum number of users
3004 AddTestCase(
3005 new MuSigDurationTest({{EhtRu::RuSpec{RuType::RU_26_TONE, 1, true, true}, 8, 1}, // CC1
3006 {EhtRu::RuSpec{RuType::RU_26_TONE, 2, true, true}, 8, 1}, // CC1
3007 {EhtRu::RuSpec{RuType::RU_26_TONE, 3, true, true}, 8, 1}, // CC1
3008 {EhtRu::RuSpec{RuType::RU_26_TONE, 4, true, true}, 8, 1}, // CC1
3009 {EhtRu::RuSpec{RuType::RU_26_TONE, 5, true, true}, 8, 1}, // CC1
3010 {EhtRu::RuSpec{RuType::RU_26_TONE, 6, true, true}, 8, 1}, // CC1
3011 {EhtRu::RuSpec{RuType::RU_26_TONE, 7, true, true}, 8, 1}, // CC1
3012 {EhtRu::RuSpec{RuType::RU_26_TONE, 8, true, true}, 8, 1}, // CC1
3013 {EhtRu::RuSpec{RuType::RU_26_TONE, 9, true, true}, 8, 1}, // CC1
3014 {EhtRu::RuSpec{RuType::RU_26_TONE, 10, true, true}, 8, 1}, // CC2
3015 {EhtRu::RuSpec{RuType::RU_26_TONE, 11, true, true}, 8, 1}, // CC2
3016 {EhtRu::RuSpec{RuType::RU_26_TONE, 12, true, true}, 8, 1}, // CC2
3017 {EhtRu::RuSpec{RuType::RU_26_TONE, 13, true, true}, 8, 1}, // CC2
3018 {EhtRu::RuSpec{RuType::RU_26_TONE, 14, true, true}, 8, 1}, // CC2
3019 {EhtRu::RuSpec{RuType::RU_26_TONE, 15, true, true}, 8, 1}, // CC2
3020 {EhtRu::RuSpec{RuType::RU_26_TONE, 16, true, true}, 8, 1}, // CC2
3021 {EhtRu::RuSpec{RuType::RU_26_TONE, 17, true, true}, 8, 1}, // CC2
3022 {EhtRu::RuSpec{RuType::RU_26_TONE, 18, true, true}, 8, 1}, // CC2
3023 {EhtRu::RuSpec{RuType::RU_26_TONE, 20, true, true}, 8, 1}, // CC1
3024 {EhtRu::RuSpec{RuType::RU_26_TONE, 21, true, true}, 8, 1}, // CC1
3025 {EhtRu::RuSpec{RuType::RU_26_TONE, 22, true, true}, 8, 1}, // CC1
3026 {EhtRu::RuSpec{RuType::RU_26_TONE, 23, true, true}, 8, 1}, // CC1
3027 {EhtRu::RuSpec{RuType::RU_26_TONE, 24, true, true}, 8, 1}, // CC1
3028 {EhtRu::RuSpec{RuType::RU_26_TONE, 25, true, true}, 8, 1}, // CC1
3029 {EhtRu::RuSpec{RuType::RU_26_TONE, 26, true, true}, 8, 1}, // CC1
3030 {EhtRu::RuSpec{RuType::RU_26_TONE, 27, true, true}, 8, 1}, // CC1
3031 {EhtRu::RuSpec{RuType::RU_26_TONE, 28, true, true}, 8, 1}, // CC2
3032 {EhtRu::RuSpec{RuType::RU_26_TONE, 29, true, true}, 8, 1}, // CC2
3033 {EhtRu::RuSpec{RuType::RU_26_TONE, 30, true, true}, 8, 1}, // CC2
3034 {EhtRu::RuSpec{RuType::RU_26_TONE, 31, true, true}, 8, 1}, // CC2
3035 {EhtRu::RuSpec{RuType::RU_26_TONE, 32, true, true}, 8, 1}, // CC2
3036 {EhtRu::RuSpec{RuType::RU_26_TONE, 33, true, true}, 8, 1}, // CC2
3037 {EhtRu::RuSpec{RuType::RU_26_TONE, 34, true, true}, 8, 1}, // CC2
3038 {EhtRu::RuSpec{RuType::RU_26_TONE, 35, true, true}, 8, 1}, // CC2
3039 {EhtRu::RuSpec{RuType::RU_26_TONE, 36, true, true}, 8, 1}, // CC2
3040 {EhtRu::RuSpec{RuType::RU_26_TONE, 37, true, true}, 8, 1}, // CC2
3041 {EhtRu::RuSpec{RuType::RU_26_TONE, 1, true, false}, 8, 1}, // CC1
3042 {EhtRu::RuSpec{RuType::RU_26_TONE, 2, true, false}, 8, 1}, // CC1
3043 {EhtRu::RuSpec{RuType::RU_26_TONE, 3, true, false}, 8, 1}, // CC1
3044 {EhtRu::RuSpec{RuType::RU_26_TONE, 4, true, false}, 8, 1}, // CC1
3045 {EhtRu::RuSpec{RuType::RU_26_TONE, 5, true, false}, 8, 1}, // CC1
3046 {EhtRu::RuSpec{RuType::RU_26_TONE, 6, true, false}, 8, 1}, // CC1
3047 {EhtRu::RuSpec{RuType::RU_26_TONE, 7, true, false}, 8, 1}, // CC1
3048 {EhtRu::RuSpec{RuType::RU_26_TONE, 8, true, false}, 8, 1}, // CC1
3049 {EhtRu::RuSpec{RuType::RU_26_TONE, 9, true, false}, 8, 1}, // CC1
3050 {EhtRu::RuSpec{RuType::RU_26_TONE, 10, true, false}, 8, 1}, // CC2
3051 {EhtRu::RuSpec{RuType::RU_26_TONE, 11, true, false}, 8, 1}, // CC2
3052 {EhtRu::RuSpec{RuType::RU_26_TONE, 12, true, false}, 8, 1}, // CC2
3053 {EhtRu::RuSpec{RuType::RU_26_TONE, 13, true, false}, 8, 1}, // CC2
3054 {EhtRu::RuSpec{RuType::RU_26_TONE, 14, true, false}, 8, 1}, // CC2
3055 {EhtRu::RuSpec{RuType::RU_26_TONE, 15, true, false}, 8, 1}, // CC2
3056 {EhtRu::RuSpec{RuType::RU_26_TONE, 16, true, false}, 8, 1}, // CC2
3057 {EhtRu::RuSpec{RuType::RU_26_TONE, 17, true, false}, 8, 1}, // CC2
3058 {EhtRu::RuSpec{RuType::RU_26_TONE, 18, true, false}, 8, 1}, // CC2
3059 {EhtRu::RuSpec{RuType::RU_26_TONE, 20, true, false}, 8, 1}, // CC1
3060 {EhtRu::RuSpec{RuType::RU_26_TONE, 21, true, false}, 8, 1}, // CC1
3061 {EhtRu::RuSpec{RuType::RU_26_TONE, 22, true, false}, 8, 1}, // CC1
3062 {EhtRu::RuSpec{RuType::RU_26_TONE, 23, true, false}, 8, 1}, // CC1
3063 {EhtRu::RuSpec{RuType::RU_26_TONE, 24, true, false}, 8, 1}, // CC1
3064 {EhtRu::RuSpec{RuType::RU_26_TONE, 25, true, false}, 8, 1}, // CC1
3065 {EhtRu::RuSpec{RuType::RU_26_TONE, 26, true, false}, 8, 1}, // CC1
3066 {EhtRu::RuSpec{RuType::RU_26_TONE, 27, true, false}, 8, 1}, // CC1
3067 {EhtRu::RuSpec{RuType::RU_26_TONE, 28, true, false}, 8, 1}, // CC2
3068 {EhtRu::RuSpec{RuType::RU_26_TONE, 29, true, false}, 8, 1}, // CC2
3069 {EhtRu::RuSpec{RuType::RU_26_TONE, 30, true, false}, 8, 1}, // CC2
3070 {EhtRu::RuSpec{RuType::RU_26_TONE, 31, true, false}, 8, 1}, // CC2
3071 {EhtRu::RuSpec{RuType::RU_26_TONE, 32, true, false}, 8, 1}, // CC2
3072 {EhtRu::RuSpec{RuType::RU_26_TONE, 33, true, false}, 8, 1}, // CC2
3073 {EhtRu::RuSpec{RuType::RU_26_TONE, 34, true, false}, 8, 1}, // CC2
3074 {EhtRu::RuSpec{RuType::RU_26_TONE, 35, true, false}, 8, 1}, // CC2
3075 {EhtRu::RuSpec{RuType::RU_26_TONE, 36, true, false}, 8, 1}, // CC2
3076 {EhtRu::RuSpec{RuType::RU_26_TONE, 37, true, false}, 8, 1}, // CC2
3077 {EhtRu::RuSpec{RuType::RU_26_TONE, 1, false, true}, 8, 1}, // CC1
3078 {EhtRu::RuSpec{RuType::RU_26_TONE, 2, false, true}, 8, 1}, // CC1
3079 {EhtRu::RuSpec{RuType::RU_26_TONE, 3, false, true}, 8, 1}, // CC1
3080 {EhtRu::RuSpec{RuType::RU_26_TONE, 4, false, true}, 8, 1}, // CC1
3081 {EhtRu::RuSpec{RuType::RU_26_TONE, 5, false, true}, 8, 1}, // CC1
3082 {EhtRu::RuSpec{RuType::RU_26_TONE, 6, false, true}, 8, 1}, // CC1
3083 {EhtRu::RuSpec{RuType::RU_26_TONE, 7, false, true}, 8, 1}, // CC1
3084 {EhtRu::RuSpec{RuType::RU_26_TONE, 8, false, true}, 8, 1}, // CC1
3085 {EhtRu::RuSpec{RuType::RU_26_TONE, 9, false, true}, 8, 1}, // CC1
3086 {EhtRu::RuSpec{RuType::RU_26_TONE, 10, false, true}, 8, 1}, // CC2
3087 {EhtRu::RuSpec{RuType::RU_26_TONE, 11, false, true}, 8, 1}, // CC2
3088 {EhtRu::RuSpec{RuType::RU_26_TONE, 12, false, true}, 8, 1}, // CC2
3089 {EhtRu::RuSpec{RuType::RU_26_TONE, 13, false, true}, 8, 1}, // CC2
3090 {EhtRu::RuSpec{RuType::RU_26_TONE, 14, false, true}, 8, 1}, // CC2
3091 {EhtRu::RuSpec{RuType::RU_26_TONE, 15, false, true}, 8, 1}, // CC2
3092 {EhtRu::RuSpec{RuType::RU_26_TONE, 16, false, true}, 8, 1}, // CC2
3093 {EhtRu::RuSpec{RuType::RU_26_TONE, 17, false, true}, 8, 1}, // CC2
3094 {EhtRu::RuSpec{RuType::RU_26_TONE, 18, false, true}, 8, 1}, // CC2
3095 {EhtRu::RuSpec{RuType::RU_26_TONE, 20, false, true}, 8, 1}, // CC1
3096 {EhtRu::RuSpec{RuType::RU_26_TONE, 21, false, true}, 8, 1}, // CC1
3097 {EhtRu::RuSpec{RuType::RU_26_TONE, 22, false, true}, 8, 1}, // CC1
3098 {EhtRu::RuSpec{RuType::RU_26_TONE, 23, false, true}, 8, 1}, // CC1
3099 {EhtRu::RuSpec{RuType::RU_26_TONE, 24, false, true}, 8, 1}, // CC1
3100 {EhtRu::RuSpec{RuType::RU_26_TONE, 25, false, true}, 8, 1}, // CC1
3101 {EhtRu::RuSpec{RuType::RU_26_TONE, 26, false, true}, 8, 1}, // CC1
3102 {EhtRu::RuSpec{RuType::RU_26_TONE, 27, false, true}, 8, 1}, // CC1
3103 {EhtRu::RuSpec{RuType::RU_26_TONE, 28, false, true}, 8, 1}, // CC2
3104 {EhtRu::RuSpec{RuType::RU_26_TONE, 29, false, true}, 8, 1}, // CC2
3105 {EhtRu::RuSpec{RuType::RU_26_TONE, 30, false, true}, 8, 1}, // CC2
3106 {EhtRu::RuSpec{RuType::RU_26_TONE, 31, false, true}, 8, 1}, // CC2
3107 {EhtRu::RuSpec{RuType::RU_26_TONE, 32, false, true}, 8, 1}, // CC2
3108 {EhtRu::RuSpec{RuType::RU_26_TONE, 33, false, true}, 8, 1}, // CC2
3109 {EhtRu::RuSpec{RuType::RU_26_TONE, 34, false, true}, 8, 1}, // CC2
3110 {EhtRu::RuSpec{RuType::RU_26_TONE, 35, false, true}, 8, 1}, // CC2
3111 {EhtRu::RuSpec{RuType::RU_26_TONE, 36, false, true}, 8, 1}, // CC2
3112 {EhtRu::RuSpec{RuType::RU_26_TONE, 37, false, true}, 8, 1}, // CC2
3113 {EhtRu::RuSpec{RuType::RU_26_TONE, 1, false, false}, 8, 1}, // CC1
3114 {EhtRu::RuSpec{RuType::RU_26_TONE, 2, false, false}, 8, 1}, // CC1
3115 {EhtRu::RuSpec{RuType::RU_26_TONE, 3, false, false}, 8, 1}, // CC1
3116 {EhtRu::RuSpec{RuType::RU_26_TONE, 4, false, false}, 8, 1}, // CC1
3117 {EhtRu::RuSpec{RuType::RU_26_TONE, 5, false, false}, 8, 1}, // CC1
3118 {EhtRu::RuSpec{RuType::RU_26_TONE, 6, false, false}, 8, 1}, // CC1
3119 {EhtRu::RuSpec{RuType::RU_26_TONE, 7, false, false}, 8, 1}, // CC1
3120 {EhtRu::RuSpec{RuType::RU_26_TONE, 8, false, false}, 8, 1}, // CC1
3121 {EhtRu::RuSpec{RuType::RU_26_TONE, 9, false, false}, 8, 1}, // CC1
3122 {EhtRu::RuSpec{RuType::RU_26_TONE, 10, false, false}, 8, 1}, // CC2
3123 {EhtRu::RuSpec{RuType::RU_26_TONE, 11, false, false}, 8, 1}, // CC2
3124 {EhtRu::RuSpec{RuType::RU_26_TONE, 12, false, false}, 8, 1}, // CC2
3125 {EhtRu::RuSpec{RuType::RU_26_TONE, 13, false, false}, 8, 1}, // CC2
3126 {EhtRu::RuSpec{RuType::RU_26_TONE, 14, false, false}, 8, 1}, // CC2
3127 {EhtRu::RuSpec{RuType::RU_26_TONE, 15, false, false}, 8, 1}, // CC2
3128 {EhtRu::RuSpec{RuType::RU_26_TONE, 16, false, false}, 8, 1}, // CC2
3129 {EhtRu::RuSpec{RuType::RU_26_TONE, 17, false, false}, 8, 1}, // CC2
3130 {EhtRu::RuSpec{RuType::RU_26_TONE, 18, false, false}, 8, 1}, // CC2
3131 {EhtRu::RuSpec{RuType::RU_26_TONE, 20, false, false}, 8, 1}, // CC1
3132 {EhtRu::RuSpec{RuType::RU_26_TONE, 21, false, false}, 8, 1}, // CC1
3133 {EhtRu::RuSpec{RuType::RU_26_TONE, 22, false, false}, 8, 1}, // CC1
3134 {EhtRu::RuSpec{RuType::RU_26_TONE, 23, false, false}, 8, 1}, // CC1
3135 {EhtRu::RuSpec{RuType::RU_26_TONE, 24, false, false}, 8, 1}, // CC1
3136 {EhtRu::RuSpec{RuType::RU_26_TONE, 25, false, false}, 8, 1}, // CC1
3137 {EhtRu::RuSpec{RuType::RU_26_TONE, 26, false, false}, 8, 1}, // CC1
3138 {EhtRu::RuSpec{RuType::RU_26_TONE, 27, false, false}, 8, 1}, // CC1
3139 {EhtRu::RuSpec{RuType::RU_26_TONE, 28, false, false}, 8, 1}, // CC2
3140 {EhtRu::RuSpec{RuType::RU_26_TONE, 29, false, false}, 8, 1}, // CC2
3141 {EhtRu::RuSpec{RuType::RU_26_TONE, 30, false, false}, 8, 1}, // CC2
3142 {EhtRu::RuSpec{RuType::RU_26_TONE, 31, false, false}, 8, 1}, // CC2
3143 {EhtRu::RuSpec{RuType::RU_26_TONE, 32, false, false}, 8, 1}, // CC2
3144 {EhtRu::RuSpec{RuType::RU_26_TONE, 33, false, false}, 8, 1}, // CC2
3145 {EhtRu::RuSpec{RuType::RU_26_TONE, 34, false, false}, 8, 1}, // CC2
3146 {EhtRu::RuSpec{RuType::RU_26_TONE, 35, false, false}, 8, 1}, // CC2
3147 {EhtRu::RuSpec{RuType::RU_26_TONE, 36, false, false}, 8, 1}, // CC2
3148 {EhtRu::RuSpec{RuType::RU_26_TONE, 37, false, false}, 8, 1}}, // CC2
3149 VhtPhy::GetVhtMcs5(),
3150 MHz_u{320},
3151 0,
3152 MuSigDurationTest::OFDMA,
3153 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
3154 std::make_pair(72,
3155 72), // 72 users in each content channel
3156 MicroSeconds(40)), // ten OFDM symbols
3157 TestCase::Duration::QUICK);
3158
3159 // 160 MHz band, OFDMA, 11ax single-user using 2x996 tones RU
3160 AddTestCase(
3161 new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 8, 1}}, // CC1
3162 VhtPhy::GetVhtMcs5(),
3163 MHz_u{160},
3164 0,
3165 MuSigDurationTest::OFDMA,
3166 {208, 208, 208, 208, 208, 208, 208, 208},
3167 std::make_pair(1, 0), // one user in HE-SIG-B content channel 1
3168 MicroSeconds(4)), // one OFDM symbol;
3169 TestCase::Duration::QUICK);
3170
3171 // 160 MHz band, OFDMA, 11ax with primary80 is in the high 80 MHz band
3172 AddTestCase(
3173 new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_996_TONE, 1, false}, 8, 1}, // CC2
3174 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 8, 1}}, // CC1
3175 VhtPhy::GetVhtMcs5(),
3176 MHz_u{160},
3177 4,
3178 MuSigDurationTest::OFDMA,
3179 {208, 115, 208, 115, 115, 208, 115, 208},
3180 std::make_pair(1, 1), // one user in each HE-SIG-B content channel
3181 MicroSeconds(4)), // one OFDM symbol;
3182 TestCase::Duration::QUICK);
3183
3184 // 40 MHz band, OFDMA, first 20 MHz is punctured
3185 AddTestCase(
3186 new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_242_TONE, 2, true}, 11, 1}}, // CC2
3187 VhtPhy::GetVhtMcs5(),
3188 MHz_u{40},
3189 1,
3190 MuSigDurationTest::OFDMA,
3191 {113, 192},
3192 std::make_pair(0, 1), // one user in HE-SIG-B content channel 1
3193 MicroSeconds(4)), // one OFDM symbol;
3194 TestCase::Duration::QUICK);
3195
3196 // 20 MHz band, MU-MIMO, 2 users
3197 AddTestCase(new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 11, 1}, // CC1
3198 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 10, 4}}, // CC1
3199 VhtPhy::GetVhtMcs5(),
3200 MHz_u{20},
3201 0,
3202 MuSigDurationTest::MU_MIMO,
3203 {192},
3204 std::make_pair(2, 0), // both users in content channel 1
3205 MicroSeconds(4)), // one OFDM symbol
3206 TestCase::Duration::QUICK);
3207
3208 // 20 MHz band, MU-MIMO, 3 users
3209 AddTestCase(new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 4, 3}, // CC1
3210 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 5, 2}, // CC1
3211 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 6, 1}}, // CC1
3212 VhtPhy::GetVhtMcs4(),
3213 MHz_u{20},
3214 0,
3215 MuSigDurationTest::MU_MIMO,
3216 {192},
3217 std::make_pair(3, 0), // all users in content channel 1
3218 MicroSeconds(4)), // one OFDM symbol
3219 TestCase::Duration::QUICK);
3220
3221 // 20 MHz band, MU-MIMO, 4 users
3222 AddTestCase(new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 4, 1}, // CC1
3223 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 5, 2}, // CC1
3224 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 6, 3}, // CC1
3225 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 7, 2}}, // CC1
3226 VhtPhy::GetVhtMcs4(),
3227 MHz_u{20},
3228 0,
3229 MuSigDurationTest::MU_MIMO,
3230 {192},
3231 std::make_pair(4, 0), // all users in content channel 1
3232 MicroSeconds(4)), // one OFDM symbol
3233 TestCase::Duration::QUICK);
3234
3235 // 20 MHz band, MU-MIMO, 6 users
3236 AddTestCase(new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 4, 1}, // CC1
3237 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 5, 1}, // CC1
3238 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 6, 2}, // CC1
3239 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 7, 2}, // CC1
3240 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 8, 1}, // CC1
3241 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 9, 1}}, // CC1
3242 VhtPhy::GetVhtMcs4(),
3243 MHz_u{20},
3244 0,
3245 MuSigDurationTest::MU_MIMO,
3246 {192},
3247 std::make_pair(6, 0), // all users in content channel 1
3248 MicroSeconds(4)), // one OFDM symbol
3249 TestCase::Duration::QUICK);
3250
3251 // 20 MHz band, MU-MIMO, 8 users
3252 AddTestCase(new MuSigDurationTest({{HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 4, 1}, // CC1
3253 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 5, 1}, // CC1
3254 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 6, 1}, // CC1
3255 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 7, 1}, // CC1
3256 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 8, 1}, // CC1
3257 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 9, 1}, // CC1
3258 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 10, 1}, // CC1
3259 {HeRu::RuSpec{RuType::RU_242_TONE, 1, true}, 11, 1}}, // CC1
3260 VhtPhy::GetVhtMcs4(),
3261 MHz_u{20},
3262 0,
3263 MuSigDurationTest::MU_MIMO,
3264 {192},
3265 std::make_pair(8, 0), // all users in content channel 1
3266 MicroSeconds(8)), // two OFDM symbols
3267 TestCase::Duration::QUICK);
3268
3269 // 40 MHz band, MU-MIMO, 2 users
3270 AddTestCase(new MuSigDurationTest(
3271 {{HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 11, 1}, // CC1
3272 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 10, 4}}, // CC2
3273 VhtPhy::GetVhtMcs5(),
3274 MHz_u{40},
3275 0,
3276 MuSigDurationTest::MU_MIMO,
3277 {200, 200},
3278 std::make_pair(1, 1), // users equally split between the two content channels
3279 MicroSeconds(4)), // one OFDM symbol
3280 TestCase::Duration::QUICK);
3281
3282 // 40 MHz band, MU-MIMO, 3 users
3283 AddTestCase(
3284 new MuSigDurationTest(
3285 {{HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 4, 3}, // CC1
3286 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 5, 2}, // CC2
3287 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 6, 1}}, // CC1
3288 VhtPhy::GetVhtMcs4(),
3289 MHz_u{40},
3290 0,
3291 MuSigDurationTest::MU_MIMO,
3292 {200, 200},
3293 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
3294 MicroSeconds(4)), // one OFDM symbol
3295 TestCase::Duration::QUICK);
3296
3297 // 40 MHz band, MU-MIMO, 4 users
3298 AddTestCase(new MuSigDurationTest(
3299 {{HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 4, 1}, // CC1
3300 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 5, 2}, // CC2
3301 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 6, 3}, // CC1
3302 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 7, 2}}, // CC2
3303 VhtPhy::GetVhtMcs4(),
3304 MHz_u{40},
3305 0,
3306 MuSigDurationTest::MU_MIMO,
3307 {200, 200},
3308 std::make_pair(2, 2), // users equally split between the two content channels
3309 MicroSeconds(4)), // one OFDM symbol
3310 TestCase::Duration::QUICK);
3311
3312 // 40 MHz band, MU-MIMO, 6 users
3313 AddTestCase(new MuSigDurationTest(
3314 {{HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 4, 1}, // CC1
3315 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 5, 1}, // CC2
3316 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 6, 2}, // CC1
3317 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 7, 2}, // CC2
3318 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 8, 1}, // CC1
3319 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 9, 1}}, // CC2
3320 VhtPhy::GetVhtMcs4(),
3321 MHz_u{40},
3322 0,
3323 MuSigDurationTest::MU_MIMO,
3324 {200, 200},
3325 std::make_pair(3, 3), // users equally split between the two content channels
3326 MicroSeconds(4)), // one OFDM symbol
3327 TestCase::Duration::QUICK);
3328
3329 // 40 MHz band, MU-MIMO, 8 users
3330 AddTestCase(new MuSigDurationTest(
3331 {{HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 4, 1}, // CC1
3332 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 5, 1}, // CC2
3333 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 6, 1}, // CC1
3334 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 7, 1}, // CC2
3335 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 8, 1}, // CC1
3336 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 9, 1}, // CC2
3337 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 10, 1}, // CC1
3338 {HeRu::RuSpec{RuType::RU_484_TONE, 1, true}, 11, 1}}, // CC2
3339 VhtPhy::GetVhtMcs4(),
3340 MHz_u{40},
3341 0,
3342 MuSigDurationTest::MU_MIMO,
3343 {200, 200},
3344 std::make_pair(4, 4), // users equally split between the two content channels
3345 MicroSeconds(4)), // one OFDM symbol
3346 TestCase::Duration::QUICK);
3347
3348 // 80 MHz band, MU-MIMO, 2 users
3349 AddTestCase(new MuSigDurationTest(
3350 {{HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 11, 1}, // CC1
3351 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 10, 4}}, // CC2
3352 VhtPhy::GetVhtMcs5(),
3353 MHz_u{80},
3354 0,
3355 MuSigDurationTest::MU_MIMO,
3356 {208, 208, 208, 208},
3357 std::make_pair(1, 1), // users equally split between the two content channels
3358 MicroSeconds(4)), // one OFDM symbol
3359 TestCase::Duration::QUICK);
3360
3361 // 80 MHz band, MU-MIMO, 3 users
3362 AddTestCase(
3363 new MuSigDurationTest(
3364 {{HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 4, 3}, // CC1
3365 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 5, 2}, // CC2
3366 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 6, 1}}, // CC1
3367 VhtPhy::GetVhtMcs4(),
3368 MHz_u{80},
3369 0,
3370 MuSigDurationTest::MU_MIMO,
3371 {208, 208, 208, 208},
3372 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
3373 MicroSeconds(4)), // one OFDM symbol
3374 TestCase::Duration::QUICK);
3375
3376 // 80 MHz band, MU-MIMO, 4 users
3377 AddTestCase(new MuSigDurationTest(
3378 {{HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 4, 1}, // CC1
3379 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 5, 2}, // CC2
3380 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 6, 3}, // CC1
3381 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 7, 2}}, // CC2
3382 VhtPhy::GetVhtMcs4(),
3383 MHz_u{80},
3384 0,
3385 MuSigDurationTest::MU_MIMO,
3386 {208, 208, 208, 208},
3387 std::make_pair(2, 2), // users equally split between the two content channels
3388 MicroSeconds(4)), // one OFDM symbol
3389 TestCase::Duration::QUICK);
3390
3391 // 80 MHz band, MU-MIMO, 6 users
3392 AddTestCase(new MuSigDurationTest(
3393 {{HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 4, 1}, // CC1
3394 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 5, 1}, // CC2
3395 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 6, 2}, // CC1
3396 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 7, 2}, // CC2
3397 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 8, 1}, // CC1
3398 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 9, 1}}, // CC2
3399 VhtPhy::GetVhtMcs4(),
3400 MHz_u{80},
3401 0,
3402 MuSigDurationTest::MU_MIMO,
3403 {208, 208, 208, 208},
3404 std::make_pair(3, 3), // users equally split between the two content channels
3405 MicroSeconds(4)), // one OFDM symbol
3406 TestCase::Duration::QUICK);
3407
3408 // 80 MHz band, MU-MIMO, 8 users
3409 AddTestCase(new MuSigDurationTest(
3410 {{HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 4, 1}, // CC1
3411 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 5, 1}, // CC2
3412 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 6, 1}, // CC1
3413 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 7, 1}, // CC2
3414 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 8, 1}, // CC1
3415 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 9, 1}, // CC2
3416 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 10, 1}, // CC1
3417 {HeRu::RuSpec{RuType::RU_996_TONE, 1, true}, 11, 1}}, // CC2
3418 VhtPhy::GetVhtMcs4(),
3419 MHz_u{80},
3420 0,
3421 MuSigDurationTest::MU_MIMO,
3422 {208, 208, 208, 208},
3423 std::make_pair(4, 4), // users equally split between the two content channels
3424 MicroSeconds(4)), // one OFDM symbol
3425 TestCase::Duration::QUICK);
3426
3427 // 160 MHz band, MU-MIMO, 2 users
3428 AddTestCase(new MuSigDurationTest(
3429 {{HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 11, 1}, // CC1
3430 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 10, 4}}, // CC2
3431 VhtPhy::GetVhtMcs5(),
3432 MHz_u{160},
3433 0,
3434 MuSigDurationTest::MU_MIMO,
3435 {208, 208, 208, 208, 208, 208, 208, 208},
3436 std::make_pair(1, 1), // users equally split between the two content channels
3437 MicroSeconds(4)), // one OFDM symbol
3438 TestCase::Duration::QUICK);
3439
3440 // 160 MHz band, MU-MIMO, 3 users
3441 AddTestCase(
3442 new MuSigDurationTest(
3443 {{HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 4, 3}, // CC1
3444 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 5, 2}, // CC2
3445 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 6, 1}}, // CC1
3446 VhtPhy::GetVhtMcs4(),
3447 MHz_u{160},
3448 0,
3449 MuSigDurationTest::MU_MIMO,
3450 {208, 208, 208, 208, 208, 208, 208, 208},
3451 std::make_pair(2, 1), // 2 users in content channel 1 and 1 user in content channel 2
3452 MicroSeconds(4)), // one OFDM symbol
3453 TestCase::Duration::QUICK);
3454
3455 // 160 MHz band, MU-MIMO, 4 users
3456 AddTestCase(new MuSigDurationTest(
3457 {{HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 4, 1}, // CC1
3458 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 5, 2}, // CC2
3459 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 6, 3}, // CC1
3460 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 7, 2}}, // CC2
3461 VhtPhy::GetVhtMcs4(),
3462 MHz_u{160},
3463 0,
3464 MuSigDurationTest::MU_MIMO,
3465 {208, 208, 208, 208, 208, 208, 208, 208},
3466 std::make_pair(2, 2), // users equally split between the two content channels
3467 MicroSeconds(4)), // one OFDM symbol
3468 TestCase::Duration::QUICK);
3469
3470 // 160 MHz band, MU-MIMO, 6 users
3471 AddTestCase(new MuSigDurationTest(
3472 {{HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 4, 1}, // CC1
3473 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 5, 1}, // CC2
3474 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 6, 2}, // CC1
3475 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 7, 2}, // CC2
3476 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 8, 1}, // CC1
3477 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 9, 1}}, // CC2
3478 VhtPhy::GetVhtMcs4(),
3479 MHz_u{160},
3480 0,
3481 MuSigDurationTest::MU_MIMO,
3482 {208, 208, 208, 208, 208, 208, 208, 208},
3483 std::make_pair(3, 3), // users equally split between the two content channels
3484 MicroSeconds(4)), // one OFDM symbol
3485 TestCase::Duration::QUICK);
3486
3487 // 160 MHz band, MU-MIMO, 8 users
3488 AddTestCase(new MuSigDurationTest(
3489 {{HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 4, 1}, // CC1
3490 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 5, 1}, // CC2
3491 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 6, 1}, // CC1
3492 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 7, 1}, // CC2
3493 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 8, 1}, // CC1
3494 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 9, 1}, // CC2
3495 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 10, 1}, // CC1
3496 {HeRu::RuSpec{RuType::RU_2x996_TONE, 1, true}, 11, 1}}, // CC2
3497 VhtPhy::GetVhtMcs4(),
3498 MHz_u{160},
3499 0,
3500 MuSigDurationTest::MU_MIMO,
3501 {208, 208, 208, 208, 208, 208, 208, 208},
3502 std::make_pair(4, 4), // users equally split between the two content channels
3503 MicroSeconds(4)), // one OFDM symbol
3504 TestCase::Duration::QUICK);
3505}
3506
3507static TxDurationTestSuite g_txDurationTestSuite; ///< the test suite
MuSigDurationTest
HE-SIG-B/EHT-SIG duration test.
Definition tx-duration-test.cc:2022
MuSigDurationTest::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition tx-duration-test.cc:2211
MuSigDurationTest::m_expectedMuType
MuType m_expectedMuType
Expected MU type (OFDMA or MU-MIMO).
Definition tx-duration-test.cc:2071
MuSigDurationTest::BuildTxVector
WifiTxVector BuildTxVector() const
Build a TXVECTOR for HE MU or EHT MU.
Definition tx-duration-test.cc:2100
MuSigDurationTest::m_sigBMode
WifiMode m_sigBMode
Mode used to transmit HE-SIG-B.
Definition tx-duration-test.cc:2068
MuSigDurationTest::MuSigDurationTest
MuSigDurationTest(const std::list< HeMuUserInfo > &userInfos, const WifiMode &sigBMode, MHz_u channelWidth, uint8_t p20Index, MuType expectedMuType, const RuAllocation &expectedRuAllocation, const std::pair< std::size_t, std::size_t > &expectedNumUsersPerCc, Time expectedSigBDuration)
Constructor.
Definition tx-duration-test.cc:2078
MuSigDurationTest::m_userInfos
std::list< HeMuUserInfo > m_userInfos
HE MU specific per-user information.
Definition tx-duration-test.cc:2067
MuSigDurationTest::MuType
MuType
OFDMA or MU-MIMO.
Definition tx-duration-test.cc:2028
MuSigDurationTest::m_channelWidth
MHz_u m_channelWidth
Channel width.
Definition tx-duration-test.cc:2069
MuSigDurationTest::m_expectedSigBDuration
Time m_expectedSigBDuration
Expected duration of the HE-SIG-B/EHT-SIG header.
Definition tx-duration-test.cc:2075
MuSigDurationTest::m_expectedRuAllocation
RuAllocation m_expectedRuAllocation
Expected RuType::RU_ALLOCATION.
Definition tx-duration-test.cc:2072
MuSigDurationTest::m_phy
Ptr< YansWifiPhy > m_phy
the PHY under test
Definition tx-duration-test.cc:2065
MuSigDurationTest::m_p20Index
uint8_t m_p20Index
index of the primary20 channel
Definition tx-duration-test.cc:2070
MuSigDurationTest::m_expectedNumUsersPerCc
std::pair< std::size_t, std::size_t > m_expectedNumUsersPerCc
Expected number of users per content channel.
Definition tx-duration-test.cc:2074
MuSigDurationTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition tx-duration-test.cc:2126
PhyHeaderSectionsTest
PHY header sections consistency test.
Definition tx-duration-test.cc:2224
PhyHeaderSectionsTest::CheckPhyHeaderSections
void CheckPhyHeaderSections(PhyHeaderSections obtained, 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:2251
PhyHeaderSectionsTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition tx-duration-test.cc:2294
TxDurationTest
Tx Duration Test.
Definition tx-duration-test.cc:65
TxDurationTest::~TxDurationTest
~TxDurationTest() override
Definition tx-duration-test.cc:155
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:360
TxDurationTest::CheckTxDuration
bool CheckTxDuration(uint32_t size, WifiMode payloadMode, MHz_u channelWidth, Time guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the overall tx duration returned by the PHY corresponds to a known value.
Definition tx-duration-test.cc:210
TxDurationTest::CheckMuTxDuration
static bool CheckMuTxDuration(std::list< uint32_t > sizes, std::list< HeMuUserInfo > userInfos, MHz_u channelWidth, Time 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:267
TxDurationTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition tx-duration-test.cc:380
TxDurationTest::CheckPayloadDuration
bool CheckPayloadDuration(uint32_t size, WifiMode payloadMode, MHz_u channelWidth, Time guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the payload tx duration returned by the PHY corresponds to a known value.
Definition tx-duration-test.cc:160
TxDurationTestSuite
Tx Duration Test Suite.
Definition tx-duration-test.cc:2579
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::GetEhtMcs0
static WifiMode GetEhtMcs0()
Return MCS 0 from EHT MCS values.
ns3::EhtPhy::GetEhtMcs13
static WifiMode GetEhtMcs13()
Return MCS 13 from EHT MCS values.
ns3::EhtPhy::GetEhtMcs9
static WifiMode GetEhtMcs9()
Return MCS 9 from EHT MCS values.
ns3::EhtRu::RuSpec
RU Specification.
Definition eht-ru.h:34
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:126
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(MHz_u channelWidth, WifiModulationClass mc, const RuAllocation &ruAllocation, std::optional< Center26ToneRuIndication > center26ToneRuIndication, bool sigBCompression, uint8_t numMuMimoUsers)
Get the number of STAs per HE-SIG-B content channel.
Definition he-ppdu.cc:552
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:663
ns3::HeRu::RuSpec
RU Specification.
Definition he-ru.h:37
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, MHz_u bw=MHz_u{20})
Return a WifiMode for OFDM corresponding to the provided rate and the channel bandwidth (20,...
Definition ofdm-phy.cc:403
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:67
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:293
ns3::TestCase::Duration::QUICK
@ QUICK
Fast test.
Definition test.h:1054
ns3::TestCase::TestCase
TestCase(const TestCase &)=delete
ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1257
ns3::TestSuite::TestSuite
TestSuite(std::string name, Type type=Type::UNIT)
Construct a new test suite.
Definition test.cc:491
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition nstime.h:96
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:87
ns3::WifiMacHeader::GetSerializedSize
uint32_t GetSerializedSize() const override
Definition wifi-mac-header.cc:1221
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:104
ns3::WifiMode
represent a single transmission mode
Definition wifi-mode.h:38
ns3::WifiMode::GetModulationClass
WifiModulationClass GetModulationClass() const
Definition wifi-mode.cc:172
ns3::WifiMode::GetDataRate
uint64_t GetDataRate(MHz_u channelWidth, Time guardInterval, uint8_t nss) const
Definition wifi-mode.cc:110
ns3::WifiPhy::GetPayloadDuration
static Time GetPayloadDuration(uint32_t size, const WifiTxVector &txVector, WifiPhyBand band, MpduType mpdutype=NORMAL_MPDU, uint16_t staId=SU_STA_ID)
Definition wifi-phy.cc:1521
ns3::WifiPhy::CalculateTxDuration
static Time CalculateTxDuration(uint32_t size, const WifiTxVector &txVector, WifiPhyBand band, uint16_t staId=SU_STA_ID)
Definition wifi-phy.cc:1568
ns3::WifiPhy::ChannelTuple
WifiChannelConfig::SegmentWithoutUnits ChannelTuple
kept for backward compatibility, can be deprecated when using strong types
Definition wifi-phy.h:949
ns3::WifiPhyOperatingChannel::FindFirst
static ConstIterator FindFirst(uint8_t number, MHz_u frequency, MHz_u width, WifiStandard standard, WifiPhyBand band, ConstIterator start=GetFrequencyChannels().begin())
Find the first frequency segment matching the specified parameters.
Definition wifi-phy-operating-channel.cc:451
ns3::WifiRu::RuSpec
std::variant< HeRu::RuSpec, EhtRu::RuSpec > RuSpec
variant of the RU specification
Definition wifi-ru.h:27
ns3::WifiRu::IsHe
static bool IsHe(RuSpec ru)
Get whether a given RU variant is a HE RU.
Definition wifi-ru.cc:248
ns3::WifiRu::GetBandwidth
static MHz_u GetBandwidth(RuType ruType)
Get the approximate bandwidth occupied by a RU.
Definition wifi-ru.cc:78
ns3::WifiRu::GetRuType
static RuType GetRuType(RuSpec ru)
Get the type of a given RU.
Definition wifi-ru.cc:45
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:98
ns3::WifiTxVector::SetRuAllocation
void SetRuAllocation(const RuAllocation &ruAlloc, uint8_t p20Index)
Set RU_ALLOCATION field.
Definition wifi-tx-vector.cc:410
ns3::WifiTxVector::SetStbc
void SetStbc(bool stbc)
Sets if STBC is being used.
Definition wifi-tx-vector.cc:350
ns3::WifiTxVector::SetNess
void SetNess(uint8_t ness)
Sets the Ness number.
Definition wifi-tx-vector.cc:338
ns3::WifiTxVector::SetEhtPpduType
void SetEhtPpduType(uint8_t type)
Set the EHT_PPDU_TYPE parameter.
Definition wifi-tx-vector.cc:430
ns3::WifiTxVector::SetGuardInterval
void SetGuardInterval(Time guardInterval)
Sets the guard interval duration (in nanoseconds).
Definition wifi-tx-vector.cc:312
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:634
ns3::WifiTxVector::SetChannelWidth
void SetChannelWidth(MHz_u channelWidth)
Sets the selected channelWidth.
Definition wifi-tx-vector.cc:306
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:557
ns3::WifiTxVector::SetSigBMode
void SetSigBMode(const WifiMode &mode)
Set the MCS used for SIG-B.
Definition wifi-tx-vector.cc:398
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:584
ns3::WifiTxVector::SetMode
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
Definition wifi-tx-vector.cc:275
ns3::WifiTxVector::SetNss
void SetNss(uint8_t nss)
Sets the number of Nss.
Definition wifi-tx-vector.cc:324
ns3::WifiTxVector::SetPreambleType
void SetPreambleType(WifiPreamble preamble)
Sets the preamble type.
Definition wifi-tx-vector.cc:300
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:55
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:75
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:97
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
ns3::CreateObject
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
ns3::Create
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:439
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:240
ns3::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1393
ns3::NanoSeconds
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1405
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1369
ns3::WifiPreamble
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition wifi-phy-common.h:176
ns3::WifiPhyBand
WifiPhyBand
Identifies the PHY band.
Definition wifi-phy-band.h:22
ns3::WifiPpduField
WifiPpduField
The type of PPDU field (grouped for convenience).
Definition wifi-phy-common.h:311
ns3::WIFI_STANDARD_80211be
@ WIFI_STANDARD_80211be
Definition wifi-standards.h:39
ns3::WIFI_PREAMBLE_LONG
@ WIFI_PREAMBLE_LONG
Definition wifi-phy-common.h:177
ns3::WIFI_PREAMBLE_EHT_TB
@ WIFI_PREAMBLE_EHT_TB
Definition wifi-phy-common.h:190
ns3::WIFI_PREAMBLE_HE_ER_SU
@ WIFI_PREAMBLE_HE_ER_SU
Definition wifi-phy-common.h:186
ns3::WIFI_PREAMBLE_HE_TB
@ WIFI_PREAMBLE_HE_TB
Definition wifi-phy-common.h:188
ns3::WIFI_PREAMBLE_EHT_MU
@ WIFI_PREAMBLE_EHT_MU
Definition wifi-phy-common.h:189
ns3::WIFI_PREAMBLE_HE_MU
@ WIFI_PREAMBLE_HE_MU
Definition wifi-phy-common.h:187
ns3::WIFI_PREAMBLE_HE_SU
@ WIFI_PREAMBLE_HE_SU
Definition wifi-phy-common.h:185
ns3::WIFI_PREAMBLE_VHT_MU
@ WIFI_PREAMBLE_VHT_MU
Definition wifi-phy-common.h:181
ns3::WIFI_PREAMBLE_VHT_SU
@ WIFI_PREAMBLE_VHT_SU
Definition wifi-phy-common.h:180
ns3::WIFI_PREAMBLE_SHORT
@ WIFI_PREAMBLE_SHORT
Definition wifi-phy-common.h:178
ns3::WIFI_PREAMBLE_HT_MF
@ WIFI_PREAMBLE_HT_MF
Definition wifi-phy-common.h:179
ns3::WIFI_PHY_BAND_6GHZ
@ WIFI_PHY_BAND_6GHZ
The 6 GHz band.
Definition wifi-phy-band.h:28
ns3::WIFI_PHY_BAND_2_4GHZ
@ WIFI_PHY_BAND_2_4GHZ
The 2.4 GHz band.
Definition wifi-phy-band.h:24
ns3::WIFI_PHY_BAND_5GHZ
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
Definition wifi-phy-band.h:26
ns3::WIFI_MOD_CLASS_OFDM
@ WIFI_MOD_CLASS_OFDM
OFDM (Clause 17).
Definition wifi-phy-common.h:253
ns3::WIFI_MOD_CLASS_VHT
@ WIFI_MOD_CLASS_VHT
VHT (Clause 22).
Definition wifi-phy-common.h:255
ns3::WIFI_MOD_CLASS_HE
@ WIFI_MOD_CLASS_HE
HE (Clause 27).
Definition wifi-phy-common.h:260
ns3::OFDM_PHY_10_MHZ
@ OFDM_PHY_10_MHZ
Definition ofdm-phy.h:35
ns3::OFDM_PHY_DEFAULT
@ OFDM_PHY_DEFAULT
Definition ofdm-phy.h:34
ns3::OFDM_PHY_5_MHZ
@ OFDM_PHY_5_MHZ
Definition ofdm-phy.h:36
ns3::WIFI_PPDU_FIELD_SIG_B
@ WIFI_PPDU_FIELD_SIG_B
SIG-B field.
Definition wifi-phy-common.h:329
ns3::WIFI_PPDU_FIELD_TRAINING
@ WIFI_PPDU_FIELD_TRAINING
STF + LTF fields (excluding those in preamble for HT-GF).
Definition wifi-phy-common.h:327
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:325
ns3::WIFI_PPDU_FIELD_EHT_SIG
@ WIFI_PPDU_FIELD_EHT_SIG
EHT-SIG field.
Definition wifi-phy-common.h:331
ns3::WIFI_PPDU_FIELD_HT_SIG
@ WIFI_PPDU_FIELD_HT_SIG
HT-SIG field.
Definition wifi-phy-common.h:326
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:318
ns3::WIFI_PPDU_FIELD_U_SIG
@ WIFI_PPDU_FIELD_U_SIG
U-SIG field.
Definition wifi-phy-common.h:330
ns3::WIFI_PPDU_FIELD_SIG_A
@ WIFI_PPDU_FIELD_SIG_A
SIG-A field.
Definition wifi-phy-common.h:328
anonymous_namespace{tx-duration-test.cc}::MakeRuSpec
WifiRu::RuSpec MakeRuSpec(RuType ruType, std::size_t index, bool primaryOrLow80MHz, std::optional< bool > primary160MHz=std::nullopt)
Create an HE or an EHT RU Specification.
Definition tx-duration-test.cc:44
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::IsEht
bool IsEht(WifiPreamble preamble)
Return true if a preamble corresponds to an EHT transmission.
Definition wifi-phy-common.cc:331
ns3::RuType
RuType
The different Resource Unit (RU) types.
Definition wifi-types.h:240
ns3::PhyHeaderSections
std::map< WifiPpduField, PhyHeaderChunkInfo > PhyHeaderSections
A map of PhyHeaderChunkInfo elements per PPDU field.
Definition wifi-phy-common.h:768
ns3::MHz_u
double MHz_u
MHz weak type.
Definition wifi-units.h:31
ns3::WIFI_MAC_CTL_ACK
@ WIFI_MAC_CTL_ACK
Definition wifi-mac-header.h:32
ns3::WifiConstPsduMap
std::unordered_map< uint16_t, Ptr< const WifiPsdu > > WifiConstPsduMap
Map of const PSDUs indexed by STA-ID.
Definition wifi-ppdu.h:38
ns3::SU_STA_ID
static constexpr uint16_t SU_STA_ID
STA_ID to identify a single user (SU).
Definition wifi-standard-constants.h:106
ns3::RuAllocation
std::vector< uint16_t > RuAllocation
9 bits RU_ALLOCATION per 20 MHz
Definition wifi-tx-vector.h:52
ns3::HeMuUserInfo
HE MU specific user transmission parameters.
Definition wifi-tx-vector.h:30
g_txDurationTestSuite
static TxDurationTestSuite g_txDurationTestSuite
the test suite
Definition tx-duration-test.cc:3507