A Discrete-Event Network Simulator
API
tx-duration-test.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2009 CTTC
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation;
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16  *
17  * Authors: Nicola Baldo <nbaldo@cttc.es>
18  * Sébastien Deronne <sebastien.deronne@gmail.com>
19  */
20 
21 #include "ns3/dsss-phy.h"
22 #include "ns3/eht-phy.h" //includes OFDM, HT, VHT and HE
23 #include "ns3/erp-ofdm-phy.h"
24 #include "ns3/he-ru.h"
25 #include "ns3/log.h"
26 #include "ns3/packet.h"
27 #include "ns3/simulator.h"
28 #include "ns3/test.h"
29 #include "ns3/wifi-psdu.h"
30 #include "ns3/yans-wifi-phy.h"
31 
32 #include <numeric>
33 
34 using namespace ns3;
35 
36 NS_LOG_COMPONENT_DEFINE("InterferenceHelperTxDurationTest");
37 
44 class TxDurationTest : public TestCase
45 {
46  public:
47  TxDurationTest();
48  ~TxDurationTest() override;
49  void DoRun() override;
50 
51  private:
65  bool CheckPayloadDuration(uint32_t size,
66  WifiMode payloadMode,
67  uint16_t channelWidth,
68  uint16_t guardInterval,
69  WifiPreamble preamble,
70  Time knownDuration);
71 
85  bool CheckTxDuration(uint32_t size,
86  WifiMode payloadMode,
87  uint16_t channelWidth,
88  uint16_t guardInterval,
89  WifiPreamble preamble,
90  Time knownDuration);
91 
105  static bool CheckMuTxDuration(std::list<uint32_t> sizes,
106  std::list<HeMuUserInfo> userInfos,
107  uint16_t channelWidth,
108  uint16_t guardInterval,
109  WifiPreamble preamble,
110  Time knownDuration);
111 
126  static Time CalculateTxDurationUsingList(std::list<uint32_t> sizes,
127  std::list<uint16_t> staIds,
128  WifiTxVector txVector,
129  WifiPhyBand band);
130 };
131 
132 TxDurationTest::TxDurationTest()
133  : TestCase("Wifi TX Duration")
134 {
135 }
136 
137 TxDurationTest::~TxDurationTest()
138 {
139 }
140 
141 bool
142 TxDurationTest::CheckPayloadDuration(uint32_t size,
143  WifiMode payloadMode,
144  uint16_t channelWidth,
145  uint16_t guardInterval,
146  WifiPreamble preamble,
147  Time knownDuration)
148 {
149  WifiTxVector txVector;
150  txVector.SetMode(payloadMode);
151  txVector.SetPreambleType(preamble);
152  txVector.SetChannelWidth(channelWidth);
153  txVector.SetGuardInterval(guardInterval);
154  txVector.SetNss(1);
155  txVector.SetStbc(0);
156  txVector.SetNess(0);
157  std::list<WifiPhyBand> testedBands;
158  Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
159  if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM)
160  {
161  testedBands.push_back(WIFI_PHY_BAND_5GHZ);
162  }
163  if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_HE)
164  {
165  testedBands.push_back(WIFI_PHY_BAND_6GHZ);
166  }
167  if (payloadMode.GetModulationClass() != WIFI_MOD_CLASS_VHT)
168  {
169  testedBands.push_back(WIFI_PHY_BAND_2_4GHZ);
170  }
171  for (auto& testedBand : testedBands)
172  {
173  if ((testedBand == WIFI_PHY_BAND_2_4GHZ) &&
174  (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM))
175  {
176  knownDuration +=
177  MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
178  }
179  Time calculatedDuration = phy->GetPayloadDuration(size, txVector, testedBand);
180  if (calculatedDuration != knownDuration)
181  {
182  std::cerr << "size=" << size << " band=" << testedBand << " mode=" << payloadMode
183  << " channelWidth=" << channelWidth << " guardInterval=" << guardInterval
184  << " datarate=" << payloadMode.GetDataRate(channelWidth, guardInterval, 1)
185  << " known=" << knownDuration << " calculated=" << calculatedDuration
186  << std::endl;
187  return false;
188  }
189  }
190  return true;
191 }
192 
193 bool
194 TxDurationTest::CheckTxDuration(uint32_t size,
195  WifiMode payloadMode,
196  uint16_t channelWidth,
197  uint16_t guardInterval,
198  WifiPreamble preamble,
199  Time knownDuration)
200 {
201  WifiTxVector txVector;
202  txVector.SetMode(payloadMode);
203  txVector.SetPreambleType(preamble);
204  txVector.SetChannelWidth(channelWidth);
205  txVector.SetGuardInterval(guardInterval);
206  txVector.SetNss(1);
207  txVector.SetStbc(0);
208  txVector.SetNess(0);
209  std::list<WifiPhyBand> testedBands;
210  Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
211  if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM)
212  {
213  testedBands.push_back(WIFI_PHY_BAND_5GHZ);
214  }
215  if (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_HE)
216  {
217  testedBands.push_back(WIFI_PHY_BAND_6GHZ);
218  }
219  if (payloadMode.GetModulationClass() != WIFI_MOD_CLASS_VHT)
220  {
221  testedBands.push_back(WIFI_PHY_BAND_2_4GHZ);
222  }
223  for (auto& testedBand : testedBands)
224  {
225  if ((testedBand == WIFI_PHY_BAND_2_4GHZ) &&
226  (payloadMode.GetModulationClass() >= WIFI_MOD_CLASS_OFDM))
227  {
228  knownDuration +=
229  MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
230  }
231  Time calculatedDuration = phy->CalculateTxDuration(size, txVector, testedBand);
232  Time calculatedDurationUsingList =
233  CalculateTxDurationUsingList(std::list<uint32_t>{size},
234  std::list<uint16_t>{SU_STA_ID},
235  txVector,
236  testedBand);
237  if (calculatedDuration != knownDuration ||
238  calculatedDuration != calculatedDurationUsingList)
239  {
240  std::cerr << "size=" << size << " band=" << testedBand << " mode=" << payloadMode
241  << " channelWidth=" << +channelWidth << " guardInterval=" << guardInterval
242  << " datarate=" << payloadMode.GetDataRate(channelWidth, guardInterval, 1)
243  << " preamble=" << preamble << " known=" << knownDuration
244  << " calculated=" << calculatedDuration
245  << " calculatedUsingList=" << calculatedDurationUsingList << std::endl;
246  return false;
247  }
248  }
249  return true;
250 }
251 
252 bool
253 TxDurationTest::CheckMuTxDuration(std::list<uint32_t> sizes,
254  std::list<HeMuUserInfo> userInfos,
255  uint16_t channelWidth,
256  uint16_t guardInterval,
257  WifiPreamble preamble,
258  Time knownDuration)
259 {
260  NS_ASSERT(sizes.size() == userInfos.size() && sizes.size() > 1);
261  NS_ABORT_MSG_IF(
262  channelWidth < std::accumulate(
263  std::begin(userInfos),
264  std::end(userInfos),
265  0,
266  [](const uint16_t prevBw, const HeMuUserInfo& info) {
267  return prevBw + HeRu::GetBandwidth(info.ru.GetRuType());
268  }),
269  "Cannot accommodate all the RUs in the provided band"); // MU-MIMO (for which allocations
270  // use the same RU) is not supported
271  WifiTxVector txVector;
272  txVector.SetPreambleType(preamble);
273  txVector.SetChannelWidth(channelWidth);
274  txVector.SetGuardInterval(guardInterval);
275  txVector.SetStbc(0);
276  txVector.SetNess(0);
277  if (IsEht(preamble))
278  {
279  txVector.SetEhtPpduType(0);
280  }
281  std::list<uint16_t> staIds;
282 
283  uint16_t staId = 1;
284  for (const auto& userInfo : userInfos)
285  {
286  txVector.SetHeMuUserInfo(staId, userInfo);
287  staIds.push_back(staId++);
288  }
289  txVector.SetSigBMode(VhtPhy::GetVhtMcs0());
290  txVector.SetRuAllocation({192, 192});
291 
292  Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy>();
293  std::list<WifiPhyBand> testedBands{
294  WIFI_PHY_BAND_5GHZ,
295  WIFI_PHY_BAND_6GHZ,
296  WIFI_PHY_BAND_2_4GHZ}; // Durations vary depending on frequency; test also 2.4 GHz (bug
297  // 1971)
298  for (auto& testedBand : testedBands)
299  {
300  if (testedBand == WIFI_PHY_BAND_2_4GHZ)
301  {
302  knownDuration +=
303  MicroSeconds(6); // 2.4 GHz band should be at the end of the bands to test
304  }
305  Time calculatedDuration = NanoSeconds(0);
306  uint32_t longuestSize = 0;
307  auto iterStaId = staIds.begin();
308  for (auto& size : sizes)
309  {
310  Time ppduDurationForSta =
311  phy->CalculateTxDuration(size, txVector, testedBand, *iterStaId);
312  if (ppduDurationForSta > calculatedDuration)
313  {
314  calculatedDuration = ppduDurationForSta;
315  staId = *iterStaId;
316  longuestSize = size;
317  }
318  ++iterStaId;
319  }
320  Time calculatedDurationUsingList =
321  CalculateTxDurationUsingList(sizes, staIds, txVector, testedBand);
322  if (calculatedDuration != knownDuration ||
323  calculatedDuration != calculatedDurationUsingList)
324  {
325  std::cerr << "size=" << longuestSize << " band=" << testedBand << " staId=" << staId
326  << " nss=" << +txVector.GetNss(staId) << " mode=" << txVector.GetMode(staId)
327  << " channelWidth=" << channelWidth << " guardInterval=" << guardInterval
328  << " datarate="
329  << txVector.GetMode(staId).GetDataRate(channelWidth,
330  guardInterval,
331  txVector.GetNss(staId))
332  << " known=" << knownDuration << " calculated=" << calculatedDuration
333  << " calculatedUsingList=" << calculatedDurationUsingList << std::endl;
334  return false;
335  }
336  }
337  return true;
338 }
339 
340 Time
341 TxDurationTest::CalculateTxDurationUsingList(std::list<uint32_t> sizes,
342  std::list<uint16_t> staIds,
343  WifiTxVector txVector,
344  WifiPhyBand band)
345 {
346  NS_ASSERT(sizes.size() == staIds.size());
347  WifiConstPsduMap psduMap;
348  auto itStaId = staIds.begin();
349  WifiMacHeader hdr;
350  hdr.SetType(WIFI_MAC_CTL_ACK); // so that size may not be empty while being as short as possible
351  for (auto& size : sizes)
352  {
353  // MAC header and FCS are to deduce from size
354  psduMap[*itStaId++] =
355  Create<WifiPsdu>(Create<Packet>(size - hdr.GetSerializedSize() - 4), hdr);
356  }
357  return WifiPhy::CalculateTxDuration(psduMap, txVector, band);
358 }
359 
360 void
361 TxDurationTest::DoRun()
362 {
363  bool retval = true;
364 
365  // IEEE Std 802.11-2007 Table 18-2 "Example of LENGTH calculations for CCK"
366  retval = retval &&
367  CheckPayloadDuration(1023,
368  DsssPhy::GetDsssRate11Mbps(),
369  22,
370  800,
371  WIFI_PREAMBLE_LONG,
372  MicroSeconds(744)) &&
373  CheckPayloadDuration(1024,
374  DsssPhy::GetDsssRate11Mbps(),
375  22,
376  800,
377  WIFI_PREAMBLE_LONG,
378  MicroSeconds(745)) &&
379  CheckPayloadDuration(1025,
380  DsssPhy::GetDsssRate11Mbps(),
381  22,
382  800,
383  WIFI_PREAMBLE_LONG,
384  MicroSeconds(746)) &&
385  CheckPayloadDuration(1026,
386  DsssPhy::GetDsssRate11Mbps(),
387  22,
388  800,
389  WIFI_PREAMBLE_LONG,
390  MicroSeconds(747));
391 
392  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11b CCK duration failed");
393 
394  // Similar, but we add PHY preamble and header durations
395  // and we test different rates.
396  // The payload durations for modes other than 11mbb have been
397  // calculated by hand according to IEEE Std 802.11-2007 18.2.3.5
398  retval = retval &&
399  CheckTxDuration(1023,
400  DsssPhy::GetDsssRate11Mbps(),
401  22,
402  800,
403  WIFI_PREAMBLE_SHORT,
404  MicroSeconds(744 + 96)) &&
405  CheckTxDuration(1024,
406  DsssPhy::GetDsssRate11Mbps(),
407  22,
408  800,
409  WIFI_PREAMBLE_SHORT,
410  MicroSeconds(745 + 96)) &&
411  CheckTxDuration(1025,
412  DsssPhy::GetDsssRate11Mbps(),
413  22,
414  800,
415  WIFI_PREAMBLE_SHORT,
416  MicroSeconds(746 + 96)) &&
417  CheckTxDuration(1026,
418  DsssPhy::GetDsssRate11Mbps(),
419  22,
420  800,
421  WIFI_PREAMBLE_SHORT,
422  MicroSeconds(747 + 96)) &&
423  CheckTxDuration(1023,
424  DsssPhy::GetDsssRate11Mbps(),
425  22,
426  800,
427  WIFI_PREAMBLE_LONG,
428  MicroSeconds(744 + 192)) &&
429  CheckTxDuration(1024,
430  DsssPhy::GetDsssRate11Mbps(),
431  22,
432  800,
433  WIFI_PREAMBLE_LONG,
434  MicroSeconds(745 + 192)) &&
435  CheckTxDuration(1025,
436  DsssPhy::GetDsssRate11Mbps(),
437  22,
438  800,
439  WIFI_PREAMBLE_LONG,
440  MicroSeconds(746 + 192)) &&
441  CheckTxDuration(1026,
442  DsssPhy::GetDsssRate11Mbps(),
443  22,
444  800,
445  WIFI_PREAMBLE_LONG,
446  MicroSeconds(747 + 192)) &&
447  CheckTxDuration(1023,
448  DsssPhy::GetDsssRate5_5Mbps(),
449  22,
450  800,
451  WIFI_PREAMBLE_SHORT,
452  MicroSeconds(1488 + 96)) &&
453  CheckTxDuration(1024,
454  DsssPhy::GetDsssRate5_5Mbps(),
455  22,
456  800,
457  WIFI_PREAMBLE_SHORT,
458  MicroSeconds(1490 + 96)) &&
459  CheckTxDuration(1025,
460  DsssPhy::GetDsssRate5_5Mbps(),
461  22,
462  800,
463  WIFI_PREAMBLE_SHORT,
464  MicroSeconds(1491 + 96)) &&
465  CheckTxDuration(1026,
466  DsssPhy::GetDsssRate5_5Mbps(),
467  22,
468  800,
469  WIFI_PREAMBLE_SHORT,
470  MicroSeconds(1493 + 96)) &&
471  CheckTxDuration(1023,
472  DsssPhy::GetDsssRate5_5Mbps(),
473  22,
474  800,
475  WIFI_PREAMBLE_LONG,
476  MicroSeconds(1488 + 192)) &&
477  CheckTxDuration(1024,
478  DsssPhy::GetDsssRate5_5Mbps(),
479  22,
480  800,
481  WIFI_PREAMBLE_LONG,
482  MicroSeconds(1490 + 192)) &&
483  CheckTxDuration(1025,
484  DsssPhy::GetDsssRate5_5Mbps(),
485  22,
486  800,
487  WIFI_PREAMBLE_LONG,
488  MicroSeconds(1491 + 192)) &&
489  CheckTxDuration(1026,
490  DsssPhy::GetDsssRate5_5Mbps(),
491  22,
492  800,
493  WIFI_PREAMBLE_LONG,
494  MicroSeconds(1493 + 192)) &&
495  CheckTxDuration(1023,
496  DsssPhy::GetDsssRate2Mbps(),
497  22,
498  800,
499  WIFI_PREAMBLE_SHORT,
500  MicroSeconds(4092 + 96)) &&
501  CheckTxDuration(1024,
502  DsssPhy::GetDsssRate2Mbps(),
503  22,
504  800,
505  WIFI_PREAMBLE_SHORT,
506  MicroSeconds(4096 + 96)) &&
507  CheckTxDuration(1025,
508  DsssPhy::GetDsssRate2Mbps(),
509  22,
510  800,
511  WIFI_PREAMBLE_SHORT,
512  MicroSeconds(4100 + 96)) &&
513  CheckTxDuration(1026,
514  DsssPhy::GetDsssRate2Mbps(),
515  22,
516  800,
517  WIFI_PREAMBLE_SHORT,
518  MicroSeconds(4104 + 96)) &&
519  CheckTxDuration(1023,
520  DsssPhy::GetDsssRate2Mbps(),
521  22,
522  800,
523  WIFI_PREAMBLE_LONG,
524  MicroSeconds(4092 + 192)) &&
525  CheckTxDuration(1024,
526  DsssPhy::GetDsssRate2Mbps(),
527  22,
528  800,
529  WIFI_PREAMBLE_LONG,
530  MicroSeconds(4096 + 192)) &&
531  CheckTxDuration(1025,
532  DsssPhy::GetDsssRate2Mbps(),
533  22,
534  800,
535  WIFI_PREAMBLE_LONG,
536  MicroSeconds(4100 + 192)) &&
537  CheckTxDuration(1026,
538  DsssPhy::GetDsssRate2Mbps(),
539  22,
540  800,
541  WIFI_PREAMBLE_LONG,
542  MicroSeconds(4104 + 192)) &&
543  CheckTxDuration(1023,
544  DsssPhy::GetDsssRate1Mbps(),
545  22,
546  800,
547  WIFI_PREAMBLE_SHORT,
548  MicroSeconds(8184 + 192)) &&
549  CheckTxDuration(1024,
550  DsssPhy::GetDsssRate1Mbps(),
551  22,
552  800,
553  WIFI_PREAMBLE_SHORT,
554  MicroSeconds(8192 + 192)) &&
555  CheckTxDuration(1025,
556  DsssPhy::GetDsssRate1Mbps(),
557  22,
558  800,
559  WIFI_PREAMBLE_SHORT,
560  MicroSeconds(8200 + 192)) &&
561  CheckTxDuration(1026,
562  DsssPhy::GetDsssRate1Mbps(),
563  22,
564  800,
565  WIFI_PREAMBLE_SHORT,
566  MicroSeconds(8208 + 192)) &&
567  CheckTxDuration(1023,
568  DsssPhy::GetDsssRate1Mbps(),
569  22,
570  800,
571  WIFI_PREAMBLE_LONG,
572  MicroSeconds(8184 + 192)) &&
573  CheckTxDuration(1024,
574  DsssPhy::GetDsssRate1Mbps(),
575  22,
576  800,
577  WIFI_PREAMBLE_LONG,
578  MicroSeconds(8192 + 192)) &&
579  CheckTxDuration(1025,
580  DsssPhy::GetDsssRate1Mbps(),
581  22,
582  800,
583  WIFI_PREAMBLE_LONG,
584  MicroSeconds(8200 + 192)) &&
585  CheckTxDuration(1026,
586  DsssPhy::GetDsssRate1Mbps(),
587  22,
588  800,
589  WIFI_PREAMBLE_LONG,
590  MicroSeconds(8208 + 192));
591 
592  // values from http://mailman.isi.edu/pipermail/ns-developers/2009-July/006226.html
593  retval = retval && CheckTxDuration(14,
594  DsssPhy::GetDsssRate1Mbps(),
595  22,
596  800,
597  WIFI_PREAMBLE_LONG,
598  MicroSeconds(304));
599 
600  // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
601  retval = retval &&
602  CheckTxDuration(1536,
603  DsssPhy::GetDsssRate11Mbps(),
604  22,
605  800,
606  WIFI_PREAMBLE_LONG,
607  MicroSeconds(1310)) &&
608  CheckTxDuration(76,
609  DsssPhy::GetDsssRate11Mbps(),
610  22,
611  800,
612  WIFI_PREAMBLE_LONG,
613  MicroSeconds(248)) &&
614  CheckTxDuration(14,
615  DsssPhy::GetDsssRate11Mbps(),
616  22,
617  800,
618  WIFI_PREAMBLE_LONG,
619  MicroSeconds(203));
620 
621  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11b duration failed");
622 
623  // 802.11a durations
624  // values from http://www.oreillynet.com/pub/a/wireless/2003/08/08/wireless_throughput.html
625  retval = retval &&
626  CheckTxDuration(1536,
627  OfdmPhy::GetOfdmRate54Mbps(),
628  20,
629  800,
630  WIFI_PREAMBLE_LONG,
631  MicroSeconds(248)) &&
632  CheckTxDuration(76,
633  OfdmPhy::GetOfdmRate54Mbps(),
634  20,
635  800,
636  WIFI_PREAMBLE_LONG,
637  MicroSeconds(32)) &&
638  CheckTxDuration(14,
639  OfdmPhy::GetOfdmRate54Mbps(),
640  20,
641  800,
642  WIFI_PREAMBLE_LONG,
643  MicroSeconds(24));
644 
645  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11a duration failed");
646 
647  // 802.11g durations are same as 802.11a durations but with 6 us signal extension
648  retval = retval &&
649  CheckTxDuration(1536,
650  ErpOfdmPhy::GetErpOfdmRate54Mbps(),
651  20,
652  800,
653  WIFI_PREAMBLE_LONG,
654  MicroSeconds(254)) &&
655  CheckTxDuration(76,
656  ErpOfdmPhy::GetErpOfdmRate54Mbps(),
657  20,
658  800,
659  WIFI_PREAMBLE_LONG,
660  MicroSeconds(38)) &&
661  CheckTxDuration(14,
662  ErpOfdmPhy::GetErpOfdmRate54Mbps(),
663  20,
664  800,
665  WIFI_PREAMBLE_LONG,
666  MicroSeconds(30));
667 
668  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11g duration failed");
669 
670  // 802.11n durations
671  retval =
672  retval &&
673  CheckTxDuration(1536,
674  HtPhy::GetHtMcs7(),
675  20,
676  800,
677  WIFI_PREAMBLE_HT_MF,
678  MicroSeconds(228)) &&
679  CheckTxDuration(76, HtPhy::GetHtMcs7(), 20, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(48)) &&
680  CheckTxDuration(14, HtPhy::GetHtMcs7(), 20, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(40)) &&
681  CheckTxDuration(1536,
682  HtPhy::GetHtMcs0(),
683  20,
684  400,
685  WIFI_PREAMBLE_HT_MF,
686  NanoSeconds(1742400)) &&
687  CheckTxDuration(76, HtPhy::GetHtMcs0(), 20, 400, WIFI_PREAMBLE_HT_MF, MicroSeconds(126)) &&
688  CheckTxDuration(14, HtPhy::GetHtMcs0(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(57600)) &&
689  CheckTxDuration(1536,
690  HtPhy::GetHtMcs6(),
691  20,
692  400,
693  WIFI_PREAMBLE_HT_MF,
694  NanoSeconds(226800)) &&
695  CheckTxDuration(76, HtPhy::GetHtMcs6(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(46800)) &&
696  CheckTxDuration(14, HtPhy::GetHtMcs6(), 20, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(39600)) &&
697  CheckTxDuration(1536,
698  HtPhy::GetHtMcs7(),
699  40,
700  800,
701  WIFI_PREAMBLE_HT_MF,
702  MicroSeconds(128)) &&
703  CheckTxDuration(76, HtPhy::GetHtMcs7(), 40, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(44)) &&
704  CheckTxDuration(14, HtPhy::GetHtMcs7(), 40, 800, WIFI_PREAMBLE_HT_MF, MicroSeconds(40)) &&
705  CheckTxDuration(1536,
706  HtPhy::GetHtMcs7(),
707  40,
708  400,
709  WIFI_PREAMBLE_HT_MF,
710  NanoSeconds(118800)) &&
711  CheckTxDuration(76, HtPhy::GetHtMcs7(), 40, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(43200)) &&
712  CheckTxDuration(14, HtPhy::GetHtMcs7(), 40, 400, WIFI_PREAMBLE_HT_MF, NanoSeconds(39600));
713 
714  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11n duration failed");
715 
716  // 802.11ac durations
717  retval = retval &&
718  CheckTxDuration(1536,
719  VhtPhy::GetVhtMcs8(),
720  20,
721  800,
722  WIFI_PREAMBLE_VHT_SU,
723  MicroSeconds(196)) &&
724  CheckTxDuration(76,
725  VhtPhy::GetVhtMcs8(),
726  20,
727  800,
728  WIFI_PREAMBLE_VHT_SU,
729  MicroSeconds(48)) &&
730  CheckTxDuration(14,
731  VhtPhy::GetVhtMcs8(),
732  20,
733  800,
734  WIFI_PREAMBLE_VHT_SU,
735  MicroSeconds(40)) &&
736  CheckTxDuration(1536,
737  VhtPhy::GetVhtMcs8(),
738  20,
739  400,
740  WIFI_PREAMBLE_VHT_SU,
741  MicroSeconds(180)) &&
742  CheckTxDuration(76,
743  VhtPhy::GetVhtMcs8(),
744  20,
745  400,
746  WIFI_PREAMBLE_VHT_SU,
747  NanoSeconds(46800)) &&
748  CheckTxDuration(14,
749  VhtPhy::GetVhtMcs8(),
750  20,
751  400,
752  WIFI_PREAMBLE_VHT_SU,
753  NanoSeconds(39600)) &&
754  CheckTxDuration(1536,
755  VhtPhy::GetVhtMcs9(),
756  40,
757  800,
758  WIFI_PREAMBLE_VHT_SU,
759  MicroSeconds(108)) &&
760  CheckTxDuration(76,
761  VhtPhy::GetVhtMcs9(),
762  40,
763  800,
764  WIFI_PREAMBLE_VHT_SU,
765  MicroSeconds(40)) &&
766  CheckTxDuration(14,
767  VhtPhy::GetVhtMcs9(),
768  40,
769  800,
770  WIFI_PREAMBLE_VHT_SU,
771  MicroSeconds(40)) &&
772  CheckTxDuration(1536,
773  VhtPhy::GetVhtMcs9(),
774  40,
775  400,
776  WIFI_PREAMBLE_VHT_SU,
777  NanoSeconds(100800)) &&
778  CheckTxDuration(76,
779  VhtPhy::GetVhtMcs9(),
780  40,
781  400,
782  WIFI_PREAMBLE_VHT_SU,
783  NanoSeconds(39600)) &&
784  CheckTxDuration(14,
785  VhtPhy::GetVhtMcs9(),
786  40,
787  400,
788  WIFI_PREAMBLE_VHT_SU,
789  NanoSeconds(39600)) &&
790  CheckTxDuration(1536,
791  VhtPhy::GetVhtMcs0(),
792  80,
793  800,
794  WIFI_PREAMBLE_VHT_SU,
795  MicroSeconds(460)) &&
796  CheckTxDuration(76,
797  VhtPhy::GetVhtMcs0(),
798  80,
799  800,
800  WIFI_PREAMBLE_VHT_SU,
801  MicroSeconds(60)) &&
802  CheckTxDuration(14,
803  VhtPhy::GetVhtMcs0(),
804  80,
805  800,
806  WIFI_PREAMBLE_VHT_SU,
807  MicroSeconds(44)) &&
808  CheckTxDuration(1536,
809  VhtPhy::GetVhtMcs0(),
810  80,
811  400,
812  WIFI_PREAMBLE_VHT_SU,
813  NanoSeconds(417600)) &&
814  CheckTxDuration(76,
815  VhtPhy::GetVhtMcs0(),
816  80,
817  400,
818  WIFI_PREAMBLE_VHT_SU,
819  NanoSeconds(57600)) &&
820  CheckTxDuration(14,
821  VhtPhy::GetVhtMcs0(),
822  80,
823  400,
824  WIFI_PREAMBLE_VHT_SU,
825  NanoSeconds(43200)) &&
826  CheckTxDuration(1536,
827  VhtPhy::GetVhtMcs9(),
828  80,
829  800,
830  WIFI_PREAMBLE_VHT_SU,
831  MicroSeconds(68)) &&
832  CheckTxDuration(76,
833  VhtPhy::GetVhtMcs9(),
834  80,
835  800,
836  WIFI_PREAMBLE_VHT_SU,
837  MicroSeconds(40)) &&
838  CheckTxDuration(14,
839  VhtPhy::GetVhtMcs9(),
840  80,
841  800,
842  WIFI_PREAMBLE_VHT_SU,
843  MicroSeconds(40)) &&
844  CheckTxDuration(1536,
845  VhtPhy::GetVhtMcs9(),
846  80,
847  400,
848  WIFI_PREAMBLE_VHT_SU,
849  NanoSeconds(64800)) &&
850  CheckTxDuration(76,
851  VhtPhy::GetVhtMcs9(),
852  80,
853  400,
854  WIFI_PREAMBLE_VHT_SU,
855  NanoSeconds(39600)) &&
856  CheckTxDuration(14,
857  VhtPhy::GetVhtMcs9(),
858  80,
859  400,
860  WIFI_PREAMBLE_VHT_SU,
861  NanoSeconds(39600)) &&
862  CheckTxDuration(1536,
863  VhtPhy::GetVhtMcs8(),
864  160,
865  800,
866  WIFI_PREAMBLE_VHT_SU,
867  MicroSeconds(56)) &&
868  CheckTxDuration(76,
869  VhtPhy::GetVhtMcs8(),
870  160,
871  800,
872  WIFI_PREAMBLE_VHT_SU,
873  MicroSeconds(40)) &&
874  CheckTxDuration(14,
875  VhtPhy::GetVhtMcs8(),
876  160,
877  800,
878  WIFI_PREAMBLE_VHT_SU,
879  MicroSeconds(40)) &&
880  CheckTxDuration(1536,
881  VhtPhy::GetVhtMcs8(),
882  160,
883  400,
884  WIFI_PREAMBLE_VHT_SU,
885  MicroSeconds(54)) &&
886  CheckTxDuration(76,
887  VhtPhy::GetVhtMcs8(),
888  160,
889  400,
890  WIFI_PREAMBLE_VHT_SU,
891  NanoSeconds(39600)) &&
892  CheckTxDuration(14,
893  VhtPhy::GetVhtMcs8(),
894  160,
895  400,
896  WIFI_PREAMBLE_VHT_SU,
897  NanoSeconds(39600));
898 
899  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ac duration failed");
900 
901  // 802.11ax SU durations
902  retval =
903  retval &&
904  CheckTxDuration(1536,
905  HePhy::GetHeMcs0(),
906  20,
907  800,
908  WIFI_PREAMBLE_HE_SU,
909  NanoSeconds(1485600)) &&
910  CheckTxDuration(76,
911  HePhy::GetHeMcs0(),
912  20,
913  800,
914  WIFI_PREAMBLE_HE_SU,
915  NanoSeconds(125600)) &&
916  CheckTxDuration(14, HePhy::GetHeMcs0(), 20, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(71200)) &&
917  CheckTxDuration(1536,
918  HePhy::GetHeMcs0(),
919  40,
920  800,
921  WIFI_PREAMBLE_HE_SU,
922  NanoSeconds(764800)) &&
923  CheckTxDuration(76, HePhy::GetHeMcs0(), 40, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(84800)) &&
924  CheckTxDuration(14, HePhy::GetHeMcs0(), 40, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(57600)) &&
925  CheckTxDuration(1536,
926  HePhy::GetHeMcs0(),
927  80,
928  800,
929  WIFI_PREAMBLE_HE_SU,
930  NanoSeconds(397600)) &&
931  CheckTxDuration(76, HePhy::GetHeMcs0(), 80, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(71200)) &&
932  CheckTxDuration(14, HePhy::GetHeMcs0(), 80, 800, WIFI_PREAMBLE_HE_SU, NanoSeconds(57600)) &&
933  CheckTxDuration(1536,
934  HePhy::GetHeMcs0(),
935  160,
936  800,
937  WIFI_PREAMBLE_HE_SU,
938  NanoSeconds(220800)) &&
939  CheckTxDuration(76,
940  HePhy::GetHeMcs0(),
941  160,
942  800,
943  WIFI_PREAMBLE_HE_SU,
944  NanoSeconds(57600)) &&
945  CheckTxDuration(14,
946  HePhy::GetHeMcs0(),
947  160,
948  800,
949  WIFI_PREAMBLE_HE_SU,
950  NanoSeconds(57600)) &&
951  CheckTxDuration(1536,
952  HePhy::GetHeMcs0(),
953  20,
954  1600,
955  WIFI_PREAMBLE_HE_SU,
956  NanoSeconds(1570400)) &&
957  CheckTxDuration(76,
958  HePhy::GetHeMcs0(),
959  20,
960  1600,
961  WIFI_PREAMBLE_HE_SU,
962  NanoSeconds(130400)) &&
963  CheckTxDuration(14,
964  HePhy::GetHeMcs0(),
965  20,
966  1600,
967  WIFI_PREAMBLE_HE_SU,
968  NanoSeconds(72800)) &&
969  CheckTxDuration(1536,
970  HePhy::GetHeMcs0(),
971  40,
972  1600,
973  WIFI_PREAMBLE_HE_SU,
974  NanoSeconds(807200)) &&
975  CheckTxDuration(76,
976  HePhy::GetHeMcs0(),
977  40,
978  1600,
979  WIFI_PREAMBLE_HE_SU,
980  NanoSeconds(87200)) &&
981  CheckTxDuration(14,
982  HePhy::GetHeMcs0(),
983  40,
984  1600,
985  WIFI_PREAMBLE_HE_SU,
986  NanoSeconds(58400)) &&
987  CheckTxDuration(1536,
988  HePhy::GetHeMcs0(),
989  80,
990  1600,
991  WIFI_PREAMBLE_HE_SU,
992  NanoSeconds(418400)) &&
993  CheckTxDuration(76,
994  HePhy::GetHeMcs0(),
995  80,
996  1600,
997  WIFI_PREAMBLE_HE_SU,
998  NanoSeconds(72800)) &&
999  CheckTxDuration(14,
1000  HePhy::GetHeMcs0(),
1001  80,
1002  1600,
1003  WIFI_PREAMBLE_HE_SU,
1004  NanoSeconds(58400)) &&
1005  CheckTxDuration(1536,
1006  HePhy::GetHeMcs0(),
1007  160,
1008  1600,
1009  WIFI_PREAMBLE_HE_SU,
1010  NanoSeconds(231200)) &&
1011  CheckTxDuration(76,
1012  HePhy::GetHeMcs0(),
1013  160,
1014  1600,
1015  WIFI_PREAMBLE_HE_SU,
1016  NanoSeconds(58400)) &&
1017  CheckTxDuration(14,
1018  HePhy::GetHeMcs0(),
1019  160,
1020  1600,
1021  WIFI_PREAMBLE_HE_SU,
1022  NanoSeconds(58400)) &&
1023  CheckTxDuration(1536,
1024  HePhy::GetHeMcs0(),
1025  20,
1026  3200,
1027  WIFI_PREAMBLE_HE_SU,
1028  MicroSeconds(1740)) &&
1029  CheckTxDuration(76, HePhy::GetHeMcs0(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(140)) &&
1030  CheckTxDuration(14, HePhy::GetHeMcs0(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(76)) &&
1031  CheckTxDuration(1536,
1032  HePhy::GetHeMcs0(),
1033  40,
1034  3200,
1035  WIFI_PREAMBLE_HE_SU,
1036  MicroSeconds(892)) &&
1037  CheckTxDuration(76, HePhy::GetHeMcs0(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(92)) &&
1038  CheckTxDuration(14, HePhy::GetHeMcs0(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1039  CheckTxDuration(1536,
1040  HePhy::GetHeMcs0(),
1041  80,
1042  3200,
1043  WIFI_PREAMBLE_HE_SU,
1044  MicroSeconds(460)) &&
1045  CheckTxDuration(76, HePhy::GetHeMcs0(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(76)) &&
1046  CheckTxDuration(14, HePhy::GetHeMcs0(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1047  CheckTxDuration(1536,
1048  HePhy::GetHeMcs0(),
1049  160,
1050  3200,
1051  WIFI_PREAMBLE_HE_SU,
1052  MicroSeconds(252)) &&
1053  CheckTxDuration(76, HePhy::GetHeMcs0(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1054  CheckTxDuration(14, HePhy::GetHeMcs0(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1055  CheckTxDuration(1536,
1056  HePhy::GetHeMcs11(),
1057  20,
1058  800,
1059  WIFI_PREAMBLE_HE_SU,
1060  NanoSeconds(139200)) &&
1061  CheckTxDuration(76,
1062  HePhy::GetHeMcs11(),
1063  20,
1064  800,
1065  WIFI_PREAMBLE_HE_SU,
1066  NanoSeconds(57600)) &&
1067  CheckTxDuration(14,
1068  HePhy::GetHeMcs11(),
1069  20,
1070  800,
1071  WIFI_PREAMBLE_HE_SU,
1072  NanoSeconds(57600)) &&
1073  CheckTxDuration(1536,
1074  HePhy::GetHeMcs11(),
1075  40,
1076  800,
1077  WIFI_PREAMBLE_HE_SU,
1078  NanoSeconds(98400)) &&
1079  CheckTxDuration(76,
1080  HePhy::GetHeMcs11(),
1081  40,
1082  800,
1083  WIFI_PREAMBLE_HE_SU,
1084  NanoSeconds(57600)) &&
1085  CheckTxDuration(14,
1086  HePhy::GetHeMcs11(),
1087  40,
1088  800,
1089  WIFI_PREAMBLE_HE_SU,
1090  NanoSeconds(57600)) &&
1091  CheckTxDuration(1536,
1092  HePhy::GetHeMcs11(),
1093  80,
1094  800,
1095  WIFI_PREAMBLE_HE_SU,
1096  NanoSeconds(71200)) &&
1097  CheckTxDuration(76,
1098  HePhy::GetHeMcs11(),
1099  80,
1100  800,
1101  WIFI_PREAMBLE_HE_SU,
1102  NanoSeconds(57600)) &&
1103  CheckTxDuration(14,
1104  HePhy::GetHeMcs11(),
1105  80,
1106  800,
1107  WIFI_PREAMBLE_HE_SU,
1108  NanoSeconds(57600)) &&
1109  CheckTxDuration(1536,
1110  HePhy::GetHeMcs11(),
1111  160,
1112  800,
1113  WIFI_PREAMBLE_HE_SU,
1114  NanoSeconds(57600)) &&
1115  CheckTxDuration(76,
1116  HePhy::GetHeMcs11(),
1117  160,
1118  800,
1119  WIFI_PREAMBLE_HE_SU,
1120  NanoSeconds(57600)) &&
1121  CheckTxDuration(14,
1122  HePhy::GetHeMcs11(),
1123  160,
1124  800,
1125  WIFI_PREAMBLE_HE_SU,
1126  NanoSeconds(57600)) &&
1127  CheckTxDuration(1536,
1128  HePhy::GetHeMcs11(),
1129  20,
1130  1600,
1131  WIFI_PREAMBLE_HE_SU,
1132  NanoSeconds(144800)) &&
1133  CheckTxDuration(76,
1134  HePhy::GetHeMcs11(),
1135  20,
1136  1600,
1137  WIFI_PREAMBLE_HE_SU,
1138  NanoSeconds(58400)) &&
1139  CheckTxDuration(14,
1140  HePhy::GetHeMcs11(),
1141  20,
1142  1600,
1143  WIFI_PREAMBLE_HE_SU,
1144  NanoSeconds(58400)) &&
1145  CheckTxDuration(1536,
1146  HePhy::GetHeMcs11(),
1147  40,
1148  1600,
1149  WIFI_PREAMBLE_HE_SU,
1150  NanoSeconds(101600)) &&
1151  CheckTxDuration(76,
1152  HePhy::GetHeMcs11(),
1153  40,
1154  1600,
1155  WIFI_PREAMBLE_HE_SU,
1156  NanoSeconds(58400)) &&
1157  CheckTxDuration(14,
1158  HePhy::GetHeMcs11(),
1159  40,
1160  1600,
1161  WIFI_PREAMBLE_HE_SU,
1162  NanoSeconds(58400)) &&
1163  CheckTxDuration(1536,
1164  HePhy::GetHeMcs11(),
1165  80,
1166  1600,
1167  WIFI_PREAMBLE_HE_SU,
1168  NanoSeconds(72800)) &&
1169  CheckTxDuration(76,
1170  HePhy::GetHeMcs11(),
1171  80,
1172  1600,
1173  WIFI_PREAMBLE_HE_SU,
1174  NanoSeconds(58400)) &&
1175  CheckTxDuration(14,
1176  HePhy::GetHeMcs11(),
1177  80,
1178  1600,
1179  WIFI_PREAMBLE_HE_SU,
1180  NanoSeconds(58400)) &&
1181  CheckTxDuration(1536,
1182  HePhy::GetHeMcs11(),
1183  160,
1184  1600,
1185  WIFI_PREAMBLE_HE_SU,
1186  NanoSeconds(58400)) &&
1187  CheckTxDuration(76,
1188  HePhy::GetHeMcs11(),
1189  160,
1190  1600,
1191  WIFI_PREAMBLE_HE_SU,
1192  NanoSeconds(58400)) &&
1193  CheckTxDuration(14,
1194  HePhy::GetHeMcs11(),
1195  160,
1196  1600,
1197  WIFI_PREAMBLE_HE_SU,
1198  NanoSeconds(58400)) &&
1199  CheckTxDuration(1536,
1200  HePhy::GetHeMcs11(),
1201  20,
1202  3200,
1203  WIFI_PREAMBLE_HE_SU,
1204  MicroSeconds(156)) &&
1205  CheckTxDuration(76, HePhy::GetHeMcs11(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1206  CheckTxDuration(14, HePhy::GetHeMcs11(), 20, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1207  CheckTxDuration(1536,
1208  HePhy::GetHeMcs11(),
1209  40,
1210  3200,
1211  WIFI_PREAMBLE_HE_SU,
1212  MicroSeconds(108)) &&
1213  CheckTxDuration(76, HePhy::GetHeMcs11(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1214  CheckTxDuration(14, HePhy::GetHeMcs11(), 40, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1215  CheckTxDuration(1536,
1216  HePhy::GetHeMcs11(),
1217  80,
1218  3200,
1219  WIFI_PREAMBLE_HE_SU,
1220  MicroSeconds(76)) &&
1221  CheckTxDuration(76, HePhy::GetHeMcs11(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1222  CheckTxDuration(14, HePhy::GetHeMcs11(), 80, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60)) &&
1223  CheckTxDuration(1536,
1224  HePhy::GetHeMcs11(),
1225  160,
1226  3200,
1227  WIFI_PREAMBLE_HE_SU,
1228  MicroSeconds(60)) &&
1229  CheckTxDuration(76,
1230  HePhy::GetHeMcs11(),
1231  160,
1232  3200,
1233  WIFI_PREAMBLE_HE_SU,
1234  MicroSeconds(60)) &&
1235  CheckTxDuration(14, HePhy::GetHeMcs11(), 160, 3200, WIFI_PREAMBLE_HE_SU, MicroSeconds(60));
1236 
1237  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax SU duration failed");
1238 
1239  // 802.11ax MU durations
1240  retval = retval &&
1241  CheckMuTxDuration(
1242  std::list<uint32_t>{1536, 1536},
1243  std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1244  {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1245  40,
1246  800,
1247  WIFI_PREAMBLE_HE_MU,
1248  NanoSeconds(
1249  1493600)) // equivalent to HE_SU for 20 MHz with 2 extra HE-SIG-B (i.e. 8 us)
1250  && CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1251  std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 1, 1},
1252  {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1253  40,
1254  800,
1255  WIFI_PREAMBLE_HE_MU,
1256  NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
1257  && CheckMuTxDuration(std::list<uint32_t>{1536, 76},
1258  std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1259  {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1260  40,
1261  800,
1262  WIFI_PREAMBLE_HE_MU,
1263  NanoSeconds(1493600));
1264 
1265  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11ax MU duration failed");
1266 
1267  // 802.11be MU durations
1268  retval = retval &&
1269  CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1270  std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1271  {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1272  40,
1273  800,
1274  WIFI_PREAMBLE_EHT_MU,
1275  NanoSeconds(1493600)) // equivalent to 802.11ax MU
1276  && CheckMuTxDuration(std::list<uint32_t>{1536, 1536},
1277  std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 1, 1},
1278  {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1279  40,
1280  800,
1281  WIFI_PREAMBLE_EHT_MU,
1282  NanoSeconds(1493600)) // shouldn't change if first PSDU is shorter
1283  && CheckMuTxDuration(std::list<uint32_t>{1536, 76},
1284  std::list<HeMuUserInfo>{{{HeRu::RU_242_TONE, 1, true}, 0, 1},
1285  {{HeRu::RU_242_TONE, 2, true}, 0, 1}},
1286  40,
1287  800,
1288  WIFI_PREAMBLE_EHT_MU,
1289  NanoSeconds(1493600));
1290 
1291  NS_TEST_EXPECT_MSG_EQ(retval, true, "an 802.11be MU duration failed");
1292 
1293  Simulator::Destroy();
1294 }
1295 
1302 class HeSigBDurationTest : public TestCase
1303 {
1304  public:
1305  HeSigBDurationTest();
1306  ~HeSigBDurationTest() override;
1307  void DoRun() override;
1308 
1309  private:
1318  static WifiTxVector BuildTxVector(uint16_t bw, std::list<HeMuUserInfo> userInfos);
1319 };
1320 
1321 HeSigBDurationTest::HeSigBDurationTest()
1322  : TestCase("Check HE-SIG-B duration computation")
1323 {
1324 }
1325 
1326 HeSigBDurationTest::~HeSigBDurationTest()
1327 {
1328 }
1329 
1330 WifiTxVector
1331 HeSigBDurationTest::BuildTxVector(uint16_t bw, std::list<HeMuUserInfo> userInfos)
1332 {
1333  WifiTxVector txVector;
1334  txVector.SetPreambleType(WIFI_PREAMBLE_HE_MU);
1335  txVector.SetChannelWidth(bw);
1336  txVector.SetGuardInterval(3200);
1337  txVector.SetStbc(0);
1338  txVector.SetNess(0);
1339  std::list<uint16_t> staIds;
1340  uint16_t staId = 1;
1341  for (const auto& userInfo : userInfos)
1342  {
1343  txVector.SetHeMuUserInfo(staId, userInfo);
1344  staIds.push_back(staId++);
1345  }
1346  return txVector;
1347 }
1348 
1349 void
1350 HeSigBDurationTest::DoRun()
1351 {
1352  const auto& hePhy = WifiPhy::GetStaticPhyEntity(WIFI_MOD_CLASS_HE);
1353 
1354  // 20 MHz band
1355  std::list<HeMuUserInfo> userInfos;
1356  userInfos.push_back({{HeRu::RU_106_TONE, 1, true}, 11, 1});
1357  userInfos.push_back({{HeRu::RU_106_TONE, 2, true}, 10, 4});
1358  WifiTxVector txVector = BuildTxVector(20, userInfos);
1359  txVector.SetSigBMode(VhtPhy::GetVhtMcs5());
1360  txVector.SetRuAllocation({96});
1361  NS_TEST_EXPECT_MSG_EQ(hePhy->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
1362  VhtPhy::GetVhtMcs5(),
1363  "HE-SIG-B should be sent at MCS 5");
1364  std::pair<std::size_t, std::size_t> numUsersPerCc = txVector.GetNumRusPerHeSigBContentChannel();
1365  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
1366  2,
1367  "Both users should be on HE-SIG-B content channel 1");
1368  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
1369  0,
1370  "Both users should be on HE-SIG-B content channel 2");
1371  NS_TEST_EXPECT_MSG_EQ(hePhy->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
1372  MicroSeconds(4),
1373  "HE-SIG-B should only last one OFDM symbol");
1374 
1375  // 40 MHz band, even number of users per HE-SIG-B content channel
1376  userInfos.push_back({{HeRu::RU_52_TONE, 5, true}, 4, 1});
1377  userInfos.push_back({{HeRu::RU_52_TONE, 6, true}, 6, 2});
1378  userInfos.push_back({{HeRu::RU_52_TONE, 7, true}, 5, 3});
1379  userInfos.push_back({{HeRu::RU_52_TONE, 8, true}, 6, 2});
1380  txVector = BuildTxVector(40, userInfos);
1381  txVector.SetSigBMode(VhtPhy::GetVhtMcs4());
1382  txVector.SetRuAllocation({96, 112});
1383  NS_TEST_EXPECT_MSG_EQ(hePhy->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
1384  VhtPhy::GetVhtMcs4(),
1385  "HE-SIG-B should be sent at MCS 4");
1386  numUsersPerCc = txVector.GetNumRusPerHeSigBContentChannel();
1387  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
1388  2,
1389  "Two users should be on HE-SIG-B content channel 1");
1390  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
1391  4,
1392  "Four users should be on HE-SIG-B content channel 2");
1393  NS_TEST_EXPECT_MSG_EQ(hePhy->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
1394  MicroSeconds(4),
1395  "HE-SIG-B should only last one OFDM symbol");
1396 
1397  // 40 MHz band, odd number of users per HE-SIG-B content channel
1398  userInfos.push_back({{HeRu::RU_26_TONE, 14, true}, 3, 1});
1399  txVector = BuildTxVector(40, userInfos);
1400  txVector.SetSigBMode(VhtPhy::GetVhtMcs3());
1401  txVector.SetRuAllocation({96, 15});
1402  NS_TEST_EXPECT_MSG_EQ(hePhy->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
1403  VhtPhy::GetVhtMcs3(),
1404  "HE-SIG-B should be sent at MCS 3");
1405  numUsersPerCc = txVector.GetNumRusPerHeSigBContentChannel();
1406  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
1407  2,
1408  "Two users should be on HE-SIG-B content channel 1");
1409  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
1410  5,
1411  "Five users should be on HE-SIG-B content channel 2");
1412  NS_TEST_EXPECT_MSG_EQ(hePhy->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
1413  MicroSeconds(8),
1414  "HE-SIG-B should last two OFDM symbols");
1415 
1416  // 80 MHz band
1417  userInfos.push_back({{HeRu::RU_242_TONE, 3, true}, 1, 1});
1418  userInfos.push_back({{HeRu::RU_242_TONE, 4, true}, 4, 1});
1419  txVector = BuildTxVector(80, userInfos);
1420  txVector.SetSigBMode(VhtPhy::GetVhtMcs1());
1421  txVector.SetRuAllocation({96, 15, 192, 192});
1422  NS_TEST_EXPECT_MSG_EQ(hePhy->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
1423  VhtPhy::GetVhtMcs1(),
1424  "HE-SIG-B should be sent at MCS 1");
1425  numUsersPerCc = txVector.GetNumRusPerHeSigBContentChannel();
1426  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
1427  3,
1428  "Three users should be on HE-SIG-B content channel 1");
1429  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
1430  6,
1431  "Six users should be on HE-SIG-B content channel 2");
1432  NS_TEST_EXPECT_MSG_EQ(hePhy->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
1433  MicroSeconds(16),
1434  "HE-SIG-B should last four OFDM symbols");
1435 
1436  // 160 MHz band
1437  userInfos.push_back({{HeRu::RU_996_TONE, 1, false}, 1, 1});
1438  txVector = BuildTxVector(160, userInfos);
1439  txVector.SetSigBMode(VhtPhy::GetVhtMcs1());
1440  txVector.SetRuAllocation({96, 15, 192, 192, 208, 208, 208, 208});
1441  NS_TEST_EXPECT_MSG_EQ(hePhy->GetSigMode(WIFI_PPDU_FIELD_SIG_B, txVector),
1442  VhtPhy::GetVhtMcs1(),
1443  "HE-SIG-B should be sent at MCS 1");
1444  numUsersPerCc = txVector.GetNumRusPerHeSigBContentChannel();
1445  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.first,
1446  4,
1447  "Four users should be on HE-SIG-B content channel 1");
1448  NS_TEST_EXPECT_MSG_EQ(numUsersPerCc.second,
1449  7,
1450  "Seven users should be on HE-SIG-B content channel 2");
1451  NS_TEST_EXPECT_MSG_EQ(hePhy->GetDuration(WIFI_PPDU_FIELD_SIG_B, txVector),
1452  MicroSeconds(20),
1453  "HE-SIG-B should last five OFDM symbols");
1454 }
1455 
1462 class PhyHeaderSectionsTest : public TestCase
1463 {
1464  public:
1465  PhyHeaderSectionsTest();
1466  ~PhyHeaderSectionsTest() override;
1467  void DoRun() override;
1468 
1469  private:
1477  void CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained,
1478  PhyEntity::PhyHeaderSections expected);
1479 };
1480 
1481 PhyHeaderSectionsTest::PhyHeaderSectionsTest()
1482  : TestCase("PHY header sections consistency")
1483 {
1484 }
1485 
1486 PhyHeaderSectionsTest::~PhyHeaderSectionsTest()
1487 {
1488 }
1489 
1490 void
1491 PhyHeaderSectionsTest::CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained,
1492  PhyEntity::PhyHeaderSections expected)
1493 {
1494  NS_ASSERT_MSG(obtained.size() == expected.size(),
1495  "The expected map size (" << expected.size() << ") was not obtained ("
1496  << obtained.size() << ")");
1497 
1498  auto itObtained = obtained.begin();
1499  auto itExpected = expected.begin();
1500  for (; itObtained != obtained.end() || itExpected != expected.end();)
1501  {
1502  WifiPpduField field = itObtained->first;
1503  auto window = itObtained->second.first;
1504  auto mode = itObtained->second.second;
1505 
1506  WifiPpduField fieldRef = itExpected->first;
1507  auto windowRef = itExpected->second.first;
1508  auto modeRef = itExpected->second.second;
1509 
1510  NS_TEST_EXPECT_MSG_EQ(field,
1511  fieldRef,
1512  "The expected PPDU field (" << fieldRef << ") was not obtained ("
1513  << field << ")");
1514  NS_TEST_EXPECT_MSG_EQ(window.first,
1515  windowRef.first,
1516  "The expected start time (" << windowRef.first
1517  << ") was not obtained (" << window.first
1518  << ")");
1519  NS_TEST_EXPECT_MSG_EQ(window.second,
1520  windowRef.second,
1521  "The expected stop time (" << windowRef.second
1522  << ") was not obtained (" << window.second
1523  << ")");
1524  NS_TEST_EXPECT_MSG_EQ(mode,
1525  modeRef,
1526  "The expected mode (" << modeRef << ") was not obtained (" << mode
1527  << ")");
1528  ++itObtained;
1529  ++itExpected;
1530  }
1531 }
1532 
1533 void
1534 PhyHeaderSectionsTest::DoRun()
1535 {
1536  Time ppduStart = Seconds(1.0);
1537  Ptr<PhyEntity> phyEntity;
1538  PhyEntity::PhyHeaderSections sections;
1539  WifiTxVector txVector;
1540  WifiMode nonHtMode;
1541 
1542  // ==================================================================================
1543  // 11b (HR/DSSS)
1544  phyEntity = Create<DsssPhy>();
1545  txVector.SetMode(DsssPhy::GetDsssRate1Mbps());
1546  txVector.SetChannelWidth(22);
1547 
1548  // -> long PPDU format
1549  txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
1550  nonHtMode = DsssPhy::GetDsssRate1Mbps();
1551  sections = {
1552  {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(144)}, nonHtMode}},
1553  {WIFI_PPDU_FIELD_NON_HT_HEADER,
1554  {{ppduStart + MicroSeconds(144), ppduStart + MicroSeconds(192)}, nonHtMode}},
1555  };
1556  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1557 
1558  // -> long PPDU format if data rate is 1 Mbps (even if preamble is tagged short)
1559  txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
1560  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1561 
1562  // -> short PPDU format
1563  txVector.SetMode(DsssPhy::GetDsssRate11Mbps());
1564  nonHtMode = DsssPhy::GetDsssRate2Mbps();
1565  txVector.SetPreambleType(WIFI_PREAMBLE_SHORT);
1566  sections = {
1567  {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(72)}, nonHtMode}},
1568  {WIFI_PPDU_FIELD_NON_HT_HEADER,
1569  {{ppduStart + MicroSeconds(72), ppduStart + MicroSeconds(96)}, nonHtMode}},
1570  };
1571  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1572 
1573  // ==================================================================================
1574  // 11a (OFDM)
1575  txVector.SetPreambleType(WIFI_PREAMBLE_LONG);
1576 
1577  // -> one iteration per variant: default, 10 MHz, and 5 MHz
1578  std::map<OfdmPhyVariant, std::size_t> variants{
1579  // number to use to deduce rate and BW info for each variant
1580  {OFDM_PHY_DEFAULT, 1},
1581  {OFDM_PHY_10_MHZ, 2},
1582  {OFDM_PHY_5_MHZ, 4},
1583  };
1584  for (auto variant : variants)
1585  {
1586  phyEntity = Create<OfdmPhy>(variant.first);
1587  std::size_t ratio = variant.second;
1588  uint16_t bw = 20 / ratio; // MHz
1589  txVector.SetChannelWidth(bw);
1590  txVector.SetMode(OfdmPhy::GetOfdmRate(12000000 / ratio, bw));
1591  nonHtMode = OfdmPhy::GetOfdmRate(6000000 / ratio, bw);
1592  sections = {
1593  {WIFI_PPDU_FIELD_PREAMBLE,
1594  {{ppduStart, ppduStart + MicroSeconds(16 * ratio)}, nonHtMode}},
1595  {WIFI_PPDU_FIELD_NON_HT_HEADER,
1596  {{ppduStart + MicroSeconds(16 * ratio), ppduStart + MicroSeconds(20 * ratio)},
1597  nonHtMode}},
1598  };
1599  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1600  }
1601 
1602  // ==================================================================================
1603  // 11g (ERP-OFDM)
1604  phyEntity = Create<ErpOfdmPhy>();
1605  txVector.SetChannelWidth(20);
1606  txVector.SetMode(ErpOfdmPhy::GetErpOfdmRate(54000000));
1607  nonHtMode = ErpOfdmPhy::GetErpOfdmRate6Mbps();
1608  sections = {
1609  {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1610  {WIFI_PPDU_FIELD_NON_HT_HEADER,
1611  {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1612  };
1613  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1614 
1615  // ==================================================================================
1616  // 11n (HT)
1617  phyEntity = Create<HtPhy>(4);
1618  txVector.SetChannelWidth(20);
1619  txVector.SetMode(HtPhy::GetHtMcs6());
1620  nonHtMode = OfdmPhy::GetOfdmRate6Mbps();
1621  WifiMode htSigMode = nonHtMode;
1622 
1623  // -> HT-mixed format for 2 SS and no ESS
1624  txVector.SetPreambleType(WIFI_PREAMBLE_HT_MF);
1625  txVector.SetNss(2);
1626  txVector.SetNess(0);
1627  sections = {
1628  {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1629  {WIFI_PPDU_FIELD_NON_HT_HEADER,
1630  {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1631  {WIFI_PPDU_FIELD_HT_SIG,
1632  {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, htSigMode}},
1633  {WIFI_PPDU_FIELD_TRAINING,
1634  {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(40)}, // 1 HT-STF + 2 HT-LTFs
1635  htSigMode}},
1636  };
1637  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1638  txVector.SetChannelWidth(20); // shouldn't have any impact
1639  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1640 
1641  // -> HT-mixed format for 3 SS and 1 ESS
1642  txVector.SetNss(3);
1643  txVector.SetNess(1);
1644  sections[WIFI_PPDU_FIELD_TRAINING] = {
1645  {ppduStart + MicroSeconds(28),
1646  ppduStart + MicroSeconds(52)}, // 1 HT-STF + 5 HT-LTFs (4 data + 1 extension)
1647  htSigMode};
1648  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1649 
1650  // ==================================================================================
1651  // 11ac (VHT)
1652  phyEntity = Create<VhtPhy>();
1653  txVector.SetChannelWidth(20);
1654  txVector.SetNess(0);
1655  txVector.SetMode(VhtPhy::GetVhtMcs7());
1656  WifiMode sigAMode = nonHtMode;
1657  WifiMode sigBMode = VhtPhy::GetVhtMcs0();
1658 
1659  // -> VHT SU format for 5 SS
1660  txVector.SetPreambleType(WIFI_PREAMBLE_VHT_SU);
1661  txVector.SetNss(5);
1662  sections = {
1663  {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1664  {WIFI_PPDU_FIELD_NON_HT_HEADER,
1665  {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(20)}, nonHtMode}},
1666  {WIFI_PPDU_FIELD_SIG_A,
1667  {{ppduStart + MicroSeconds(20), ppduStart + MicroSeconds(28)}, sigAMode}},
1668  {WIFI_PPDU_FIELD_TRAINING,
1669  {{ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(56)}, // 1 VHT-STF + 6 VHT-LTFs
1670  sigAMode}},
1671  };
1672  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1673 
1674  // -> VHT SU format for 7 SS
1675  txVector.SetNss(7);
1676  sections[WIFI_PPDU_FIELD_TRAINING] = {
1677  {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(64)}, // 1 VHT-STF + 8 VHT-LTFs
1678  sigAMode};
1679  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1680 
1681  // -> VHT MU format for 3 SS
1682  txVector.SetPreambleType(WIFI_PREAMBLE_VHT_MU);
1683  txVector.SetNss(3);
1684  sections[WIFI_PPDU_FIELD_TRAINING] = {
1685  {ppduStart + MicroSeconds(28), ppduStart + MicroSeconds(48)}, // 1 VHT-STF + 4 VHT-LTFs
1686  sigAMode};
1687  sections[WIFI_PPDU_FIELD_SIG_B] = {{ppduStart + MicroSeconds(48), ppduStart + MicroSeconds(52)},
1688  sigBMode};
1689  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1690  txVector.SetChannelWidth(80); // shouldn't have any impact
1691  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1692 
1693  // ==================================================================================
1694  // 11ax (HE)
1695  phyEntity = Create<HePhy>();
1696  txVector.SetChannelWidth(20);
1697  txVector.SetNss(2); // HE-LTF duration assumed to be always 8 us for the time being (see note in
1698  // HePhy::GetTrainingDuration)
1699  txVector.SetMode(HePhy::GetHeMcs9());
1700  std::map<uint16_t, HeMuUserInfo> userInfoMap = {{1, {{HeRu::RU_106_TONE, 1, true}, 4, 2}},
1701  {2, {{HeRu::RU_106_TONE, 1, true}, 9, 1}}};
1702  sigAMode = HePhy::GetVhtMcs0();
1703  sigBMode = HePhy::GetVhtMcs4(); // because of first user info map
1704 
1705  // -> HE SU format
1706  txVector.SetPreambleType(WIFI_PREAMBLE_HE_SU);
1707  sections = {
1708  {WIFI_PPDU_FIELD_PREAMBLE, {{ppduStart, ppduStart + MicroSeconds(16)}, nonHtMode}},
1709  {WIFI_PPDU_FIELD_NON_HT_HEADER,
1710  {{ppduStart + MicroSeconds(16), ppduStart + MicroSeconds(24)}, // L-SIG + RL-SIG
1711  nonHtMode}},
1712  {WIFI_PPDU_FIELD_SIG_A,
1713  {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)}, sigAMode}},
1714  {WIFI_PPDU_FIELD_TRAINING,
1715  {{ppduStart + MicroSeconds(32),
1716  ppduStart + MicroSeconds(52)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1717  sigAMode}},
1718  };
1719  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1720 
1721  // -> HE ER SU format
1722  txVector.SetPreambleType(WIFI_PREAMBLE_HE_ER_SU);
1723  sections[WIFI_PPDU_FIELD_SIG_A] = {
1724  {ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(40)}, // 16 us HE-SIG-A
1725  sigAMode};
1726  sections[WIFI_PPDU_FIELD_TRAINING] = {
1727  {ppduStart + MicroSeconds(40),
1728  ppduStart + MicroSeconds(60)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1729  sigAMode};
1730  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1731 
1732  // -> HE TB format
1733  txVector.SetPreambleType(WIFI_PREAMBLE_HE_TB);
1734  txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
1735  txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
1736  sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1737  sigAMode};
1738  sections[WIFI_PPDU_FIELD_TRAINING] = {
1739  {ppduStart + MicroSeconds(32),
1740  ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 8 us) + 2 HE-LTFs (@ 8 us)
1741  sigAMode};
1742  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1743 
1744  // -> HE MU format
1745  txVector.SetPreambleType(WIFI_PREAMBLE_HE_MU);
1746  txVector.SetSigBMode(sigBMode);
1747  txVector.SetRuAllocation({96});
1748  sections[WIFI_PPDU_FIELD_SIG_A] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1749  sigAMode};
1750  sections[WIFI_PPDU_FIELD_SIG_B] = {
1751  {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
1752  sigBMode};
1753  sections[WIFI_PPDU_FIELD_TRAINING] = {
1754  {ppduStart + MicroSeconds(36),
1755  ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1756  sigBMode};
1757  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1758  txVector.SetChannelWidth(160); // shouldn't have any impact
1759  txVector.SetRuAllocation({96, 113, 113, 113, 113, 113, 113, 113});
1760 
1761  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1762 
1763  // ==================================================================================
1764  // 11be (EHT)
1765  sections.erase(WIFI_PPDU_FIELD_SIG_A); // FIXME: do we keep using separate type for 11be?
1766  sections.erase(WIFI_PPDU_FIELD_SIG_B); // FIXME: do we keep using separate type for 11be?
1767  phyEntity = Create<EhtPhy>();
1768  txVector.SetChannelWidth(20);
1769  txVector.SetNss(2); // EHT-LTF duration assumed to be always 8 us for the time being (see note
1770  // in HePhy::GetTrainingDuration)
1771  txVector.SetMode(EhtPhy::GetEhtMcs9());
1772  userInfoMap = {{1, {{HeRu::RU_106_TONE, 1, true}, 4, 2}},
1773  {2, {{HeRu::RU_106_TONE, 1, true}, 9, 1}}};
1774  WifiMode uSigMode = EhtPhy::GetVhtMcs0();
1775  WifiMode ehtSigMode = EhtPhy::GetVhtMcs4(); // because of first user info map
1776 
1777  // -> EHT TB format
1778  txVector.SetPreambleType(WIFI_PREAMBLE_EHT_TB);
1779  txVector.SetHeMuUserInfo(1, userInfoMap.at(1));
1780  txVector.SetHeMuUserInfo(2, userInfoMap.at(2));
1781  sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1782  uSigMode};
1783  sections[WIFI_PPDU_FIELD_TRAINING] = {
1784  {ppduStart + MicroSeconds(32),
1785  ppduStart + MicroSeconds(56)}, // 1 EHT-STF (@ 8 us) + 2 EHT-LTFs (@ 8 us)
1786  uSigMode};
1787  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1788 
1789  // -> EHT MU format
1790  txVector.SetPreambleType(WIFI_PREAMBLE_EHT_MU);
1791  txVector.SetEhtPpduType(0); // EHT MU transmission
1792  txVector.SetRuAllocation({96});
1793  sections[WIFI_PPDU_FIELD_U_SIG] = {{ppduStart + MicroSeconds(24), ppduStart + MicroSeconds(32)},
1794  uSigMode};
1795  sections[WIFI_PPDU_FIELD_EHT_SIG] = {
1796  {ppduStart + MicroSeconds(32), ppduStart + MicroSeconds(36)}, // only one symbol
1797  ehtSigMode};
1798  sections[WIFI_PPDU_FIELD_TRAINING] = {
1799  {ppduStart + MicroSeconds(36),
1800  ppduStart + MicroSeconds(56)}, // 1 HE-STF (@ 4 us) + 2 HE-LTFs (@ 8 us)
1801  ehtSigMode};
1802  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1803  txVector.SetChannelWidth(160); // shouldn't have any impact
1804  txVector.SetRuAllocation({96, 113, 113, 113, 113, 113, 113, 113});
1805 
1806  CheckPhyHeaderSections(phyEntity->GetPhyHeaderSections(txVector, ppduStart), sections);
1807 }
1808 
1815 class TxDurationTestSuite : public TestSuite
1816 {
1817  public:
1818  TxDurationTestSuite();
1819 };
1820 
1821 TxDurationTestSuite::TxDurationTestSuite()
1822  : TestSuite("wifi-devices-tx-duration", UNIT)
1823 {
1824  AddTestCase(new HeSigBDurationTest, TestCase::QUICK);
1825  AddTestCase(new TxDurationTest, TestCase::QUICK);
1826  AddTestCase(new PhyHeaderSectionsTest, TestCase::QUICK);
1827 }
1828 
1829 static TxDurationTestSuite g_txDurationTestSuite;
HeSigBDurationTest
HE-SIG-B duration test.
Definition: tx-duration-test.cc:1303
HeSigBDurationTest::BuildTxVector
static WifiTxVector BuildTxVector(uint16_t bw, std::list< HeMuUserInfo > userInfos)
Build a TXVECTOR for HE MU with the given bandwidth and user information.
Definition: tx-duration-test.cc:1331
HeSigBDurationTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:1350
HeSigBDurationTest::~HeSigBDurationTest
~HeSigBDurationTest() override
Definition: tx-duration-test.cc:1326
PhyHeaderSectionsTest
PHY header sections consistency test.
Definition: tx-duration-test.cc:1463
PhyHeaderSectionsTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:1534
PhyHeaderSectionsTest::CheckPhyHeaderSections
void CheckPhyHeaderSections(PhyEntity::PhyHeaderSections obtained, PhyEntity::PhyHeaderSections expected)
Check if map of PHY header sections returned by a given PHY entity corresponds to a known value.
Definition: tx-duration-test.cc:1491
TxDurationTest
Tx Duration Test.
Definition: tx-duration-test.cc:45
TxDurationTest::~TxDurationTest
~TxDurationTest() override
Definition: tx-duration-test.cc:137
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:341
TxDurationTest::CheckMuTxDuration
static bool CheckMuTxDuration(std::list< uint32_t > sizes, std::list< HeMuUserInfo > userInfos, uint16_t channelWidth, uint16_t guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the overall Tx duration returned by WifiPhy for a MU PPDU corresponds to a known value.
Definition: tx-duration-test.cc:253
TxDurationTest::CheckTxDuration
bool CheckTxDuration(uint32_t size, WifiMode payloadMode, uint16_t channelWidth, uint16_t guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the overall tx duration returned by InterferenceHelper corresponds to a known value.
Definition: tx-duration-test.cc:194
TxDurationTest::CheckPayloadDuration
bool CheckPayloadDuration(uint32_t size, WifiMode payloadMode, uint16_t channelWidth, uint16_t guardInterval, WifiPreamble preamble, Time knownDuration)
Check if the payload tx duration returned by InterferenceHelper corresponds to a known value.
Definition: tx-duration-test.cc:142
TxDurationTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tx-duration-test.cc:361
TxDurationTestSuite
Tx Duration Test Suite.
Definition: tx-duration-test.cc:1816
ns3::HeRu::RuSpec::GetRuType
RuType GetRuType() const
Get the RU type.
Definition: he-ru.cc:435
ns3::PhyEntity::PhyHeaderSections
std::map< WifiPpduField, PhyHeaderChunkInfo > PhyHeaderSections
A map of PhyHeaderChunkInfo elements per PPDU field.
Definition: phy-entity.h:327
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::WifiMacHeader
Implements the IEEE 802.11 MAC header.
Definition: wifi-mac-header.h:97
ns3::WifiMacHeader::GetSerializedSize
uint32_t GetSerializedSize() const override
Definition: wifi-mac-header.cc:1190
ns3::WifiMacHeader::SetType
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:133
ns3::WifiMode
represent a single transmission mode
Definition: wifi-mode.h:50
ns3::WifiMode::GetModulationClass
WifiModulationClass GetModulationClass() const
Definition: wifi-mode.cc:185
ns3::WifiMode::GetDataRate
uint64_t GetDataRate(uint16_t channelWidth, uint16_t guardInterval, uint8_t nss) const
Definition: wifi-mode.cc:122
ns3::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:101
ns3::WifiTxVector::SetStbc
void SetStbc(bool stbc)
Sets if STBC is being used.
Definition: wifi-tx-vector.cc:336
ns3::WifiTxVector::SetNess
void SetNess(uint8_t ness)
Sets the Ness number.
Definition: wifi-tx-vector.cc:324
ns3::WifiTxVector::SetEhtPpduType
void SetEhtPpduType(uint8_t type)
Set the EHT_PPDU_TYPE parameter.
Definition: wifi-tx-vector.cc:416
ns3::WifiTxVector::SetChannelWidth
void SetChannelWidth(uint16_t channelWidth)
Sets the selected channelWidth (in MHz)
Definition: wifi-tx-vector.cc:292
ns3::WifiTxVector::SetGuardInterval
void SetGuardInterval(uint16_t guardInterval)
Sets the guard interval duration (in nanoseconds)
Definition: wifi-tx-vector.cc:298
ns3::WifiTxVector::GetMode
WifiMode GetMode(uint16_t staId=SU_STA_ID) const
If this TX vector is associated with an SU PPDU, return the selected payload transmission mode.
Definition: wifi-tx-vector.cc:133
ns3::WifiTxVector::SetHeMuUserInfo
void SetHeMuUserInfo(uint16_t staId, HeMuUserInfo userInfo)
Set the HE MU user-specific transmission information for the given STA-ID.
Definition: wifi-tx-vector.cc:506
ns3::WifiTxVector::SetRuAllocation
void SetRuAllocation(const RuAllocation &ruAlloc)
Set RU Allocation of SIG-B common field.
Definition: wifi-tx-vector.cc:396
ns3::WifiTxVector::GetNss
uint8_t GetNss(uint16_t staId=SU_STA_ID) const
If this TX vector is associated with an SU PPDU, return the number of spatial streams.
Definition: wifi-tx-vector.cc:203
ns3::WifiTxVector::SetSigBMode
void SetSigBMode(const WifiMode &mode)
Set the MCS used for SIG-B.
Definition: wifi-tx-vector.cc:384
ns3::WifiTxVector::GetNumRusPerHeSigBContentChannel
std::pair< std::size_t, std::size_t > GetNumRusPerHeSigBContentChannel() const
Get the number of RUs per HE-SIG-B content channel.
Definition: wifi-tx-vector.cc:531
ns3::WifiTxVector::SetMode
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
Definition: wifi-tx-vector.cc:264
ns3::WifiTxVector::SetNss
void SetNss(uint8_t nss)
Sets the number of Nss.
Definition: wifi-tx-vector.cc:310
ns3::WifiTxVector::SetPreambleType
void SetPreambleType(WifiPreamble preamble)
Sets the preamble type.
Definition: wifi-tx-vector.cc:286
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:86
NS_ABORT_MSG_IF
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_TEST_EXPECT_MSG_EQ
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:251
ns3::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1360
ns3::NanoSeconds
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1372
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
ns3::WifiPreamble
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
Definition: wifi-phy-common.h:79
ns3::WifiPhyBand
WifiPhyBand
Identifies the PHY band.
Definition: wifi-phy-band.h:33
ns3::WifiPpduField
WifiPpduField
The type of PPDU field (grouped for convenience)
Definition: wifi-phy-common.h:214
ns3::WIFI_PREAMBLE_LONG
@ WIFI_PREAMBLE_LONG
Definition: wifi-phy-common.h:80
ns3::WIFI_PREAMBLE_EHT_TB
@ WIFI_PREAMBLE_EHT_TB
Definition: wifi-phy-common.h:93
ns3::WIFI_PREAMBLE_HE_ER_SU
@ WIFI_PREAMBLE_HE_ER_SU
Definition: wifi-phy-common.h:89
ns3::WIFI_PREAMBLE_HE_TB
@ WIFI_PREAMBLE_HE_TB
Definition: wifi-phy-common.h:91
ns3::WIFI_PREAMBLE_EHT_MU
@ WIFI_PREAMBLE_EHT_MU
Definition: wifi-phy-common.h:92
ns3::WIFI_PREAMBLE_HE_MU
@ WIFI_PREAMBLE_HE_MU
Definition: wifi-phy-common.h:90
ns3::WIFI_PREAMBLE_HE_SU
@ WIFI_PREAMBLE_HE_SU
Definition: wifi-phy-common.h:88
ns3::WIFI_PREAMBLE_VHT_MU
@ WIFI_PREAMBLE_VHT_MU
Definition: wifi-phy-common.h:84
ns3::WIFI_PREAMBLE_VHT_SU
@ WIFI_PREAMBLE_VHT_SU
Definition: wifi-phy-common.h:83
ns3::WIFI_PREAMBLE_SHORT
@ WIFI_PREAMBLE_SHORT
Definition: wifi-phy-common.h:81
ns3::WIFI_PREAMBLE_HT_MF
@ WIFI_PREAMBLE_HT_MF
Definition: wifi-phy-common.h:82
ns3::WIFI_PHY_BAND_6GHZ
@ WIFI_PHY_BAND_6GHZ
The 6 GHz band.
Definition: wifi-phy-band.h:39
ns3::WIFI_PHY_BAND_2_4GHZ
@ WIFI_PHY_BAND_2_4GHZ
The 2.4 GHz band.
Definition: wifi-phy-band.h:35
ns3::WIFI_PHY_BAND_5GHZ
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
Definition: wifi-phy-band.h:37
ns3::WIFI_MOD_CLASS_OFDM
@ WIFI_MOD_CLASS_OFDM
OFDM (Clause 17)
Definition: wifi-phy-common.h:156
ns3::WIFI_MOD_CLASS_VHT
@ WIFI_MOD_CLASS_VHT
VHT (Clause 22)
Definition: wifi-phy-common.h:158
ns3::WIFI_MOD_CLASS_HE
@ WIFI_MOD_CLASS_HE
HE (Clause 27)
Definition: wifi-phy-common.h:163
ns3::OFDM_PHY_10_MHZ
@ OFDM_PHY_10_MHZ
Definition: ofdm-phy.h:46
ns3::OFDM_PHY_DEFAULT
@ OFDM_PHY_DEFAULT
Definition: ofdm-phy.h:45
ns3::OFDM_PHY_5_MHZ
@ OFDM_PHY_5_MHZ
Definition: ofdm-phy.h:47
ns3::WIFI_PPDU_FIELD_SIG_B
@ WIFI_PPDU_FIELD_SIG_B
SIG-B field.
Definition: wifi-phy-common.h:232
ns3::WIFI_PPDU_FIELD_TRAINING
@ WIFI_PPDU_FIELD_TRAINING
STF + LTF fields (excluding those in preamble for HT-GF)
Definition: wifi-phy-common.h:230
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:228
ns3::WIFI_PPDU_FIELD_EHT_SIG
@ WIFI_PPDU_FIELD_EHT_SIG
EHT-SIG field.
Definition: wifi-phy-common.h:234
ns3::WIFI_PPDU_FIELD_HT_SIG
@ WIFI_PPDU_FIELD_HT_SIG
HT-SIG field.
Definition: wifi-phy-common.h:229
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:221
ns3::WIFI_PPDU_FIELD_U_SIG
@ WIFI_PPDU_FIELD_U_SIG
U-SIG field.
Definition: wifi-phy-common.h:233
ns3::WIFI_PPDU_FIELD_SIG_A
@ WIFI_PPDU_FIELD_SIG_A
SIG-A field.
Definition: wifi-phy-common.h:231
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::WifiConstPsduMap
std::unordered_map< uint16_t, Ptr< const WifiPsdu > > WifiConstPsduMap
Map of const PSDUs indexed by STA-ID.
Definition: he-frame-exchange-manager.h:45
ns3::IsEht
bool IsEht(WifiPreamble preamble)
Return true if a preamble corresponds to an EHT transmission.
Definition: wifi-phy-common.cc:272
ns3::WIFI_MAC_CTL_ACK
@ WIFI_MAC_CTL_ACK
Definition: wifi-mac-header.h:42
third.phy
phy
Definition: third.py:82
visualizer.ipython_view.window
window
GTK Window.
Definition: ipython_view.py:641
ns3::HeMuUserInfo
HE MU specific user transmission parameters.
Definition: wifi-tx-vector.h:37
ns3::HeMuUserInfo::ru
HeRu::RuSpec ru
RU specification.
Definition: wifi-tx-vector.h:38
g_txDurationTestSuite
static TxDurationTestSuite g_txDurationTestSuite
the test suite
Definition: tx-duration-test.cc:1829
SU_STA_ID
#define SU_STA_ID
Definition: wifi-mode.h:34