From 435fc0866d1f3a682d3c4f377d20f993501a8303 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:41:53 +0200 Subject: [PATCH 01/41] queueing: add: preserve pull effects for selected extraction Before this commit, consumers can inspect queued packets but cannot extract a later eligible packet with ordinary pull effects. Collection removal represents disposal. Deferred Block Ack DATA needs selection past an ineligible head without loss of queue observations. After this commit, the optional collection contract provides a pure predicate query and atomic selected extraction. PacketQueue, CompoundPacketQueueBase, and PriorityScheduler preserve configured service order. Each layer applies its ordinary pull effects once. For example, extraction behind a deferred head retains ownership, residence metadata, and queue events. An unsupported provider reports UnsupportedPacketSelection before extraction. Other queue and predicate errors retain their types. Direct tests cover storage, ownership, metadata, events, scheduler order, and unsupported providers. Ordinary head service remains unchanged. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.queueing | behavior.add | test whatsnew | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 + .../contract/ISelectivePacketCollection.h | 34 +++ .../queueing/queue/CompoundPacketQueueBase.cc | 20 ++ .../queueing/queue/CompoundPacketQueueBase.h | 5 +- src/inet/queueing/queue/PacketQueue.cc | 28 ++- src/inet/queueing/queue/PacketQueue.h | 6 +- .../queueing/scheduler/PriorityScheduler.cc | 46 ++++ .../queueing/scheduler/PriorityScheduler.h | 5 +- tests/module/PacketSelectiveExtraction_1.test | 213 ++++++++++++++++++ 9 files changed, 356 insertions(+), 5 deletions(-) create mode 100644 src/inet/queueing/contract/ISelectivePacketCollection.h create mode 100644 tests/module/PacketSelectiveExtraction_1.test diff --git a/WHATSNEW b/WHATSNEW index bdad647e6ad..e60ba90f7e1 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -510,6 +510,10 @@ Notable backward compatible changes are the following: QoS recovery now keeps separate retry counters for each receiver. Frames with equal TID, sequence number, and fragment number no longer share a counter across receivers. An acknowledgment or retry-limit disposal for one receiver preserves the other receiver's counter. This repair applies before DATA lifetime expiration. +16. Optional selected extraction from packet queues + + PacketQueue, CompoundPacketQueueBase, and PriorityScheduler now support the optional ISelectivePacketCollection contract. A consumer can find an eligible packet without a state change. It can extract that packet with ordinary pull events, residence metadata, and ownership transfer. Ordinary head selection remains unchanged. Providers without this capability report UnsupportedPacketSelection before extraction. + Notable bug fixes are the following: 1. IEEE 802.11 HT modes preserve the requested band and preamble diff --git a/src/inet/queueing/contract/ISelectivePacketCollection.h b/src/inet/queueing/contract/ISelectivePacketCollection.h new file mode 100644 index 00000000000..7dd07ba071c --- /dev/null +++ b/src/inet/queueing/contract/ISelectivePacketCollection.h @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_ISELECTIVEPACKETCOLLECTION_H +#define __INET_ISELECTIVEPACKETCOLLECTION_H + +#include + +#include "inet/common/packet/Packet.h" + +namespace inet { +namespace queueing { + +class INET_API UnsupportedPacketSelection : public cRuntimeError +{ + public: + explicit UnsupportedPacketSelection(const char *message) : cRuntimeError("%s", message) {} +}; + +// Optional atomic selection in the configured service order. +// UnsupportedPacketSelection identifies an unavailable capability; other errors retain their original type. +class INET_API ISelectivePacketCollection +{ + public: + virtual ~ISelectivePacketCollection() {} + // The result is borrowed. The query changes no packet or queue state. + virtual Packet *peekEligiblePacket(const std::function& predicate) const = 0; + // The caller receives ownership. Each layer applies its ordinary pull effects once. + virtual Packet *extractPacket(Packet *packet) = 0; +}; + +} // namespace queueing +} // namespace inet + +#endif diff --git a/src/inet/queueing/queue/CompoundPacketQueueBase.cc b/src/inet/queueing/queue/CompoundPacketQueueBase.cc index 7d290d0cc1e..d633b869478 100644 --- a/src/inet/queueing/queue/CompoundPacketQueueBase.cc +++ b/src/inet/queueing/queue/CompoundPacketQueueBase.cc @@ -14,6 +14,26 @@ namespace queueing { Define_Module(CompoundPacketQueueBase); +Packet *CompoundPacketQueueBase::peekEligiblePacket(const std::function& predicate) const +{ + if (auto selected = dynamic_cast(collection)) + return selected->peekEligiblePacket(predicate); + throw UnsupportedPacketSelection("CompoundPacketQueueBase provider does not support ISelectivePacketCollection"); +} + +Packet *CompoundPacketQueueBase::extractPacket(Packet *packet) +{ + Enter_Method("extractPacket"); + if (auto selected = dynamic_cast(collection)) + selected->extractPacket(packet); + else + throw UnsupportedPacketSelection("Provider does not support selected extraction"); + take(packet); + emit(packetPulledSignal, packet); + drop(packet); + return packet; +} + void CompoundPacketQueueBase::initialize(int stage) { PacketQueueBase::initialize(stage); diff --git a/src/inet/queueing/queue/CompoundPacketQueueBase.h b/src/inet/queueing/queue/CompoundPacketQueueBase.h index 706d9fb32c5..bff3acf749a 100644 --- a/src/inet/queueing/queue/CompoundPacketQueueBase.h +++ b/src/inet/queueing/queue/CompoundPacketQueueBase.h @@ -13,11 +13,12 @@ #include "inet/queueing/common/PassivePacketSourceRef.h" #include "inet/queueing/contract/IPacketCollection.h" #include "inet/queueing/contract/IPacketDropperFunction.h" +#include "inet/queueing/contract/ISelectivePacketCollection.h" namespace inet { namespace queueing { -class INET_API CompoundPacketQueueBase : public PacketQueueBase, public cListener +class INET_API CompoundPacketQueueBase : public PacketQueueBase, public cListener, public ISelectivePacketCollection { protected: int packetCapacity = -1; @@ -37,6 +38,8 @@ class INET_API CompoundPacketQueueBase : public PacketQueueBase, public cListene virtual bool isOverloaded() const; public: + virtual Packet *peekEligiblePacket(const std::function& predicate) const override; + virtual Packet *extractPacket(Packet *packet) override; virtual ~CompoundPacketQueueBase() { delete packetDropperFunction; } virtual int getMaxNumPackets() const override { return packetCapacity; } diff --git a/src/inet/queueing/queue/PacketQueue.cc b/src/inet/queueing/queue/PacketQueue.cc index 5cb89c3a638..dc6c386d1e7 100644 --- a/src/inet/queueing/queue/PacketQueue.cc +++ b/src/inet/queueing/queue/PacketQueue.cc @@ -118,14 +118,38 @@ void PacketQueue::pushPacket(Packet *packet, const cGate *gate) Packet *PacketQueue::pullPacket(const cGate *gate) { Enter_Method("pullPacket"); - auto packet = check_and_cast(queue.front()); + return pullSelectedPacket(check_and_cast(queue.front())); +} + +Packet *PacketQueue::peekEligiblePacket(const std::function& predicate) const +{ + for (cQueue::Iterator it(queue); !it.end(); it++) { + auto packet = check_and_cast(*it); + if (predicate(packet)) + return packet; + } + return nullptr; +} + +Packet *PacketQueue::extractPacket(Packet *packet) +{ + Enter_Method("extractPacket"); + if (!queue.contains(packet)) + throw cRuntimeError("Selected packet is not in this queue"); + pullSelectedPacket(packet); + drop(packet); + return packet; +} + +Packet *PacketQueue::pullSelectedPacket(Packet *packet) +{ EV_INFO << "Pulling packet" << EV_FIELD(packet) << EV_ENDL; if (buffer != nullptr) { queue.remove(packet); buffer->removePacket(packet); } else - queue.pop(); + queue.remove(packet); auto queueingTime = simTime() - packet->getArrivalTime(); auto packetEvent = new PacketEvent(); insertPacketEvent(this, packet, PEK_QUEUED, 0, queueingTime, packetEvent); diff --git a/src/inet/queueing/queue/PacketQueue.h b/src/inet/queueing/queue/PacketQueue.h index 4debf8541ec..0f9b5f5945a 100644 --- a/src/inet/queueing/queue/PacketQueue.h +++ b/src/inet/queueing/queue/PacketQueue.h @@ -17,11 +17,12 @@ #include "inet/queueing/contract/IPacketBuffer.h" #include "inet/queueing/contract/IPacketComparatorFunction.h" #include "inet/queueing/contract/IPacketDropperFunction.h" +#include "inet/queueing/contract/ISelectivePacketCollection.h" namespace inet { namespace queueing { -class INET_API PacketQueue : public PacketQueueBase, public IPacketBuffer::ICallback, public TransparentProtocolRegistrationListener +class INET_API PacketQueue : public PacketQueueBase, public IPacketBuffer::ICallback, public TransparentProtocolRegistrationListener, public ISelectivePacketCollection { protected: int packetCapacity = -1; @@ -43,8 +44,11 @@ class INET_API PacketQueue : public PacketQueueBase, public IPacketBuffer::ICall virtual IPacketComparatorFunction *createComparatorFunction(const char *comparatorClass) const; virtual bool isOverloaded() const; + Packet *pullSelectedPacket(Packet *packet); public: + virtual Packet *peekEligiblePacket(const std::function& predicate) const override; + virtual Packet *extractPacket(Packet *packet) override; virtual ~PacketQueue() { delete packetDropperFunction; } virtual cGate *getRegistrationForwardingGate(cGate *gate) override; diff --git a/src/inet/queueing/scheduler/PriorityScheduler.cc b/src/inet/queueing/scheduler/PriorityScheduler.cc index 0c2c1d5d3a0..c352065993e 100644 --- a/src/inet/queueing/scheduler/PriorityScheduler.cc +++ b/src/inet/queueing/scheduler/PriorityScheduler.cc @@ -6,12 +6,58 @@ #include "inet/queueing/scheduler/PriorityScheduler.h" +#include "inet/common/Simsignals.h" namespace inet { namespace queueing { Define_Module(PriorityScheduler); +Packet *PriorityScheduler::peekEligiblePacket(const std::function& predicate) const +{ + if (isStreamingPacket()) + throw UnsupportedPacketSelection("Selected extraction does not support packet streaming"); + for (size_t i = 0; i < providers.size(); i++) { + int index = getInputGateIndex(i); + if (auto selected = dynamic_cast(collections[index])) { + if (auto packet = selected->peekEligiblePacket(predicate)) + return packet; + } + else if (!collections[index] || !collections[index]->isEmpty()) + throw UnsupportedPacketSelection("PriorityScheduler child does not support ISelectivePacketCollection"); + } + return nullptr; +} + +Packet *PriorityScheduler::extractPacket(Packet *packet) +{ + Enter_Method("extractPacket"); + if (isStreamingPacket()) + throw UnsupportedPacketSelection("Selected extraction does not support packet streaming"); + for (size_t i = 0; i < collections.size(); i++) { + auto collection = collections[i]; + if (!collection) + throw UnsupportedPacketSelection("PriorityScheduler provider does not support IPacketCollection"); + for (int j = 0; j < collection->getNumPackets(); j++) { + if (collection->getPacket(j) != packet) + continue; + auto selected = dynamic_cast(collection); + if (!selected) + throw UnsupportedPacketSelection("Provider does not support selected extraction"); + selected->extractPacket(packet); + take(packet); + handlePacketScheduled(packet, i); + handlePacketProcessed(packet); + emit(packetPulledSignal, packet); + if (collector != nullptr) + animatePullPacket(packet, outputGate, collector.getReferencedGate()); + drop(packet); + return packet; + } + } + throw cRuntimeError("Selected packet is not in this scheduler"); +} + void PriorityScheduler::initialize(int stage) { PacketSchedulerBase::initialize(stage); diff --git a/src/inet/queueing/scheduler/PriorityScheduler.h b/src/inet/queueing/scheduler/PriorityScheduler.h index cf35dce4822..2cfe2704249 100644 --- a/src/inet/queueing/scheduler/PriorityScheduler.h +++ b/src/inet/queueing/scheduler/PriorityScheduler.h @@ -10,11 +10,12 @@ #include "inet/queueing/base/PacketSchedulerBase.h" #include "inet/queueing/contract/IPacketCollection.h" +#include "inet/queueing/contract/ISelectivePacketCollection.h" namespace inet { namespace queueing { -class INET_API PriorityScheduler : public PacketSchedulerBase, public virtual IPacketCollection +class INET_API PriorityScheduler : public PacketSchedulerBase, public virtual IPacketCollection, public ISelectivePacketCollection { protected: std::vector collections; @@ -24,6 +25,8 @@ class INET_API PriorityScheduler : public PacketSchedulerBase, public virtual IP virtual int schedulePacket() const override; public: + virtual Packet *peekEligiblePacket(const std::function& predicate) const override; + virtual Packet *extractPacket(Packet *packet) override; virtual int getMaxNumPackets() const override { return -1; } virtual int getNumPackets() const override; diff --git a/tests/module/PacketSelectiveExtraction_1.test b/tests/module/PacketSelectiveExtraction_1.test new file mode 100644 index 00000000000..1391d286fd5 --- /dev/null +++ b/tests/module/PacketSelectiveExtraction_1.test @@ -0,0 +1,213 @@ +%description: +Check selected extraction through simple and compound queues. +Extraction must preserve ownership, residence metadata, and one pull event per queue layer. +The predicate query must preserve storage and configured scheduler order. + +%extraargs: -r 0..5 + +%file: SelectiveExtraction.cc +#include "inet/common/PacketEventTag.h" +#include "inet/common/Simsignals.h" +#include "inet/common/TimeTag.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/queueing/contract/IPacketQueue.h" +#include "inet/queueing/contract/ISelectivePacketCollection.h" +#include "inet/queueing/scheduler/PriorityScheduler.h" + +namespace inet::queueing { +class SelectiveScheduler : public PriorityScheduler { + public: + int getProcessedCount() const { return numProcessedPackets; } +}; +Define_Module(SelectiveScheduler); + +class SelectiveExtractionTest : public cSimpleModule, public cListener { + protected: + IPacketQueue *queue = nullptr; + cModule *queueModule = nullptr; + Packet *first = nullptr; + Packet *second = nullptr; + std::map pulls; + int removals = 0; + + Packet *makePacket(const char *name, bool multicast) { + auto header = makeShared(); + header->setType(ieee80211::ST_DATA_WITH_QOS); + header->addChunkLength(ieee80211::QOSCONTROL_PART_LENGTH); + header->setTid(5); + header->setReceiverAddress(MacAddress(multicast ? "01:00:00:00:00:01" : "02:00:00:00:00:02")); + auto packet = new Packet(name, header); + packet->setArrivalTime(simTime()); + packet->insertAtBack(makeShared(B(20))); + auto timeTag = packet->addRegionTag(); + timeTag->setPacketTotalTimesArraySize(1); + timeTag->setPacketTotalTimes(0, SIMTIME_ZERO); + packet->addRegionTag(); + return packet; + } + + void initialize() override { + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("enqueue")); + } + + void handleMessage(cMessage *message) override { + bool enqueue = !strcmp(message->getName(), "enqueue"); + delete message; + if (enqueue) { + queueModule = getModuleByPath(par("compound").boolValue() ? "^.compound" : "^.simpleQueue"); + queue = check_and_cast(queueModule); + queueModule->subscribe(packetPulledSignal, this); + queueModule->subscribe(packetRemovedSignal, this); + first = makePacket("first", true); + second = makePacket("second", false); + queue->enqueuePacket(first); + queue->enqueuePacket(second); + scheduleAt(SimTime(11, SIMTIME_MS), new cMessage("extract")); + return; + } + auto selective = check_and_cast(queue); + auto unsupported = check_and_cast(getModuleByPath("^.unsupportedScheduler")); + bool unsupportedQuery = false; + try { + unsupported->peekEligiblePacket([](Packet *) { return true; }); + } + catch (const UnsupportedPacketSelection&) { + unsupportedQuery = true; + } + ASSERT(unsupportedQuery); + auto selected = par("head").boolValue() ? first : second; + auto predicate = [selected](Packet *packet) { return packet == selected; }; + ASSERT(selective->peekEligiblePacket(predicate) == selected); + ASSERT(queue->getNumPackets() == 2); + ASSERT(pulls.empty() && removals == 0); + auto outsider = makePacket("outsider", false); + bool unsupportedExtraction = false; + try { + unsupported->extractPacket(outsider); + } + catch (const UnsupportedPacketSelection&) { + unsupportedExtraction = true; + } + ASSERT(unsupportedExtraction); + bool rejected = false; + try { + selective->extractPacket(outsider); + } + catch (const cRuntimeError&) { + rejected = true; + } + ASSERT(rejected && queue->getNumPackets() == 2); + ASSERT(pulls.empty() && removals == 0); + delete outsider; + if (par("compound").boolValue()) { + auto any = selective->peekEligiblePacket([](Packet *) { return true; }); + ASSERT(any == (par("reverse").boolValue() ? second : first)); + } + auto extracted = selective->extractPacket(selected); + ASSERT(extracted == selected); + take(extracted); + ASSERT(extracted->getOwner() == this); + ASSERT(queue->getNumPackets() == 1); + ASSERT(queue->getPacket(0) == (selected == first ? second : first)); + ASSERT(removals == 0); + auto timeTag = extracted->findRegionTag(); + ASSERT(timeTag != nullptr); + ASSERT(timeTag->getPacketTotalTimes(0) == SimTime(10, SIMTIME_MS)); + auto eventTag = extracted->findRegionTag(); + ASSERT(eventTag != nullptr && eventTag->getPacketEventsArraySize() == 1); + ASSERT(eventTag->getPacketEvents(0)->getKind() == PEK_QUEUED); + ASSERT(eventTag->getPacketEvents(0)->getPacketDuration() == SimTime(10, SIMTIME_MS)); + auto retained = queue->getPacket(0); + ASSERT(retained->findRegionTag()->getPacketTotalTimes(0) == SIMTIME_ZERO); + ASSERT(retained->findRegionTag()->getPacketEventsArraySize() == 0); + if (par("compound").boolValue()) { + ASSERT(pulls.size() == 3); + auto scheduler = check_and_cast(queueModule->getSubmodule("prioritizer")); + ASSERT(scheduler->getProcessedCount() == 1); + } + else + ASSERT(pulls.size() == 1); + for (auto entry : pulls) + ASSERT(entry.second == 1); + delete extracted; + queueModule->unsubscribe(packetPulledSignal, this); + queueModule->unsubscribe(packetRemovedSignal, this); + std::cout << "Selected extraction assertions passed.\n"; + } + + void receiveSignal(cComponent *source, simsignal_t signal, cObject *, cObject *) override { + if (signal == packetPulledSignal) + pulls[source->getFullPath()]++; + else if (signal == packetRemovedSignal) + removals++; + } +}; +Define_Module(SelectiveExtractionTest); +} + +%file: test.ned +import inet.queueing.classifier.PacketClassifier; +import inet.queueing.queue.CompoundPacketQueueBase; +import inet.queueing.queue.PacketQueue; +import inet.queueing.scheduler.PriorityScheduler; +import inet.queueing.source.PassivePacketSource; +simple SelectiveScheduler extends PriorityScheduler { parameters: @class(::inet::queueing::SelectiveScheduler); } +module SelectiveCompoundQueue extends CompoundPacketQueueBase { + submodules: + classifier: PacketClassifier { + parameters: classifierClass = "inet::ieee80211::MgmtOverMulticastOverUnicastClassifier"; + } + managementQueue: PacketQueue; + multicastQueue: PacketQueue; + unicastQueue: PacketQueue; + prioritizer: SelectiveScheduler; + connections: + in --> classifier.in; + classifier.out++ --> managementQueue.in; + classifier.out++ --> multicastQueue.in; + classifier.out++ --> unicastQueue.in; + managementQueue.out --> prioritizer.in++; + multicastQueue.out --> prioritizer.in++; + unicastQueue.out --> prioritizer.in++; + prioritizer.out --> out; +} +simple SelectiveExtractionTest { + parameters: + bool compound; + bool head; + bool reverse; + @class(::inet::queueing::SelectiveExtractionTest); +} +network SelectiveExtractionNetwork { + submodules: + simpleQueue: PacketQueue; + compound: SelectiveCompoundQueue; + unsupportedProvider: PassivePacketSource { + parameters: packetLength = 20B; + } + unsupportedQueue: PacketQueue; + unsupportedScheduler: PriorityScheduler; + test: SelectiveExtractionTest; + connections allowunconnected: + unsupportedProvider.out --> unsupportedScheduler.in++; + unsupportedQueue.out --> unsupportedScheduler.in++; +} + +%inifile: omnetpp.ini +[General] +network = SelectiveExtractionNetwork +ned-path = .;../../../../src +sim-time-limit = 12ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.test.compound = ${compound=false,true,true} +*.test.reverse = ${reverse=false,false,true ! compound} +*.test.head = ${head=false,true} +*.compound.classifier.classifierClass = "inet::ieee80211::MgmtOverMulticastOverUnicastClassifier" +*.compound.prioritizer.reverseOrder = ${reverse} + +%contains: stdout +Selected extraction assertions passed. From 2c6b1df761f67abd436526bb821282306f1c143e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:44:06 +0200 Subject: [PATCH 02/41] ieee80211: fix: preserve Block Ack lifecycle boundaries Before this commit, Action dispatch can reuse deleted headers and repeat agreement effects. Setup can accept an uncorrelated response. Teardown can retain obsolete work or unsent fragments of transmitted DATA. DATA extraction can advance sequence state before setup resolves. After this commit, HCF dispatches complete accepted Actions once. Handlers correlate peer, TID, and dialog token before acceptance. The response determines agreement parameters. Directional retirement detaches the agreement before cleanup. Association replacement clears both roles before notification. Accepted physical exchanges finish safely but cannot submit retired protected frames after CTS. Setup defers new DATA extraction until the procedure resolves. Already numbered DATA resolves before ADDBA. A later successor can start setup after an empty interval without an empty request. The response timeout starts after the request ACK. Uncertain setup requires DELBA before surviving unsent DATA can resume. The QoS data service assigns a monotonic allocation index before fragmentation. All fragments retain that index in a tag. The agreement retains its highest transmitted index after ACK removal. Teardown uses that index to discard incomplete DATA. Older retransmissions cannot move the boundary backward. Wire sequence numbers remain unchanged. For example, sequence 0 transmits before sequences 1 through 2047 expire. Fragment 0 of sequence 2048 next transmits. Teardown discards its unsent siblings despite the exact half-range gap. Later intact DATA and unrelated peer DATA remain eligible. Deferred deletion protects references during accepted physical exchanges. An internal collision that discards first DATA also triggers retirement. HCF queues DELBA before the unsent successor can resume. Contention uses current eligibility, so deferred work cannot charge another category an internal collision. HCF schedules the earliest absolute deadline across both agreement roles. These lifecycle contracts change together because retirement requires safe Action invalidation and accepted-exchange completion at first use. The shared queue capability precedes this commit. Direct fixtures cover Action correlation, timeout, collision, fragment retirement, sequence gaps, and association reset. The migration guide explains custom-module contracts. Seven approved Basic fingerprint rows describe the changed setup boundaries. Numbered DATA resolves before setup, while infrastructure MacQosWithBlockAck waits for later DATA instead of empty-successor setup. Graphical expectations remain unchanged. Basic remains the default. Compressed exchanges, final-transfer arbitration, and MAC stop/start remain outside this commit. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.change.fix | test whatsnew migration fingerprint | ieee80211-compressed-blockack-replacement --- WHATSNEW | 16 + doc/src/migration-guide/index.rst | 45 ++ .../mac/Ieee80211DataSequenceTag.msg | 17 + .../linklayer/ieee80211/mac/Ieee80211Mac.cc | 7 + .../linklayer/ieee80211/mac/Ieee80211Mac.h | 4 +- .../blockack/OriginatorBlockAckAgreement.h | 16 + .../OriginatorBlockAckAgreementHandler.cc | 125 ++- .../OriginatorBlockAckAgreementHandler.h | 16 +- .../OriginatorBlockAckAgreementPolicy.cc | 27 +- .../OriginatorBlockAckAgreementPolicy.h | 1 + .../OriginatorBlockAckAgreementPolicy.ned | 5 +- .../mac/blockack/RecipientBlockAckAgreement.h | 13 + .../RecipientBlockAckAgreementHandler.cc | 83 +- .../RecipientBlockAckAgreementHandler.h | 9 +- .../RecipientBlockAckAgreementPolicy.cc | 17 +- .../RecipientBlockAckAgreementPolicy.h | 1 + .../RecipientBlockAckAgreementPolicy.ned | 2 +- .../blockackreordering/BlockAckReordering.cc | 38 + .../blockackreordering/BlockAckReordering.h | 2 + .../ieee80211/mac/channelaccess/Edcaf.cc | 5 + .../ieee80211/mac/channelaccess/Edcaf.h | 3 + .../mac/contention/EdcaCollisionController.cc | 4 +- .../ieee80211/mac/contract/BlockAckVariant.h | 14 + .../IBlockAckAgreementHandlerCallback.h | 3 +- .../contract/IBlockAckAgreementLifecycle.h | 22 + .../mac/contract/IFrameSequenceHandler.h | 2 + .../IOriginatorBlockAckAgreementHandler.h | 20 + .../IOriginatorBlockAckAgreementPolicy.h | 3 + .../IRecipientBlockAckAgreementHandler.h | 7 + .../IRecipientBlockAckAgreementPolicy.h | 3 + .../contract/IRecipientQosMacDataService.h | 2 + .../ieee80211/mac/coordinationfunction/Hcf.cc | 755 +++++++++++++++++- .../ieee80211/mac/coordinationfunction/Hcf.h | 39 +- .../duplicateremoval/QosDuplicateRemoval.cc | 18 + .../duplicateremoval/QosDuplicateRemoval.h | 2 + .../mac/fragmentation/BasicReassembly.cc | 6 +- .../mac/framesequence/FrameSequenceHandler.cc | 11 + .../mac/framesequence/FrameSequenceHandler.h | 1 + .../framesequence/PrimitiveFrameSequences.cc | 16 +- .../mac/originator/NonQosRecoveryProcedure.cc | 27 +- .../mac/originator/NonQosRecoveryProcedure.h | 2 + .../mac/originator/OriginatorQosAckPolicy.cc | 4 +- .../originator/OriginatorQosMacDataService.cc | 67 +- .../originator/OriginatorQosMacDataService.h | 12 +- .../ieee80211/mac/queue/InProgressFrames.cc | 1 + .../ieee80211/mac/queue/InProgressFrames.h | 3 + .../recipient/RecipientQosMacDataService.cc | 61 +- .../recipient/RecipientQosMacDataService.h | 2 + .../QoSSequenceNumberAssignment.cc | 6 + .../QoSSequenceNumberAssignment.h | 1 + .../ieee80211/mgmt/Ieee80211MgmtAp.cc | 11 + .../ieee80211/mgmt/Ieee80211MgmtBase.cc | 7 + .../ieee80211/mgmt/Ieee80211MgmtBase.h | 1 + .../ieee80211/mgmt/Ieee80211MgmtSta.cc | 1 + tests/fingerprint/examples.csv | 4 +- tests/fingerprint/showcases.csv | 10 +- .../Ieee80211BlockAckActionDelivery_1.test | 70 ++ .../Ieee80211BlockAckActionDispatch_1.test | 178 +++++ .../Ieee80211BlockAckActionDisposal_1.test | 470 +++++++++++ .../module/Ieee80211BlockAckAdmission_1.test | 132 +++ .../Ieee80211BlockAckAssociationReset_1.test | 451 +++++++++++ .../Ieee80211BlockAckDataSelection_1.test | 313 ++++++++ tests/module/Ieee80211BlockAckDeferral_1.test | 393 +++++++++ .../Ieee80211BlockAckDeferredCollision_1.test | 203 +++++ ...Ieee80211BlockAckFragmentRetirement_1.test | 297 +++++++ .../module/Ieee80211BlockAckLifecycle_1.test | 358 +++++++++ .../Ieee80211BlockAckNegotiation_1.test | 83 ++ .../Ieee80211BlockAckResponseWait_1.test | 242 ++++++ .../Ieee80211BlockAckRetiredData_1.test | 325 ++++++++ 69 files changed, 4994 insertions(+), 121 deletions(-) create mode 100644 src/inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag.msg create mode 100644 src/inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h create mode 100644 src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h create mode 100644 tests/module/Ieee80211BlockAckActionDelivery_1.test create mode 100644 tests/module/Ieee80211BlockAckActionDispatch_1.test create mode 100644 tests/module/Ieee80211BlockAckActionDisposal_1.test create mode 100644 tests/module/Ieee80211BlockAckAdmission_1.test create mode 100644 tests/module/Ieee80211BlockAckAssociationReset_1.test create mode 100644 tests/module/Ieee80211BlockAckDataSelection_1.test create mode 100644 tests/module/Ieee80211BlockAckDeferral_1.test create mode 100644 tests/module/Ieee80211BlockAckDeferredCollision_1.test create mode 100644 tests/module/Ieee80211BlockAckFragmentRetirement_1.test create mode 100644 tests/module/Ieee80211BlockAckLifecycle_1.test create mode 100644 tests/module/Ieee80211BlockAckNegotiation_1.test create mode 100644 tests/module/Ieee80211BlockAckResponseWait_1.test create mode 100644 tests/module/Ieee80211BlockAckRetiredData_1.test diff --git a/WHATSNEW b/WHATSNEW index e60ba90f7e1..097c0d79b9e 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -428,6 +428,22 @@ Notable backward incompatible changes are the following: The new parameter urgentOutOfBand, which LinuxTcp sets, gives the receive side of urgent data of Linux without SO_OOBINLINE: the last byte of urgent data leaves the stream, and a read stops before it. INET does not deliver that byte, which Linux gives to recv(MSG_OOB), and it sends no urgent data. Tcp keeps treating URG-marked bytes as ordinary data. Simulations change only where a peer sends urgent data to LinuxTcp. +55. IEEE 802.11 Block Ack agreement lifecycle + + HCF now dispatches accepted Block Ack Actions once after duplicate checks. Setup correlates the peer, TID, and dialog token. The recipient response determines the accepted buffer size and inactivity timeout. Both negotiated flags control A-MSDU use. + + HCF defers new DATA extraction during setup and recovery. The first DATA under an accepted agreement retains the request sequence number. The response timeout starts after the request ACK, with a configurable default of 100 ms. Uncertain setup requires DELBA before surviving unsent DATA can resume. Failed DELBA discards the current deferred batch. Later DATA can start a fresh recovery exchange. + + If an internal collision discards the first DATA before transmission, HCF retires the agreement and queues DELBA. The unsent successor remains deferred until recovery resolves. Lifetime expiry and RTS failure use the same retirement mechanism. + + Directional teardown preserves the opposite agreement. The originator discards transmitted, unacknowledged DATA, even when its lifetime remains valid at inactivity expiration. It also discards unsent fragments through the highest transmitted allocation index. This local index records allocation order before fragmentation. This prevents transmission of an incomplete unit outside the agreement. Later intact DATA remains eligible, including across sequence wraparound. + + Originator retirement now uses local allocation indices to preserve this boundary across large sequence gaps. A distance of exactly 2048 between DATA transmissions no longer lets unsent fragments survive teardown. The wire sequence numbers remain unchanged. + + The recipient delivers complete buffered units in cyclic order across receive gaps before resource release. Association reset instead discards old buffered units in both directions. With Block Ack enabled, reset also discards queued and in-progress QoS DATA for the old peer, including unsent Normal Ack DATA. These changes can alter delivery, disposal, frame exchanges, and fingerprints. + + Basic remains the default. Compressed selection still stops initialization. Custom agreement handlers, recipient services, and management implementations require the changes in the migration guide. External queues need the optional selected-extraction contract only when deferred DATA hides eligible work. Built-in queues preserve ordinary pull accounting for that extraction. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 6da76178c57..138bc9d7fa1 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -158,6 +158,51 @@ The protected ``getEarliestCompleteMsduOrAMsduIfExists()`` helper remains availa No configuration change is necessary. Gap release, window movement, and BAR before DATA can change delivery times and fingerprints in affected Basic Block Ack scenarios. These repairs do not enable Compressed Block Ack. +IEEE 802.11 Block Ack Agreement Lifecycle +------------------------------------------ + +HCF now defers new DATA extraction for a peer and TID during Block Ack setup or recovery. Already numbered DATA resolves before HCF creates ADDBA. The first DATA under an accepted agreement therefore retains the request sequence number. Basic remains the default. Compressed selection still stops initialization. + +The recipient response now determines the buffer size and inactivity timeout. The built-in recipient selects the smaller of 64 and its configured maximum. A request size of zero supplies no size guidance. The response copies the request dialog token. Both negotiated A-MSDU flags must permit aggregation under an active agreement. + +The originator starts ``mac.hcf.originatorBlockAckAgreementPolicy.addbaFailureTimeout`` after the request receives its ACK. Its default is 100 ms. The value must be positive and finite. + +If the response does not arrive, HCF sends DELBA before it releases surviving unsent DATA. DATA lifetime separately limits retained DATA. Failed DELBA disposes of the current deferred batch. Later DATA starts one fresh recovery exchange. + +At ordinary teardown, the originator discards every transmitted, unacknowledged MPDU for the selected agreement. This includes DATA whose lifetime remains valid when inactivity expires. It also discards unsent fragments through the highest transmitted allocation index, even if an earlier fragment received an ACK. This local index records allocation order before fragmentation. Later unsent DATA retains sequence continuity. + +For example, fragment 0 of sequence 4095 enters transmission before teardown. Teardown discards its unsent fragments and preserves the intact successor with sequence 0. The recipient delivers complete buffered units in cyclic order before it releases resources. It discards incomplete units. For example, complete units 101 and 102 can reach the upper process after teardown across absent unit 100. + +Custom originator code must call ``recordTransmittedData(allocationIndex)`` instead of ``markFirstDataTransmitted()`` or the former cyclic-sequence overload. The QoS data service assigns an increasing local index before fragmentation. All fragments retain this index in ``Ieee80211DataSequenceTag``. Custom QoS data services must supply the same metadata. The agreement exposes its highest transmitted index through ``getHighestTransmittedDataIndex()``, which replaces ``getHighestTransmittedSequence()``. HCF records this index when the transmitter accepts DATA. + +The index remains available after ACK processing removes a frame. Teardown compares allocation indices to remove unsent fragments of a partially transmitted unit. This comparison remains valid across sequence gaps and wraparound. For example, transmission of sequences 0 and 2048 updates the boundary correctly when intervening DATA receives allocation indices but never transmits. Retransmission of older DATA cannot move the boundary backward. + +Association reset instead discards all buffered units from the old association. Management calls ``IBlockAckAgreementLifecycle::resetPeerAgreements()`` with the old peer address before replacement. The MAC implements this contract and forwards the reset to HCF. Custom management implementations must supply this handoff for association replacement and loss. A rate-state notification alone cannot identify replacement with identical capabilities. + +With Block Ack support enabled, peer reset also discards queued and in-progress QoS DATA addressed to the old peer. This includes unsent Normal Ack DATA without an agreement. Accepted physical exchanges retain their context until safe completion. Reset preserves other peers' queued DATA and lifetime records. + +Custom MAC implementations that use these management modules must implement ``IBlockAckAgreementLifecycle``. The reset must complete both agreement roles' cleanup before it reports deletion. It must preserve an unrelated management exchange that already holds an accepted transmission. + +``blockAckAgreementDeleted`` now supplies a nonnull agreement after removal from lookup and completion of the required cleanup. The payload identifies the selected role through its agreement class. The payload remains valid only during the synchronous callback. Listeners must not retain or modify it. Association reset removes both roles before the first callback. Ordinary directional teardown preserves the opposite role. + +Custom QoS recipient services must return accepted, complete Actions from ``managementFrameReceived()``. HCF owns their agreement dispatch after duplicate checks. Services must implement directional retirement and peer cleanup through the recipient-service contract. Custom agreement policies must implement ``isProfileAllowed()`` with the supplied typed profile and usable capability inputs. Basic admission must preserve its historical non-HT compatibility. + +Custom agreement handlers must implement the new procedure and retirement operations in their handler contracts. The originator handler owns setup intent, request identity, response deadlines, teardown, and recovery state. Its ``noteEligibleDataTransmission(peer, tid)`` operation records ``WAITING_FOR_SUCCESSOR`` after an eligible DATA transmission. This phase permits ordinary DATA access and has no request or deadline. A later queued successor promotes the phase to setup intent before extraction. Peer reset clears the phase. + +The recipient handler owns its active agreements and pending teardown. Detachment removes an agreement from lookup and transfers it to the caller. The caller retains the object through its deletion callback. Const observations expose current state without a second agreement store. + +Custom implementations of ``IBlockAckAgreementHandlerCallback`` must implement ``scheduleInactivityTimer()`` without a deadline argument. Agreement handlers request recomputation after their state changes. HCF queries both roles and schedules their earliest absolute deadline. It cancels the timer when neither role has a finite deadline. Custom callers must remove the old deadline argument. + +Custom subclasses of ``OriginatorQosMacDataService`` must adapt the protected ``aMsduAggregateIfNeeded(queue, selected)`` helper. The selected packet is the first eligible packet in service order. An aggregate candidate list must start with that packet. The service validates every candidate before source removal and calls the aggregation policy once. + +Custom queues need ``inet::queueing::ISelectivePacketCollection`` only when a deferred next frame hides eligible work. HCF retains ordinary dequeue when the advertised next frame is eligible. It waits when every frame is deferred. It reports the missing capability before mutation when eligible work requires a bypass. + +The optional ``peekEligiblePacket(predicate)`` operation returns a borrowed packet in configured service order without mutation. ``extractPacket(packet)`` transfers that exact packet to its caller. Implementations must preserve their ordinary pull effects, including ownership, residence metadata, events, statistics, and applicable animation. Built-in simple queues, priority schedulers, and compound queues support this contract. Custom subclasses that change pull effects must adapt selected extraction. The optional contract supports complete packets only. + +Providers that cannot perform a selected operation must throw ``inet::queueing::UnsupportedPacketSelection``. This exception permits ordinary service and collection inspection without the optional capability. Genuine queue and predicate errors must retain their original type. + +External frame-sequence handlers must implement ``interruptFrameSequence(notifyFailure)``. A false argument ends an exchange that an accepted Action already resolves, without obsolete failure feedback. Cleanup must destroy the exchange context before it deletes deferred frame copies. These repairs do not add MAC stop/start recovery or final-transfer teardown. + IEEE 802.11 Response Query Roles -------------------------------- diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag.msg b/src/inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag.msg new file mode 100644 index 00000000000..3d586aad6c0 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag.msg @@ -0,0 +1,17 @@ +// +// Copyright (C) 2026 OpenSim Ltd. +// +// SPDX-License-Identifier: LGPL-3.0-or-later +// + +import inet.common.INETDefs; +import inet.common.TagBase; + +namespace inet::ieee80211; + +// Local allocation order before fragmentation. All fragments retain this index. +// Unlike the wire sequence number, the index does not wrap at 4096. +class Ieee80211DataSequenceTag extends TagBase +{ + int64_t allocationIndex = -1; +} diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc index b864c39f435..5db40af167f 100644 --- a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc @@ -34,6 +34,13 @@ namespace inet { namespace ieee80211 { +void Ieee80211Mac::resetPeerAgreements(const MacAddress& peer) +{ + Enter_Method("resetPeerAgreements"); + if (hcf) + hcf->resetPeer(peer); +} + using namespace inet::physicallayer; Define_Module(Ieee80211Mac); diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.h b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.h index 25d1b25fe65..0b28e4a8bc0 100644 --- a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.h +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.h @@ -11,6 +11,7 @@ #include "inet/common/ModuleRefByPar.h" #include "inet/linklayer/base/MacProtocolBase.h" #include "inet/linklayer/ieee80211/mac/contract/IDs.h" +#include "inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h" #include "inet/linklayer/ieee80211/mac/contract/IRateControl.h" #include "inet/linklayer/ieee80211/mac/contract/IRateSelection.h" #include "inet/linklayer/ieee80211/mac/contract/IRx.h" @@ -35,7 +36,7 @@ class Ieee80211MacHeader; * exact operation of the MAC depend on the plugged-in components (see IUpperMac, * IRx, ITx, IContention and other interface classes). */ -class INET_API Ieee80211Mac : public MacProtocolBase +class INET_API Ieee80211Mac : public MacProtocolBase, public IBlockAckAgreementLifecycle { public: static simsignal_t frameTransmissionOutcomeSignal; @@ -106,6 +107,7 @@ class INET_API Ieee80211Mac : public MacProtocolBase virtual void sendUpFrame(Packet *frame); virtual void sendDownFrame(Packet *frame); virtual void sendDownPendingRadioConfigMsg(); + virtual void resetPeerAgreements(const MacAddress& peer) override; virtual void processUpperFrame(Packet *packet, const Ptr& header); virtual void processLowerFrame(Packet *packet, const Ptr& header); diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h index a516527bc34..8ef73652db3 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h @@ -24,6 +24,9 @@ class INET_API OriginatorBlockAckAgreement : public cObject SequenceNumberCyclic startingSequenceNumber; int bufferSize = -1; bool isAMsduSupported = false; + bool responseAMsduSupported = false; + int dialogToken = -1; + int64_t highestTransmittedDataIndex = -1; bool isDelayedBlockAckPolicySupported = false; bool isAddbaResponseReceived = false; bool isAddbaRequestSent = false; @@ -49,6 +52,19 @@ class INET_API OriginatorBlockAckAgreement : public cObject virtual bool getIsAddbaResponseReceived() const { return isAddbaResponseReceived; } virtual bool getIsAddbaRequestSent() const { return isAddbaRequestSent; } virtual bool getIsAMsduSupported() const { return isAMsduSupported; } + // IEEE Std 802.11-2024, 10.25.2 defines ADDBA negotiation; INET requires both flags before A-MSDU aggregation. + bool isAMsduPermitted() const { return isAMsduSupported && responseAMsduSupported; } + int getDialogToken() const { return dialogToken; } + void setDialogToken(int token) { dialogToken = token; } + void setResponseAMsduSupported(bool value) { responseAMsduSupported = value; } + bool getFirstDataTransmitted() const { return highestTransmittedDataIndex >= 0; } + int64_t getHighestTransmittedDataIndex() const { return highestTransmittedDataIndex; } + void recordTransmittedData(int64_t allocationIndex) + { + ASSERT(allocationIndex >= 0); + if (highestTransmittedDataIndex < allocationIndex) + highestTransmittedDataIndex = allocationIndex; + } virtual bool getIsDelayedBlockAckPolicySupported() const { return isDelayedBlockAckPolicySupported; } virtual MacAddress getReceiverAddr() const { return receiverAddr; } virtual Tid getTid() const { return tid; } diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc index 2f11dc365db..fdc8c44dd1e 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc @@ -8,15 +8,108 @@ #include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" namespace inet { namespace ieee80211 { +void OriginatorBlockAckAgreementHandler::noteEligibleDataTransmission(MacAddress peer, Tid tid) +{ + Procedure procedure; + procedure.state = ProcedureState::WAITING_FOR_SUCCESSOR; + procedures.emplace(AgreementId(peer, tid), procedure); +} + +void OriginatorBlockAckAgreementHandler::beginSetupIntent(MacAddress peer, Tid tid) +{ + auto result = procedures.emplace(AgreementId(peer, tid), Procedure()); + if (result.first->second.state == ProcedureState::WAITING_FOR_SUCCESSOR) + result.first->second.state = ProcedureState::SETUP_INTENT; +} + +void OriginatorBlockAckAgreementHandler::beginTeardown(MacAddress peer, Tid tid) +{ + Procedure procedure; + procedure.state = ProcedureState::TEARDOWN_PENDING; + procedures[{peer, tid}] = procedure; +} + +void OriginatorBlockAckAgreementHandler::failTeardown(MacAddress peer, Tid tid) +{ + Procedure procedure; + procedure.state = ProcedureState::RECOVERY_NEEDED; + procedures[{peer, tid}] = procedure; +} + +void OriginatorBlockAckAgreementHandler::finishProcedure(MacAddress peer, Tid tid) +{ + procedures.erase({peer, tid}); +} + +void OriginatorBlockAckAgreementHandler::markRequestAttempted(MacAddress peer, Tid tid) +{ + auto it = procedures.find({peer, tid}); + if (it != procedures.end() && it->second.state == ProcedureState::REQUEST_PENDING) + it->second.requestAttempted = true; +} + +void OriginatorBlockAckAgreementHandler::acknowledgeRequest(MacAddress peer, Tid tid, simtime_t timeout) +{ + auto it = procedures.find({peer, tid}); + if (it != procedures.end() && it->second.state == ProcedureState::REQUEST_PENDING) + it->second.responseDeadline = simTime() + timeout; +} + void OriginatorBlockAckAgreementHandler::createAgreement(const Ptr& addbaRequest) { OriginatorBlockAckAgreement *blockAckAgreement = new OriginatorBlockAckAgreement(addbaRequest->getReceiverAddress(), addbaRequest->getTid(), addbaRequest->getStartingSequenceNumber(), addbaRequest->getBufferSize(), addbaRequest->getAMsduSupported(), addbaRequest->getBlockAckPolicy() == 0); auto agreementId = std::make_pair(addbaRequest->getReceiverAddress(), addbaRequest->getTid()); blockAckAgreements[agreementId] = blockAckAgreement; + blockAckAgreement->setDialogToken(addbaRequest->getDialogToken()); + procedures[agreementId].state = ProcedureState::REQUEST_PENDING; +} + +OriginatorBlockAckAgreement *OriginatorBlockAckAgreementHandler::detachAgreement(MacAddress peer, Tid tid) +{ + auto it = blockAckAgreements.find({peer, tid}); + if (it == blockAckAgreements.end()) + return nullptr; + auto agreement = it->second; + blockAckAgreements.erase(it); + return agreement; +} + +std::vector OriginatorBlockAckAgreementHandler::detachPeer(MacAddress peer) +{ + std::vector removed; + for (auto it = blockAckAgreements.begin(); it != blockAckAgreements.end();) { + if (it->first.first == peer) { + removed.push_back(it->second); + it = blockAckAgreements.erase(it); + } + else + ++it; + } + for (auto it = procedures.begin(); it != procedures.end();) { + if (it->first.first == peer) + it = procedures.erase(it); + else + ++it; + } + return removed; +} + +void OriginatorBlockAckAgreementHandler::startSetup(MacAddress peer, Tid tid, SequenceNumberCyclic sequence, + IOriginatorBlockAckAgreementPolicy *policy, IProcedureCallback *callback, bool aMsdu) +{ + auto request = buildAddbaRequest(peer, tid, sequence, policy); + request->setAMsduSupported(aMsdu && policy->isMsduSupported()); + // IEEE Std 802.11-2024, Table 9-466: ordinary setup uses a nonzero dialog token. + auto& token = dialogTokens[{peer, tid}]; + token = token % 255 + 1; + request->setDialogToken(token); + createAgreement(request); + callback->processMgmtFrame(new Packet("AddbaReq", request), request); } simtime_t OriginatorBlockAckAgreementHandler::computeEarliestExpirationTime() @@ -40,15 +133,16 @@ void OriginatorBlockAckAgreementHandler::blockAckAgreementExpired(IProcedureCall // primitive with the ReasonCode parameter having a value of TIMEOUT. // The procedure is illustrated in Figure 10-14. simtime_t now = simTime(); + std::vector expired; for (auto id : blockAckAgreements) { auto agreement = id.second; - if (agreement->getExpirationTime() == now) { - MacAddress receiverAddr = id.first.first; - Tid tid = id.first.second; - const auto& delba = buildDelba(receiverAddr, tid, 39); - auto delbaPacket = new Packet("Delba", delba); - procedureCallback->processMgmtFrame(delbaPacket, delba); // 39 - TIMEOUT see: Table 8-36—Reason codes - } + if (agreement->getIsAddbaResponseReceived() && agreement->getExpirationTime() <= now) + expired.push_back(id.first); + } + for (const auto& id : expired) { + const auto& delba = buildDelba(id.first, id.second, 39); + auto delbaPacket = new Packet("Delba", delba); + procedureCallback->processMgmtFrame(delbaPacket, delba); } scheduleInactivityTimer(agreementHandlerCallback); } @@ -87,9 +181,7 @@ void OriginatorBlockAckAgreementHandler::processReceivedBlockAck(const PtrscheduleInactivityTimer(earliestExpirationTime); + callback->scheduleInactivityTimer(); } OriginatorBlockAckAgreement *OriginatorBlockAckAgreementHandler::getAgreement(MacAddress receiverAddr, Tid tid) @@ -124,12 +216,8 @@ void OriginatorBlockAckAgreementHandler::terminateAgreement(MacAddress originato void OriginatorBlockAckAgreementHandler::processTransmittedDataFrame(Packet *packet, const Ptr& dataHeader, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) { auto agreement = getAgreement(dataHeader->getReceiverAddress(), dataHeader->getTid()); - if (blockAckAgreementPolicy->isAddbaReqNeeded(packet, dataHeader) && agreement == nullptr) { - auto addbaReq = buildAddbaRequest(dataHeader->getReceiverAddress(), dataHeader->getTid(), dataHeader->getSequenceNumber() + 1, blockAckAgreementPolicy); - createAgreement(addbaReq); - auto addbaPacket = new Packet("AddbaReq", addbaReq); - callback->processMgmtFrame(addbaPacket, addbaReq); - } + if (agreement && agreement->getIsAddbaResponseReceived()) + agreement->recordTransmittedData(packet->getTag()->getAllocationIndex()); } void OriginatorBlockAckAgreementHandler::processReceivedAddbaResp(const Ptr& addbaResp, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy, IBlockAckAgreementHandlerCallback *callback) @@ -149,6 +237,7 @@ void OriginatorBlockAckAgreementHandler::updateAgreement(OriginatorBlockAckAgree agreement->setIsAddbaResponseReceived(true); agreement->setBufferSize(addbaResp->getBufferSize()); agreement->setBlockAckTimeoutValue(addbaResp->getBlockAckTimeoutValue()); + agreement->setResponseAMsduSupported(addbaResp->getAMsduSupported()); agreement->calculateExpirationTime(); } @@ -157,13 +246,11 @@ void OriginatorBlockAckAgreementHandler::processTransmittedAddbaReq(const PtrgetReceiverAddress(), addbaReq->getTid()); if (agreement) agreement->setIsAddbaRequestSent(true); - else - throw cRuntimeError("Block Ack Agreement should have already been added"); } void OriginatorBlockAckAgreementHandler::processTransmittedDelba(const Ptr& delba) { - terminateAgreement(delba->getReceiverAddress(), delba->getTid()); + // HCF retires the agreement before it queues DELBA. ACK completes teardown. } void OriginatorBlockAckAgreementHandler::processReceivedDelba(const Ptr& delba, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy) diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h index 4a449d17da3..af0c99d0cb7 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h @@ -21,6 +21,8 @@ class INET_API OriginatorBlockAckAgreementHandler : public IOriginatorBlockAckAg { protected: std::map, OriginatorBlockAckAgreement *> blockAckAgreements; + std::map procedures; + std::map dialogTokens; protected: virtual const Ptr buildAddbaRequest(MacAddress receiverAddr, Tid tid, SequenceNumberCyclic startingSequenceNumber, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy); @@ -28,10 +30,22 @@ class INET_API OriginatorBlockAckAgreementHandler : public IOriginatorBlockAckAg virtual void updateAgreement(OriginatorBlockAckAgreement *agreement, const Ptr& addbaResp); virtual void terminateAgreement(MacAddress originatorAddr, Tid tid); virtual const Ptr buildDelba(MacAddress receiverAddr, Tid tid, int reasonCode); - virtual simtime_t computeEarliestExpirationTime(); virtual void scheduleInactivityTimer(IBlockAckAgreementHandlerCallback *callback); public: + virtual simtime_t computeEarliestExpirationTime() override; + const std::map& getAgreements() const override { return blockAckAgreements; } + const std::map& getProcedures() const override { return procedures; } + virtual void noteEligibleDataTransmission(MacAddress peer, Tid tid) override; + virtual void beginSetupIntent(MacAddress peer, Tid tid) override; + virtual void beginTeardown(MacAddress peer, Tid tid) override; + virtual void failTeardown(MacAddress peer, Tid tid) override; + virtual void finishProcedure(MacAddress peer, Tid tid) override; + virtual void markRequestAttempted(MacAddress peer, Tid tid) override; + virtual void acknowledgeRequest(MacAddress peer, Tid tid, simtime_t timeout) override; + OriginatorBlockAckAgreement *detachAgreement(MacAddress peer, Tid tid) override; + std::vector detachPeer(MacAddress peer) override; + void startSetup(MacAddress peer, Tid tid, SequenceNumberCyclic sequence, IOriginatorBlockAckAgreementPolicy *policy, IProcedureCallback *callback, bool aMsdu) override; virtual ~OriginatorBlockAckAgreementHandler(); virtual void processTransmittedAddbaReq(const Ptr& addbaReq) override; virtual void processTransmittedDataFrame(Packet *packet, const Ptr& dataHeader, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) override; diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc index 44b4c0874fa..835216df923 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc @@ -9,6 +9,7 @@ #include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" #include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h" namespace inet { namespace ieee80211 { @@ -24,15 +25,23 @@ void OriginatorBlockAckAgreementPolicy::initialize(int stage) aMsduSupported = par("aMsduSupported"); maximumAllowedBufferSize = par("maximumAllowedBufferSize"); blockAckTimeoutValue = par("blockAckTimeoutValue"); - // TODO addbaFailureTimeout = par("addbaFailureTimeout"); + addbaFailureTimeout = par("addbaFailureTimeout"); + if (addbaFailureTimeout <= SIMTIME_ZERO || addbaFailureTimeout == SIMTIME_MAX) + throw cRuntimeError("addbaFailureTimeout must be positive and finite"); + if (maximumAllowedBufferSize <= 0 || blockAckTimeoutValue < SIMTIME_ZERO) + throw cRuntimeError("Invalid Block Ack buffer size or inactivity timeout"); WATCH(blockAckReqThreshold); } } simtime_t OriginatorBlockAckAgreementPolicy::computeAddbaFailureTimeout() const { - // TODO ADDBAFailureTimeout -- 6.3.29.2.2 Semantics of the service primitive - throw cRuntimeError("Unimplemented"); + return addbaFailureTimeout; +} + +bool OriginatorBlockAckAgreementPolicy::isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const +{ + return variant == BlockAckVariant::BASIC || (localHt && peerHt); } bool OriginatorBlockAckAgreementPolicy::isAddbaReqNeeded(Packet *packet, const Ptr& header) @@ -42,8 +51,16 @@ bool OriginatorBlockAckAgreementPolicy::isAddbaReqNeeded(Packet *packet, const P bool OriginatorBlockAckAgreementPolicy::isAddbaReqAccepted(const Ptr& addbaResp, OriginatorBlockAckAgreement *agreement) { - ASSERT(agreement); - return true; + // IEEE Std 802.11-2024, 10.25.2 and Table 9-466: match the pending setup and its nonzero dialog token. + // Immediate Block Ack and the 64-entry bound are INET profile limits for historical Basic compatibility. + return agreement != nullptr && !agreement->getIsAddbaResponseReceived() && + addbaResp->getTransmitterAddress() == agreement->getReceiverAddr() && + addbaResp->getTid() == agreement->getTid() && + addbaResp->getDialogToken() > 0 && addbaResp->getDialogToken() <= 255 && + addbaResp->getDialogToken() == agreement->getDialogToken() && + addbaResp->getStatusCode() == SC_SUCCESSFUL && addbaResp->getBlockAckPolicy() && + addbaResp->getBufferSize() > 0 && addbaResp->getBufferSize() <= 64 && + addbaResp->getBlockAckTimeoutValue() >= SIMTIME_ZERO; } bool OriginatorBlockAckAgreementPolicy::isDelbaAccepted(const Ptr& delba) diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.h b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.h index b762cc29828..b0b7e9cce24 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.h @@ -32,6 +32,7 @@ class INET_API OriginatorBlockAckAgreementPolicy : public ModeSetListener, publi virtual void initialize(int stage) override; public: + virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const override; virtual bool isAddbaReqNeeded(Packet *packet, const Ptr& header) override; virtual bool isAddbaReqAccepted(const Ptr& addbaResp, OriginatorBlockAckAgreement *agreement) override; virtual bool isDelbaAccepted(const Ptr& delba) override; diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.ned b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.ned index bbb569b4b20..ab9970f883f 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.ned +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.ned @@ -21,8 +21,9 @@ simple OriginatorBlockAckAgreementPolicy extends SimpleModule like IOriginatorBl bool delayedAckPolicySupported = default(false); bool aMsduSupported = default(true); - int maximumAllowedBufferSize = default(64); - double blockAckTimeoutValue @unit(s) = default(0s); // 0 means that it depends on the originator + int maximumAllowedBufferSize = default(64); // The ADDBA Request uses this advisory buffer size; the recipient response determines the accepted allocation. + double blockAckTimeoutValue @unit(s) = default(0s); // Zero disables inactivity expiration. + double addbaFailureTimeout @unit(s) = default(100ms); // Response wait after request ACK. @display("i=block/control"); } diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h index 40a4186fead..6e9634cae6f 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h @@ -23,6 +23,8 @@ class INET_API RecipientBlockAckAgreement : public cObject simtime_t blockAckTimeoutValue = 0; bool isAddbaResponseSent = false; simtime_t expirationTime = -1; + SequenceNumberCyclic highestReceivedSequence; + int highestReceivedFragment = 0; public: RecipientBlockAckAgreement(MacAddress originatorAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber, int bufferSize, simtime_t blockAckTimeoutValue); @@ -33,6 +35,17 @@ class INET_API RecipientBlockAckAgreement : public cObject virtual BlockAckRecord *getBlockAckRecord() const { return blockAckRecord; } virtual simtime_t getBlockAckTimeoutValue() const { return blockAckTimeoutValue; } virtual int getBufferSize() const { return bufferSize; } + void recordReceived(const Ptr& header) { + auto sequence = header->getSequenceNumber(); + if (!highestReceivedSequence.isSpecified() || highestReceivedSequence < sequence) { + highestReceivedSequence = sequence; + highestReceivedFragment = header->getFragmentNumber(); + } + else if (highestReceivedSequence == sequence) + highestReceivedFragment = std::max(highestReceivedFragment, int(header->getFragmentNumber())); + } + const SequenceNumberCyclic& getHighestReceivedSequence() const { return highestReceivedSequence; } + int getHighestReceivedFragment() const { return highestReceivedFragment; } virtual SequenceNumberCyclic getStartingSequenceNumber() const { return startingSequenceNumber; } virtual void addbaResposneSent() { isAddbaResponseSent = true; } diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc index 6219ac77140..717368a5a46 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc @@ -8,6 +8,7 @@ #include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h" namespace inet { namespace ieee80211 { @@ -24,9 +25,7 @@ simtime_t RecipientBlockAckAgreementHandler::computeEarliestExpirationTime() void RecipientBlockAckAgreementHandler::scheduleInactivityTimer(IBlockAckAgreementHandlerCallback *callback) { - simtime_t earliestExpirationTime = computeEarliestExpirationTime(); - if (earliestExpirationTime != SIMTIME_MAX) - callback->scheduleInactivityTimer(earliestExpirationTime); + callback->scheduleInactivityTimer(); } // The inactivity timer at a recipient is reset when MPDUs corresponding to the TID for which the Block Ack @@ -35,12 +34,15 @@ void RecipientBlockAckAgreementHandler::scheduleInactivityTimer(IBlockAckAgreeme // void RecipientBlockAckAgreementHandler::qosFrameReceived(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) { + // IEEE Std 802.11-2024, 11.5.4: matching Block Ack-policy DATA refreshes inactivity, including a duplicate. if (qosHeader->getAckPolicy() == AckPolicy::BLOCK_ACK) { // TODO + Implicit Block Ack Tid tid = qosHeader->getTid(); MacAddress originatorAddr = qosHeader->getTransmitterAddress(); auto agreement = getAgreement(tid, originatorAddr); - if (agreement) + if (agreement) { + agreement->calculateExpirationTime(); scheduleInactivityTimer(callback); + } } } @@ -51,15 +53,16 @@ void RecipientBlockAckAgreementHandler::blockAckAgreementExpired(IProcedureCallb // primitive with the ReasonCode parameter having a value of TIMEOUT. // The procedure is illustrated in Figure 10-14. simtime_t now = simTime(); + std::vector> expired; for (auto id : blockAckAgreements) { auto agreement = id.second; - if (agreement->getExpirationTime() == now) { - MacAddress receiverAddr = id.first.first; - Tid tid = id.first.second; - const auto& delba = buildDelba(receiverAddr, tid, 39); - auto delbaPacket = new Packet("Delba", delba); - procedureCallback->processMgmtFrame(delbaPacket, delba); // 39 - TIMEOUT see: Table 8-36—Reason codes - } + if (agreement->getExpirationTime() <= now) + expired.push_back(id.first); + } + for (const auto& id : expired) { + const auto& delba = buildDelba(id.first, id.second, 39); + auto delbaPacket = new Packet("Delba", delba); + procedureCallback->processMgmtFrame(delbaPacket, delba); } scheduleInactivityTimer(agreementHandlerCallback); } @@ -110,8 +113,10 @@ const Ptr RecipientBlockAckAgreementHandler::buildAddbaR Tid tid = addbaRequest->getTid(); addbaResponse->setTid(tid); addbaResponse->setBlockAckPolicy(!addbaRequest->getBlockAckPolicy() && blockAckAgreementPolicy->delayedBlockAckPolicySupported() ? false : true); - addbaResponse->setBufferSize(addbaRequest->getBufferSize() <= blockAckAgreementPolicy->getMaximumAllowedBufferSize() ? addbaRequest->getBufferSize() : blockAckAgreementPolicy->getMaximumAllowedBufferSize()); - addbaResponse->setBlockAckTimeoutValue(blockAckAgreementPolicy->getBlockAckTimeoutValue() == 0 ? blockAckAgreementPolicy->getBlockAckTimeoutValue() : addbaRequest->getBlockAckTimeoutValue()); + addbaResponse->setDialogToken(addbaRequest->getDialogToken()); + // IEEE Std 802.11-2024, 10.25.2: the request allocation and timeout are advisory. + addbaResponse->setBufferSize(std::min(64, blockAckAgreementPolicy->getMaximumAllowedBufferSize())); + addbaResponse->setBlockAckTimeoutValue(blockAckAgreementPolicy->getBlockAckTimeoutValue()); addbaResponse->setAMsduSupported(blockAckAgreementPolicy->aMsduSupported()); return addbaResponse; } @@ -124,8 +129,6 @@ void RecipientBlockAckAgreementHandler::updateAgreement(const Ptrsecond; agreement->addbaResposneSent(); } - else - throw cRuntimeError("Agreement is not found"); } void RecipientBlockAckAgreementHandler::terminateAgreement(MacAddress originatorAddr, Tid tid) @@ -155,26 +158,62 @@ void RecipientBlockAckAgreementHandler::processTransmittedAddbaResp(const Ptr& addbaRequest, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) { EV_INFO << "Processing Addba Request from " << addbaRequest->getTransmitterAddress() << endl; - if (blockAckAgreementPolicy->isAddbaReqAccepted(addbaRequest)) { + auto id = std::make_pair(addbaRequest->getTransmitterAddress(), addbaRequest->getTid()); + auto addbaResponse = buildAddbaResponse(addbaRequest, blockAckAgreementPolicy); + bool accepted = blockAckAgreementPolicy->isAddbaReqAccepted(addbaRequest) && + blockAckAgreements.count(id) == 0 && pendingTeardowns.count(id) == 0; + addbaResponse->setStatusCode(accepted ? SC_SUCCESSFUL : SC_UNSPECIFIED); + if (accepted) { EV_DETAIL << "Addba Request has been accepted. Creating a new Block Ack Agreement." << endl; - auto agreement = addAgreement(addbaRequest); + auto parameters = makeShared(*addbaRequest); + parameters->setBufferSize(addbaResponse->getBufferSize()); + parameters->setBlockAckTimeoutValue(addbaResponse->getBlockAckTimeoutValue()); + auto agreement = addAgreement(parameters); EV_DETAIL << "Agreement is added with the following parameters: " << *agreement << endl; EV_DETAIL << "Building Addba Response" << endl; - auto addbaResponse = buildAddbaResponse(addbaRequest, blockAckAgreementPolicy); - auto addbaResponsePacket = new Packet("AddbaResponse", addbaResponse); - callback->processMgmtFrame(addbaResponsePacket, addbaResponse); } + callback->processMgmtFrame(new Packet("AddbaResponse", addbaResponse), addbaResponse); +} + +RecipientBlockAckAgreement *RecipientBlockAckAgreementHandler::detachAgreement(MacAddress peer, Tid tid) +{ + auto it = blockAckAgreements.find({peer, tid}); + if (it == blockAckAgreements.end()) + return nullptr; + auto agreement = it->second; + blockAckAgreements.erase(it); + return agreement; +} + +std::vector RecipientBlockAckAgreementHandler::detachPeer(MacAddress peer) +{ + std::vector removed; + for (auto it = blockAckAgreements.begin(); it != blockAckAgreements.end();) { + if (it->first.first == peer) { + removed.push_back(it->second); + it = blockAckAgreements.erase(it); + } + else + ++it; + } + for (auto it = pendingTeardowns.begin(); it != pendingTeardowns.end();) { + if (it->first == peer) + it = pendingTeardowns.erase(it); + else + ++it; + } + return removed; } void RecipientBlockAckAgreementHandler::processTransmittedDelba(const Ptr& delba) { - terminateAgreement(delba->getReceiverAddress(), delba->getTid()); + // HCF retains teardown state until the Action reaches a terminal result. } void RecipientBlockAckAgreementHandler::processReceivedDelba(const Ptr& delba, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy) { if (blockAckAgreementPolicy->isDelbaAccepted(delba)) - terminateAgreement(delba->getReceiverAddress(), delba->getTid()); + terminateAgreement(delba->getTransmitterAddress(), delba->getTid()); } RecipientBlockAckAgreementHandler::~RecipientBlockAckAgreementHandler() diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h index 1e65a1557ef..ac93c8366e6 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h @@ -26,6 +26,7 @@ class INET_API RecipientBlockAckAgreementHandler : public IRecipientBlockAckAgre { protected: std::map, RecipientBlockAckAgreement *> blockAckAgreements; + std::set> pendingTeardowns; protected: virtual void terminateAgreement(MacAddress originatorAddr, Tid tid); @@ -33,10 +34,16 @@ class INET_API RecipientBlockAckAgreementHandler : public IRecipientBlockAckAgre virtual void updateAgreement(const Ptr& addbaResponse); virtual const Ptr buildAddbaResponse(const Ptr& addbaRequest, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy); virtual const Ptr buildDelba(MacAddress receiverAddr, Tid tid, int reasonCode); - virtual simtime_t computeEarliestExpirationTime(); virtual void scheduleInactivityTimer(IBlockAckAgreementHandlerCallback *callback); public: + virtual simtime_t computeEarliestExpirationTime() override; + const std::map, RecipientBlockAckAgreement *>& getAgreements() const override { return blockAckAgreements; } + bool isTeardownPending(MacAddress peer, Tid tid) const override { return pendingTeardowns.count({peer, tid}) != 0; } + void beginTeardown(MacAddress peer, Tid tid) override { pendingTeardowns.insert({peer, tid}); } + void finishTeardown(MacAddress peer, Tid tid) override { pendingTeardowns.erase({peer, tid}); } + RecipientBlockAckAgreement *detachAgreement(MacAddress peer, Tid tid) override; + std::vector detachPeer(MacAddress peer) override; virtual ~RecipientBlockAckAgreementHandler(); virtual void processTransmittedAddbaResp(const Ptr& addbaResp, IBlockAckAgreementHandlerCallback *callback) override; virtual void processReceivedAddbaRequest(const Ptr& addbaRequest, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) override; diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc index 73813feaa5d..f2bd97fa697 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc @@ -19,12 +19,27 @@ void RecipientBlockAckAgreementPolicy::initialize(int stage) isAMsduSupported = par("aMsduSupported"); maximumAllowedBufferSize = par("maximumAllowedBufferSize"); blockAckTimeoutValue = par("blockAckTimeoutValue"); + if (maximumAllowedBufferSize <= 0 || blockAckTimeoutValue < SIMTIME_ZERO) + throw cRuntimeError("Invalid Block Ack buffer size or inactivity timeout"); } } bool RecipientBlockAckAgreementPolicy::isAddbaReqAccepted(const Ptr& addbaReq) { - return true; + // IEEE Std 802.11-2024, 10.25.2 and Table 9-466: validate ordinary setup; the requested buffer size is advisory. + // INET supports immediate Block Ack for historical Basic compatibility and selects at most 64 entries in the response. + return !addbaReq->getTransmitterAddress().isUnspecified() && + !addbaReq->getTransmitterAddress().isMulticast() && + addbaReq->getTid() >= 0 && addbaReq->getTid() <= 15 && + addbaReq->getDialogToken() > 0 && addbaReq->getDialogToken() <= 255 && + addbaReq->getBlockAckPolicy() && addbaReq->getBufferSize() >= 0 && + addbaReq->getBufferSize() <= 1023 && addbaReq->getStartingSequenceNumber().isSpecified() && + addbaReq->getBlockAckTimeoutValue() >= SIMTIME_ZERO; +} + +bool RecipientBlockAckAgreementPolicy::isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const +{ + return variant == BlockAckVariant::BASIC || (localHt && peerHt); } bool RecipientBlockAckAgreementPolicy::isDelbaAccepted(const Ptr& delba) diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.h b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.h index 995fcc29fdb..d74bfd4240b 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.h @@ -28,6 +28,7 @@ class INET_API RecipientBlockAckAgreementPolicy : public SimpleModule, public IR virtual void initialize(int stage) override; public: + virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const override; virtual bool isAddbaReqAccepted(const Ptr& addbaReq) override; virtual bool isDelbaAccepted(const Ptr& delba) override; diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.ned b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.ned index 8c41285b009..6fb403594cf 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.ned +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.ned @@ -20,7 +20,7 @@ simple RecipientBlockAckAgreementPolicy extends SimpleModule like IRecipientBloc bool delayedAckPolicySupported = default(false); bool aMsduSupported = default(true); int maximumAllowedBufferSize = default(64); - double blockAckTimeoutValue @unit(s) = default(0s); // 0 means that it depends on the originator + double blockAckTimeoutValue @unit(s) = default(0s); // Zero disables inactivity expiration. @display("i=block/control"); } diff --git a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc index 6cffea3c37d..02a811e4732 100644 --- a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc +++ b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc @@ -12,6 +12,44 @@ namespace inet { namespace ieee80211 { +BlockAckReordering::ReleasedFrames BlockAckReordering::detachAgreement(MacAddress peer, Tid tid, + bool deliverComplete, std::vector& discarded) +{ + auto it = receiveBuffers.find({tid, peer}); + if (it == receiveBuffers.end()) + return {}; + auto buffer = it->second; + receiveBuffers.erase(it); + ReleasedFrames released; + auto start = buffer->getNextExpectedSequenceNumber(); + for (int i = 0; i < buffer->getBufferSize(); i++) { + auto sequence = start + i; + auto position = buffer->getBuffer().find(sequence.get()); + if (position == buffer->getBuffer().end()) + continue; + auto fragments = position->second; + if (deliverComplete && isComplete(fragments)) + released.push_back({sequence.get(), fragments}); + else + discarded.insert(discarded.end(), fragments.begin(), fragments.end()); + buffer->removeFrame(sequence); + } + delete buffer; + return released; +} + +void BlockAckReordering::clearPeer(MacAddress peer) +{ + for (auto it = receiveBuffers.begin(); it != receiveBuffers.end();) { + if (it->first.second == peer) { + delete it->second; + it = receiveBuffers.erase(it); + } + else + ++it; + } +} + BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader) { ReceiveBuffer *receiveBuffer = createReceiveBufferIfNecessary(agreement); diff --git a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h index 42215dd9b40..05a203ed44b 100644 --- a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h +++ b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h @@ -50,6 +50,8 @@ class INET_API BlockAckReordering public: virtual ~BlockAckReordering(); + ReleasedFrames detachAgreement(MacAddress peer, Tid tid, bool deliverComplete, std::vector& discarded); + void clearPeer(MacAddress peer); void processReceivedDelba(const Ptr& delba); ReleasedFrames processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader); diff --git a/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.cc b/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.cc index 5dc48059089..cb0e9d6549b 100644 --- a/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.cc +++ b/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.cc @@ -165,6 +165,11 @@ bool Edcaf::isInternalCollision() return collisionController->isInternalCollision(this); } +bool Edcaf::hasEligibleFrames() const +{ + return frameEligibility ? frameEligibility() : !pendingQueue->isEmpty() || inProgressFrames->getLength() != 0; +} + int Edcaf::getCwMax(AccessCategory ac, int aCwMax, int aCwMin) { switch (ac) { diff --git a/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h b/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h index c2d716ade33..b9a77e9c051 100644 --- a/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h +++ b/src/inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h @@ -49,6 +49,7 @@ class INET_API Edcaf : public IChannelAccess, public IContention::ICallback, pub InProgressFrames *inProgressFrames = nullptr; bool owning = false; + std::function frameEligibility; simtime_t slotTime = -1; simtime_t sifs = -1; @@ -102,6 +103,8 @@ class INET_API Edcaf : public IChannelAccess, public IContention::ICallback, pub // Edcaf virtual bool isOwning() { return owning; } virtual bool isInternalCollision(); + void setFrameEligibility(std::function predicate) { frameEligibility = predicate; } + bool hasEligibleFrames() const; virtual AccessCategory getAccessCategory() { return ac; } }; diff --git a/src/inet/linklayer/ieee80211/mac/contention/EdcaCollisionController.cc b/src/inet/linklayer/ieee80211/mac/contention/EdcaCollisionController.cc index 33b94c93563..4b3172e039f 100644 --- a/src/inet/linklayer/ieee80211/mac/contention/EdcaCollisionController.cc +++ b/src/inet/linklayer/ieee80211/mac/contention/EdcaCollisionController.cc @@ -36,9 +36,9 @@ bool EdcaCollisionController::isInternalCollision(Edcaf *edcaf) simtime_t now = simTime(); AccessCategory accessCategory = edcaf->getAccessCategory(); auto hasFrames = [](const Edcaf *candidate) { - return !candidate->getPendingQueue()->isEmpty() || candidate->getInProgressFrames()->getLength() != 0; + return candidate->hasEligibleFrames(); }; - // An expired empty queue cannot initiate a TXOP or cause an internal collision. + // Deferred or expired DATA cannot initiate a TXOP or cause an internal collision. // Keep the winner's in-progress frame visible until its transmission completes. if (txStartTimes[accessCategory] == now && hasFrames(edcaf)) { for (int ac = accessCategory + 1; ac < 4; ac++) { diff --git a/src/inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h b/src/inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h new file mode 100644 index 00000000000..f02e1033036 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_BLOCKACKVARIANT_H +#define __INET_BLOCKACKVARIANT_H + +namespace inet { +namespace ieee80211 { + +enum class BlockAckVariant { BASIC, COMPRESSED }; + +} // namespace ieee80211 +} // namespace inet + +#endif diff --git a/src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h b/src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h index cc4a7b86b92..3fefe1666c0 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h @@ -18,7 +18,8 @@ class INET_API IBlockAckAgreementHandlerCallback public: virtual ~IBlockAckAgreementHandlerCallback() {} - virtual void scheduleInactivityTimer(simtime_t timeout) = 0; + // The coordinator recomputes the earliest absolute deadline across both agreement roles. + virtual void scheduleInactivityTimer() = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h b/src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h new file mode 100644 index 00000000000..46e49e22386 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_IBLOCKACKAGREEMENTLIFECYCLE_H +#define __INET_IBLOCKACKAGREEMENTLIFECYCLE_H + +#include "inet/linklayer/common/MacAddress.h" + +namespace inet { +namespace ieee80211 { + +// Management supplies the old peer identity before association replacement or loss. +class INET_API IBlockAckAgreementLifecycle +{ + public: + virtual ~IBlockAckAgreementLifecycle() {} + virtual void resetPeerAgreements(const MacAddress& peer) = 0; +}; + +} // namespace ieee80211 +} // namespace inet + +#endif diff --git a/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h b/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h index ee9d4d37465..0f61eaa9891 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h @@ -48,6 +48,8 @@ class INET_API IFrameSequenceHandler virtual void transmissionComplete() = 0; virtual bool isSequenceRunning() = 0; virtual void handleStartRxTimeout() = 0; + // The caller can suppress failure feedback for an exchange that its procedure already resolved. + virtual void interruptFrameSequence(bool notifyFailure) = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h index 4a01e89b6c3..7161304e0ad 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h @@ -22,7 +22,27 @@ namespace ieee80211 { class INET_API IOriginatorBlockAckAgreementHandler { public: + typedef std::pair AgreementId; + enum class ProcedureState { SETUP_INTENT, REQUEST_PENDING, TEARDOWN_PENDING, RECOVERY_NEEDED, WAITING_FOR_SUCCESSOR }; + struct Procedure { + ProcedureState state = ProcedureState::SETUP_INTENT; + bool requestAttempted = false; + simtime_t responseDeadline = SIMTIME_MAX; + }; virtual ~IOriginatorBlockAckAgreementHandler() {} + virtual const std::map& getAgreements() const = 0; + virtual const std::map& getProcedures() const = 0; + virtual simtime_t computeEarliestExpirationTime() = 0; + virtual OriginatorBlockAckAgreement *detachAgreement(MacAddress peer, Tid tid) = 0; + virtual std::vector detachPeer(MacAddress peer) = 0; + virtual void noteEligibleDataTransmission(MacAddress peer, Tid tid) = 0; + virtual void beginSetupIntent(MacAddress peer, Tid tid) = 0; + virtual void beginTeardown(MacAddress peer, Tid tid) = 0; + virtual void failTeardown(MacAddress peer, Tid tid) = 0; + virtual void finishProcedure(MacAddress peer, Tid tid) = 0; + virtual void markRequestAttempted(MacAddress peer, Tid tid) = 0; + virtual void acknowledgeRequest(MacAddress peer, Tid tid, simtime_t timeout) = 0; + virtual void startSetup(MacAddress peer, Tid tid, SequenceNumberCyclic sequence, IOriginatorBlockAckAgreementPolicy *policy, IProcedureCallback *callback, bool aMsdu) = 0; virtual void processReceivedBlockAck(const Ptr& blockAck, IBlockAckAgreementHandlerCallback *callback) = 0; virtual void processTransmittedAddbaReq(const Ptr& addbaReq) = 0; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h index 40ea82aa95e..c6e1ddd9638 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h @@ -9,6 +9,7 @@ #define __INET_IORIGINATORBLOCKACKAGREEMENTPOLICY_H #include "inet/common/packet/Packet.h" +#include "inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h" #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" namespace inet { @@ -21,6 +22,8 @@ class INET_API IOriginatorBlockAckAgreementPolicy public: virtual ~IOriginatorBlockAckAgreementPolicy() {} + virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const = 0; + virtual bool isAddbaReqNeeded(Packet *packet, const Ptr& header) = 0; virtual bool isAddbaReqAccepted(const Ptr& addbaResp, OriginatorBlockAckAgreement *agreement) = 0; virtual bool isDelbaAccepted(const Ptr& delba) = 0; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h index 357745c3ddb..5c4beb3fe04 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h @@ -23,6 +23,13 @@ class INET_API IRecipientBlockAckAgreementHandler { public: virtual ~IRecipientBlockAckAgreementHandler() {} + virtual simtime_t computeEarliestExpirationTime() = 0; + virtual const std::map, RecipientBlockAckAgreement *>& getAgreements() const = 0; + virtual RecipientBlockAckAgreement *detachAgreement(MacAddress peer, Tid tid) = 0; + virtual std::vector detachPeer(MacAddress peer) = 0; + virtual bool isTeardownPending(MacAddress peer, Tid tid) const = 0; + virtual void beginTeardown(MacAddress peer, Tid tid) = 0; + virtual void finishTeardown(MacAddress peer, Tid tid) = 0; virtual void processTransmittedAddbaResp(const Ptr& addbaResp, IBlockAckAgreementHandlerCallback *callback) = 0; virtual void processReceivedAddbaRequest(const Ptr& addbaRequest, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) = 0; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h index 48009a67161..2f429ef7169 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h @@ -9,6 +9,7 @@ #define __INET_IRECIPIENTBLOCKACKAGREEMENTPOLICY_H #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h" namespace inet { namespace ieee80211 { @@ -18,6 +19,8 @@ class INET_API IRecipientBlockAckAgreementPolicy public: virtual ~IRecipientBlockAckAgreementPolicy() {} + virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const = 0; + virtual bool isAddbaReqAccepted(const Ptr& addbaReq) = 0; virtual bool isDelbaAccepted(const Ptr& delba) = 0; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h index 8a3ff4c0b7c..7e97329e94d 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h @@ -23,6 +23,8 @@ class INET_API IRecipientQosMacDataService public: virtual ~IRecipientQosMacDataService() {} + virtual std::vector retireAgreement(RecipientBlockAckAgreement *agreement, bool associationReset) = 0; + virtual void clearPeer(MacAddress peer) = 0; virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) = 0; virtual std::vector controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) = 0; diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index a05c4f1d269..7deeca7ef0f 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -10,6 +10,7 @@ #include "inet/common/ModuleAccess.h" #include "inet/common/Simsignals.h" #include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" #include "inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h" #include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h" @@ -19,6 +20,9 @@ #include "inet/linklayer/ieee80211/mac/rateselection/RateSelection.h" #include "inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h" #include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/queueing/contract/ISelectivePacketCollection.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" namespace inet { @@ -46,9 +50,11 @@ void Hcf::initialize(int stage) if (blockAckVariant == BlockAckVariant::COMPRESSED) throw cRuntimeError("Compressed Block Ack exchanges are not implemented"); mac = check_and_cast(getContainingNicModule(this)->getSubmodule("mac")); + mib = check_and_cast(mac->getModuleByPath(mac->par("mibModule"))); startRxTimer = new cMessage("startRxTimeout"); inactivityTimer = new cMessage("blockAckInactivityTimer"); dataLifetimeTimer = new cMessage("dataLifetimeTimer"); + addbaResponseTimer = new cMessage("addbaResponseTimer"); edca = check_and_cast(getSubmodule("edca")); hcca = check_and_cast(getSubmodule("hcca")); tx = check_and_cast(getModuleByPath(par("txModule"))); @@ -83,10 +89,17 @@ void Hcf::initialize(int stage) lifetimeHandler->setDeadlineChangedCallback([this]() { scheduleDataLifetimeTimer(); }); check_and_cast(originatorDataService)->setLifetimeHandler( lifetimeHandler, [this]() { expireDataFrames(); }); + check_and_cast(originatorDataService)->setEligibility( + [this](Packet *packet) { return isFrameEligible(packet, false); }, + [this](Packet *packet) { return isAMsduPermitted(packet); }); + mib->subscribe(Ieee80211Mib::rateStateChangedSignal, this); for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + edca->getEdcaf(static_cast(ac))->setFrameEligibility( + [this, ac]() { return hasEligibleFrameToTransmit(static_cast(ac)); }); check_and_cast(edca->getEdcaf(static_cast(ac))->getPendingQueue())->subscribe(packetDroppedSignal, this); auto frames = edca->getEdcaf(static_cast(ac))->getInProgressFrames(); frames->setLifetimeHandler(lifetimeHandler); + frames->setTransmissionEligibility([this](Packet *packet) { return isFrameEligible(packet, true); }); frames->subscribe(InProgressFrames::packetDequeuedSignal, this); } } @@ -179,6 +192,8 @@ void Hcf::expireDataFrames(bool preserveSequence) PacketDropDetails details; details.setReason(LIFETIME_EXPIRED); emit(packetDroppedSignal, packet, &details); + if (inProgress) + firstDataDiscarded(header); if (!inProgress) delete packet; } @@ -200,8 +215,22 @@ void Hcf::forEachChild(cVisitor *v) void Hcf::handleMessage(cMessage *msg) { - if (msg == dataLifetimeTimer) + if (msg == addbaResponseTimer) { + std::vector> expired; + for (const auto& entry : originatorBlockAckAgreementHandler->getProcedures()) { + if (entry.second.responseDeadline <= simTime()) + expired.push_back(entry.first); + } + for (const auto& id : expired) + beginTeardown(id.first, id.second, true, 39); + scheduleAddbaResponseTimer(); + updateContention(); + } + else if (msg == dataLifetimeTimer) { expireDataFrames(); + updateAgreementProcedures(); + updateContention(); + } else if (msg == startRxTimer) { if (!isReceptionInProgress()) { frameSequenceHandler->handleStartRxTimeout(); @@ -209,8 +238,19 @@ void Hcf::handleMessage(cMessage *msg) } else if (msg == inactivityTimer) { if (originatorBlockAckAgreementHandler && recipientBlockAckAgreementHandler) { - originatorBlockAckAgreementHandler->blockAckAgreementExpired(this, this); - recipientBlockAckAgreementHandler->blockAckAgreementExpired(this, this); + std::vector> expired; + for (const auto& entry : originatorBlockAckAgreementHandler->getAgreements()) { + if (entry.second->getIsAddbaResponseReceived() && entry.second->getExpirationTime() <= simTime()) + expired.push_back({entry.first.first, entry.first.second, true}); + } + for (const auto& entry : recipientBlockAckAgreementHandler->getAgreements()) { + if (entry.second->getExpirationTime() <= simTime()) + expired.push_back({entry.first.first, entry.first.second, false}); + } + for (const auto& entry : expired) + beginTeardown(std::get<0>(entry), std::get<1>(entry), std::get<2>(entry), 39); + scheduleInactivityTimer(); + updateContention(); } else throw cRuntimeError("Unknown event"); @@ -255,7 +295,8 @@ void Hcf::processUpperFrame(Packet *packet, const PtrgetType() == ST_DATA_WITH_QOS) edca->getLifetimeHandler()->registerFrame(packet, ac); pendingQueue->enqueuePacket(packet); - if (!pendingQueue->isEmpty()) { + updateAgreementProcedures(); + if (!pendingQueue->isEmpty() && !handlingAgreementAction && hasFrameToTransmit(ac)) { auto edcaf = edca->getChannelOwner(); if (edcaf == nullptr || edcaf->getAccessCategory() != ac) { EV_DETAIL << "Requesting channel for access category " << printAccessCategory(ac) << endl; @@ -274,6 +315,7 @@ void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, Enter_Method("%s", cComponent::getSignalName(signalID)); auto packet = check_and_cast(obj); edca->getLifetimeHandler()->forgetFrame(packet->getId()); + actionTerminated(packet, false); if (packet->findTag() != nullptr) { FrameTransmissionDetails transmissionDetails; transmissionDetails.setStatus(FRAME_TRANSMISSION_STATUS_DROPPED_BEFORE_TRANSMISSION); @@ -290,10 +332,463 @@ void Hcf::scheduleStartRxTimer(simtime_t timeout) scheduleAfter(timeout, startRxTimer); } -void Hcf::scheduleInactivityTimer(simtime_t timeout) +void Hcf::scheduleInactivityTimer() { Enter_Method("scheduleInactivityTimer"); - rescheduleAfter(timeout, inactivityTimer); + // IEEE Std 802.11-2024, 11.5.4 requires inactivity expiration. HCF reads each role's absolute deadline. + simtime_t deadline = SIMTIME_MAX; + if (originatorBlockAckAgreementHandler && recipientBlockAckAgreementHandler) + deadline = std::min(originatorBlockAckAgreementHandler->computeEarliestExpirationTime(), + recipientBlockAckAgreementHandler->computeEarliestExpirationTime()); + cancelEvent(inactivityTimer); + if (deadline != SIMTIME_MAX) + scheduleAt(std::max(simTime(), deadline), inactivityTimer); +} + +void Hcf::scheduleAddbaResponseTimer() +{ + simtime_t deadline = SIMTIME_MAX; + if (originatorBlockAckAgreementHandler) { + for (const auto& entry : originatorBlockAckAgreementHandler->getProcedures()) + deadline = std::min(deadline, entry.second.responseDeadline); + } + cancelEvent(addbaResponseTimer); + if (deadline != SIMTIME_MAX) + scheduleAt(std::max(simTime(), deadline), addbaResponseTimer); +} + +bool Hcf::isProfileAllowed(MacAddress peer, bool originator) const +{ + auto state = mib->findPeerHtState(peer); + bool peerHt = state && state->valid && (originator ? state->negotiatedCapabilities.localTxPeerRx.valid : + state->negotiatedCapabilities.localRxPeerTx.valid); + return originator ? originatorBlockAckAgreementPolicy->isProfileAllowed(blockAckVariant, mib->isHtOperationSupported(), peerHt) : + recipientBlockAckAgreementPolicy->isProfileAllowed(blockAckVariant, mib->isHtOperationSupported(), peerHt); +} + +bool Hcf::hasObsoleteActionInFlight(MacAddress peer, Tid tid, bool originator) const +{ + if (finishingSequence || !frameSequenceHandler->isSequenceRunning()) + return false; + auto context = frameSequenceHandler->getContext(); + for (int i = 0; i < context->getNumSteps(); i++) { + auto step = dynamic_cast(context->getStep(i)); + if (!step) + continue; + auto packet = step->getFrameToTransmit(); + if (!obsoleteActions.count(packet->getId())) + continue; + auto header = packet->peekAtFront(); + if (header->getReceiverAddress() != peer) + continue; + if (auto request = dynamicPtrCast(header)) { + if (originator && request->getTid() == tid) + return true; + } + else if (auto response = dynamicPtrCast(header)) { + if (!originator && response->getTid() == tid) + return true; + } + else if (auto delba = dynamicPtrCast(header)) { + if (delba->getInitiator() == originator && delba->getTid() == tid) + return true; + } + } + return false; +} + +bool Hcf::isFrameEligible(Packet *packet, bool numbered) const +{ + if (obsoleteActions.count(packet->getId())) + return false; + auto data = dynamicPtrCast(packet->peekAtFront()); + if (!data || data->getType() != ST_DATA_WITH_QOS || !originatorBlockAckAgreementHandler) + return true; + auto peer = data->getReceiverAddress(); + auto tid = data->getTid(); + if (hasObsoleteActionInFlight(peer, tid, true)) + return false; + const auto& procedures = originatorBlockAckAgreementHandler->getProcedures(); + auto it = procedures.find({peer, tid}); + if (it == procedures.end()) + return true; + if (it->second.state == IOriginatorBlockAckAgreementHandler::ProcedureState::WAITING_FOR_SUCCESSOR) + return true; + return numbered && it->second.state == IOriginatorBlockAckAgreementHandler::ProcedureState::SETUP_INTENT; +} + +bool Hcf::isAMsduPermitted(Packet *packet) const +{ + auto data = dynamicPtrCast(packet->peekAtFront()); + if (!data || !originatorBlockAckAgreementHandler) + return true; + auto agreement = originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()); + return !agreement || !agreement->getIsAddbaResponseReceived() || agreement->isAMsduPermitted(); +} + +bool Hcf::hasQueuedData(MacAddress peer, Tid tid) const +{ + auto matches = [this, peer, tid](Packet *packet) { + auto data = dynamicPtrCast(packet->peekAtFront()); + return data && data->getType() == ST_DATA_WITH_QOS && data->getReceiverAddress() == peer && data->getTid() == tid && + !edca->getLifetimeHandler()->isExpired(packet); + }; + for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + auto queue = edca->getEdcaf(static_cast(ac))->getPendingQueue(); + if (auto selected = dynamic_cast(queue)) { + try { + if (selected->peekEligiblePacket(matches)) + return true; + continue; + } + catch (const queueing::UnsupportedPacketSelection&) { + // Existence checks also support queues without optional selected extraction. + } + } + for (int i = 0; i < queue->getNumPackets(); i++) { + if (matches(queue->getPacket(i))) + return true; + } + } + return false; +} + +bool Hcf::hasNumberedData(MacAddress peer, Tid tid) const +{ + for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + auto frames = edca->getEdcaf(static_cast(ac))->getInProgressFrames(); + for (int i = 0; i < frames->getLength(); i++) { + auto data = dynamicPtrCast(frames->getFrames(i)->peekAtFront()); + if (data && data->getReceiverAddress() == peer && data->getTid() == tid) + return true; + } + } + return false; +} + +void Hcf::updateAgreementProcedures() +{ + if (!originatorBlockAckAgreementHandler || updatingProcedures) + return; + updatingProcedures = true; + auto procedures = originatorBlockAckAgreementHandler->getProcedures(); + for (const auto& entry : procedures) { + auto peer = entry.first.first; + auto tid = entry.first.second; + auto state = entry.second.state; + using State = IOriginatorBlockAckAgreementHandler::ProcedureState; + bool queued = hasQueuedData(peer, tid); + // INET setup policy waits for a successor after the first eligible DATA transmission. + if (state == State::WAITING_FOR_SUCCESSOR) { + if (!queued) + continue; + originatorBlockAckAgreementHandler->beginSetupIntent(peer, tid); + state = State::SETUP_INTENT; + } + if (state == State::SETUP_INTENT) { + if (!queued) + originatorBlockAckAgreementHandler->finishProcedure(peer, tid); + else if (!hasNumberedData(peer, tid) && !hasObsoleteActionInFlight(peer, tid, true)) { + auto service = check_and_cast(originatorDataService); + originatorBlockAckAgreementHandler->startSetup(peer, tid, service->getNextSequenceNumber(peer, tid), + originatorBlockAckAgreementPolicy, this, service->hasAMsduAggregation()); + } + } + else if (state == State::REQUEST_PENDING && !queued) { + if (entry.second.requestAttempted) + beginTeardown(peer, tid, true, 37); + else { + originatorBlockAckAgreementHandler->finishProcedure(peer, tid); + retireAgreement(peer, tid, true); + } + } + else if (state == State::RECOVERY_NEEDED && queued) + beginTeardown(peer, tid, true, 37); + } + updatingProcedures = false; + scheduleAddbaResponseTimer(); +} + +void Hcf::updateContention() +{ + if (handlingAgreementAction) + return; + for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + auto edcaf = edca->getEdcaf(static_cast(ac)); + if (edcaf->isOwning()) + continue; + if (hasFrameToTransmit(static_cast(ac))) + edcaf->requestChannel(this); + } +} + +void Hcf::discardAgreementData(MacAddress peer, Tid tid, bool all, int64_t highestTransmittedDataIndex) +{ + for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + auto edcaf = edca->getEdcaf(static_cast(ac)); + auto frames = edcaf->getInProgressFrames(); + std::vector discard; + for (int i = 0; i < frames->getLength(); i++) { + auto packet = frames->getFrames(i); + auto data = dynamicPtrCast(packet->peekAtFront()); + bool transmitted = data && edcaf->getAckHandler()->getQoSDataAckStatus(data) != QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED; + if (data && frameSequenceHandler->isSequenceRunning()) { + auto context = frameSequenceHandler->getContext(); + for (int j = 0; j < context->getNumSteps(); j++) { + if (auto step = dynamic_cast(context->getStep(j))) + transmitted |= step->getFrameToTransmit() == packet; + } + } + // IEEE Std 802.11-2024, 11.5.3.4: the next MPDU must follow the highest transmitted sequence. + // Include unsent fragments even if ACK processing already removed an earlier fragment. + // Local allocation indices preserve order across gaps and wire sequence wraparound. + if (data && data->getReceiverAddress() == peer && data->getTid() == tid && + (all || transmitted || (highestTransmittedDataIndex >= 0 && + packet->getTag()->getAllocationIndex() <= highestTransmittedDataIndex))) + discard.push_back(packet); + } + for (auto packet : discard) { + auto data = packet->peekAtFront(); + edcaf->getAckHandler()->dropFrame(data); + edcaf->getRecoveryProcedure()->dropFrame(data); + frames->dropFrame(packet); + PacketDropDetails details; + details.setReason(OTHER_PACKET_DROP); + emit(packetDroppedSignal, packet, &details); + } + if (all) { + auto queue = edcaf->getPendingQueue(); + discard.clear(); + for (int i = 0; i < queue->getNumPackets(); i++) { + auto packet = queue->getPacket(i); + auto data = dynamicPtrCast(packet->peekAtFront()); + if (data && data->getReceiverAddress() == peer && data->getTid() == tid) + discard.push_back(packet); + } + for (auto packet : discard) { + queue->removePacket(packet); + take(packet); + edca->getLifetimeHandler()->forgetFrame(packet->getId()); + PacketDropDetails details; + details.setReason(OTHER_PACKET_DROP); + emit(packetDroppedSignal, packet, &details); + delete packet; + } + } + if (!frameSequenceHandler->isSequenceRunning() || frameSequenceHandler->getContext()->getInProgressFrames() != frames) + frames->clearDroppedFrames(); + } +} + +void Hcf::firstDataDiscarded(const Ptr& header) +{ + if (!originatorBlockAckAgreementHandler) + return; + auto agreement = originatorBlockAckAgreementHandler->getAgreement(header->getReceiverAddress(), header->getTid()); + if (agreement && agreement->getIsAddbaResponseReceived() && !agreement->getFirstDataTransmitted() && + agreement->getStartingSequenceNumber() == header->getSequenceNumber()) + beginTeardown(header->getReceiverAddress(), header->getTid(), true, 37); +} + +void Hcf::invalidateActions(MacAddress peer, Tid tid, bool originator) +{ + std::set invalid; + std::set attempted; + std::set rtsRecoveryOwned; + for (auto it = ownedActions.begin(); it != ownedActions.end();) { + if (it->second.peer == peer && it->second.tid == tid && it->second.originator == originator) { + invalid.insert(it->first); + if (it->second.attempted) + attempted.insert(it->first); + if (it->second.rtsRecoveryOwned) + rtsRecoveryOwned.insert(it->first); + obsoleteActions.insert(it->first); + it = ownedActions.erase(it); + } + else + ++it; + } + for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + auto edcaf = edca->getEdcaf(static_cast(ac)); + auto queue = edcaf->getPendingQueue(); + std::vector removed; + for (int i = 0; i < queue->getNumPackets(); i++) { + if (invalid.count(queue->getPacket(i)->getId())) + removed.push_back(queue->getPacket(i)); + } + for (auto packet : removed) { + queue->removePacket(packet); + take(packet); + obsoleteActions.erase(packet->getId()); + delete packet; + } + auto frames = edcaf->getInProgressFrames(); + removed.clear(); + for (int i = 0; i < frames->getLength(); i++) { + if (invalid.count(frames->getFrames(i)->getId())) + removed.push_back(frames->getFrames(i)); + } + for (auto packet : removed) { + auto header = packet->peekAtFront(); + edcaf->getAckHandler()->dropFrame(header); + if (attempted.count(packet->getId())) + edcaf->getMgmtAndNonQoSRecoveryProcedure()->dropFrame(packet, header); + if (rtsRecoveryOwned.count(packet->getId())) + edcaf->getMgmtAndNonQoSRecoveryProcedure()->dropRtsProtectedFrame(header); + frames->dropFrame(packet); + if (!frameSequenceHandler->isSequenceRunning() || frameSequenceHandler->getContext()->getInProgressFrames() != frames) + obsoleteActions.erase(packet->getId()); + } + if (!frameSequenceHandler->isSequenceRunning() || frameSequenceHandler->getContext()->getInProgressFrames() != frames) + frames->clearDroppedFrames(); + } +} + +void Hcf::retireAgreement(MacAddress peer, Tid tid, bool originator, bool associationReset) +{ + if (originator) { + auto agreement = originatorBlockAckAgreementHandler->detachAgreement(peer, tid); + invalidateActions(peer, tid, originator); + discardAgreementData(peer, tid, associationReset, agreement ? agreement->getHighestTransmittedDataIndex() : -1); + if (agreement) { + if (agreement->getIsAddbaResponseReceived()) + emit(blockAckAgreementDeletedSignal, agreement); + delete agreement; + } + } + else { + auto agreement = recipientBlockAckAgreementHandler->detachAgreement(peer, tid); + invalidateActions(peer, tid, originator); + if (agreement) { + sendUp(recipientDataService->retireAgreement(agreement, associationReset)); + emit(blockAckAgreementDeletedSignal, agreement); + delete agreement; + } + } + scheduleInactivityTimer(); +} + +void Hcf::beginTeardown(MacAddress peer, Tid tid, bool originator, int reasonCode) +{ + if (!originatorBlockAckAgreementHandler || !recipientBlockAckAgreementHandler) + return; + if (originator) { + const auto& procedures = originatorBlockAckAgreementHandler->getProcedures(); + auto it = procedures.find({peer, tid}); + if (it != procedures.end() && it->second.state == IOriginatorBlockAckAgreementHandler::ProcedureState::TEARDOWN_PENDING) + return; + originatorBlockAckAgreementHandler->beginTeardown(peer, tid); + } + else { + if (recipientBlockAckAgreementHandler->isTeardownPending(peer, tid)) + return; + recipientBlockAckAgreementHandler->beginTeardown(peer, tid); + } + retireAgreement(peer, tid, originator); + auto delba = makeShared(); + delba->setReceiverAddress(peer); + delba->setTid(tid); + delba->setInitiator(originator); + delba->setReasonCode(reasonCode); + processMgmtFrame(new Packet("Delba", delba), delba); + scheduleAddbaResponseTimer(); +} + +void Hcf::actionTerminated(Packet *packet, bool acknowledged) +{ + auto it = ownedActions.find(packet->getId()); + if (it == ownedActions.end()) + return; + auto action = it->second; + ownedActions.erase(it); + if (action.rtsRecoveryOwned) + edca->getEdcaf(AC_VO)->getMgmtAndNonQoSRecoveryProcedure()->dropRtsProtectedFrame(packet->peekAtFront()); + if (action.kind == OwnedAction::REQUEST) { + auto agreement = originatorBlockAckAgreementHandler->getAgreement(action.peer, action.tid); + if (!agreement || agreement->getIsAddbaResponseReceived()) + return; + if (acknowledged) + originatorBlockAckAgreementHandler->acknowledgeRequest(action.peer, action.tid, + originatorBlockAckAgreementPolicy->computeAddbaFailureTimeout()); + else if (action.attempted) + // INET recovery policy confirms peer teardown before another setup. + beginTeardown(action.peer, action.tid, true, 37); + else { + originatorBlockAckAgreementHandler->finishProcedure(action.peer, action.tid); + retireAgreement(action.peer, action.tid, true); + } + } + else if (action.kind == OwnedAction::DELBA) { + if (action.originator) { + if (acknowledged) + originatorBlockAckAgreementHandler->finishProcedure(action.peer, action.tid); + else { + // INET recovery policy discards this batch after failed DELBA delivery. + originatorBlockAckAgreementHandler->failTeardown(action.peer, action.tid); + discardAgreementData(action.peer, action.tid, true); + } + } + else + recipientBlockAckAgreementHandler->finishTeardown(action.peer, action.tid); + } + scheduleAddbaResponseTimer(); + if (action.kind == OwnedAction::DELBA || (action.kind == OwnedAction::REQUEST && !acknowledged)) { + updateAgreementProcedures(); + updateContention(); + } +} + +void Hcf::resetPeer(MacAddress peer) +{ + Enter_Method("resetPeer"); + if (!originatorBlockAckAgreementHandler) + return; + bool previous = handlingAgreementAction; + handlingAgreementAction = true; + auto originators = originatorBlockAckAgreementHandler->detachPeer(peer); + auto recipients = recipientBlockAckAgreementHandler->detachPeer(peer); + for (int tid = 0; tid < 16; tid++) { + invalidateActions(peer, tid, true); + invalidateActions(peer, tid, false); + discardAgreementData(peer, tid, true); + } + for (auto agreement : recipients) + sendUp(recipientDataService->retireAgreement(agreement, true)); + recipientDataService->clearPeer(peer); + for (auto agreement : originators) { + if (agreement->getIsAddbaResponseReceived()) + emit(blockAckAgreementDeletedSignal, agreement); + delete agreement; + } + for (auto agreement : recipients) { + emit(blockAckAgreementDeletedSignal, agreement); + delete agreement; + } + handlingAgreementAction = previous; + scheduleInactivityTimer(); + scheduleAddbaResponseTimer(); +} + +void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, bool value, cObject *details) +{ + if (signalID != Ieee80211Mib::rateStateChangedSignal) + return; + Enter_Method("rateStateChanged"); + // This cleanup prepares Compressed support. Basic agreements do not depend on HT admission state. + if (blockAckVariant == BlockAckVariant::BASIC || !originatorBlockAckAgreementHandler) + return; + std::vector> retired; + for (const auto& entry : originatorBlockAckAgreementHandler->getAgreements()) { + if (!isProfileAllowed(entry.first.first, true)) + retired.push_back({entry.first.first, entry.first.second, true}); + } + for (const auto& entry : recipientBlockAckAgreementHandler->getAgreements()) { + if (!isProfileAllowed(entry.first.first, false)) + retired.push_back({entry.first.first, entry.first.second, false}); + } + for (const auto& entry : retired) + beginTeardown(std::get<0>(entry), std::get<1>(entry), std::get<2>(entry), 37); + updateContention(); } void Hcf::processLowerFrame(Packet *packet, const Ptr& header) @@ -302,6 +797,33 @@ void Hcf::processLowerFrame(Packet *packet, const Ptr& take(packet); EV_INFO << "Processing lower frame: " << packet->getName() << endl; auto edcaf = edca->getChannelOwner(); + auto action = dynamicPtrCast(header); + bool blockAckAction = dynamicPtrCast(header) || + dynamicPtrCast(header) || dynamicPtrCast(header); + if (action && blockAckAction && isForUs(header) && edcaf && frameSequenceHandler->isSequenceRunning() && + dynamic_cast(frameSequenceHandler->getContext()->getLastStep())) { + handlingAgreementAction = true; + emit(packetReceivedFromPeerSignal, packet); + std::unique_ptr responseSource(packet->dup()); + auto outgoing = check_and_cast(frameSequenceHandler->getContext()->getStepBeforeLast())->getFrameToTransmit(); + auto accepted = recipientDataService->managementFrameReceived(packet, action); + for (auto frame : accepted) { + take(frame); + dispatchAgreementAction(frame->peekAtFront()); + } + cancelEvent(startRxTimer); + bool resolved = obsoleteActions.count(outgoing->getId()) || + (dynamicPtrCast(outgoing->peekAtFront()) && + !edcaf->getInProgressFrames()->containsFrame(outgoing)); + frameSequenceHandler->interruptFrameSequence(!resolved); + recipientAckProcedure->processReceivedFrame(responseSource.get(), action, check_and_cast(recipientAckPolicy), this); + for (auto frame : accepted) + delete frame; + handlingAgreementAction = false; + updateAgreementProcedures(); + updateContention(); + return; + } if (edcaf && frameSequenceHandler->isSequenceRunning()) { // TODO always call processResponse? if ((!isForUs(header) && !startRxTimer->isScheduled()) || isForUs(header)) { @@ -420,6 +942,8 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) transmissionDetails.setStatus(FRAME_TRANSMISSION_STATUS_RETRY_LIMIT_REACHED); emit(Ieee80211Mac::frameTransmissionOutcomeSignal, internallyCollidedFrame, &transmissionDetails); } + else if (auto dataHeader = dynamicPtrCast(internallyCollidedHeader)) + firstDataDiscarded(dataHeader); if (hasFrameToTransmit(ac)) edcaf->requestChannel(this); } @@ -437,12 +961,14 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) void Hcf::frameSequenceFinished() { Enter_Method("frameSequenceFinished"); + finishingSequence = true; emit(IFrameSequenceHandler::frameSequenceFinishedSignal, frameSequenceHandler->getContext()); auto edcaf = edca->getChannelOwner(); if (edcaf) { // The context still owns references. dropFrame defers deletion until context disposal. expireDataFrames(false); - bool startContention = hasFrameToTransmit(); // TODO outstanding frame + updateAgreementProcedures(); + bool startContention = !handlingAgreementAction && hasFrameToTransmit(); edcaf->releaseChannel(this); mac->sendDownPendingRadioConfigMsg(); // TODO review edcaf->getTxopProcedure()->endTxop(); @@ -457,12 +983,51 @@ void Hcf::frameSequenceFinished() } else throw cRuntimeError("Frame sequence finished but channel owner not found!"); + obsoleteActions.clear(); + finishingSequence = false; } void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr& header) { EV_INFO << "Processing received frame " << packet->getName() << " as recipient.\n"; emit(packetReceivedFromPeerSignal, packet); + if (recipientBlockAckAgreementHandler) { + // IEEE Std 802.11-2024, 11.5.4: valid Block Ack traffic without an agreement requires DELBA. + // Reject malformed DATA and unsupported BAR fields before this recovery path. + if (auto data = dynamicPtrCast(header)) { + if (data->getType() == ST_DATA_WITH_QOS && data->getAckPolicy() == BLOCK_ACK && + (data->getTid() < 0 || data->getTid() > 15 || !data->getSequenceNumber().isSpecified() || + data->getTransmitterAddress().isUnspecified() || data->getTransmitterAddress().isMulticast())) { + delete packet; + return; + } + if (data->getType() == ST_DATA_WITH_QOS && data->getAckPolicy() == BLOCK_ACK && + !recipientBlockAckAgreementHandler->getAgreement(data->getTid(), data->getTransmitterAddress())) { + beginTeardown(data->getTransmitterAddress(), data->getTid(), false, 38); + PacketDropDetails details; + details.setReason(OTHER_PACKET_DROP); + emit(packetDroppedSignal, packet, &details); + delete packet; + return; + } + } + else if (auto bar = dynamicPtrCast(header)) { + if (bar->getFragmentNumber() != 0 || bar->getMultiTid() || bar->getCompressedBitmap() || + bar->getTidInfo() < 0 || bar->getTidInfo() > 15 || !bar->getStartingSequenceNumber().isSpecified() || + bar->getTransmitterAddress().isUnspecified() || bar->getTransmitterAddress().isMulticast()) { + delete packet; + return; + } + auto agreement = recipientBlockAckAgreementHandler->getAgreement(bar->getTidInfo(), bar->getTransmitterAddress()); + if (!agreement) { + beginTeardown(bar->getTransmitterAddress(), bar->getTidInfo(), false, 38); + delete packet; + return; + } + agreement->calculateExpirationTime(); + scheduleInactivityTimer(); + } + } if (auto dataOrMgmtHeader = dynamicPtrCast(header)) recipientAckProcedure->processReceivedFrame(packet, dataOrMgmtHeader, check_and_cast(recipientAckPolicy), this); if (auto dataHeader = dynamicPtrCast(header)) { @@ -471,8 +1036,19 @@ void Hcf::recipientProcessReceivedFrame(Packet *packet, const PtrdataFrameReceived(packet, dataHeader, recipientBlockAckAgreementHandler)); } else if (auto mgmtHeader = dynamicPtrCast(header)) { - sendUp(recipientDataService->managementFrameReceived(packet, mgmtHeader)); - recipientProcessReceivedManagementFrame(mgmtHeader); + auto accepted = recipientDataService->managementFrameReceived(packet, mgmtHeader); + for (auto frame : accepted) { + take(frame); + auto completeHeader = frame->peekAtFront(); + if (dynamicPtrCast(completeHeader)) { + recipientProcessReceivedManagementFrame(completeHeader); + delete frame; + } + else + sendUp({frame}); + } + updateAgreementProcedures(); + updateContention(); } else { // TODO else if (auto ctrlFrame = dynamic_cast(frame)) sendUp(recipientDataService->controlFrameReceived(packet, header, recipientBlockAckAgreementHandler)); @@ -496,35 +1072,76 @@ void Hcf::recipientProcessReceivedControlFrame(Packet *packet, const Ptr& header) +{ + dispatchAgreementAction(header); +} + +bool Hcf::dispatchAgreementAction(const Ptr& header) { if (recipientBlockAckAgreementHandler && originatorBlockAckAgreementHandler) { if (auto addbaRequest = dynamicPtrCast(header)) { + auto peer = addbaRequest->getTransmitterAddress(); + auto tid = addbaRequest->getTid(); + auto previous = recipientBlockAckAgreementHandler->getAgreement(tid, peer); + if (!isProfileAllowed(peer, false) || hasObsoleteActionInFlight(peer, tid, false)) { + auto response = makeShared(); + response->setReceiverAddress(peer); + response->setTid(tid); + response->setDialogToken(addbaRequest->getDialogToken()); + response->setStatusCode(SC_UNSPECIFIED); + processMgmtFrame(new Packet("AddbaResponse", response), response); + return false; + } recipientBlockAckAgreementHandler->processReceivedAddbaRequest(addbaRequest, recipientBlockAckAgreementPolicy, this); auto agreement = recipientBlockAckAgreementHandler->getAgreement(addbaRequest->getTid(), addbaRequest->getTransmitterAddress()); - emit(blockAckAgreementAddedSignal, agreement); + if (!previous && agreement) + emit(blockAckAgreementAddedSignal, agreement); + scheduleInactivityTimer(); } else if (auto addbaResp = dynamicPtrCast(header)) { + auto peer = addbaResp->getTransmitterAddress(); + auto tid = addbaResp->getTid(); + auto pending = originatorBlockAckAgreementHandler->getAgreement(peer, tid); + if (!pending || pending->getIsAddbaResponseReceived() || pending->getDialogToken() != addbaResp->getDialogToken()) + return false; + if (addbaResp->getStatusCode() != SC_SUCCESSFUL) { + originatorBlockAckAgreementHandler->finishProcedure(peer, tid); + retireAgreement(peer, tid, true); + scheduleAddbaResponseTimer(); + return true; + } + if (!isProfileAllowed(peer, true) || !originatorBlockAckAgreementPolicy->isAddbaReqAccepted(addbaResp, pending)) + return false; originatorBlockAckAgreementHandler->processReceivedAddbaResp(addbaResp, originatorBlockAckAgreementPolicy, this); auto agreement = originatorBlockAckAgreementHandler->getAgreement(addbaResp->getTransmitterAddress(), addbaResp->getTid()); + originatorBlockAckAgreementHandler->finishProcedure(peer, tid); + invalidateActions(peer, tid, true); emit(blockAckAgreementAddedSignal, agreement); + scheduleAddbaResponseTimer(); + if (!hasQueuedData(peer, tid) && !hasNumberedData(peer, tid)) + beginTeardown(peer, tid, true, 37); + return true; } else if (auto delba = dynamicPtrCast(header)) { - if (delba->getInitiator()) { - auto agreement = recipientBlockAckAgreementHandler->getAgreement(delba->getTid(), delba->getReceiverAddress()); - emit(blockAckAgreementDeletedSignal, agreement); - recipientBlockAckAgreementHandler->processReceivedDelba(delba, recipientBlockAckAgreementPolicy); - } - else { - auto agreement = originatorBlockAckAgreementHandler->getAgreement(delba->getReceiverAddress(), delba->getTid()); - emit(blockAckAgreementDeletedSignal, agreement); - originatorBlockAckAgreementHandler->processReceivedDelba(delba, originatorBlockAckAgreementPolicy); - } + auto peer = delba->getTransmitterAddress(); + auto tid = delba->getTid(); + bool originator = !delba->getInitiator(); + if (tid < 0 || tid > 15 || peer.isMulticast() || peer.isUnspecified()) + return false; + if (originator) + originatorBlockAckAgreementHandler->finishProcedure(peer, tid); + else + recipientBlockAckAgreementHandler->finishTeardown(peer, tid); + retireAgreement(peer, tid, originator); + scheduleAddbaResponseTimer(); + return true; } else ; // Beacon, etc } else ; // Optional modules + return false; } void Hcf::transmissionComplete(Packet *packet, const Ptr& header) @@ -550,6 +1167,8 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) Enter_Method("originatorProcessRtsProtectionFailed"); auto protectedHeader = packet->peekAtFront(); auto edcaf = edca->getChannelOwner(); + if (obsoleteActions.count(packet->getId()) || !edcaf->getInProgressFrames()->containsFrame(packet)) + return; if (edcaf) { EV_INFO << "RTS frame transmission failed\n"; bool retryLimitReached = false; @@ -559,6 +1178,9 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) } else if (auto mgmtHeader = dynamicPtrCast(protectedHeader)) { edcaf->getMgmtAndNonQoSRecoveryProcedure()->rtsFrameTransmissionFailed(mgmtHeader, edcaf->getStationRetryCounters()); + auto action = ownedActions.find(packet->getId()); + if (action != ownedActions.end()) + action->second.rtsRecoveryOwned = true; retryLimitReached = edcaf->getMgmtAndNonQoSRecoveryProcedure()->isRtsFrameRetryLimitReached(packet, mgmtHeader); } else @@ -577,7 +1199,10 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) details.setLimit(-1); // TODO emit(packetDroppedSignal, packet, &details); emit(linkBrokenSignal, packet); + if (auto data = dynamicPtrCast(protectedHeader)) + firstDataDiscarded(data); if (dynamicPtrCast(protectedHeader)) { + actionTerminated(packet, false); FrameTransmissionDetails transmissionDetails; transmissionDetails.setStatus(FRAME_TRANSMISSION_STATUS_RETRY_LIMIT_REACHED); emit(Ieee80211Mac::frameTransmissionOutcomeSignal, packet, &transmissionDetails); @@ -591,6 +1216,13 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) void Hcf::originatorProcessTransmittedFrame(Packet *packet) { Enter_Method("originatorProcessTransmittedFrame"); + auto edcaf = edca->getChannelOwner(); + if (edcaf) + edcaf->emit(packetSentToPeerSignal, packet); + if (obsoleteActions.count(packet->getId()) || + (dynamicPtrCast(packet->peekAtFront()) && + !edca->getChannelOwner()->getInProgressFrames()->containsFrame(packet))) + return; EV_INFO << "Processing transmitted frame " << packet->getName() << " as originator in frame sequence.\n"; auto transmittedHeader = packet->peekAtFront(); if (auto dataOrMgmt = dynamicPtrCast(transmittedHeader)) { @@ -599,9 +1231,7 @@ void Hcf::originatorProcessTransmittedFrame(Packet *packet) rx->successfulFrameTransmitted(step->getPpduEnd(), transmittedHeader->getDurationField()); } } - auto edcaf = edca->getChannelOwner(); if (edcaf) { - edcaf->emit(packetSentToPeerSignal, packet); AccessCategory ac = edcaf->getAccessCategory(); if (transmittedHeader->getReceiverAddress().isMulticast()) { if (dynamicPtrCast(transmittedHeader)) @@ -630,6 +1260,14 @@ void Hcf::originatorProcessTransmittedDataFrame(Packet *packet, const PtrgetAckHandler()->processTransmittedDataOrMgmtFrame(dataHeader); if (originatorBlockAckAgreementHandler) originatorBlockAckAgreementHandler->processTransmittedDataFrame(packet, dataHeader, originatorBlockAckAgreementPolicy, this); + if (originatorBlockAckAgreementHandler && dataHeader->getType() == ST_DATA_WITH_QOS && + !dataHeader->getReceiverAddress().isMulticast() && isProfileAllowed(dataHeader->getReceiverAddress(), true) && + originatorBlockAckAgreementPolicy->isAddbaReqNeeded(packet, dataHeader) && + !originatorBlockAckAgreementHandler->getAgreement(dataHeader->getReceiverAddress(), dataHeader->getTid())) { + originatorBlockAckAgreementHandler->noteEligibleDataTransmission(dataHeader->getReceiverAddress(), dataHeader->getTid()); + if (hasQueuedData(dataHeader->getReceiverAddress(), dataHeader->getTid())) + originatorBlockAckAgreementHandler->beginSetupIntent(dataHeader->getReceiverAddress(), dataHeader->getTid()); + } if (dataHeader->getAckPolicy() == NO_ACK) edcaf->getInProgressFrames()->dropFrame(packet); } @@ -670,6 +1308,9 @@ void Hcf::originatorProcessFailedFrame(Packet *failedPacket) Enter_Method("originatorProcessFailedFrame"); auto failedHeader = failedPacket->peekAtFront(); auto edcaf = edca->getChannelOwner(); + if (obsoleteActions.count(failedPacket->getId()) || + (dynamicPtrCast(failedHeader) && !edcaf->getInProgressFrames()->containsFrame(failedPacket))) + return; if (edcaf) { bool retryLimitReached = false; if (auto dataHeader = dynamicPtrCast(failedHeader)) { @@ -713,6 +1354,7 @@ void Hcf::originatorProcessFailedFrame(Packet *failedPacket) emit(packetDroppedSignal, failedPacket, &details); emit(linkBrokenSignal, failedPacket); if (dynamicPtrCast(failedHeader)) { + actionTerminated(failedPacket, false); FrameTransmissionDetails transmissionDetails; transmissionDetails.setStatus(FRAME_TRANSMISSION_STATUS_RETRY_LIMIT_REACHED); emit(Ieee80211Mac::frameTransmissionOutcomeSignal, failedPacket, &transmissionDetails); @@ -732,8 +1374,12 @@ void Hcf::originatorProcessFailedFrame(Packet *failedPacket) void Hcf::originatorProcessReceivedFrame(Packet *receivedPacket, Packet *lastTransmittedPacket) { Enter_Method("originatorProcessReceivedFrame"); - EV_INFO << "Processing received frame " << receivedPacket->getName() << " as originator in frame sequence.\n"; emit(packetReceivedFromPeerSignal, receivedPacket); + if (obsoleteActions.count(lastTransmittedPacket->getId()) || + (dynamicPtrCast(lastTransmittedPacket->peekAtFront()) && + !edca->getChannelOwner()->getInProgressFrames()->containsFrame(lastTransmittedPacket))) + return; + EV_INFO << "Processing received frame " << receivedPacket->getName() << " as originator in frame sequence.\n"; auto receivedHeader = receivedPacket->peekAtFront(); auto lastTransmittedHeader = lastTransmittedPacket->peekAtFront(); auto step = check_and_cast(frameSequenceHandler->getContext()->getStepBeforeLast()); @@ -786,6 +1432,7 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const PtrgetInProgressFrames()->dropFrame(lastTransmittedPacket); edcaf->getAckHandler()->dropFrame(lastTransmittedDataOrMgmtHeader); if (dynamicPtrCast(lastTransmittedHeader)) { + actionTerminated(lastTransmittedPacket, true); FrameTransmissionDetails transmissionDetails; transmissionDetails.setStatus(FRAME_TRANSMISSION_STATUS_ACKNOWLEDGED); emit(Ieee80211Mac::frameTransmissionOutcomeSignal, lastTransmittedPacket, &transmissionDetails); @@ -833,9 +1480,15 @@ void Hcf::originatorProcessReceivedDataFrame(const PtrgetEdcaf(ac); if (edcaf) - return !edcaf->getPendingQueue()->isEmpty() || edcaf->getInProgressFrames()->hasInProgressFrames(); + return edcaf->getInProgressFrames()->hasEligibleInProgressFrames() || + check_and_cast(originatorDataService)->peekEligibleFrame(edcaf->getPendingQueue()) != nullptr; else throw cRuntimeError("Hcca is unimplemented"); } @@ -845,7 +1498,7 @@ bool Hcf::hasFrameToTransmit() expireDataFrames(); auto edcaf = edca->getChannelOwner(); if (edcaf) - return !edcaf->getPendingQueue()->isEmpty() || edcaf->getInProgressFrames()->hasInProgressFrames(); + return hasFrameToTransmit(edcaf->getAccessCategory()); else throw cRuntimeError("Hcca is unimplemented"); } @@ -974,6 +1627,12 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) Enter_Method("transmitFrame"); auto channelOwner = edca->getChannelOwner(); if (channelOwner) { + auto header = packet->peekAtFront(); + if (dynamicPtrCast(header) && + !channelOwner->getInProgressFrames()->containsFrame(packet)) + return false; + if (!isFrameEligible(packet, true)) + return false; auto lifetimeHandler = edca->getLifetimeHandler(); auto step = frameSequenceHandler->getContext()->getLastStep(); auto protectedPacket = dynamic_cast(step); @@ -981,7 +1640,6 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) // IEEE Std 802.11-2024, 10.23.2.12.1: a delayed start cannot exceed DATA lifetime. if (lifetimeHandler->isExpired(data, simTime() + ifs)) return false; - auto header = packet->peekAtFront(); auto txop = channelOwner->getTxopProcedure(); auto context = frameSequenceHandler->getContext(); bool scopedSingle = txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && !par("isBlockAckSupported").boolValue(); @@ -1077,6 +1735,19 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) RateSelection::emitDatarateSelected(this, header, mode); EV_DEBUG << "Datarate for " << packet->getName() << " is set to " << mode->getDataMode()->getNetBitrate() << ".\n"; tx->transmitFrame(packet, packet->peekAtFront(), ifs, false, this); + if (auto dataHeader = dynamicPtrCast(header)) { + if (originatorBlockAckAgreementHandler) { + auto agreement = originatorBlockAckAgreementHandler->getAgreement(dataHeader->getReceiverAddress(), dataHeader->getTid()); + if (agreement && agreement->getIsAddbaResponseReceived()) + agreement->recordTransmittedData(packet->getTag()->getAllocationIndex()); + } + } + auto action = ownedActions.find(packet->getId()); + if (action != ownedActions.end()) { + action->second.attempted = true; + if (action->second.kind == OwnedAction::REQUEST) + originatorBlockAckAgreementHandler->markRequestAttempted(action->second.peer, action->second.tid); + } return true; } else @@ -1124,6 +1795,37 @@ void Hcf::recipientProcessTransmittedControlResponseFrame(Packet *packet, const void Hcf::processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) { Enter_Method("processMgmtFrame"); + OwnedAction action; + action.peer = mgmtHeader->getReceiverAddress(); + bool owned = true; + if (auto request = dynamicPtrCast(mgmtHeader)) { + action.tid = request->getTid(); + action.originator = true; + action.kind = OwnedAction::REQUEST; + } + else if (auto response = dynamicPtrCast(mgmtHeader)) { + action.tid = response->getTid(); + action.originator = false; + action.kind = OwnedAction::RESPONSE; + } + else if (auto delba = dynamicPtrCast(mgmtHeader)) { + action.tid = delba->getTid(); + action.originator = delba->getInitiator(); + action.kind = OwnedAction::DELBA; + bool pending = action.originator ? + originatorBlockAckAgreementHandler->getProcedures().count({action.peer, action.tid}) != 0 && + originatorBlockAckAgreementHandler->getProcedures().at({action.peer, action.tid}).state == IOriginatorBlockAckAgreementHandler::ProcedureState::TEARDOWN_PENDING : + recipientBlockAckAgreementHandler->isTeardownPending(action.peer, action.tid); + if (!pending) { + beginTeardown(action.peer, action.tid, action.originator, delba->getReasonCode()); + delete mgmtPacket; + return; + } + } + else + owned = false; + if (owned) + ownedActions.emplace(mgmtPacket->getId(), action); mgmtPacket->insertAtBack(makeShared()); processUpperFrame(mgmtPacket, mgmtHeader); } @@ -1167,6 +1869,7 @@ void Hcf::corruptedFrameReceived() Hcf::~Hcf() { + cancelAndDelete(addbaResponseTimer); cancelAndDelete(dataLifetimeTimer); cancelAndDelete(startRxTimer); cancelAndDelete(inactivityTimer); diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h index 4a0537880f8..aaa5c20cad6 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h @@ -12,6 +12,7 @@ #include "inet/linklayer/ieee80211/mac/channelaccess/Hcca.h" #include "inet/linklayer/ieee80211/mac/common/ModeSetListener.h" #include "inet/linklayer/ieee80211/mac/contract/IAckHandler.h" +#include "inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h" #include "inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h" #include "inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h" #include "inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h" @@ -41,6 +42,7 @@ namespace inet { namespace ieee80211 { class Ieee80211Mac; +class Ieee80211Mib; /** * Implements IEEE 802.11 Hybrid Coordination Function. @@ -48,7 +50,6 @@ class Ieee80211Mac; class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler::ICallback, public IChannelAccess::ICallback, public ITx::ICallback, public IProcedureCallback, public IBlockAckAgreementHandlerCallback, public ModeSetListener { private: - enum class BlockAckVariant { BASIC, COMPRESSED }; BlockAckVariant blockAckVariant = BlockAckVariant::BASIC; public: @@ -58,11 +59,26 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: protected: Ieee80211Mac *mac = nullptr; + Ieee80211Mib *mib = nullptr; IRateControl *dataAndMgmtRateControl = nullptr; cMessage *startRxTimer = nullptr; cMessage *inactivityTimer = nullptr; cMessage *dataLifetimeTimer = nullptr; + cMessage *addbaResponseTimer = nullptr; + struct OwnedAction { + MacAddress peer; + Tid tid = -1; + bool originator = false; + enum Kind { REQUEST, RESPONSE, DELBA } kind = REQUEST; + bool attempted = false; + bool rtsRecoveryOwned = false; + }; + std::map ownedActions; + std::set obsoleteActions; + bool handlingAgreementAction = false; + bool finishingSequence = false; + bool updatingProcedures = false; // Transmission and Reception IRx *rx = nullptr; @@ -113,6 +129,7 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: virtual void forEachChild(cVisitor *v) override; virtual void handleMessage(cMessage *msg) override; virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + virtual void receiveSignal(cComponent *source, simsignal_t signalID, bool value, cObject *details) override; virtual void refreshDisplay() const override; void startFrameSequence(AccessCategory ac); @@ -131,10 +148,27 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: TxopProcedure *txop, simtime_t ppduDuration); virtual bool hasFrameToTransmit(); virtual bool hasFrameToTransmit(AccessCategory ac); + bool hasEligibleFrameToTransmit(AccessCategory ac) const; virtual bool isReceptionInProgress(); void scheduleDataLifetimeTimer(); void expireDataFrames(bool preserveSequence = true); std::set getReferencedDataFrames() const; + bool isFrameEligible(Packet *packet, bool numbered) const; + bool isAMsduPermitted(Packet *packet) const; + bool hasQueuedData(MacAddress peer, Tid tid) const; + bool hasNumberedData(MacAddress peer, Tid tid) const; + bool hasObsoleteActionInFlight(MacAddress peer, Tid tid, bool originator) const; + void updateAgreementProcedures(); + void updateContention(); + void scheduleAddbaResponseTimer(); + void actionTerminated(Packet *packet, bool acknowledged); + void invalidateActions(MacAddress peer, Tid tid, bool originator); + void retireAgreement(MacAddress peer, Tid tid, bool originator, bool associationReset = false); + void beginTeardown(MacAddress peer, Tid tid, bool originator, int reasonCode); + void discardAgreementData(MacAddress peer, Tid tid, bool all, int64_t highestTransmittedDataIndex = -1); + void firstDataDiscarded(const Ptr& header); + bool dispatchAgreementAction(const Ptr& header); + bool isProfileAllowed(MacAddress peer, bool originator) const; // Recipient virtual void recipientProcessReceivedFrame(Packet *packet, const Ptr& header); @@ -176,12 +210,13 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: virtual void processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) override; // IProcedureCallback - virtual void scheduleInactivityTimer(simtime_t timeout) override; + virtual void scheduleInactivityTimer() override; std::string getFrameSequenceInfo() const; public: virtual ~Hcf(); + void resetPeer(MacAddress peer); // ICoordinationFunction virtual void processUpperFrame(Packet *packet, const Ptr& header) override; diff --git a/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.cc b/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.cc index 88395deef09..098aad01b1c 100644 --- a/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.cc +++ b/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.cc @@ -12,6 +12,24 @@ namespace inet { namespace ieee80211 { +void QoSDuplicateRemoval::setLastReceived(MacAddress peer, Tid tid, const SequenceNumberCyclic& sequence, int fragment) +{ + if (sequence.isSpecified()) + lastSeenSeqNumCache.insert_or_assign(Key(peer, tid), SequenceControlField(sequence.get(), fragment)); +} + +void QoSDuplicateRemoval::clearPeer(MacAddress peer) +{ + for (auto it = lastSeenSeqNumCache.begin(); it != lastSeenSeqNumCache.end();) { + if (it->first.first == peer) + it = lastSeenSeqNumCache.erase(it); + else + ++it; + } + lastSeenSharedSeqNumCache.erase(peer); + lastSeenTimePriorityManagementSeqNumCache.erase(peer); +} + bool QoSDuplicateRemoval::isDuplicate(const Ptr& header) { SequenceControlField seqVal(header->getSequenceNumber().get(), header->getFragmentNumber()); diff --git a/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.h b/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.h index d1075215fbc..4a947d4a9f5 100644 --- a/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.h +++ b/src/inet/linklayer/ieee80211/mac/duplicateremoval/QosDuplicateRemoval.h @@ -28,6 +28,8 @@ class INET_API QoSDuplicateRemoval : public IDuplicateRemoval Mac2SeqValMap lastSeenTimePriorityManagementSeqNumCache; public: + void setLastReceived(MacAddress peer, Tid tid, const SequenceNumberCyclic& sequence, int fragment); + void clearPeer(MacAddress peer); virtual bool isDuplicate(const Ptr& header) override; }; diff --git a/src/inet/linklayer/ieee80211/mac/fragmentation/BasicReassembly.cc b/src/inet/linklayer/ieee80211/mac/fragmentation/BasicReassembly.cc index 2f32f0207b9..ce397baca9e 100644 --- a/src/inet/linklayer/ieee80211/mac/fragmentation/BasicReassembly.cc +++ b/src/inet/linklayer/ieee80211/mac/fragmentation/BasicReassembly.cc @@ -26,8 +26,10 @@ Packet *BasicReassembly::addFragment(Packet *packet) // Frame is not fragmented if (!header->getMoreFragments() && header->getFragmentNumber() == 0) return packet; - // FIXME temporary fix for mgmt frames - if (dynamicPtrCast(header)) + // IEEE Std 802.11-2024, 10.4: dispatch Block Ack Actions only after complete MMPDU reassembly. + bool blockAckAction = dynamicPtrCast(header) || + dynamicPtrCast(header) || dynamicPtrCast(header); + if (dynamicPtrCast(header) && !blockAckAction) return packet; // find entry for this frame Key key; diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc index 66699fadeb0..cc6450101f3 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc @@ -14,6 +14,17 @@ namespace inet { namespace ieee80211 { +void FrameSequenceHandler::interruptFrameSequence(bool notifyFailure) +{ + ASSERT(isSequenceRunning()); + ASSERT(dynamic_cast(context->getLastStep())); + context->getLastStep()->setCompletion(IFrameSequenceStep::Completion::REJECTED); + if (notifyFailure) + abortFrameSequence(); + else + finishFrameSequence(); +} + void FrameSequenceHandler::handleStartRxTimeout() { auto lastStep = context->getLastStep(); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h index de514c54c9d..fa65175856a 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h @@ -35,6 +35,7 @@ class INET_API FrameSequenceHandler : public IFrameSequenceHandler virtual void processResponse(Packet *frame) override; virtual void transmissionComplete() override; virtual void handleStartRxTimeout() override; + virtual void interruptFrameSequence(bool notifyFailure) override; virtual bool isSequenceRunning() override { return frameSequence != nullptr; } virtual ~FrameSequenceHandler(); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc index 60c875bb16f..3fda1fcd52c 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc @@ -150,7 +150,13 @@ IFrameSequenceStep *ManagementAckFs::prepareStep(FrameSequenceContext *context) { switch (step) { case 0: { - auto packet = context->getInProgressFrames()->getFrameToTransmit(); + Packet *packet = nullptr; + if (context->getQoSContext() && dynamic_cast(context->getLastStep())) { + if (auto rts = dynamic_cast(context->getStepBeforeLast())) + packet = const_cast(rts->getProtectedFrame()); + } + if (packet == nullptr) + packet = context->getInProgressFrames()->getFrameToTransmit(); return new TransmitStep(packet, context->getIfs()); } case 1: { @@ -195,7 +201,13 @@ IFrameSequenceStep *ManagementFs::prepareStep(FrameSequenceContext *context) { switch (step) { case 0: { - auto packet = context->getInProgressFrames()->getFrameToTransmit(); + Packet *packet = nullptr; + if (context->getQoSContext() && dynamic_cast(context->getLastStep())) { + if (auto rts = dynamic_cast(context->getStepBeforeLast())) + packet = const_cast(rts->getProtectedFrame()); + } + if (packet == nullptr) + packet = context->getInProgressFrames()->getFrameToTransmit(); return new TransmitStep(packet, context->getIfs()); } case 1: diff --git a/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.cc b/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.cc index 4074ff0004c..2b77ca61c30 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.cc @@ -133,20 +133,25 @@ void NonQosRecoveryProcedure::ackFrameReceived(Packet *packet, const Ptr& header) { EV_WARN << "Retry limit reached for " << *packet << ".\n"; - auto id = SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()); - if (packet->getByteLength() >= rtsThreshold) { - auto it = longRetryCounter.find(id); - if (it != longRetryCounter.end()) - longRetryCounter.erase(it); - } - else { - auto it = shortRetryCounter.find(id); - if (it != shortRetryCounter.end()) - shortRetryCounter.erase(it); - } + dropFrame(packet, header); emit(retryLimitReachedSignal, packet); } +void NonQosRecoveryProcedure::dropFrame(Packet *packet, const Ptr& header) +{ + auto id = SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()); + if (packet->getByteLength() >= rtsThreshold) + longRetryCounter.erase(id); + else + shortRetryCounter.erase(id); +} + +void NonQosRecoveryProcedure::dropRtsProtectedFrame(const Ptr& header) +{ + auto id = SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()); + shortRetryCounter.erase(id); +} + // // The SRC for an MPDU of type Data or MMPDU and the SSRC shall be incremented every // time transmission of a MAC frame of length less than or equal to dot11RTSThreshold diff --git a/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h b/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h index f738e56dde6..83c04085b1b 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h +++ b/src/inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h @@ -65,6 +65,8 @@ class INET_API NonQosRecoveryProcedure : public SimpleModule, public IRecoveryPr virtual bool isRtsFrameRetryLimitReached(Packet *packet, const Ptr& protectedHeader); virtual void retryLimitReached(Packet *packet, const Ptr& header); + void dropFrame(Packet *packet, const Ptr& header); + void dropRtsProtectedFrame(const Ptr& header); virtual int getLongRetryLimit() { return longRetryLimit; } virtual int getShortRetryLimit() { return shortRetryLimit; } diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc index 484f239cb09..b99e0a3339b 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc @@ -98,6 +98,8 @@ AckPolicy OriginatorQosAckPolicy::computeAckPolicy(Packet *packet, const PtrgetIsAddbaResponseReceived() && header->getAMsduPresent() && !agreement->isAMsduPermitted()) + throw cRuntimeError("A-MSDU is not permitted by both ADDBA flags"); if (agreement->getIsAddbaResponseReceived() && isBlockAckPolicyEligibleFrame(packet, header)) { if (checkAgreementPolicy(header, agreement)) return AckPolicy::BLOCK_ACK; @@ -116,7 +118,7 @@ bool OriginatorQosAckPolicy::isBlockAckPolicyEligibleFrame(Packet *packet, const bool OriginatorQosAckPolicy::checkAgreementPolicy(const Ptr& header, OriginatorBlockAckAgreement *agreement) const { bool bufferFull = agreement->getBufferSize() == agreement->getNumSentBaPolicyFrames(); - bool aMsduOk = agreement->getIsAMsduSupported() || !header->getAMsduPresent(); + bool aMsduOk = agreement->isAMsduPermitted() || !header->getAMsduPresent(); // TODO bool baPolicy = agreement->getIsDelayedBlockAckPolicySupported() || !frame->getAckPolicy(); return !bufferFull && aMsduOk && (header->getSequenceNumber() >= agreement->getStartingSequenceNumber()); // TODO && baPolicy } diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc index ef82c225c78..40f7e33106c 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc @@ -9,11 +9,13 @@ #include +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" #include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" #include "inet/linklayer/ieee80211/mac/aggregation/MsduAggregation.h" #include "inet/linklayer/ieee80211/mac/channelaccess/Edca.h" #include "inet/linklayer/ieee80211/mac/fragmentation/Fragmentation.h" #include "inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h" +#include "inet/queueing/contract/ISelectivePacketCollection.h" namespace inet { namespace ieee80211 { @@ -33,9 +35,29 @@ void OriginatorQosMacDataService::initialize() fragmentation = new Fragmentation(); } -Packet *OriginatorQosMacDataService::aMsduAggregateIfNeeded(queueing::IPacketQueue *pendingQueue) +Packet *OriginatorQosMacDataService::aMsduAggregateIfNeeded(queueing::IPacketQueue *pendingQueue, Packet *selected) { auto subframes = aMsduAggregationPolicy->computeAggregateFrames(pendingQueue); + if (subframes) { + bool valid = !subframes->empty() && subframes->front() == selected; + std::set unique; + for (auto frame : *subframes) { + bool present = false; + for (int i = 0; i < pendingQueue->getNumPackets(); i++) { + if (pendingQueue->getPacket(i) == frame) { + present = true; + break; + } + } + valid &= present && unique.insert(frame).second && + (!extractionEligible || extractionEligible(frame)) && + (!aMsduPermitted || aMsduPermitted(frame)); + } + if (!valid) { + delete subframes; + return nullptr; + } + } if (subframes) { std::vector sourceIds; AccessCategory ac = AC_BE; @@ -105,16 +127,20 @@ std::vector *OriginatorQosMacDataService::extractFramesToTransmit(queu Enter_Method("extractFramesToTransmit"); if (expireFrames) expireFrames(); - if (pendingQueue->isEmpty()) + auto selected = peekEligibleFrame(pendingQueue); + if (selected == nullptr) return nullptr; else { // if (msduRateLimiting) // txRateLimitingIfNeeded(); Packet *packet = nullptr; - if (aMsduAggregationPolicy) - packet = aMsduAggregateIfNeeded(pendingQueue); + auto module = dynamic_cast(pendingQueue); + auto next = pendingQueue->canPullPacket(module ? module->gate("out") : nullptr); + if (selected == next && aMsduAggregationPolicy && (!aMsduPermitted || aMsduPermitted(selected))) + packet = aMsduAggregateIfNeeded(pendingQueue, selected); if (!packet) { - packet = pendingQueue->dequeuePacket(); + packet = selected == next ? pendingQueue->dequeuePacket() : + check_and_cast(pendingQueue)->extractPacket(selected); take(packet); } // PS Defer Queueing @@ -123,6 +149,8 @@ std::vector *OriginatorQosMacDataService::extractFramesToTransmit(queu assignSequenceNumber(header); packet->insertAtFront(header); } + if (dynamicPtrCast(packet->peekAtFront())) + packet->addTagIfAbsent()->setAllocationIndex(nextDataAllocationIndex++); // if (msduIntegrityAndProtection) // frame = protectMsduIfNeeded(frame); std::vector *fragments = nullptr; @@ -143,6 +171,35 @@ std::vector *OriginatorQosMacDataService::extractFramesToTransmit(queu } } +Packet *OriginatorQosMacDataService::peekEligibleFrame(queueing::IPacketQueue *queue) const +{ + if (queue->isEmpty()) + return nullptr; + auto predicate = [this](Packet *packet) { return !extractionEligible || extractionEligible(packet); }; + auto module = dynamic_cast(queue); + auto packet = queue->canPullPacket(module ? module->gate("out") : nullptr); + if (packet && predicate(packet)) + return packet; + if (auto selected = dynamic_cast(queue)) { + try { + return selected->peekEligiblePacket(predicate); + } + catch (const queueing::UnsupportedPacketSelection&) { + // Ordinary service remains valid when this composition cannot bypass a deferred head. + } + } + for (int i = 0; i < queue->getNumPackets(); i++) { + if (predicate(queue->getPacket(i))) + throw cRuntimeError("Deferred DATA hides an eligible frame: queue requires ISelectivePacketCollection"); + } + return nullptr; +} + +SequenceNumberCyclic OriginatorQosMacDataService::getNextSequenceNumber(MacAddress peer, Tid tid) const +{ + return check_and_cast(sequenceNumberAssignment)->getNextSequenceNumber(peer, tid); +} + OriginatorQosMacDataService::~OriginatorQosMacDataService() { delete aMsduAggregation; diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h index 9e377d36427..40366a32b9c 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h @@ -41,16 +41,26 @@ class INET_API OriginatorQosMacDataService : public IOriginatorMacDataService, p IMpduAggregation *aMpduAggregation = nullptr; EdcaTransmitLifetimeHandler *lifetimeHandler = nullptr; // Borrowed from EDCA. std::function expireFrames; + std::function extractionEligible; + std::function aMsduPermitted; + int64_t nextDataAllocationIndex = 0; protected: virtual void initialize() override; virtual void assignSequenceNumber(const Ptr& header); virtual std::vector *fragmentIfNeeded(Packet *frame); - virtual Packet *aMsduAggregateIfNeeded(queueing::IPacketQueue *pendingQueue); + virtual Packet *aMsduAggregateIfNeeded(queueing::IPacketQueue *pendingQueue, Packet *selected); virtual Packet *aMpduAggregateIfNeeded(std::vector *fragments); public: + void setEligibility(std::function eligible, std::function permission) { + extractionEligible = eligible; + aMsduPermitted = permission; + } + Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const; + SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const; + bool hasAMsduAggregation() const { return aMsduAggregationPolicy != nullptr; } virtual ~OriginatorQosMacDataService(); void setLifetimeHandler(EdcaTransmitLifetimeHandler *handler, std::function expiration) { lifetimeHandler = handler; diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc index 76838835cce..e9918ee20f7 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc @@ -63,6 +63,7 @@ bool InProgressFrames::containsFrame(const Packet *packet) const bool InProgressFrames::isEligibleToTransmit(Packet *packet) { return (!lifetimeHandler || !lifetimeHandler->isExpired(packet)) && + (!transmissionEligible || transmissionEligible(packet)) && ackHandler->isEligibleToTransmit(packet->peekAtFront()); } diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h index ca7175ee2d5..293aebfc3a3 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h @@ -32,6 +32,7 @@ class INET_API InProgressFrames : public SimpleModule EdcaTransmitLifetimeHandler *lifetimeHandler = nullptr; // Borrowed from EDCA; null for DCF. std::vector inProgressFrames; std::vector droppedFrames; + std::function transmissionEligible; protected: virtual void initialize(int stage) override; @@ -43,6 +44,8 @@ class INET_API InProgressFrames : public SimpleModule public: virtual ~InProgressFrames(); void setLifetimeHandler(EdcaTransmitLifetimeHandler *handler) { lifetimeHandler = handler; } + void setTransmissionEligibility(std::function predicate) { transmissionEligible = predicate; } + bool hasEligibleInProgressFrames() { return hasEligibleFrameToTransmit(); } virtual std::string str() const override; virtual void forEachChild(cVisitor *v) override; diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc index 95fac972e3a..e73a15720c1 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc @@ -57,6 +57,11 @@ std::vector RecipientQosMacDataService::dataFrameReceived(Packet *data { Enter_Method("dataFrameReceived"); take(dataPacket); + if (blockAckAgreementHandler) { + auto agreement = blockAckAgreementHandler->getAgreement(dataHeader->getTid(), dataHeader->getTransmitterAddress()); + if (agreement) + agreement->recordReceived(dataHeader); + } // TODO A-MPDU Deaggregation, MPDU Header+FCS Validation, Address1 Filtering, Duplicate Removal, MPDU Decryption if (duplicateRemoval && duplicateRemoval->isDuplicate(dataHeader)) { EV_WARN << "Dropping duplicate packet " << *dataPacket << ".\n"; @@ -116,20 +121,17 @@ std::vector RecipientQosMacDataService::managementFrameReceived(Packet Enter_Method("managementFrameReceived"); take(mgmtPacket); // TODO MPDU Header+FCS Validation, Address1 Filtering, Duplicate Removal, MPDU Decryption - if (duplicateRemoval && duplicateRemoval->isDuplicate(mgmtHeader)) + if (duplicateRemoval && duplicateRemoval->isDuplicate(mgmtHeader)) { + delete mgmtPacket; return std::vector(); + } if (basicReassembly) { // FIXME defragmentation mgmtPacket = defragment(mgmtPacket); } - if (auto delba = dynamicPtrCast(mgmtHeader)) - blockAckReordering->processReceivedDelba(delba); // TODO Defrag, MSDU Integrity, Replay Detection, RX MSDU Rate Limiting - if (dynamicPtrCast(mgmtHeader)) { - delete mgmtPacket; + if (mgmtPacket == nullptr) return std::vector(); - } - else - return std::vector({ mgmtPacket }); + return std::vector({ mgmtPacket }); } std::vector RecipientQosMacDataService::controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) @@ -193,6 +195,49 @@ RecipientQosMacDataService::~RecipientQosMacDataService() delete blockAckReordering; } +std::vector RecipientQosMacDataService::retireAgreement(RecipientBlockAckAgreement *agreement, bool associationReset) +{ + Enter_Method("retireAgreement"); + auto peer = agreement->getBlockAckRecord()->getOriginatorAddress(); + auto tid = agreement->getBlockAckRecord()->getTid(); + auto duplicate = check_and_cast(duplicateRemoval); + // IEEE Std 802.11-2024, 11.5.3.5: ordinary teardown retains the highest received sequence number. + if (!associationReset) + duplicate->setLastReceived(peer, tid, agreement->getHighestReceivedSequence(), agreement->getHighestReceivedFragment()); + std::vector discarded; + auto released = blockAckReordering->detachAgreement(peer, tid, !associationReset, discarded); + for (auto packet : discarded) { + PacketDropDetails details; + details.setReason(OTHER_PACKET_DROP); + emit(packetDroppedSignal, packet, &details); + delete packet; + } + std::vector complete; + for (const auto& unit : released) { + auto frame = defragment(unit.second); + if (!frame) + continue; + if (frame->peekAtFront()->getAMsduPresent()) { + emit(packetDeaggregatedSignal, frame); + auto subframes = aMsduDeaggregation->deaggregateFrame(frame); + complete.insert(complete.end(), subframes->begin(), subframes->end()); + delete subframes; + } + else + complete.push_back(frame); + } + return complete; +} + +void RecipientQosMacDataService::clearPeer(MacAddress peer) +{ + Enter_Method("clearPeer"); + blockAckReordering->clearPeer(peer); + check_and_cast(duplicateRemoval)->clearPeer(peer); + for (int tid = -1; tid < 16; tid++) + basicReassembly->purge(peer, tid, 0, 4095); +} + } /* namespace ieee80211 */ } /* namespace inet */ diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h index e4b8ee28865..10b26ca843f 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h @@ -46,6 +46,8 @@ class INET_API RecipientQosMacDataService : public IRecipientQosMacDataService, virtual Packet *defragment(Packet *mgmtFragment); public: + virtual std::vector retireAgreement(RecipientBlockAckAgreement *agreement, bool associationReset) override; + virtual void clearPeer(MacAddress peer) override; virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) override; virtual std::vector controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) override; virtual std::vector managementFrameReceived(Packet *mgmtPacket, const Ptr& mgmtHeader) override; diff --git a/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.cc b/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.cc index c0d2085cf3d..8f5f1340436 100644 --- a/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.cc +++ b/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.cc @@ -10,6 +10,12 @@ namespace inet { namespace ieee80211 { +SequenceNumberCyclic QoSSequenceNumberAssignment::getNextSequenceNumber(MacAddress peer, Tid tid) const +{ + auto it = lastSentSeqNums.find({peer, tid}); + return it == lastSentSeqNums.end() ? SequenceNumberCyclic(0) : it->second + 1; +} + QoSSequenceNumberAssignment::CacheType QoSSequenceNumberAssignment::getCacheType(const Ptr& header, bool incoming) { bool isTimePriorityFrame = false; // TODO diff --git a/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h b/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h index 07928c860b5..81cb584ace8 100644 --- a/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h +++ b/src/inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h @@ -36,6 +36,7 @@ class INET_API QoSSequenceNumberAssignment : public ISequenceNumberAssignment virtual CacheType getCacheType(const Ptr& header, bool incoming); public: + SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const; virtual void assignSequenceNumber(const Ptr& header) override; }; diff --git a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.cc b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.cc index b4439163dc0..3442658d920 100644 --- a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.cc +++ b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.cc @@ -130,6 +130,8 @@ void Ieee80211MgmtAp::frameTransmissionFinished(const Packet *responseFrame, Fra if (status == FRAME_TRANSMISSION_STATUS_ACKNOWLEDGED) { if (sta->second.pendingAssociationSuccessful) { bool wasAssociated = mib->bssAccessPointData.stations[address] == Ieee80211Mib::ASSOCIATED; + if (wasAssociated) + resetPeerAgreements(address); mib->commitAssociationId(address); mib->bssAccessPointData.stations[address] = Ieee80211Mib::ASSOCIATED; auto peerRateSet = sta->second.pendingPeerRateSet; @@ -155,6 +157,7 @@ void Ieee80211MgmtAp::frameTransmissionFinished(const Packet *responseFrame, Fra sendAssocNotification(address); } else if (mib->bssAccessPointData.stations[address] == Ieee80211Mib::ASSOCIATED) { + resetPeerAgreements(address); // This model does not implement negotiated management-frame protection. // IEEE Std 802.11-2024, 11.3.5.3(p) for association and 11.3.5.5(n) // for same-AP reassociation therefore require the existing association @@ -254,6 +257,8 @@ void Ieee80211MgmtAp::handleAuthenticationFrame(Packet *packet, const PtrbssAccessPointData.stations[sta->address] == Ieee80211Mib::ASSOCIATED; + if (wasAssociated) + resetPeerAgreements(sta->address); mib->bssAccessPointData.stations[sta->address] = Ieee80211Mib::NOT_AUTHENTICATED; sta->authSeqExpected = 1; if (wasAssociated) @@ -294,6 +299,8 @@ void Ieee80211MgmtAp::handleAuthenticationFrame(Packet *packet, const PtrbssAccessPointData.stations[sta->address] == Ieee80211Mib::ASSOCIATED; + if (wasAssociated) + resetPeerAgreements(sta->address); mib->bssAccessPointData.stations[sta->address] = Ieee80211Mib::AUTHENTICATED; // TODO only when ACK of this frame arrives if (wasAssociated) mib->releaseAssociationId(sta->address); @@ -320,6 +327,8 @@ void Ieee80211MgmtAp::handleDeauthenticationFrame(Packet *packet, const PtrbssAccessPointData.stations[sta->address] == Ieee80211Mib::ASSOCIATED; // mark STA as not authenticated; alternatively, it could also be removed from staList + if (wasAssociated) + resetPeerAgreements(sta->address); mib->bssAccessPointData.stations[sta->address] = Ieee80211Mib::NOT_AUTHENTICATED; sta->authSeqExpected = 1; if (wasAssociated) @@ -523,6 +532,8 @@ void Ieee80211MgmtAp::handleDisassociationFrame(Packet *packet, const PtrbssAccessPointData.stations[sta->address] == Ieee80211Mib::ASSOCIATED; + if (wasAssociated) + resetPeerAgreements(sta->address); mib->bssAccessPointData.stations[sta->address] = Ieee80211Mib::AUTHENTICATED; if (wasAssociated) mib->releaseAssociationId(sta->address); diff --git a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.cc b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.cc index 3276906bbaa..5e61e81d759 100644 --- a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.cc +++ b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.cc @@ -17,6 +17,7 @@ #include "inet/common/lifecycle/NodeStatus.h" #include "inet/linklayer/common/InterfaceTag_m.h" #include "inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h" +#include "inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h" #include "inet/networklayer/common/NetworkInterface.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" @@ -26,6 +27,12 @@ namespace ieee80211 { using namespace inet::physicallayer; +void Ieee80211MgmtBase::resetPeerAgreements(const MacAddress& peer) +{ + auto mac = getModuleFromPar(par("macModule"), this); + check_and_cast(mac)->resetPeerAgreements(peer); +} + void Ieee80211MgmtBase::initialize(int stage) { OperationalBase::initialize(stage); diff --git a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.h b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.h index e05f29ace6c..10baef736c4 100644 --- a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.h +++ b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtBase.h @@ -62,6 +62,7 @@ class INET_API Ieee80211MgmtBase : public OperationalBase, public cListener /** Utility method to dispose of an unhandled frame */ virtual void dropManagementFrame(Packet *frame); + void resetPeerAgreements(const MacAddress& peer); // Convert the modeled legacy rate elements to the existing MIB representation. static Ieee80211RateSetState makeRateSet(const Ieee80211SupportedRatesElement& rates, diff --git a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtSta.cc b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtSta.cc index 5a2c15ca8b3..1bf033e08b0 100644 --- a/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtSta.cc +++ b/src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtSta.cc @@ -622,6 +622,7 @@ void Ieee80211MgmtSta::clearCurrentAssociation() { ASSERT(mib->bssStationData.isAssociated); auto address = assocAP.address; + resetPeerAgreements(address); mib->bssStationData.isAssociated = false; cancelAndDelete(assocAP.beaconTimeoutMsg); assocAP.beaconTimeoutMsg = nullptr; diff --git a/tests/fingerprint/examples.csv b/tests/fingerprint/examples.csv index 3ae180b8557..88293c812bb 100644 --- a/tests/fingerprint/examples.csv +++ b/tests/fingerprint/examples.csv @@ -7,7 +7,7 @@ # /examples/adhoc/ieee80211/, -f omnetpp.ini -c Ping2 -r 0, 100s, 0000-0000/tplx;0000-0000/~tNl;0000-0000/~tND, ERROR, wireless adhoc # [Config Ping2] # interactive config, needed a *.numHosts parameter /examples/adhoc/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 5749-0281/tplx;f38a-cb93/~tNl;c2ed-b352/~tND;0eb8-3e3b/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;2c1e-66e5/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, b80d-4ae8/tplx;72b7-86c2/~tNl;d385-62e0/~tND;a587-3a4d/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 5fbb-9fd9/tplx;c0a4-97f6/~tNl;2373-df01/~tND;a587-3a4d/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;33b7-00f9/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, 2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;df04-18f7/tyf, PASS, wireless adhoc Ipv4 @@ -658,7 +658,7 @@ /examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, d929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;9f3c-4512/tyf, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;317d-aa4f/~tND;a4c3-19bf/tyf, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;b2d6-1329/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, fbab-b84e/tplx;47cb-b9e5/~tNl;c4f3-fa00/~tND;08b5-d005/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, f8a4-9474/tplx;1cba-cccc/~tNl;538e-67df/~tND;08b5-d005/tyf, PASS, wireless Ipv4 /examples/wireless/ratecontrol/, -f omnetpp.ini -c Mac -r 0, 100s, bf30-2f13/tplx;7b2f-653d/~tNl;6f09-d8eb/~tND;19fe-8b0e/tyf, PASS, wireless diff --git a/tests/fingerprint/showcases.csv b/tests/fingerprint/showcases.csv index 572d1330c90..836d42b5183 100644 --- a/tests/fingerprint/showcases.csv +++ b/tests/fingerprint/showcases.csv @@ -199,9 +199,9 @@ /showcases/wireless/analogmodel/, -f omnetpp.ini -c Distance -r 0, 2.5s, 1e75-270e/tplx;6d7a-d84c/~tNl;7b7c-2bfb/~tND;5575-fd8f/tyf, PASS, wireless Ipv4 /showcases/wireless/analogmodel/, -f omnetpp.ini -c Noise -r 0, 0.1s, dd08-a63c/tplx;e167-9c84/~tNl;d680-b8ad/~tND;0d1f-df73/tyf, PASS, wireless Ipv4 -/showcases/wireless/blockack/, -f omnetpp.ini -c NoFragmentation -r 0, 1s, 1082-899c/tplx;0068-9ae9/~tNl;e0b3-3193/~tND, PASS, wireless Ipv4 -/showcases/wireless/blockack/, -f omnetpp.ini -c Fragmentation -r 0, 1s, 2235-516d/tplx;7b51-e67c/~tNl;9a3f-afc7/~tND, PASS, wireless Ipv4 -/showcases/wireless/blockack/, -f omnetpp.ini -c MixedTraffic -r 0, 1s, 8bfb-6ac9/tplx;5647-2cd1/~tNl;481a-ec9d/~tND, PASS, wireless Ipv4 +/showcases/wireless/blockack/, -f omnetpp.ini -c NoFragmentation -r 0, 1s, b828-6bd6/tplx;026f-2c6d/~tNl;2cd4-4795/~tND, PASS, wireless Ipv4 +/showcases/wireless/blockack/, -f omnetpp.ini -c Fragmentation -r 0, 1s, 021a-d29a/tplx;1597-ec6a/~tNl;feff-7e88/~tND, PASS, wireless Ipv4 +/showcases/wireless/blockack/, -f omnetpp.ini -c MixedTraffic -r 0, 1s, 5b9e-801f/tplx;8731-2504/~tNl;9724-d1ce/~tND, PASS, wireless Ipv4 /showcases/wireless/crosstalk/, -f omnetpp.ini -c CompletelyOverlappingFrequencyBands -r 0, 1s, d0d7-43e0/tplx;867a-07a4/~tNl;fc60-7eb7/~tND;3ea3-43da/tyf, PASS, wireless Ipv4 /showcases/wireless/crosstalk/, -f omnetpp.ini -c IndependentFrequencyBandsOneRadioMediumModule -r 0, 1s, 70c6-72b6/tplx;cf96-5e4d/~tNl;6f3a-074a/~tND;d1b2-9fd4/tyf, PASS, wireless Ipv4 @@ -267,7 +267,7 @@ /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFnofrag -r 0, 1s, 52b9-628f/tplx;3fec-74a2/~tNl;dbb5-67b0/~tND;8871-1dd1/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;f985-34fb/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;335d-6687/tyf, PASS, wireless Ipv4 -/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 4228-9743/tplx;8610-abcd/~tNl;68c2-19f0/~tND;6f6e-b101/tyf, PASS, wireless Ipv4 +/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, f509-65f1/tplx;6b3a-0d65/~tNl;c474-7174/~tND;6f6e-b101/tyf, PASS, wireless Ipv4 /showcases/wireless/handover/, -f omnetpp.ini -c General -r 0, 250s, 6150-7a8b/tplx;bcc9-11d2/~tNl;99fd-923d/~tND;02e9-9ad3/tyf, PASS, wireless @@ -341,5 +341,5 @@ /showcases/wireless/throughput/, -f omnetpp.ini -c General -r 0, 1s, 030e-c416/tplx;66e6-0bca/~tNl;3cb5-d354/~tND;e6a5-bde0/tyf, PASS, wireless Ipv4 -/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, 4ffd-4fbf/tplx;3a89-2021/~tNl;c87d-3f3a/tyf, PASS, wireless Ipv4 +/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, f58d-d2fd/tplx;38f7-f642/~tNl;c87d-3f3a/tyf, PASS, wireless Ipv4 diff --git a/tests/module/Ieee80211BlockAckActionDelivery_1.test b/tests/module/Ieee80211BlockAckActionDelivery_1.test new file mode 100644 index 00000000000..b2ac3745b86 --- /dev/null +++ b/tests/module/Ieee80211BlockAckActionDelivery_1.test @@ -0,0 +1,70 @@ +%description: +Check complete Block Ack Action delivery through the production recipient data service. +An original Action reaches HCF. Its MAC retry does not reach the agreement handler. +A new Action with another sequence number remains eligible for dispatch. +Two management fragments produce one complete Action after the final fragment. + +%file: ActionDelivery.cc +#include "inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" + +namespace inet::ieee80211 { +class ActionDeliveryTest : public cSimpleModule { + protected: + void initialize() override { + scheduleAt(SIMTIME_ZERO, new cMessage("test")); + } + void handleMessage(cMessage *message) override { + delete message; + auto service = check_and_cast(getModuleByPath("^.recipient")); + for (int index = 0; index < 6; index++) { + auto header = makeShared(); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); + header->setReceiverAddress(MacAddress("02:00:00:00:00:01")); + header->setSequenceNumber(SequenceNumberCyclic(index < 2 ? 10 : index == 2 ? 11 : 12)); + header->setStartingSequenceNumber(SequenceNumberCyclic(100)); + header->setDialogToken(37); + header->setTid(5); + header->setBufferSize(8); + header->setBlockAckPolicy(true); + header->setRetry(index == 1 || index == 5); + header->setMoreFragments(index == 3); + header->setFragmentNumber(index >= 4 ? 1 : 0); + auto packet = new Packet("action", header); + packet->insertAtBack(makeShared(B(2))); + packet->insertAtBack(makeShared()); + auto frames = service->managementFrameReceived(packet, header); + ASSERT(frames.size() == (index == 0 || index == 2 || index == 4 ? 1 : 0)); + for (auto frame : frames) { + ASSERT(frame->peekAtFront() != nullptr); + take(frame); + delete frame; + } + } + std::cout << "Block Ack Action delivery assertions passed.\n"; + } +}; +Define_Module(ActionDeliveryTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.recipient.RecipientQosMacDataService; +simple ActionDeliveryTest { parameters: @class(::inet::ieee80211::ActionDeliveryTest); } +network ActionDeliveryNetwork { + submodules: + recipient: RecipientQosMacDataService; + test: ActionDeliveryTest; +} + +%inifile: omnetpp.ini +[General] +network = ActionDeliveryNetwork +ned-path = .;../../../../src +sim-time-limit = 1ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false + +%contains: stdout +Block Ack Action delivery assertions passed. diff --git a/tests/module/Ieee80211BlockAckActionDispatch_1.test b/tests/module/Ieee80211BlockAckActionDispatch_1.test new file mode 100644 index 00000000000..1ec9db351e9 --- /dev/null +++ b/tests/module/Ieee80211BlockAckActionDispatch_1.test @@ -0,0 +1,178 @@ +%description: +Check duplicate Block Ack Actions through initialized production HCF. +The test observes response submission without a wireless transmission. +HCF must acknowledge a MAC retry without a second agreement dispatch. + +The deadline check derives 5 ms from an agreement created at 1 ms with a 4 ms timeout. + +%extraargs: -r 0..2 + +%file: ActionDispatch.cc +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class ActionDispatchHcf : public Hcf { + public: + int dispatches = 0; + int acknowledgments = 0; + int responses = 0; + int delivered = 0; + Ptr response; + void checkAgreementDeadline() { + Enter_Method("checkAgreementDeadline"); + receiveRequest(false); + auto expectedDeadline = SimTime(5, SIMTIME_MS); + ASSERT(recipientBlockAckAgreementHandler->computeEarliestExpirationTime() == expectedDeadline); + scheduleInactivityTimer(); + ASSERT(inactivityTimer->getArrivalTime() == expectedDeadline); + cancelEvent(inactivityTimer); + } + void receiveRequest(bool retry) { + Enter_Method("receiveRequest"); + auto header = makeShared(); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); + header->setReceiverAddress(mac->getAddress()); + header->setSequenceNumber(SequenceNumberCyclic(10)); + header->setRetry(retry); + header->setTid(5); + header->setDialogToken(37); + header->setBlockAckPolicy(true); + header->setBufferSize(8); + header->setStartingSequenceNumber(SequenceNumberCyclic(100)); + auto packet = new Packet("request", header); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode( + modeSet->getMode(bps(6000000))); + processLowerFrame(packet, header); + } + void checkNegotiatedWindow() { + Enter_Method("checkNegotiatedWindow"); + receiveRequest(false); + ASSERT(response != nullptr && response->getBufferSize() == 8); + auto agreement = recipientBlockAckAgreementHandler->getAgreement(5, MacAddress("02:00:00:00:00:02")); + ASSERT(agreement != nullptr && agreement->getBufferSize() == 8); + auto bar = makeShared(); + bar->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); + bar->setReceiverAddress(mac->getAddress()); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(104)); + bar->setFragmentNumber(0); + auto request = new Packet("bar-before-data", bar); + request->addTag()->setMode(modeSet->getMode(bps(6000000))); + processLowerFrame(request, bar); + ASSERT(delivered == 0); + auto data = makeShared(); + data->setType(ST_DATA_WITH_QOS); + data->addChunkLength(QOSCONTROL_PART_LENGTH); + data->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); + data->setReceiverAddress(mac->getAddress()); + data->setAddress3(data->getTransmitterAddress()); + data->setTid(5); + data->setSequenceNumber(SequenceNumberCyclic(104)); + data->setAckPolicy(BLOCK_ACK); + auto packet = new Packet("first-data", data); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + processLowerFrame(packet, data); + ASSERT(delivered == 1); + } + protected: + void sendUp(const std::vector& frames) override { + for (auto frame : frames) { + delivered++; + take(frame); + delete frame; + } + } + void recipientProcessReceivedManagementFrame(const Ptr& header) override { + dispatches++; + Hcf::recipientProcessReceivedManagementFrame(header); + } + void transmitControlResponseFrame(Packet *packet, const Ptr&, + Packet *, const Ptr&) override { + acknowledgments++; + delete packet; + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + responses++; + response = dynamicPtrCast(header); + delete packet; + } +}; +Define_Module(ActionDispatchHcf); +class ActionDispatchTest : public cSimpleModule { + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("test")); } + void handleMessage(cMessage *message) override { + delete message; + auto hcf = check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf")); + if (par("scenario").intValue() == 1) + hcf->checkAgreementDeadline(); + else if (par("scenario").intValue() == 2) + hcf->checkNegotiatedWindow(); + else { + hcf->receiveRequest(false); + hcf->receiveRequest(true); + ASSERT(hcf->acknowledgments == 2); + ASSERT(hcf->dispatches == 1); + ASSERT(hcf->responses == 1); + ASSERT(hcf->response != nullptr && hcf->response->getStatusCode() == SC_SUCCESSFUL); + ASSERT(hcf->response->getDialogToken() == 37); + ASSERT(hcf->response->getBufferSize() == 64); + ASSERT(hcf->response->getBlockAckTimeoutValue() == SimTime(4, SIMTIME_MS)); + } + std::cout << "Block Ack Action dispatch assertions passed.\n"; + } +}; +Define_Module(ActionDispatchTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module ActionDispatchHcf extends Hcf { parameters: @class(::inet::ieee80211::ActionDispatchHcf); } +simple ActionDispatchTest { parameters: int scenario; @class(::inet::ieee80211::ActionDispatchTest); } +network ActionDispatchNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: ActionDispatchTest; +} + +%inifile: omnetpp.ini +[General] +network = ActionDispatchNetwork +ned-path = .;../../../../src +sim-time-limit = 2ms +seed-set = 0 +*.test.scenario = ${scenario=0,1,2} +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "ActionDispatchHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.recipientBlockAckAgreementPolicy.blockAckTimeoutValue = 4ms +**.wlan[*].mac.hcf.recipientBlockAckAgreementPolicy.maximumAllowedBufferSize = ${scenario} == 2 ? 8 : 64 +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m + +%contains: stdout +Block Ack Action dispatch assertions passed. diff --git a/tests/module/Ieee80211BlockAckActionDisposal_1.test b/tests/module/Ieee80211BlockAckActionDisposal_1.test new file mode 100644 index 00000000000..b8444ee40c4 --- /dev/null +++ b/tests/module/Ieee80211BlockAckActionDisposal_1.test @@ -0,0 +1,470 @@ +%description: +Check owned Block Ack Actions through actual pending-queue overflow. Request disposal before transmission cancels initial setup without teardown. Successful response disposal preserves its recipient agreement. Originator DELBA disposal drops its deferred batch and leaves recovery required. + +Later DATA starts another recovery DELBA. Recipient DELBA disposal preserves the opposite role. Later VO queue eviction must release deferred BE DATA without another BE arrival. An isolated cleanup case supplies another peer's retry through the production recovery API. Reset must clear a retry from an actual failed RTS before the protected Action transmits. + +The fixture supplies agreement records and does not transmit frames through a peer radio. + +%extraargs: -r 0..10 + +%file: ActionDisposal.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/queueing/queue/PacketQueue.h" + +namespace inet::ieee80211 { +class DisposalQueue : public queueing::PacketQueue { + public: + void setCapacity(int capacity) { packetCapacity = capacity; } +}; +Define_Module(DisposalQueue); +class DisposalOriginator : public OriginatorBlockAckAgreementHandler { + public: + void accept(MacAddress peer, Tid tid = 5) { + auto agreement = new OriginatorBlockAckAgreement(peer, tid, SequenceNumberCyclic(100), 64, false, false); + agreement->setIsAddbaRequestSent(true); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(SIMTIME_ZERO); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, tid}] = agreement; + } + void prepare(const Ptr& request) { createAgreement(request); } +}; +class DisposalRecipient : public RecipientBlockAckAgreementHandler { + public: + void accept(MacAddress peer) { + auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(100), 64, SIMTIME_ZERO); + agreement->addbaResposneSent(); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + } +}; +class ActionDisposalHcf : public Hcf { + public: + const MacAddress peer = MacAddress("02:00:00:00:00:02"); + int queueDrops = 0; + int requestDrops = 0; + int responseDrops = 0; + int delbaDrops = 0; + int delbaSubmissions = 0; + int attempts = 0; + int beAdmissions = 0; + int beAttempts = 0; + int requestAttempts = 0; + simtime_t firstBeAttempt = SIMTIME_MAX; + simtime_t beDeadline = SIMTIME_MAX; + Ptr rtsChargedHeader; + int selectedScenario = -1; + void run(int scenario) { + Enter_Method("run"); + selectedScenario = scenario; + delete originatorBlockAckAgreementHandler; + delete recipientBlockAckAgreementHandler; + auto originator = new DisposalOriginator(); + auto recipient = new DisposalRecipient(); + originatorBlockAckAgreementHandler = originator; + recipientBlockAckAgreementHandler = recipient; + auto queue = check_and_cast(edca->getEdcaf(AC_VO)->getPendingQueue()); + if (scenario == 9 || scenario == 10) { + queue->setCapacity(100); + queuePendingBeRequest(); + return; + } + if (scenario == 8) { + queue->setCapacity(100); + originator->accept(peer, 0); + beginTeardown(peer, 0, true, 37); + queueData("deferred-be-after-delba", 0); + ASSERT(!check_and_cast(edca->getEdcaf(AC_BE)->getSubmodule("contention"))->isContentionInProgress()); + scheduleAfter(SimTime(10, SIMTIME_MS), new cMessage("verifyBeResume")); + return; + } + if (scenario == 6) { + queue->setCapacity(1); + queueVoice("voice-blocker", B(1000)); + return; + } + if (scenario == 7) { + queue->setCapacity(100); + auto edcaf = edca->getEdcaf(AC_VO); + auto recovery = edcaf->getMgmtAndNonQoSRecoveryProcedure(); + auto other = makeShared(); + other->setReceiverAddress(MacAddress("02:00:00:00:00:03")); + other->setSequenceNumber(SequenceNumberCyclic(0)); + auto otherPacket = new Packet("other-peer-retry", other); + recovery->dataOrMgmtFrameTransmissionFailed(otherPacket, other, edcaf->getStationRetryCounters()); + ASSERT(recovery->getRetryCount(otherPacket, other) == 1); + queuePendingBeRequest(); + auto selected = edcaf->getInProgressFrames()->getFrameToTransmit(); + ASSERT(dynamicPtrCast(selected->peekAtFront()) != nullptr); + ASSERT(edcaf->getInProgressFrames()->getLength() == 1); + auto request = edcaf->getInProgressFrames()->getFrames(0)->peekAtFront(); + ASSERT(request->getSequenceNumber() == other->getSequenceNumber()); + ASSERT(request->getFragmentNumber() == other->getFragmentNumber()); + ASSERT(attempts == 0); + resetPeer(peer); + ASSERT(recovery->getRetryCount(otherPacket, other) == 1); + ASSERT(ownedActions.empty()); + delete otherPacket; + std::cout << "Block Ack Action disposal assertions passed.\n"; + endSimulation(); + } + queue->setCapacity(scenario == 4 ? 1 : scenario == 5 ? 100 : 0); + handlingAgreementAction = true; + if (scenario == 0 || scenario == 4) { + auto request = makeShared(); + request->setTransmitterAddress(mac->getAddress()); + request->setReceiverAddress(peer); + request->setTid(5); + request->setDialogToken(37); + request->setBufferSize(64); + request->setBlockAckPolicy(true); + request->setStartingSequenceNumber(SequenceNumberCyclic(100)); + originator->prepare(request); + queueData("deferred"); + processMgmtFrame(new Packet("request", request), request); + if (scenario == 4) { + ASSERT(queue->getNumPackets() == 1); + auto filler = makeShared(); + filler->setReceiverAddress(peer); + filler->setType(ST_PROBEREQUEST); + processUpperFrame(new Packet("filler", filler), filler); + } + ASSERT(requestDrops == 1); + ASSERT(originator->getAgreement(peer, 5) == nullptr); + ASSERT(originator->getProcedures().count({peer, 5}) == 0); + ASSERT(delbaSubmissions == 0); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 1); + } + else if (scenario == 1) { + originator->accept(peer); + auto request = makeShared(); + request->setTransmitterAddress(peer); + request->setReceiverAddress(mac->getAddress()); + request->setTid(5); + request->setDialogToken(37); + request->setSequenceNumber(SequenceNumberCyclic(10)); + request->setBufferSize(64); + request->setBlockAckPolicy(true); + request->setStartingSequenceNumber(SequenceNumberCyclic(100)); + auto packet = new Packet("incoming-request", request); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + processLowerFrame(packet, request); + ASSERT(responseDrops == 1); + ASSERT(recipient->getAgreement(5, peer) != nullptr); + ASSERT(originator->getAgreement(peer, 5) != nullptr); + } + else { + originator->accept(peer); + recipient->accept(peer); + if (scenario == 2 || scenario == 5) { + queueData("batch-first"); + queueData("batch-second"); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 2); + beginTeardown(peer, 5, true, 37); + if (scenario == 5) { + handlingAgreementAction = false; + updateContention(); + scheduleAfter(SimTime(2, SIMTIME_MS), new cMessage("delbaFailure")); + return; + } + ASSERT(originator->getAgreement(peer, 5) == nullptr); + ASSERT(recipient->getAgreement(5, peer) != nullptr); + ASSERT(originator->getProcedures().at({peer, 5}).state == IOriginatorBlockAckAgreementHandler::ProcedureState::RECOVERY_NEEDED); + ASSERT(!hasQueuedData(peer, 5)); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 0); + ASSERT(delbaDrops == 1); + ASSERT(delbaSubmissions == 1); + queue->setCapacity(100); + queueData("later"); + ASSERT(delbaSubmissions == 2); + ASSERT(originator->getProcedures().at({peer, 5}).state == IOriginatorBlockAckAgreementHandler::ProcedureState::TEARDOWN_PENDING); + ASSERT(hasQueuedData(peer, 5)); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 1); + } + else { + beginTeardown(peer, 5, false, 37); + ASSERT(recipient->getAgreement(5, peer) == nullptr); + ASSERT(originator->getAgreement(peer, 5) != nullptr); + ASSERT(!recipient->isTeardownPending(peer, 5)); + ASSERT(delbaDrops == 1); + } + } + ASSERT(attempts == 0); + ASSERT(queueDrops == 1); + if (scenario != 2) + ASSERT(ownedActions.empty()); + handlingAgreementAction = false; + std::cout << "Block Ack Action disposal assertions passed.\n"; + endSimulation(); + } + protected: + void handleMessage(cMessage *message) override { + if (message->isName("verifyRtsTerminal")) { + delete message; + ASSERT(rtsChargedHeader != nullptr); + ASSERT(attempts == 1); + ASSERT(requestAttempts == 0); + ASSERT(queueDrops == 0); + ASSERT(edca->getEdcaf(AC_VO)->getMgmtAndNonQoSRecoveryProcedure()->getShortRetryCount(nullptr, rtsChargedHeader) == 0); + ASSERT(ownedActions.empty()); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(peer, 0) == nullptr); + ASSERT(originatorBlockAckAgreementHandler->getProcedures().count({peer, 0}) == 0); + std::cout << "Block Ack Action disposal assertions passed.\n"; + endSimulation(); + } + if (message->isName("resetAfterRtsFailure")) { + delete message; + auto recovery = edca->getEdcaf(AC_VO)->getMgmtAndNonQoSRecoveryProcedure(); + ASSERT(rtsChargedHeader != nullptr); + ASSERT(recovery->getShortRetryCount(nullptr, rtsChargedHeader) == 1); + ASSERT(requestAttempts == 0); + resetPeer(peer); + ASSERT(recovery->getShortRetryCount(nullptr, rtsChargedHeader) == 0); + ASSERT(ownedActions.empty()); + std::cout << "Block Ack Action disposal assertions passed.\n"; + endSimulation(); + } + if (message->isName("delbaAck")) { + delete message; + auto header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + auto packet = new Packet("delba-ack", header); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + processLowerFrame(packet, header); + ASSERT(originatorBlockAckAgreementHandler->getProcedures().count({peer, 0}) == 0); + return; + } + if (message->isName("queueDeferredBe")) { + delete message; + ASSERT(tx->hasTransmission()); + auto contention = check_and_cast(edca->getEdcaf(AC_BE)->getSubmodule("contention")); + ASSERT(!contention->isContentionInProgress()); + queuePendingBeRequest(); + ASSERT(!contention->isContentionInProgress()); + ASSERT(edca->getEdcaf(AC_VO)->getPendingQueue()->getNumPackets() == 1); + ASSERT(requestAttempts == 0); + scheduleAfter(SimTime(100, SIMTIME_US), new cMessage("evictPendingRequest")); + return; + } + if (message->isName("evictPendingRequest")) { + delete message; + auto contention = check_and_cast(edca->getEdcaf(AC_BE)->getSubmodule("contention")); + ASSERT(!contention->isContentionInProgress()); + ASSERT(tx->hasTransmission()); + queueVoice("voice-evictor", B(10)); + ASSERT(requestDrops == 1); + ASSERT(requestAttempts == 0); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(peer, 0) == nullptr); + ASSERT(originatorBlockAckAgreementHandler->getProcedures().count({peer, 0}) == 0); + ASSERT(hasQueuedData(peer, 0)); + scheduleAfter(SimTime(10, SIMTIME_MS), new cMessage("verifyBeResume")); + return; + } + if (message->isName("verifyBeResume")) { + delete message; + ASSERT(beAdmissions == 1); + ASSERT(beAttempts >= 1); + ASSERT(firstBeAttempt < beDeadline); + ASSERT(simTime() < beDeadline); + ASSERT(requestAttempts == 0); + std::cout << "Block Ack Action disposal assertions passed.\n"; + endSimulation(); + } + if (!message->isName("delbaFailure")) { + Hcf::handleMessage(message); + return; + } + delete message; + ASSERT(attempts == 1); + ASSERT(queueDrops == 0); + ASSERT(delbaSubmissions == 1); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(peer, 5) == nullptr); + ASSERT(recipientBlockAckAgreementHandler->getAgreement(5, peer) != nullptr); + ASSERT(originatorBlockAckAgreementHandler->getProcedures().at({peer, 5}).state == IOriginatorBlockAckAgreementHandler::ProcedureState::RECOVERY_NEEDED); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 0); + ASSERT(!hasQueuedData(peer, 5)); + ASSERT(ownedActions.empty()); + handlingAgreementAction = true; + queueData("later-after-retry-limit"); + ASSERT(delbaSubmissions == 2); + ASSERT(originatorBlockAckAgreementHandler->getProcedures().at({peer, 5}).state == IOriginatorBlockAckAgreementHandler::ProcedureState::TEARDOWN_PENDING); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 1); + handlingAgreementAction = false; + std::cout << "Block Ack Action disposal assertions passed.\n"; + endSimulation(); + } + void queueVoice(const char *name, B payload) { + auto header = makeShared(); + header->setType(ST_PROBEREQUEST); + header->setReceiverAddress(MacAddress("02:00:00:00:00:03")); + auto packet = new Packet(name, header); + packet->insertAtBack(makeShared(payload)); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + } + void queuePendingBeRequest() { + auto request = makeShared(); + request->setTransmitterAddress(mac->getAddress()); + request->setReceiverAddress(peer); + request->setTid(0); + request->setDialogToken(37); + request->setBlockAckPolicy(true); + request->setBufferSize(64); + request->setStartingSequenceNumber(SequenceNumberCyclic(0)); + check_and_cast(originatorBlockAckAgreementHandler)->prepare(request); + queueData("deferred-be", 0); + processMgmtFrame(new Packet("pending-be-request", request), request); + } + void queueData(const char *name, Tid tid = 5) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTransmitterAddress(mac->getAddress()); + header->setReceiverAddress(peer); + header->setAddress3(peer); + header->setTid(tid); + auto packet = new Packet(name, header); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + if (tid == 0) { + beAdmissions++; + beDeadline = edca->getLifetimeHandler()->getDeadline(packet); + } + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *details) override { + if (signal == packetDroppedSignal && dynamic_cast(source) != nullptr) { + queueDrops++; + auto packet = check_and_cast(object); + auto header = packet->peekAtFront(); + requestDrops += dynamicPtrCast(header) != nullptr; + responseDrops += dynamicPtrCast(header) != nullptr; + delbaDrops += dynamicPtrCast(header) != nullptr; + } + Hcf::receiveSignal(source, signal, object, details); + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) + delbaSubmissions++; + Hcf::processMgmtFrame(packet, header); + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + attempts++; + auto header = packet->peekAtFront(); + auto data = dynamicPtrCast(header); + bool accepted = Hcf::transmitFrame(packet, ifs); + if (accepted && packet->isName("voice-blocker")) + scheduleAfter(SimTime(1, SIMTIME_NS), new cMessage("queueDeferredBe")); + if (accepted && data && data->getTid() == 0) { + beAttempts++; + firstBeAttempt = std::min(firstBeAttempt, simTime()); + } + if (accepted && dynamicPtrCast(header)) + requestAttempts++; + return accepted; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + Enter_Method("transmissionComplete"); + bool delba = dynamicPtrCast(header) != nullptr; + Hcf::transmissionComplete(packet, header); + if (delba && beAdmissions == 1) + scheduleAfter(SimTime(60, SIMTIME_US), new cMessage("delbaAck")); + } + void originatorProcessRtsProtectionFailed(Packet *packet) override { + Enter_Method("originatorProcessRtsProtectionFailed"); + auto request = dynamicPtrCast(packet->peekAtFront()); + Hcf::originatorProcessRtsProtectionFailed(packet); + if (request && selectedScenario == 10) { + rtsChargedHeader = request; + scheduleAfter(SimTime(1, SIMTIME_NS), new cMessage("verifyRtsTerminal")); + return; + } + if (request && !rtsChargedHeader) { + ASSERT(requestAttempts == 0); + ASSERT(ownedActions.count(packet->getId()) == 1); + ASSERT(!ownedActions.at(packet->getId()).attempted); + ASSERT(edca->getEdcaf(AC_VO)->getMgmtAndNonQoSRecoveryProcedure()->getShortRetryCount(packet, request) == 1); + rtsChargedHeader = request; + scheduleAfter(SimTime(1, SIMTIME_NS), new cMessage("resetAfterRtsFailure")); + } + } + void transmitControlResponseFrame(Packet *packet, const Ptr&, + Packet *, const Ptr&) override { delete packet; } + void sendUp(const std::vector& packets) override { + for (auto packet : packets) { + take(packet); + delete packet; + } + } +}; +Define_Module(ActionDisposalHcf); +class ActionDisposalTest : public cSimpleModule { + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("test")); } + void handleMessage(cMessage *message) override { + delete message; + check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf"))->run(par("scenario")); + } +}; +Define_Module(ActionDisposalTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.queue.PendingQueue; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module ActionDisposalHcf extends Hcf { parameters: @class(::inet::ieee80211::ActionDisposalHcf); } +simple DisposalQueue extends PendingQueue { parameters: @class(::inet::ieee80211::DisposalQueue); } +simple ActionDisposalTest { parameters: int scenario; @class(::inet::ieee80211::ActionDisposalTest); } +network ActionDisposalNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: ActionDisposalTest; +} + +%inifile: omnetpp.ini +[General] +network = ActionDisposalNetwork +ned-path = .;../../../../src +sim-time-limit = 20ms +seed-set = 0 +*.test.scenario = ${scenario=0..10} +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "ActionDisposalHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.originatorAckPolicy.ackTimeout = 1ms +**.mgmtAndNonQoSRecoveryProcedure.shortRetryLimit = ${scenario} == 9 ? 3 : 1 +**.mgmtAndNonQoSRecoveryProcedure.longRetryLimit = 1 +**.wlan[*].mac.hcf.rtsPolicy.rtsThreshold = (${scenario} == 9 || ${scenario} == 10) ? 0B : 2346B +**.wlan[*].mac.hcf.rtsPolicy.ctsTimeout = 1ms +**.wlan[*].mac.hcf.edca.edcaf[*].pendingQueue.typename = "DisposalQueue" +**.wlan[*].mac.hcf.edca.edcaf[*].pendingQueue.dropperClass = "inet::queueing::PacketAtCollectionBeginDropper" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m + +%contains: stdout +Block Ack Action disposal assertions passed. diff --git a/tests/module/Ieee80211BlockAckAdmission_1.test b/tests/module/Ieee80211BlockAckAdmission_1.test new file mode 100644 index 00000000000..ef1c114ebfa --- /dev/null +++ b/tests/module/Ieee80211BlockAckAdmission_1.test @@ -0,0 +1,132 @@ +%description: +Check isolated profile admission through initialized production policies. +Basic permits legacy capability state. Compressed requires local and peer HT eligibility. +The fixture leaves production HCF on Basic and creates no Compressed agreement. + +%file: Admission.cc +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h" + +namespace inet::ieee80211 { +class AdmissionTest : public cSimpleModule { + protected: + void checkResponse(IOriginatorBlockAckAgreementPolicy *policy) { + const MacAddress peer("02:00:00:00:00:02"); + OriginatorBlockAckAgreement agreement(peer, 5, SequenceNumberCyclic(100), 64, true, false); + agreement.setDialogToken(37); + auto response = makeShared(); + response->setTransmitterAddress(peer); + response->setTid(5); + response->setDialogToken(37); + response->setStatusCode(SC_SUCCESSFUL); + response->setBlockAckPolicy(true); + response->setBufferSize(8); + ASSERT(policy->isAddbaReqAccepted(response, &agreement)); + ASSERT(!policy->isAddbaReqAccepted(response, nullptr)); + response->setDialogToken(0); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + response->setDialogToken(38); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + response->setDialogToken(37); + response->setTid(4); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + response->setTid(5); + response->setTransmitterAddress(MacAddress("02:00:00:00:00:03")); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + response->setTransmitterAddress(peer); + response->setStatusCode(SC_UNSPECIFIED); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + response->setStatusCode(SC_SUCCESSFUL); + response->setBlockAckPolicy(false); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + response->setBlockAckPolicy(true); + response->setBufferSize(0); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + response->setBufferSize(8); + agreement.setIsAddbaResponseReceived(true); + ASSERT(!policy->isAddbaReqAccepted(response, &agreement)); + } + + void checkRequest(IRecipientBlockAckAgreementPolicy *policy) { + auto request = makeShared(); + request->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); + request->setTid(5); + request->setDialogToken(37); + request->setStartingSequenceNumber(SequenceNumberCyclic(100)); + request->setBlockAckPolicy(true); + for (int size : {0, 8, 64, 128}) { + request->setBufferSize(size); + ASSERT(policy->isAddbaReqAccepted(request)); + } + request->setBlockAckPolicy(false); + ASSERT(!policy->isAddbaReqAccepted(request)); + request->setBlockAckPolicy(true); + request->setDialogToken(0); + ASSERT(!policy->isAddbaReqAccepted(request)); + request->setDialogToken(37); + request->setTransmitterAddress(MacAddress::BROADCAST_ADDRESS); + ASSERT(!policy->isAddbaReqAccepted(request)); + } + + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("test")); } + void handleMessage(cMessage *message) override { + delete message; + auto originator = check_and_cast( + getModuleByPath("^.host.wlan[0].mac.hcf.originatorBlockAckAgreementPolicy")); + auto recipient = check_and_cast( + getModuleByPath("^.host.wlan[0].mac.hcf.recipientBlockAckAgreementPolicy")); + checkResponse(originator); + checkRequest(recipient); + for (bool localHt : {false, true}) { + for (bool peerHt : {false, true}) { + ASSERT(originator->isProfileAllowed(BlockAckVariant::BASIC, localHt, peerHt)); + ASSERT(recipient->isProfileAllowed(BlockAckVariant::BASIC, localHt, peerHt)); + ASSERT(originator->isProfileAllowed(BlockAckVariant::COMPRESSED, localHt, peerHt) == (localHt && peerHt)); + ASSERT(recipient->isProfileAllowed(BlockAckVariant::COMPRESSED, localHt, peerHt) == (localHt && peerHt)); + } + } + std::cout << "Block Ack admission assertions passed.\n"; + } +}; +Define_Module(AdmissionTest); +} + +%file: test.ned +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +simple AdmissionTest { parameters: @class(::inet::ieee80211::AdmissionTest); } +network AdmissionNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: AdmissionTest; +} + +%inifile: omnetpp.ini +[General] +network = AdmissionNetwork +ned-path = .;../../../../src +sim-time-limit = 2ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m + +%contains: stdout +Block Ack admission assertions passed. diff --git a/tests/module/Ieee80211BlockAckAssociationReset_1.test b/tests/module/Ieee80211BlockAckAssociationReset_1.test new file mode 100644 index 00000000000..f63356732b5 --- /dev/null +++ b/tests/module/Ieee80211BlockAckAssociationReset_1.test @@ -0,0 +1,451 @@ +%description: +Check Basic agreement cleanup through AP and STA management after a real association. AP reassociation uses identical capability and rate fields. Deletion callbacks require removal of both roles before the first callback. Another peer remains unchanged. Rate callbacks require coherent committed state. The fixture supplies Block Ack agreements and controlled management completion. + +The handler's waiting phase records a completed eligible DATA transmission until another DATA packet arrives. Reassociation removes this phase. A lone DATA packet in the new association must not cause ADDBA. + +%extraargs: -r 0..15 + +%file: AssociationReset.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtSta.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class ResetOriginator : public OriginatorBlockAckAgreementHandler { + public: + void accept(MacAddress peer) { + auto agreement = new OriginatorBlockAckAgreement(peer, 5, SequenceNumberCyclic(100), 64, false, false); + agreement->setIsAddbaRequestSent(true); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(SIMTIME_ZERO); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + } +}; +class ResetRecipient : public RecipientBlockAckAgreementHandler { + public: + void accept(MacAddress peer) { + auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(100), 64, SIMTIME_ZERO); + agreement->addbaResposneSent(); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + } +}; +class AssociationResetHcf : public Hcf { + public: + MacAddress selected; + const MacAddress other = MacAddress("02:00:00:00:00:09"); + int deletions = 0; + int deliveries = 0; + bool observeData = false; + bool retainRealAcks = false; + bool checkOtherProcedure = true; + int addbaRequests = 0; + int dataAttempts = 0; + int dataCompletions = 0; + void prepare(MacAddress peer) { + Enter_Method("prepare"); + selected = peer; + observeData = true; + delete originatorBlockAckAgreementHandler; + delete recipientBlockAckAgreementHandler; + auto originator = new ResetOriginator(); + auto recipient = new ResetRecipient(); + originatorBlockAckAgreementHandler = originator; + recipientBlockAckAgreementHandler = recipient; + for (auto address : {selected, other}) { + originator->accept(address); + recipient->accept(address); + originator->beginSetupIntent(address, 6); + } + subscribe(blockAckAgreementDeletedSignal, this); + } + void receiveNormalAckFragment(int fragment, bool more) { + Enter_Method("receiveNormalAckFragment"); + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTransmitterAddress(selected); + header->setReceiverAddress(mib->address); + header->setAddress3(selected); + header->setTid(7); + header->setSequenceNumber(SequenceNumberCyclic(100)); + header->setFragmentNumber(fragment); + header->setMoreFragments(more); + header->setAckPolicy(NORMAL_ACK); + auto packet = new Packet(fragment == 0 ? "old-unit-frag0" : "new-unit-frag1", header); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + processLowerFrame(packet, header); + } + bool hasBoth(MacAddress peer) const { + return originatorBlockAckAgreementHandler->getAgreement(peer, 5) != nullptr && + recipientBlockAckAgreementHandler->getAgreement(5, peer) != nullptr; + } + bool hasNeither(MacAddress peer) const { + return originatorBlockAckAgreementHandler->getAgreement(peer, 5) == nullptr && + recipientBlockAckAgreementHandler->getAgreement(5, peer) == nullptr; + } + bool waitsForSuccessor() const { + const auto& procedures = originatorBlockAckAgreementHandler->getProcedures(); + auto it = procedures.find({selected, 6}); + return it != procedures.end() && it->second.state == IOriginatorBlockAckAgreementHandler::ProcedureState::WAITING_FOR_SUCCESSOR; + } + bool hasSuccessorProcedure() const { + return originatorBlockAckAgreementHandler->getProcedures().count({selected, 6}) != 0; + } + void clearSeededSuccessorIntent() { + Enter_Method("clearSeededSuccessorIntent"); + originatorBlockAckAgreementHandler->finishProcedure(selected, 6); + } + void sendEligibleData(const char *name) { + Enter_Method("sendEligibleData"); + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTransmitterAddress(mib->address); + header->setReceiverAddress(selected); + header->setAddress3(mib->address); + header->setTid(6); + auto packet = new Packet(name, header); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + } + protected: + bool transmitFrame(Packet *packet, simtime_t ifs) override { + bool accepted = Hcf::transmitFrame(packet, ifs); + auto data = dynamicPtrCast(packet->peekAtFront()); + if (accepted && data && data->getReceiverAddress() == selected && data->getTid() == 6) { + ASSERT(data->getAckPolicy() == NORMAL_ACK); + dataAttempts++; + } + return accepted; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + Enter_Method("transmissionComplete"); + auto data = dynamicPtrCast(header); + Hcf::transmissionComplete(packet, header); + if (data && data->getReceiverAddress() == selected && data->getTid() == 6) + dataCompletions++; + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) + addbaRequests++; + Hcf::processMgmtFrame(packet, header); + } + void sendUp(const std::vector& packets) override { + for (auto packet : packets) { + if (observeData && dynamicPtrCast(packet->peekAtFront())) { + deliveries++; + take(packet); + delete packet; + } + else + Hcf::sendUp({packet}); + } + } + void transmitControlResponseFrame(Packet *packet, const Ptr& header, + Packet *received, const Ptr& receivedHeader) override { + if (observeData && !retainRealAcks) + delete packet; + else + Hcf::transmitControlResponseFrame(packet, header, received, receivedHeader); + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *payload, cObject *details) override { + if (signal != blockAckAgreementDeletedSignal) { + Hcf::receiveSignal(source, signal, payload, details); + return; + } + ASSERT(payload != nullptr); + ASSERT(hasNeither(selected)); + ASSERT(hasBoth(other)); + for (const auto& item : originatorBlockAckAgreementHandler->getProcedures()) + ASSERT(item.first.first != selected); + if (checkOtherProcedure) + ASSERT(originatorBlockAckAgreementHandler->getProcedures().count({other, 6}) == 1); + if (auto originator = dynamic_cast(payload)) { + ASSERT(originator->getReceiverAddr() == selected); + ASSERT(originator->getTid() == 5); + ASSERT(originator->getBufferSize() == 64); + } + else { + auto recipient = check_and_cast(payload); + ASSERT(recipient->getBlockAckRecord()->getOriginatorAddress() == selected); + ASSERT(recipient->getBlockAckRecord()->getTid() == 5); + ASSERT(recipient->getBufferSize() == 64); + } + ASSERT(hasNeither(selected)); + deletions++; + } +}; +Define_Module(AssociationResetHcf); +class AssociationResetAp : public Ieee80211MgmtAp { + public: + Ptr response; + bool controlled = false; + void reassociate(MacAddress peer, const Ptr& original, bool acknowledged = true) { + Enter_Method("reassociate"); + controlled = true; + auto request = makeShared(); + request->setCurrentAP(mib->address); + request->setSSID(original->getSSID()); + request->setSupportedRates(original->getSupportedRates()); + request->setExtendedSupportedRatesPresent(original->getExtendedSupportedRatesPresent()); + request->setExtendedSupportedRates(original->getExtendedSupportedRates()); + request->setHtCapabilitiesPresent(original->getHtCapabilitiesPresent()); + request->setHtCapabilities(original->getHtCapabilities()); + request->setChunkLength(B(100)); + auto packet = new Packet("reassociation", request); + auto header = makeShared(); + header->setTransmitterAddress(peer); + header->setReceiverAddress(mib->address); + header->setType(ST_REASSOCIATIONREQUEST); + handleReassociationRequestFrame(packet, header); + ASSERT(response->getStatusCode() == SC_SUCCESSFUL); + Packet acknowledgment("response-ack"); + auto responseHeader = makeShared(); + responseHeader->setType(ST_REASSOCIATIONRESPONSE); + responseHeader->setReceiverAddress(peer); + acknowledgment.insertAtBack(responseHeader); + acknowledgment.addTag()->setTransactionId(staList.at(peer).pendingAssociationTransactionId); + frameTransmissionFinished(&acknowledgment, acknowledged ? FRAME_TRANSMISSION_STATUS_ACKNOWLEDGED : FRAME_TRANSMISSION_STATUS_RETRY_LIMIT_REACHED); + } + void disassociatePeer(MacAddress peer) { + Enter_Method("disassociatePeer"); + auto packet = new Packet("disassociation", makeShared()); + auto header = makeShared(); + header->setTransmitterAddress(peer); + header->setType(ST_DISASSOCIATION); + handleDisassociationFrame(packet, header); + } + protected: + void sendManagementFrame(const char *name, const Ptr& body, int subtype, + const MacAddress& peer, uint64_t transactionId = 0) override { + if (subtype == ST_ASSOCIATIONRESPONSE || subtype == ST_REASSOCIATIONRESPONSE) + response = dynamicPtrCast(body); + if (!controlled) + Ieee80211MgmtAp::sendManagementFrame(name, body, subtype, peer, transactionId); + } +}; +Define_Module(AssociationResetAp); +class AssociationResetSta : public Ieee80211MgmtSta { + public: + Ptr request; + bool controlled = false; + void reassociate(const Ptr& response, bool accepted = true) { + Enter_Method("reassociate"); + controlled = true; + auto peer = assocAP.address; + auto ap = lookupAP(peer); + ASSERT(ap != nullptr); + startReassociation(ap, SimTime(1, SIMTIME_MS)); + auto body = makeShared(*response); + if (!accepted) + body->setStatusCode(SC_UNSUP_CAP); + auto packet = new Packet("reassociation-response", body); + physicallayer::Ieee80211Channel channel(&physicallayer::Ieee80211CompliantBands::band2_4GHz, 0); + packet->addTag()->setChannel(&channel); + auto header = makeShared(); + header->setTransmitterAddress(peer); + header->setType(ST_REASSOCIATIONRESPONSE); + handleReassociationResponseFrame(packet, header); + ASSERT(mib->bssStationData.isAssociated == accepted); + } + void disassociatePeer() { + Enter_Method("disassociatePeer"); + auto packet = new Packet("disassociation", makeShared()); + auto header = makeShared(); + header->setTransmitterAddress(assocAP.address); + header->setType(ST_DISASSOCIATION); + handleDisassociationFrame(packet, header); + } + protected: + void sendManagementFrame(const char *name, const Ptr& body, int subtype, + const MacAddress& peer) override { + if (subtype == ST_ASSOCIATIONREQUEST) + request = dynamicPtrCast(body); + if (!controlled) + Ieee80211MgmtSta::sendManagementFrame(name, body, subtype, peer); + } +}; +Define_Module(AssociationResetSta); +class AssociationResetTest : public cSimpleModule, public cListener { + Ieee80211Mib *observed = nullptr; + MacAddress observedPeer; + bool expectPresent = true; + int notifications = 0; + protected: + void initialize() override { scheduleAt(SimTime(500, SIMTIME_MS), new cMessage("test")); } + void receiveSignal(cComponent *, simsignal_t, bool, cObject *) override { + const auto *rates = observed->findPeerRateSet(observedPeer); + const auto *ht = observed->findPeerHtState(observedPeer); + if (rates != nullptr) { + ASSERT(rates != nullptr && rates->operational.known); + ASSERT((ht != nullptr) == observed->isHtOperationSupported()); + } + else { + ASSERT(rates == nullptr); + ASSERT(ht == nullptr); + } + notifications++; + } + void handleMessage(cMessage *message) override { + if (message->isName("checkWaitingPhase")) { + delete message; + auto hcf = check_and_cast(getModuleByPath("^.ap.wlan[0].mac.hcf")); + auto ap = check_and_cast(getModuleByPath("^.ap.wlan[0].mgmt")); + auto sta = check_and_cast(getModuleByPath("^.sta.wlan[0].mgmt")); + ASSERT(hcf->dataAttempts == 1); + ASSERT(hcf->dataCompletions == 1); + ASSERT(hcf->addbaRequests == 0); + ASSERT(hcf->waitsForSuccessor()); + ap->reassociate(observedPeer, sta->request); + ASSERT(!hcf->hasSuccessorProcedure()); + ASSERT(hcf->deletions == 2); + hcf->sendEligibleData("new-association-first"); + scheduleAfter(SimTime(2, SIMTIME_MS), new cMessage("checkNewAssociationData")); + return; + } + if (message->isName("checkNewAssociationData")) { + delete message; + auto hcf = check_and_cast(getModuleByPath("^.ap.wlan[0].mac.hcf")); + ASSERT(hcf->dataAttempts == 2); + ASSERT(hcf->dataCompletions == 2); + ASSERT(hcf->addbaRequests == 0); + ASSERT(hcf->waitsForSuccessor()); + ASSERT(hcf->hasNeither(observedPeer)); + ASSERT(hcf->hasBoth(hcf->other)); + std::cout << "Block Ack association-reset assertions passed.\n"; + endSimulation(); + } + delete message; + auto ap = check_and_cast(getModuleByPath("^.ap.wlan[0].mgmt")); + auto sta = check_and_cast(getModuleByPath("^.sta.wlan[0].mgmt")); + auto apMib = check_and_cast(getModuleByPath("^.ap.wlan[0].mib")); + auto staMib = check_and_cast(getModuleByPath("^.sta.wlan[0].mib")); + ASSERT(staMib->bssStationData.isAssociated); + ASSERT(ap->response != nullptr && sta->request != nullptr); + int scenario = par("scenario"); + bool useAp = scenario < 2 || scenario == 4 || scenario == 6 || scenario == 7; + auto hcf = check_and_cast(getModuleByPath(useAp ? "^.ap.wlan[0].mac.hcf" : "^.sta.wlan[0].mac.hcf")); + observed = useAp ? apMib : staMib; + observedPeer = useAp ? staMib->address : apMib->address; + observed->subscribe(Ieee80211Mib::rateStateChangedSignal, this); + hcf->prepare(observedPeer); + if (scenario == 7) { + auto peerHcf = check_and_cast(getModuleByPath("^.sta.wlan[0].mac.hcf")); + peerHcf->observeData = true; + peerHcf->retainRealAcks = true; + hcf->retainRealAcks = true; + hcf->checkOtherProcedure = false; + hcf->clearSeededSuccessorIntent(); + hcf->sendEligibleData("old-association-first"); + scheduleAfter(SimTime(2, SIMTIME_MS), new cMessage("checkWaitingPhase")); + return; + } + expectPresent = scenario == 0 || scenario == 2 || scenario == 4 || scenario == 6; + if (scenario == 6) { + ASSERT(observed->findPeerHtState(observedPeer) != nullptr || !observed->isHtOperationSupported()); + hcf->receiveNormalAckFragment(0, true); + ASSERT(hcf->deliveries == 0); + ap->reassociate(staMib->address, sta->request); + hcf->receiveNormalAckFragment(1, false); + ASSERT(hcf->deliveries == 0); + } + else if (scenario == 0) + ap->reassociate(staMib->address, sta->request); + else if (scenario == 1) + ap->disassociatePeer(staMib->address); + else if (scenario == 2) + sta->reassociate(ap->response); + else if (scenario == 3) + sta->disassociatePeer(); + else if (scenario == 4) + ap->reassociate(staMib->address, sta->request, false); + else + sta->reassociate(ap->response, false); + ASSERT(hcf->deletions == (scenario == 4 ? 0 : 2)); + if (scenario == 4) + ASSERT(hcf->hasBoth(observedPeer)); + else + ASSERT(hcf->hasNeither(observedPeer)); + ASSERT(hcf->hasBoth(hcf->other)); + ASSERT((observed->findPeerRateSet(observedPeer) != nullptr) == expectPresent); + ASSERT((observed->findPeerHtState(observedPeer) != nullptr) == + (expectPresent && observed->isHtOperationSupported())); + if (scenario == 0 || scenario == 4 || scenario == 6) + ASSERT(notifications == 0); + std::cout << "Block Ack association-reset assertions passed.\n"; + endSimulation(); + } +}; +Define_Module(AssociationResetTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mgmt.Ieee80211MgmtAp; +import inet.linklayer.ieee80211.mgmt.Ieee80211MgmtSta; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module AssociationResetHcf extends Hcf { parameters: @class(::inet::ieee80211::AssociationResetHcf); } +simple AssociationResetAp extends Ieee80211MgmtAp { parameters: @class(::inet::ieee80211::AssociationResetAp); } +simple AssociationResetSta extends Ieee80211MgmtSta { parameters: @class(::inet::ieee80211::AssociationResetSta); } +simple AssociationResetTest { parameters: int scenario; @class(::inet::ieee80211::AssociationResetTest); } +network AssociationResetNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + ap: AccessPoint; + sta: WirelessHost; + test: AssociationResetTest; +} + +%inifile: omnetpp.ini +[General] +network = AssociationResetNetwork +ned-path = .;../../../../src +sim-time-limit = 505ms +seed-set = 0 +*.test.scenario = ${0..7} +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.ap.wlan[0].mgmt.typename = "AssociationResetAp" +*.sta.wlan[0].mgmt.typename = "AssociationResetSta" +*.sta.wlan[0].agent.startingTime = 0s +*.sta.wlan[0].agent.channelsToScan = "0" +*.sta.wlan[0].agent.probeDelay = 1ms +*.sta.wlan[0].agent.minChannelTime = 10ms +*.sta.wlan[0].agent.maxChannelTime = 20ms +*.ap.wlan[0].address = "02:00:00:00:00:01" +*.sta.wlan[0].address = "02:00:00:00:00:02" +**.wlan[0].opMode = ${"g(mixed)","n(mixed-2.4Ghz)"} +**.wlan[0].mac.qosStation = true +**.wlan[0].mac.hcf.typename = "AssociationResetHcf" +**.wlan[0].mac.hcf.isBlockAckSupported = true +**.wlan[0].mac.hcf.blockAckVariant = "basic" +**.wlan[0].radio.bandName = "2.4 GHz" +**.wlan[0].radio.channelNumber = 0 +**.wlan[0].radio.transmitter.power = 100mW +**.wlan[0].radio.receiver.sensitivity = -85dBm +**.wlan[0].radio.receiver.snirThreshold = 4dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 10m +**.mobility.constraintAreaMaxY = 10m +**.mobility.constraintAreaMaxZ = 0m + +%contains: stdout +Block Ack association-reset assertions passed. diff --git a/tests/module/Ieee80211BlockAckDataSelection_1.test b/tests/module/Ieee80211BlockAckDataSelection_1.test new file mode 100644 index 00000000000..d1b8c948262 --- /dev/null +++ b/tests/module/Ieee80211BlockAckDataSelection_1.test @@ -0,0 +1,313 @@ +%description: +Check DATA extraction through the production QoS data service. +A compound queue uses reversed service order and a multicast/unicast classifier. +The service must extract unicast DATA individually without a multicast aggregate. +The multicast sources must retain their identities, sequence numbers, and deadlines. +Other cases use a genuine compound queue with a provider without selected extraction. +Ordinary service and existence queries must work without that optional capability. + +%extraargs: -r 0..3 + +%file: DataSelection.cc +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/queueing/base/PacketQueueBase.h" +#include "inet/queueing/queue/CompoundPacketQueueBase.h" +#include "inet/common/PacketEventTag.h" +#include "inet/common/TimeTag.h" + +using namespace inet; +using namespace inet::ieee80211; + +class LegacySelectionQueue : public queueing::PacketQueueBase { + cPacketQueue frames; + public: + int getMaxNumPackets() const override { return -1; } + int getNumPackets() const override { return frames.getLength(); } + b getMaxTotalLength() const override { return b(-1); } + b getTotalLength() const override { return b(frames.getBitLength()); } + Packet *getPacket(int index) const override { return check_and_cast(frames.get(index)); } + bool isEmpty() const override { return frames.isEmpty(); } + void removePacket(Packet *frame) override { frames.remove(frame); } + void removeAllPackets() override { frames.clear(); } + bool supportsPacketPushing(const cGate *) const override { return true; } + bool supportsPacketPulling(const cGate *) const override { return true; } + bool canPushPacket(Packet *, const cGate *) const override { return true; } + void pushPacket(Packet *frame, const cGate *) override { frames.insert(frame); } + Packet *canPullPacket(const cGate *) const override { return isEmpty() ? nullptr : getPacket(0); } + Packet *pullPacket(const cGate *) override { return check_and_cast(frames.pop()); } + void enqueuePacket(Packet *frame) override { frames.insert(frame); } + Packet *dequeuePacket() override { return check_and_cast(frames.pop()); } +}; +Define_Module(LegacySelectionQueue); + +class CompatibilityCompoundQueue : public queueing::CompoundPacketQueueBase { + public: + bool unrelatedFailure = false; + Packet *peekEligiblePacket(const std::function& predicate) const override { + if (unrelatedFailure) + throw cRuntimeError("Unrelated fixture query failure"); + return CompoundPacketQueueBase::peekEligiblePacket(predicate); + } +}; +Define_Module(CompatibilityCompoundQueue); + +class DataSelectionHcf : public Hcf { + public: + bool queued(MacAddress peer, Tid tid) const { return hasQueuedData(peer, tid); } +}; +Define_Module(DataSelectionHcf); + +class DataSelectionTest : public cSimpleModule, public cListener { + int pulls = 0; + int removals = 0; + int aggregates = 0; + protected: + void receiveSignal(cComponent *, simsignal_t signal, cObject *, cObject *) override { + if (signal == packetPulledSignal) pulls++; + if (signal == packetRemovedSignal) removals++; + if (signal == IOriginatorMacDataService::packetAggregatedSignal) aggregates++; + } + Packet *makeFrame(const char *name, MacAddress receiver) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTid(0); + header->setSequenceNumber(SequenceNumberCyclic(77)); + header->setReceiverAddress(receiver); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:01")); + header->setAddress3(receiver); + auto frame = new Packet(name, header); + frame->insertAtBack(makeShared(B(100))); + frame->insertAtBack(makeShared()); + auto timeTag = frame->addRegionTag(); + timeTag->setPacketTotalTimesArraySize(1); + timeTag->setPacketTotalTimes(0, SIMTIME_ZERO); + frame->addRegionTag(); + return frame; + } + Packet *accept(Hcf *hcf, const char *name, MacAddress receiver) { + auto frame = makeFrame(name, receiver); + hcf->processUpperFrame(frame, frame->peekAtFront()); + return frame; + } + void activity() override { + auto mac = getModuleByPath("^.host.wlan[0].mac"); + auto hcf = check_and_cast(mac->getSubmodule("hcf")); + auto edca = check_and_cast(hcf->getSubmodule("edca")); + auto queue = edca->getEdcaf(AC_BE)->getPendingQueue(); + auto lifetime = edca->getLifetimeHandler(); + auto service = check_and_cast(hcf->getSubmodule("originatorMacDataService")); + auto queueModule = check_and_cast(queue); + check_and_cast(mac->getSubmodule("rx"))->setContentionBlocked(true); + int scenario = par("scenario"); + if (scenario != 0) { + MacAddress firstPeer("02:00:00:00:00:02"); + MacAddress secondPeer("02:00:00:00:00:03"); + Packet *head; + Packet *tail; + if (scenario == 1) { + head = accept(hcf, "ordinary-head", firstPeer); + tail = accept(hcf, "ordinary-tail", secondPeer); + ASSERT(hcf->queued(firstPeer, 0)); + ASSERT(hcf->queued(secondPeer, 0)); + ASSERT(!hcf->queued(firstPeer, 5)); + service->setEligibility([](Packet *) { return true; }, [](Packet *) { return false; }); + ASSERT(service->peekEligibleFrame(queue) == head); + auto ordinary = service->extractFramesToTransmit(queue); + ASSERT(ordinary != nullptr && ordinary->size() == 1 && ordinary->front() == head); + ASSERT(queue->getNumPackets() == 1 && queue->getPacket(0) == tail); + ASSERT(head->getOwner() == service); + ASSERT(head->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(0)); + lifetime->forgetFrame(head->getId()); + take(head); + delete head; + delete ordinary; + auto composite = check_and_cast(queue); + composite->unrelatedFailure = true; + bool propagated = false; + try { hcf->queued(firstPeer, 0); } + catch (const cRuntimeError& error) { + propagated = std::string(error.what()).find("Unrelated fixture query failure") != std::string::npos; + } + ASSERT(propagated); + } + else { + head = makeFrame("deferred-head", firstPeer); + tail = makeFrame("eligible-tail", secondPeer); + queue->enqueuePacket(head); + queue->enqueuePacket(tail); + lifetime->registerFrame(head, AC_BE); + lifetime->registerFrame(tail, AC_BE); + service->setEligibility([scenario, tail](Packet *frame) { return scenario == 3 && frame == tail; }, + [](Packet *) { return false; }); + if (scenario == 2) { + ASSERT(service->peekEligibleFrame(queue) == nullptr); + ASSERT(service->extractFramesToTransmit(queue) == nullptr); + ASSERT(hcf->queued(secondPeer, 0)); + } + else { + ASSERT(hcf->queued(secondPeer, 0)); + bool refused = false; + try { service->extractFramesToTransmit(queue); } + catch (const cRuntimeError& error) { + refused = std::string(error.what()).find("Deferred DATA hides an eligible frame") != std::string::npos; + } + ASSERT(refused); + } + ASSERT(queue->getNumPackets() == 2 && queue->getPacket(0) == head && queue->getPacket(1) == tail); + ASSERT(head->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(lifetime->getDeadline(head) == SimTime(512, SIMTIME_MS)); + } + ASSERT(tail->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(lifetime->getDeadline(tail) == SimTime(512, SIMTIME_MS)); + std::cout << "Compound compatibility scenario " << scenario << " passed.\n"; + endSimulation(); + } + queueModule->subscribe(packetPulledSignal, this); + queueModule->subscribe(packetRemovedSignal, this); + service->subscribe(IOriginatorMacDataService::packetAggregatedSignal, this); + auto first = accept(hcf, "multicast-first", MacAddress("01:00:5e:00:00:01")); + auto second = accept(hcf, "multicast-second", MacAddress("01:00:5e:00:00:01")); + auto selected = accept(hcf, "selected-unicast", MacAddress("02:00:00:00:00:02")); + auto deadline = lifetime->getDeadline(first); + ASSERT(deadline == SimTime(512, SIMTIME_MS)); + ASSERT(queue->getPacket(0) == first); + ASSERT(service->peekEligibleFrame(queue) == selected); + ASSERT(service->getNextSequenceNumber(MacAddress("02:00:00:00:00:02"), 0) == SequenceNumberCyclic(0)); + wait(SimTime(100, SIMTIME_MS)); + auto extracted = service->extractFramesToTransmit(queue); + ASSERT(extracted != nullptr && extracted->size() == 1); + ASSERT(extracted->front() == selected); + ASSERT(selected->getOwner() == service); + auto header = selected->peekAtFront(); + ASSERT(!header->getAMsduPresent()); + ASSERT(header->getSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(queue->getNumPackets() == 2); + ASSERT(queue->getPacket(0) == first && queue->getPacket(1) == second); + for (auto source : {first, second}) { + ASSERT(source->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(lifetime->getDeadline(source) == deadline); + ASSERT(lifetime->findFrame(source->getId()) == source); + ASSERT(source->findRegionTag()->getPacketTotalTimes(0) == SIMTIME_ZERO); + ASSERT(source->findRegionTag()->getPacketEventsArraySize() == 0); + } + auto times = selected->getAllRegionTags(); + ASSERT(times.size() == 1); + ASSERT(times.front().getTag()->getPacketTotalTimes(0) == SimTime(100, SIMTIME_MS)); + auto eventRegions = selected->getAllRegionTags(); + ASSERT(eventRegions.size() == 1); + auto events = eventRegions.front().getTag(); + ASSERT(events->getPacketEventsArraySize() == 1); + ASSERT(events->getPacketEvents(0)->getKind() == PEK_QUEUED); + ASSERT(events->getPacketEvents(0)->getPacketDuration() == SimTime(100, SIMTIME_MS)); + ASSERT(lifetime->getDeadline(selected) == deadline); + ASSERT(lifetime->getNumFrames() == 3); + ASSERT(pulls == 3); + ASSERT(removals == 0 && aggregates == 0); + lifetime->forgetFrame(selected->getId()); + take(selected); + delete selected; + delete extracted; + queueModule->unsubscribe(packetPulledSignal, this); + queueModule->unsubscribe(packetRemovedSignal, this); + service->unsubscribe(IOriginatorMacDataService::packetAggregatedSignal, this); + auto legacy = check_and_cast(getModuleByPath("^.legacy")); + auto head = first->dup(); + auto tail = first->dup(); + legacy->enqueuePacket(head); + legacy->enqueuePacket(tail); + service->setEligibility([](Packet *) { return false; }, [](Packet *) { return false; }); + ASSERT(service->extractFramesToTransmit(legacy) == nullptr); + ASSERT(legacy->getNumPackets() == 2 && legacy->getPacket(0) == head); + service->setEligibility([tail](Packet *frame) { return frame == tail; }, [](Packet *) { return false; }); + bool refused = false; + try { service->extractFramesToTransmit(legacy); } + catch (const cRuntimeError& error) { + refused = std::string(error.what()).find("ISelectivePacketCollection") != std::string::npos; + } + ASSERT(refused); + ASSERT(legacy->getNumPackets() == 2 && legacy->getPacket(0) == head && legacy->getPacket(1) == tail); + service->setEligibility([](Packet *) { return true; }, [](Packet *) { return false; }); + auto ordinary = service->extractFramesToTransmit(legacy); + ASSERT(ordinary != nullptr && ordinary->size() == 1 && ordinary->front() == head); + ASSERT(legacy->getNumPackets() == 1 && legacy->getPacket(0) == tail); + take(ordinary->front()); + delete ordinary->front(); + delete ordinary; + std::cout << "Block Ack DATA selection assertions passed.\n"; + endSimulation(); + } + public: + DataSelectionTest() : cSimpleModule(65536) {} +}; +Define_Module(DataSelectionTest); + +%file: test.ned +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +import inet.queueing.base.PacketQueueBase; +import inet.queueing.queue.CompoundPacketQueueBase; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +simple LegacySelectionQueue extends PacketQueueBase { parameters: @class(::LegacySelectionQueue); } +module CompatibilityCompoundQueue extends CompoundPacketQueueBase { + parameters: + @class(::CompatibilityCompoundQueue); + submodules: + provider: LegacySelectionQueue; + connections: + in --> provider.in; + provider.out --> out; +} +module DataSelectionHcf extends Hcf { parameters: @class(::DataSelectionHcf); } +simple DataSelectionTest { parameters: int scenario; @class(::DataSelectionTest); } +network DataSelectionNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + legacy: LegacySelectionQueue; + test: DataSelectionTest; +} + +%inifile: omnetpp.ini +[General] +network = DataSelectionNetwork +sim-time-limit = 1s +seed-set = 0 +ned-path = .;../../../../src;../../lib +cmdenv-express-mode = true +record-scalar-results = false +record-vector-results = false +*.test.scenario = ${scenario=0..3} +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].bitrate = 6Mbps +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.isBlockAckSupported = false +**.wlan[*].mac.hcf.typename = "DataSelectionHcf" +**.wlan[*].mac.hcf.edca.edcaf[*].pendingQueue.typename = ${queueType="CompoundPendingQueue","CompatibilityCompoundQueue","CompatibilityCompoundQueue","CompatibilityCompoundQueue" ! scenario} +**.pendingQueue.classifier.classifierClass = "inet::ieee80211::MgmtOverMulticastOverUnicastClassifier" +**.pendingQueue.prioritizer.reverseOrder = true +**.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 +**.originatorMacDataService.msduAggregationPolicy.qOsCheck = true +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 10000B +*.host.wlan[0].address = "02:00:00:00:00:01" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Block Ack DATA selection assertions passed. + +%contains: stdout +Compound compatibility scenario 3 passed. diff --git a/tests/module/Ieee80211BlockAckDeferral_1.test b/tests/module/Ieee80211BlockAckDeferral_1.test new file mode 100644 index 00000000000..89da8e14084 --- /dev/null +++ b/tests/module/Ieee80211BlockAckDeferral_1.test @@ -0,0 +1,393 @@ +%description: +Check Basic setup deferral through wireless DATA, ADDBA, ACK, and DELBA exchanges. +The receiver holds its actual response queue until 150 ms after request ACK. +The 100 ms default must expire; a 250 ms timeout must accept the delayed response. +Other runs check first-DATA numbering, deferred voice versus eligible video, and genuine collision. +Request delays of 100 ms and 450 ms reverse the response deadline and DATA lifetime order. +Newer DATA must preserve the response deadline after the original DATA expires. +RTS failure and lifetime expiry must retire an agreement before its first DATA transmission. +Spaced DATA must start setup before later extraction after an earlier eligible DATA completes. +The same rule applies when greedy A-MSDU aggregation empties the earlier queue. +All runs use seed 0 and zero contention windows. + +%extraargs: -r 0..11 + +%file: Deferral.cc +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/linklayer/ieee80211/mac/contract/IContention.h" + +using namespace inet; +using namespace inet::ieee80211; + +class DeferralHcf : public Hcf { + public: + int requests = 0; + int delbas = 0; + int dataVoice = 0; + int dataVideo = 0; + int dataAfterRequest = 0; + int aggregatesAccepted = 0; + int requestStart = -1; + int firstData = -1; + simtime_t requestAccepted = SIMTIME_MAX; + simtime_t requestAck = SIMTIME_MAX; + simtime_t observedDeadline = SIMTIME_MAX; + simtime_t responseQueued = SIMTIME_MAX; + simtime_t responseAccepted = SIMTIME_MAX; + simtime_t responseReceived = SIMTIME_MAX; + bool holdResponse = false; + bool holdRequest = false; + bool dropProtectedCts = false; + int droppedCts = 0; + int firstRtsSequence = -1; + int rtsFailures = 0; + bool dataEligible(Packet *frame) const { return isFrameEligible(frame, false); } + bool hasAgreement(Tid tid) const { + auto agreement = originatorBlockAckAgreementHandler->getAgreement(MacAddress("02:00:00:00:00:02"), tid); + return agreement && agreement->getIsAddbaResponseReceived(); + } + bool deferred(Tid tid) const { + const auto& procedures = originatorBlockAckAgreementHandler->getProcedures(); + return procedures.count({MacAddress("02:00:00:00:00:02"), tid}) != 0; + } + bool contending(AccessCategory ac) const { + return check_and_cast(edca->getEdcaf(ac)->getSubmodule("contention"))->isContentionInProgress(); + } + void processMgmtFrame(Packet *frame, const Ptr& header) override { + if (dynamicPtrCast(header) && responseQueued == SIMTIME_MAX) { + responseQueued = simTime(); + if (holdResponse) + rx->setContentionBlocked(true); + } + Hcf::processMgmtFrame(frame, header); + } + protected: + void transmitControlResponseFrame(Packet *response, const Ptr& responseHeader, + Packet *received, const Ptr& receivedHeader) override { + if (dropProtectedCts && droppedCts == 0 && responseAccepted != SIMTIME_MAX && dynamicPtrCast(receivedHeader)) { + droppedCts++; + delete response; + return; + } + Hcf::transmitControlResponseFrame(response, responseHeader, received, receivedHeader); + } + void originatorProcessRtsProtectionFailed(Packet *frame) override { + if (requestStart >= 0) { + auto data = dynamicPtrCast(frame->peekAtFront()); + if (data && data->getTid() == 6) { + rtsFailures++; + if (firstRtsSequence < 0) + firstRtsSequence = data->getSequenceNumber().get(); + } + } + Hcf::originatorProcessRtsProtectionFailed(frame); + } + void frameSequenceFinished() override { + Hcf::frameSequenceFinished(); + if (holdRequest && requestAccepted == SIMTIME_MAX && deferred(6)) + rx->setContentionBlocked(true); + } + void sendUp(const std::vector& frames) override { + for (auto frame : frames) { + take(frame); + delete frame; + } + } + bool transmitFrame(Packet *frame, simtime_t ifs) override { + auto header = frame->peekAtFront(); + bool accepted = Hcf::transmitFrame(frame, ifs); + if (!accepted) + return false; + if (auto request = dynamicPtrCast(header)) { + requests++; + if (requestStart < 0) { + requestStart = request->getStartingSequenceNumber().get(); + requestAccepted = simTime(); + ASSERT(observedDeadline == SIMTIME_MAX); + } + } + if (dynamicPtrCast(header)) + delbas++; + if (dynamicPtrCast(header) && responseAccepted == SIMTIME_MAX) + responseAccepted = simTime(); + if (auto data = dynamicPtrCast(header)) { + if (data->getAMsduPresent()) aggregatesAccepted++; + if (data->getTid() == 6) dataVoice++; + if (data->getTid() == 5) dataVideo++; + if (requestStart >= 0 && data->getTid() == 6) { + if (firstData < 0) firstData = data->getSequenceNumber().get(); + dataAfterRequest++; + } + } + return true; + } + void originatorProcessReceivedControlFrame(Packet *frame, const Ptr& header, + Packet *last, const Ptr& lastHeader, AccessCategory ac) override { + bool request = dynamicPtrCast(lastHeader) != nullptr; + Hcf::originatorProcessReceivedControlFrame(frame, header, last, lastHeader, ac); + if (request && requestAck == SIMTIME_MAX) { + requestAck = simTime(); + auto it = originatorBlockAckAgreementHandler->getProcedures().find({MacAddress("02:00:00:00:00:02"), 6}); + if (it != originatorBlockAckAgreementHandler->getProcedures().end()) + observedDeadline = it->second.responseDeadline; + } + } + void recipientProcessReceivedManagementFrame(const Ptr& header) override { + if (dynamicPtrCast(header) && responseReceived == SIMTIME_MAX) + responseReceived = simTime(); + Hcf::recipientProcessReceivedManagementFrame(header); + } +}; +Define_Module(DeferralHcf); + +class DeferralTest : public cSimpleModule, public cListener { + int collisions = 0; + int videoRetryDrops = 0; + int lifetimeDrops = 0; + protected: + void receiveSignal(cComponent *, simsignal_t, unsigned long value, cObject *) override { collisions += value; } + void receiveSignal(cComponent *, simsignal_t, cObject *object, cObject *details) override { + auto drop = check_and_cast(details); + auto header = dynamicPtrCast(check_and_cast(object)->peekAtFront()); + if (drop->getReason() == RETRY_LIMIT_REACHED && header && header->getTid() == 5) + videoRetryDrops++; + if (drop->getReason() == LIFETIME_EXPIRED) + lifetimeDrops++; + } + Packet *accept(DeferralHcf *hcf, Tid tid) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTid(tid); + header->setSequenceNumber(SequenceNumberCyclic(77)); + header->setReceiverAddress(MacAddress("02:00:00:00:00:02")); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:01")); + header->setAddress3(header->getReceiverAddress()); + auto frame = new Packet(tid == 6 ? "voice-data" : "video-data", header); + frame->insertAtBack(makeShared(B(100))); + frame->insertAtBack(makeShared()); + hcf->processUpperFrame(frame, header); + return frame; + } + void activity() override { + auto sender = check_and_cast(getModuleByPath("^.sender.wlan[0].mac.hcf")); + auto receiver = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.hcf")); + auto senderRx = check_and_cast(getModuleByPath("^.sender.wlan[0].mac.rx")); + auto receiverRx = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.rx")); + int scenario = par("scenario"); + sender->subscribe(Hcf::edcaCollisionDetectedSignal, this); + sender->subscribe(packetDroppedSignal, this); + senderRx->setContentionBlocked(true); + if (scenario >= 10) { + auto edca = check_and_cast(sender->getSubmodule("edca")); + accept(sender, 6); + if (scenario == 11) + accept(sender, 6); + senderRx->setContentionBlocked(false); + wait(SimTime(5, SIMTIME_MS)); + ASSERT(sender->dataVoice == 1); + ASSERT(sender->aggregatesAccepted == (scenario == 11 ? 1 : 0)); + ASSERT(sender->requests == 0); + ASSERT(edca->getEdcaf(AC_VO)->getPendingQueue()->isEmpty()); + ASSERT(edca->getEdcaf(AC_VO)->getInProgressFrames()->getLength() == 0); + auto later = accept(sender, 6); + bool deferredBeforeExtraction = !sender->dataEligible(later); + if (scenario == 11) + accept(sender, 6); + std::cout << "Later DATA admission at " << simTime() << ": deferred=" << deferredBeforeExtraction << ".\n"; + wait(SimTime(5, SIMTIME_MS)); + std::cout << "Spaced DATA: requests=" << sender->requests << ", DATA accepted=" << sender->dataVoice + << ", aggregates=" << sender->aggregatesAccepted << ", request start=" << sender->requestStart + << ", first DATA=" << sender->firstData << ".\n"; + ASSERT(deferredBeforeExtraction); + ASSERT(sender->requests == 1 && sender->hasAgreement(6)); + ASSERT(sender->requestStart == 1 && sender->firstData == sender->requestStart); + ASSERT(sender->dataAfterRequest == 1); + ASSERT(sender->aggregatesAccepted == (scenario == 11 ? 2 : 0)); + } + else if (scenario == 4) { + accept(sender, 6); + accept(sender, 5); + ASSERT(sender->contending(AC_VO) && sender->contending(AC_VI)); + senderRx->setContentionBlocked(false); + wait(SimTime(50, SIMTIME_US)); + ASSERT(sender->dataVoice == 1 && sender->dataVideo == 0); + ASSERT(collisions == 1 && videoRetryDrops == 1); + } + else { + receiver->holdResponse = scenario != 2 && scenario < 8; + receiver->dropProtectedCts = scenario >= 8; + sender->holdRequest = scenario >= 5 && scenario != 8; + accept(sender, 6); + accept(sender, 6); + auto deferredFrame = accept(sender, 6); + auto deferredId = deferredFrame->getId(); + ASSERT(sender->contending(AC_VO)); + senderRx->setContentionBlocked(false); + wait(SimTime(5, SIMTIME_MS)); + if (scenario >= 5 && scenario != 8) { + ASSERT(sender->requests == 0 && sender->requestAck == SIMTIME_MAX); + ASSERT(sender->deferred(6)); + auto release = SimTime(scenario == 9 ? 500 : scenario == 5 ? 100 : 450, SIMTIME_MS); + wait(release - simTime()); + sender->holdRequest = false; + senderRx->setContentionBlocked(false); + wait(SimTime(5, SIMTIME_MS)); + } + std::cout << "Requests=" << sender->requests << ", start=" << sender->requestStart << ", voice DATA=" << sender->dataVoice << ".\n"; + ASSERT(sender->requests == 1); + ASSERT(sender->requestStart == sender->dataVoice - sender->dataAfterRequest); + ASSERT(sender->requestAck != SIMTIME_MAX); + ASSERT(sender->requestAck > sender->requestAccepted); + auto timeout = SimTime(scenario == 1 ? 250 : 100, SIMTIME_MS); + ASSERT(sender->observedDeadline == sender->requestAck + timeout); + if (scenario >= 8) { + if (scenario == 9) + wait(SimTime(560, SIMTIME_MS) - simTime()); + ASSERT(sender->rtsFailures >= 1); + ASSERT(sender->firstRtsSequence == sender->requestStart); + ASSERT(sender->dataAfterRequest == 0 && sender->firstData == -1); + ASSERT(!sender->hasAgreement(6)); + ASSERT(sender->delbas == 1); + ASSERT(lifetimeDrops == (scenario == 9 ? 1 : 0)); + } + else if (scenario >= 5) { + auto edca = check_and_cast(sender->getSubmodule("edca")); + auto lifetime = edca->getLifetimeHandler(); + ASSERT(lifetime->getDeadline(deferredFrame) == SimTime(512, SIMTIME_MS)); + if (scenario == 5) { + ASSERT(sender->observedDeadline < SimTime(512, SIMTIME_MS)); + wait(sender->observedDeadline + SimTime(5, SIMTIME_MS) - simTime()); + ASSERT(sender->delbas == 1 && sender->dataAfterRequest == 1); + ASSERT(lifetimeDrops == 0); + } + else { + ASSERT(sender->observedDeadline > SimTime(512, SIMTIME_MS)); + if (scenario == 7) { + wait(SimTime(480, SIMTIME_MS) - simTime()); + accept(sender, 6); + } + wait(SimTime(513, SIMTIME_MS) - simTime()); + ASSERT(lifetimeDrops == 1 && lifetime->findFrame(deferredId) == nullptr); + if (scenario == 6) + ASSERT(sender->delbas == 1 && sender->dataAfterRequest == 0); + else { + ASSERT(sender->delbas == 0 && sender->deferred(6)); + wait(sender->observedDeadline + SimTime(5, SIMTIME_MS) - simTime()); + ASSERT(sender->delbas == 1 && sender->dataAfterRequest == 1); + } + } + std::cout << "Request release=" << SimTime(scenario == 5 ? 100 : 450, SIMTIME_MS) << ", request ACK=" << sender->requestAck + << ", response deadline=" << sender->observedDeadline << ", original DATA deadline=0.512.\n"; + } + else if (scenario == 2) { + ASSERT(sender->dataAfterRequest == 1); + ASSERT(sender->firstData == sender->requestStart); + } + else { + ASSERT(sender->deferred(6)); + ASSERT(sender->dataAfterRequest == 0); + ASSERT(deferredFrame->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(!sender->contending(AC_VO)); + std::cout << "The pre-setup VO request resolved. Deferred VO has no contention request at " << simTime() << ".\n"; + if (scenario == 3) { + accept(sender, 5); + wait(SimTime(5, SIMTIME_MS)); + ASSERT(sender->dataVideo == 1); + ASSERT(sender->dataAfterRequest == 0); + ASSERT(collisions == 0 && videoRetryDrops == 0); + } + else { + wait(sender->requestAck + SimTime(150, SIMTIME_MS) - simTime()); + receiverRx->setContentionBlocked(false); + wait(SimTime(10, SIMTIME_MS)); + if (scenario == 1) { + ASSERT(receiver->responseAccepted != SIMTIME_MAX); + ASSERT(receiver->responseAccepted >= sender->requestAck + SimTime(150, SIMTIME_MS)); + } + std::cout << "Request ACK=" << sender->requestAck << ", response deadline=" << sender->observedDeadline + << ", response queued=" << receiver->responseQueued << ", response Tx accepted=" << receiver->responseAccepted << ".\n"; + if (scenario == 0) { + ASSERT(sender->delbas >= 1); + ASSERT(!sender->hasAgreement(6)); + } + else { + ASSERT(sender->delbas == 0); + ASSERT(sender->hasAgreement(6)); + ASSERT(sender->dataAfterRequest == 1); + ASSERT(sender->firstData == sender->requestStart); + } + } + } + } + sender->unsubscribe(Hcf::edcaCollisionDetectedSignal, this); + sender->unsubscribe(packetDroppedSignal, this); + std::cout << "Block Ack deferral scenario " << scenario << " passed.\n"; + endSimulation(); + } + public: + DeferralTest() : cSimpleModule(65536) {} +}; +Define_Module(DeferralTest); + +%file: test.ned +import inet.node.inet.WirelessHost; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.blockack.OriginatorBlockAckAgreementPolicy; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module DeferralHcf extends Hcf { parameters: @class(::DeferralHcf); } +simple LongTimeoutPolicy extends OriginatorBlockAckAgreementPolicy { parameters: addbaFailureTimeout = 250ms; } +simple DeferralTest { parameters: int scenario; @class(::DeferralTest); } +network DeferralNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + sender: WirelessHost; + receiver: WirelessHost; + test: DeferralTest; +} + +%inifile: omnetpp.ini +[General] +network = DeferralNetwork +sim-time-limit = 1s +seed-set = 0 +ned-path = .;../../../../src;../../lib +cmdenv-express-mode = true +record-scalar-results = false +record-vector-results = false +*.test.scenario = ${scenario=0..11} +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].bitrate = 6Mbps +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "DeferralHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = ${scenario} != 4 +**.wlan[*].mac.hcf.originatorBlockAckAgreementPolicy.typename = ${policy="OriginatorBlockAckAgreementPolicy","LongTimeoutPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy" ! scenario} +**.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = ${aggregation="","","","","","","","","","","","BasicMsduAggregationPolicy" ! scenario} +**.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 +**.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 6Mbps +**.wlan[*].mac.hcf.rtsPolicy.rtsThreshold = ${scenario} >= 8 && ${scenario} <= 9 ? 1B : 2346B +**.wlan[*].mac.hcf.rtsPolicy.ctsTimeout = ${scenario} == 9 ? 50ms : -1s +**.wlan[*].mac.hcf.edca.edcaf[*].cwMin = 0 +**.wlan[*].mac.hcf.edca.edcaf[*].cwMax = 0 +**.wlan[*].mac.hcf.edca.edcaf[*].recoveryProcedure.shortRetryLimit = ${scenario} == 9 ? 10 : 1 +*.sender.wlan[0].address = "02:00:00:00:00:01" +*.receiver.wlan[0].address = "02:00:00:00:00:02" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.sender.mobility.initialX = 0m +*.sender.mobility.initialY = 0m +*.receiver.mobility.initialX = 1m +*.receiver.mobility.initialY = 0m + +%contains: stdout +Block Ack deferral scenario 11 passed. diff --git a/tests/module/Ieee80211BlockAckDeferredCollision_1.test b/tests/module/Ieee80211BlockAckDeferredCollision_1.test new file mode 100644 index 00000000000..8bc3eef8be4 --- /dev/null +++ b/tests/module/Ieee80211BlockAckDeferredCollision_1.test @@ -0,0 +1,203 @@ +%description: +Check a pending EDCA request after production inactivity teardown defers its DATA. +The fixture supplies an accepted Basic agreement; it does not test negotiation. +VI and BE request the same grant time, at 34 microseconds. +The VI agreement expires at 33 microseconds and queues DELBA in VO. +VO uses six AIFS slots and grants later, at 70 microseconds. +Deferred VI must not cause collision feedback or disposal of eligible BE DATA. +The control retains eligible VI and must preserve the genuine collision. +The third run gives BE an accepted agreement with SSN zero and two DATA frames. +An internal collision discards sequence zero before transmission. +HCF must retire that agreement and queue DELBA before a successor can transmit. + +%extraargs: -r 0..2 + +%file: DeferredCollision.cc +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/contract/IContention.h" + +using namespace inet; +using namespace inet::ieee80211; + +class DeferredCollisionOriginator : public OriginatorBlockAckAgreementHandler { + public: + void accept(simtime_t timeout, Tid tid) { + MacAddress peer("02:00:00:00:00:02"); + auto agreement = new OriginatorBlockAckAgreement(peer, tid, SequenceNumberCyclic(0), 64, false, false); + agreement->setIsAddbaRequestSent(true); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(timeout); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, tid}] = agreement; + } +}; + +class DeferredCollisionHcf : public Hcf { + public: + int videoAccepted = 0; + int bestEffortAccepted = 0; + int delbas = 0; + void prepare(bool expire, Tid tid) { + Enter_Method("prepare"); + delete originatorBlockAckAgreementHandler; + auto handler = new DeferredCollisionOriginator(); + originatorBlockAckAgreementHandler = handler; + handler->accept(expire ? SimTime(33, SIMTIME_US) : SIMTIME_ZERO, tid); + if (expire) + scheduleInactivityTimer(); + } + bool contending(AccessCategory ac) const { + return check_and_cast(edca->getEdcaf(ac)->getSubmodule("contention"))->isContentionInProgress(); + } + bool eligible(AccessCategory ac) { return hasFrameToTransmit(ac); } + int queued(AccessCategory ac) const { return edca->getEdcaf(ac)->getPendingQueue()->getNumPackets(); } + bool hasAgreement(Tid tid) const { + return originatorBlockAckAgreementHandler->getAgreement(MacAddress("02:00:00:00:00:02"), tid) != nullptr; + } + protected: + void processMgmtFrame(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) + delbas++; + Hcf::processMgmtFrame(packet, header); + } + bool transmitFrame(Packet *frame, simtime_t ifs) override { + auto header = dynamicPtrCast(frame->peekAtFront()); + bool accepted = Hcf::transmitFrame(frame, ifs); + if (accepted && header) { + if (header->getTid() == 5) videoAccepted++; + if (header->getTid() == 0) bestEffortAccepted++; + } + return accepted; + } +}; +Define_Module(DeferredCollisionHcf); + +class DeferredCollisionTest : public cSimpleModule, public cListener { + int collisions = 0; + int bestEffortRetryDrops = 0; + protected: + void receiveSignal(cComponent *, simsignal_t, unsigned long count, cObject *) override { collisions += count; } + void receiveSignal(cComponent *, simsignal_t, cObject *object, cObject *details) override { + auto drop = check_and_cast(details); + auto header = dynamicPtrCast(check_and_cast(object)->peekAtFront()); + if (drop->getReason() == RETRY_LIMIT_REACHED && header && header->getTid() == 0) + bestEffortRetryDrops++; + } + void accept(DeferredCollisionHcf *hcf, Tid tid) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTid(tid); + header->setReceiverAddress(MacAddress("02:00:00:00:00:02")); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:01")); + header->setAddress3(header->getReceiverAddress()); + auto frame = new Packet(tid == 5 ? "video-data" : "best-effort-data", header); + frame->insertAtBack(makeShared(B(100))); + frame->insertAtBack(makeShared()); + hcf->processUpperFrame(frame, header); + } + void activity() override { + auto hcf = check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf")); + int scenario = par("scenario"); + bool expire = scenario == 0; + Tid agreementTid = scenario == 2 ? 0 : 5; + hcf->prepare(expire, agreementTid); + hcf->subscribe(Hcf::edcaCollisionDetectedSignal, this); + hcf->subscribe(packetDroppedSignal, this); + accept(hcf, 5); + accept(hcf, 0); + if (scenario == 2) + accept(hcf, 0); + ASSERT(hcf->contending(AC_VI) && hcf->contending(AC_BE)); + wait(SimTime(33500, SIMTIME_NS)); + ASSERT(hcf->hasAgreement(agreementTid) == !expire); + ASSERT(hcf->eligible(AC_VI) == !expire); + ASSERT(hcf->eligible(AC_BE)); + std::cout << "At " << simTime() << ": VI eligible=" << hcf->eligible(AC_VI) + << ", VI pending request=" << hcf->contending(AC_VI) + << ", BE pending request=" << hcf->contending(AC_BE) + << ", VO pending request=" << hcf->contending(AC_VO) << ".\n"; + wait(SimTime(16500, SIMTIME_NS)); + std::cout << "At " << simTime() << ": VI DATA accepted=" << hcf->videoAccepted + << ", BE DATA accepted=" << hcf->bestEffortAccepted + << ", collisions=" << collisions << ", BE retry drops=" << bestEffortRetryDrops << ".\n"; + ASSERT(hcf->videoAccepted == (expire ? 0 : 1)); + ASSERT(hcf->bestEffortAccepted == (expire ? 1 : 0)); + ASSERT(collisions == (expire ? 0 : 1)); + ASSERT(bestEffortRetryDrops == (expire ? 0 : 1)); + if (scenario == 2) { + ASSERT(!hcf->hasAgreement(0)); + ASSERT(hcf->delbas == 1); + ASSERT(!hcf->eligible(AC_BE)); + ASSERT(hcf->queued(AC_BE) == 1); + ASSERT(hcf->bestEffortAccepted == 0); + std::cout << "First-DATA collision retires the agreement before successor transmission.\n"; + } + hcf->unsubscribe(Hcf::edcaCollisionDetectedSignal, this); + hcf->unsubscribe(packetDroppedSignal, this); + std::cout << "Deferred collision scenario " << par("scenario").intValue() << " passed.\n"; + endSimulation(); + } + public: + DeferredCollisionTest() : cSimpleModule(65536) {} +}; +Define_Module(DeferredCollisionTest); + +%file: test.ned +import inet.node.inet.WirelessHost; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module DeferredCollisionHcf extends Hcf { parameters: @class(::DeferredCollisionHcf); } +simple DeferredCollisionTest { parameters: int scenario; @class(::DeferredCollisionTest); } +network DeferredCollisionNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: DeferredCollisionTest; +} + +%inifile: omnetpp.ini +[General] +network = DeferredCollisionNetwork +sim-time-limit = 1ms +seed-set = 0 +ned-path = .;../../../../src;../../lib +cmdenv-express-mode = true +record-scalar-results = false +record-vector-results = false +*.test.scenario = ${scenario=0,1,2} +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].bitrate = 6Mbps +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "DeferredCollisionHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +**.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 6Mbps +**.wlan[*].mac.hcf.edca.edcaf[*].cwMin = 0 +**.wlan[*].mac.hcf.edca.edcaf[*].cwMax = 0 +*.host.wlan[0].mac.hcf.edca.edcaf[3].aifsn = 6 +**.wlan[*].mac.hcf.edca.edcaf[*].aifsn = 2 +**.wlan[*].mac.hcf.edca.edcaf[*].recoveryProcedure.shortRetryLimit = 1 +*.host.wlan[0].address = "02:00:00:00:00:01" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Deferred collision scenario 1 passed. + +%contains: stdout +First-DATA collision retires the agreement before successor transmission. diff --git a/tests/module/Ieee80211BlockAckFragmentRetirement_1.test b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test new file mode 100644 index 00000000000..33429c70e6a --- /dev/null +++ b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test @@ -0,0 +1,297 @@ +%description: +Check the sequence boundary after ordinary originator teardown of fragmented DATA. +IEEE Std 802.11-2024, 11.5.3.4 requires the next MPDU to use a later sequence +when the originator discards the last transmitted MPDU. +The fixture supplies accepted Basic agreements and injects immediate ACKs. +Production fragmentation, inactivity expiry, retirement, and transmission remain active. +Runs cover sequence 0 and wraparound at 4095, with expiry during transmission +or after the first fragment receives its Normal Ack. +Later intact DATA and an unrelated peer must retain their transmissions. +Additional runs transmit an earlier DATA unit before a gap in sequence allocation. +The fixture extracts and disposes of the skipped DATA through the production allocator. +Distances 2047, 2048, 2049, and 4096 cover the half-range boundary and a full wrap. + +%extraargs: -r 0..19 + +%file: FragmentRetirement.cc +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class FragmentRetirementOriginator : public OriginatorBlockAckAgreementHandler { + public: + void accept(MacAddress peer, int start, simtime_t timeout) { + auto agreement = new OriginatorBlockAckAgreement(peer, 5, SequenceNumberCyclic(start), 64, false, false); + agreement->setIsAddbaRequestSent(true); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(timeout); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + } +}; + +class FragmentRetirementHcf : public Hcf { + const MacAddress peer = MacAddress("02:00:00:00:00:02"); + const MacAddress other = MacAddress("02:00:00:00:00:03"); + int start = 0; + int distance = 0; + bool acknowledgedFirst = false; + bool firstCompleted = false; + bool firstAcknowledged = false; + bool retired = false; + bool successorSent = false; + bool otherSent = false; + int delbas = 0; + + void skipData(int count) { + auto queue = edca->getEdcaf(AC_VI)->getPendingQueue(); + for (int i = 0; i < count; i++) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->setReceiverAddress(peer); + header->setTid(5); + auto packet = new Packet("sequence-setup", header); + packet->insertAtBack(makeShared()); + queue->enqueuePacket(packet); + auto frames = originatorDataService->extractFramesToTransmit(queue); + for (auto frame : *frames) { + take(frame); + delete frame; + } + delete frames; + } + } + + void startRetirement() { + auto agreement = originatorBlockAckAgreementHandler->getAgreement(peer, 5); + agreement->setStartingSequenceNumber(SequenceNumberCyclic(start)); + agreement->setBlockAckTimeoutValue(SimTime(1024, SIMTIME_US)); + agreement->calculateExpirationTime(); + scheduleInactivityTimer(); + scheduleAfter(SimTime(acknowledgedFirst ? 650 : 974, SIMTIME_US), new cMessage("queue-data")); + } + + void queueData(const char *name, MacAddress address, int length) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTid(5); + header->setReceiverAddress(address); + header->setTransmitterAddress(mac->getAddress()); + header->setAddress3(address); + auto packet = new Packet(name, header); + packet->insertAtBack(makeShared(B(length))); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + } + + public: + void begin() { + Enter_Method("begin"); + start = par("startSequence"); + distance = par("sequenceDistance"); + acknowledgedFirst = par("acknowledgedFirst"); + delete originatorBlockAckAgreementHandler; + auto handler = new FragmentRetirementOriginator(); + originatorBlockAckAgreementHandler = handler; + handler->accept(peer, start, SIMTIME_ZERO); + handler->accept(other, 0, SIMTIME_ZERO); + // Advance the production allocator without a radio exchange for each earlier sequence. + skipData(start); + subscribe(blockAckAgreementDeletedSignal, this); + if (distance == 0) + startRetirement(); + else { + // Force Normal Ack for the earlier DATA, independent of the fragment ACK policy. + handler->getAgreement(peer, 5)->setStartingSequenceNumber(SequenceNumberCyclic(start) + 1); + queueData("earlier-data", peer, 20); + } + scheduleAfter(SimTime(10, SIMTIME_MS), new cMessage("verify")); + } + + protected: + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *details) override { + if (signal != blockAckAgreementDeletedSignal) { + Hcf::receiveSignal(source, signal, object, details); + return; + } + ASSERT(!retired); + retired = true; + ASSERT(firstCompleted == acknowledgedFirst); + ASSERT(firstAcknowledged == acknowledgedFirst); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(peer, 5) == nullptr); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(other, 5) != nullptr); + auto frames = edca->getEdcaf(AC_VI)->getInProgressFrames(); + for (int i = 0; i < frames->getLength(); i++) { + auto data = dynamicPtrCast(frames->getFrames(i)->peekAtFront()); + ASSERT(!data || data->getReceiverAddress() != peer || data->getSequenceNumber() != SequenceNumberCyclic(start)); + } + } + + bool transmitFrame(Packet *packet, simtime_t ifs) override { + auto data = dynamicPtrCast(packet->peekAtFront()); + bool accepted = Hcf::transmitFrame(packet, ifs); + if (accepted && data) { + if (packet->isName("earlier-data")) { + ASSERT(data->getSequenceNumber() == SequenceNumberCyclic(start)); + ASSERT(data->getAckPolicy() == NORMAL_ACK); + return accepted; + } + if (data->getReceiverAddress() == peer) { + if (!retired) { + ASSERT(data->getSequenceNumber() == SequenceNumberCyclic(start)); + ASSERT(data->getFragmentNumber() == 0); + } + else { + ASSERT(data->getSequenceNumber() == SequenceNumberCyclic(start) + 1); + ASSERT(data->getFragmentNumber() == 0 && !data->getMoreFragments()); + successorSent = true; + } + } + else { + ASSERT(data->getReceiverAddress() == other); + ASSERT(data->getSequenceNumber() == SequenceNumberCyclic(0)); + otherSent = true; + } + } + return accepted; + } + + void transmissionComplete(Packet *packet, const Ptr& header) override { + Enter_Method("transmissionComplete"); + auto data = dynamicPtrCast(header); + bool earlier = packet->isName("earlier-data"); + bool first = !earlier && data && data->getReceiverAddress() == peer && data->getSequenceNumber() == SequenceNumberCyclic(start); + bool ack = dynamicPtrCast(header) || (data && data->getAckPolicy() == NORMAL_ACK); + if (first) + firstCompleted = true; + if (dynamicPtrCast(header)) + delbas++; + Hcf::transmissionComplete(packet, header); + if (ack) + scheduleAfter(SimTime(20, SIMTIME_US), new cMessage(earlier ? "ack-earlier" : first ? "ack-first" : "ack")); + } + + void handleMessage(cMessage *message) override { + if (message->isName("queue-data")) { + delete message; + queueData("fragmented-data", peer, 400); + queueData("intact-successor", peer, 20); + queueData("other-peer", other, 20); + } + else if (message->isName("ack") || message->isName("ack-first") || message->isName("ack-earlier")) { + bool first = message->isName("ack-first"); + bool earlier = message->isName("ack-earlier"); + delete message; + auto header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + auto packet = new Packet("ack", header); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + processLowerFrame(packet, header); + if (first) + firstAcknowledged = true; + if (earlier) { + skipData(distance - 1); + start = (start + distance) % 4096; + startRetirement(); + } + } + else if (message->isName("verify")) { + delete message; + ASSERT(retired && firstCompleted && successorSent && otherSent); + ASSERT(delbas == 1); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(other, 5) != nullptr); + unsubscribe(blockAckAgreementDeletedSignal, this); + std::cout << "Fragment retirement passed: start=" << start << ", acknowledgedFirst=" << acknowledgedFirst + << ", distance=" << distance << std::endl; + endSimulation(); + } + else + Hcf::handleMessage(message); + } +}; +Define_Module(FragmentRetirementHcf); + +class FragmentRetirementDriver : public cSimpleModule { + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("begin")); } + void handleMessage(cMessage *message) override { + delete message; + check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf"))->begin(); + } +}; +Define_Module(FragmentRetirementDriver); +} + +%file: test.ned +import inet.node.inet.WirelessHost; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module FragmentRetirementHcf extends Hcf { + parameters: + int startSequence; + int sequenceDistance; + bool acknowledgedFirst; + @class(::inet::ieee80211::FragmentRetirementHcf); +} +simple FragmentRetirementDriver { parameters: @class(::inet::ieee80211::FragmentRetirementDriver); } +network FragmentRetirementNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + driver: FragmentRetirementDriver; +} + +%inifile: omnetpp.ini +[General] +network = FragmentRetirementNetwork +ned-path = .;../../../../src +sim-time-limit = 20ms +seed-set = 0 +cmdenv-express-mode = true +record-scalar-results = false +record-vector-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].bitrate = 6Mbps +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "FragmentRetirementHcf" +**.wlan[*].mac.hcf.startSequence = ${start=0,4095} +**.wlan[*].mac.hcf.sequenceDistance = ${distance=0,2047,2048,2049,4096} +**.wlan[*].mac.hcf.acknowledgedFirst = ${acked=false,true} +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +**.wlan[*].mac.hcf.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 200B +**.wlan[*].mac.hcf.originatorAckPolicy.maxBlockAckPolicyFrameLength = ${acked} ? 0B : 1000B +**.wlan[*].mac.hcf.originatorAckPolicy.ackTimeout = 1ms +**.wlan[*].mac.hcf.edca.edcaf[*].cwMin = 0 +**.wlan[*].mac.hcf.edca.edcaf[*].cwMax = 0 +**.wlan[*].mac.hcf.edca.edcaf[*].aifsn = 20 +**.wlan[*].mac.hcf.edca.edcaf[2].txopProcedure.txopLimit = 0s +*.host.wlan[0].address = "02:00:00:00:00:01" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Fragment retirement passed: start=0, acknowledgedFirst=0 +%contains: stdout +Fragment retirement passed: start=0, acknowledgedFirst=1 +%contains: stdout +Fragment retirement passed: start=4095, acknowledgedFirst=0 +%contains: stdout +Fragment retirement passed: start=4095, acknowledgedFirst=1 diff --git a/tests/module/Ieee80211BlockAckLifecycle_1.test b/tests/module/Ieee80211BlockAckLifecycle_1.test new file mode 100644 index 00000000000..eb6d073cafd --- /dev/null +++ b/tests/module/Ieee80211BlockAckLifecycle_1.test @@ -0,0 +1,358 @@ +%description: +Check Basic teardown through initialized HCF and production receive paths. Each role has agreements for two peers and two TIDs. Deletion callbacks inspect the selected agreement after its removal. Recipient teardown releases complete units behind a gap before the callback. Absent-agreement DATA and BAR cause recipient-role DELBA without agreement allocation. The fixture supplies accepted agreements; it does not test negotiation or wireless transmission. + +The inactivity timer uses the earliest absolute deadline from both agreement roles. The fixture checks that derived deadline and the later expiration of the opposite role. + +%extraargs: -r 0..9 + +%file: Lifecycle.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class LifecycleOriginator : public OriginatorBlockAckAgreementHandler { + public: + void accept(MacAddress peer, Tid tid, int start = 100, simtime_t timeout = SIMTIME_ZERO) { + auto agreement = new OriginatorBlockAckAgreement(peer, tid, SequenceNumberCyclic(start), 64, false, false); + agreement->setIsAddbaRequestSent(true); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(timeout); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, tid}] = agreement; + } +}; +class LifecycleRecipient : public RecipientBlockAckAgreementHandler { + public: + void accept(MacAddress peer, Tid tid, int start = 100, simtime_t timeout = SIMTIME_ZERO) { + auto agreement = new RecipientBlockAckAgreement(peer, tid, SequenceNumberCyclic(start), 64, timeout); + agreement->addbaResposneSent(); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, tid}] = agreement; + } +}; +class LifecycleHcf : public Hcf { + public: + const MacAddress peer = MacAddress("02:00:00:00:00:02"); + const MacAddress other = MacAddress("02:00:00:00:00:03"); + std::vector delivered; + int deletions = 0; + int delbas = 0; + int controlResponses = 0; + bool selectedRecipient = false; + bool requireRelease = false; + bool strictOpposite = true; + bool dynamicRole = false; + void prepare(int start = 100, simtime_t originatorTimeout = SIMTIME_ZERO, simtime_t recipientTimeout = SIMTIME_ZERO) { + Enter_Method("prepare"); + delete originatorBlockAckAgreementHandler; + delete recipientBlockAckAgreementHandler; + auto originator = new LifecycleOriginator(); + auto recipient = new LifecycleRecipient(); + originatorBlockAckAgreementHandler = originator; + recipientBlockAckAgreementHandler = recipient; + for (auto address : {peer, other}) + for (Tid tid : {5, 6}) { + bool selected = address == peer && tid == 5; + originator->accept(address, tid, start, selected ? originatorTimeout : SIMTIME_ZERO); + recipient->accept(address, tid, start, selected ? recipientTimeout : SIMTIME_ZERO); + } + subscribe(blockAckAgreementDeletedSignal, this); + } + void checkInactivityDeadline(simtime_t expectedDeadline) { + Enter_Method("checkInactivityDeadline"); + scheduleInactivityTimer(); + ASSERT(inactivityTimer->isScheduled()); + ASSERT(inactivityTimer->getArrivalTime() == expectedDeadline); + } + bool hasInactivityTimer() const { return inactivityTimer->isScheduled(); } + void retireRecipientLocally() { + Enter_Method("retireRecipientLocally"); + selectedRecipient = true; + beginTeardown(peer, 5, false, 37); + } + bool hasOriginator(MacAddress address, Tid tid) { + return originatorBlockAckAgreementHandler->getAgreement(address, tid) != nullptr; + } + bool hasRecipient(MacAddress address, Tid tid) { + return recipientBlockAckAgreementHandler->getAgreement(tid, address) != nullptr; + } + void receiveDelba(bool initiator, int sequence) { + Enter_Method("receiveDelba"); + selectedRecipient = initiator; + auto header = makeShared(); + header->setTransmitterAddress(peer); + header->setReceiverAddress(mac->getAddress()); + header->setTid(5); + header->setInitiator(initiator); + header->setSequenceNumber(SequenceNumberCyclic(sequence)); + auto packet = new Packet("delba", header); + packet->addTag()->setMode( + physicallayer::Ieee80211ModeSet::getModeSet("a")->getMode(bps(6000000))); + packet->insertAtBack(makeShared()); + processLowerFrame(packet, header); + } + void receiveData(int sequence, const char *name, MacAddress address, bool incomplete = false) { + Enter_Method("receiveData"); + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTransmitterAddress(address); + header->setReceiverAddress(mac->getAddress()); + header->setAddress3(address); + header->setTid(5); + header->setAckPolicy(BLOCK_ACK); + header->setSequenceNumber(SequenceNumberCyclic(sequence)); + header->setMoreFragments(incomplete); + auto packet = new Packet(name, header); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + processLowerFrame(packet, header); + } + void receiveBar(MacAddress address, int fragment = 0) { + Enter_Method("receiveBar"); + auto header = makeShared(); + header->setTransmitterAddress(address); + header->setReceiverAddress(mac->getAddress()); + header->setTidInfo(5); + header->setFragmentNumber(fragment); + header->setStartingSequenceNumber(SequenceNumberCyclic(100)); + auto packet = new Packet("bar", header); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + packet->insertAtBack(makeShared()); + processLowerFrame(packet, header); + } + protected: + void receiveSignal(cComponent *source, simsignal_t signal, cObject *payload, cObject *details) override { + if (signal != blockAckAgreementDeletedSignal) { + Hcf::receiveSignal(source, signal, payload, details); + return; + } + if (requireRelease) + ASSERT((delivered == std::vector{"second", "third"})); + ASSERT(payload != nullptr); + if (dynamicRole) + selectedRecipient = dynamic_cast(payload) != nullptr; + if (selectedRecipient) { + auto agreement = check_and_cast(payload); + ASSERT(agreement->getBlockAckRecord()->getOriginatorAddress() == peer); + ASSERT(agreement->getBlockAckRecord()->getTid() == 5); + ASSERT(!hasRecipient(peer, 5)); + if (strictOpposite) + ASSERT(hasOriginator(peer, 5)); + ASSERT(agreement->getBufferSize() == 64); + } + else { + auto agreement = check_and_cast(payload); + ASSERT(agreement->getReceiverAddr() == peer); + ASSERT(agreement->getTid() == 5); + ASSERT(!hasOriginator(peer, 5)); + if (strictOpposite) + ASSERT(hasRecipient(peer, 5)); + ASSERT(agreement->getBufferSize() == 64); + } + ASSERT(hasOriginator(other, 5)); + ASSERT(hasRecipient(other, 5)); + ASSERT(hasOriginator(peer, 6)); + ASSERT(hasRecipient(peer, 6)); + deletions++; + } + void sendUp(const std::vector& frames) override { + for (auto packet : frames) { + if (dynamicPtrCast(packet->peekAtFront())) + delivered.push_back(packet->getName()); + take(packet); + delete packet; + } + } + void transmitControlResponseFrame(Packet *packet, const Ptr&, + Packet *, const Ptr&) override { + controlResponses++; + delete packet; + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + if (auto delba = dynamicPtrCast(header)) { + if (!dynamicRole) + ASSERT(!delba->getInitiator()); + delbas++; + } + delete packet; + } +}; +Define_Module(LifecycleHcf); +class LifecycleTest : public cSimpleModule { + protected: + LifecycleHcf *hcf = nullptr; + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("test")); } + void handleMessage(cMessage *message) override { + if (message->isName("recipientExpiry")) { + delete message; + ASSERT(hcf->hasOriginator(hcf->peer, 5)); + ASSERT(!hcf->hasRecipient(hcf->peer, 5)); + ASSERT(hcf->deletions == 1); + ASSERT(hcf->delbas == 1); + ASSERT((hcf->delivered == std::vector{"second", "third"})); + ASSERT(!hcf->hasInactivityTimer()); + std::cout << "Block Ack lifecycle assertions passed.\n"; + return; + } + if (message->isName("firstExpiry")) { + delete message; + ASSERT(!hcf->hasOriginator(hcf->peer, 5)); + ASSERT(hcf->hasRecipient(hcf->peer, 5)); + ASSERT(hcf->deletions == 1); + ASSERT(hcf->delbas == 1); + scheduleAt(SimTime(5000001, SIMTIME_NS), new cMessage("secondExpiry")); + return; + } + if (message->isName("secondExpiry")) { + delete message; + ASSERT(!hcf->hasOriginator(hcf->peer, 5)); + ASSERT(!hcf->hasRecipient(hcf->peer, 5)); + ASSERT(hcf->deletions == 2); + ASSERT(hcf->delbas == 2); + ASSERT(!hcf->hasInactivityTimer()); + std::cout << "Block Ack lifecycle assertions passed.\n"; + return; + } + if (message->isName("zeroExpiry")) { + delete message; + ASSERT(hcf->hasOriginator(hcf->peer, 5)); + ASSERT(hcf->hasRecipient(hcf->peer, 5)); + ASSERT(hcf->deletions == 0); + ASSERT(hcf->delbas == 0); + ASSERT(!hcf->hasInactivityTimer()); + std::cout << "Block Ack lifecycle assertions passed.\n"; + return; + } + delete message; + hcf = check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf")); + int scenario = par("scenario"); + hcf->prepare(scenario == 5 ? 4094 : 100, + scenario == 6 ? SimTime(2, SIMTIME_MS) : SIMTIME_ZERO, + scenario == 6 ? SimTime(4, SIMTIME_MS) : scenario == 9 ? SimTime(2, SIMTIME_MS) : SIMTIME_ZERO); + if (scenario >= 8) { + hcf->requireRelease = true; + hcf->selectedRecipient = true; + hcf->receiveData(101, "second", hcf->peer); + hcf->receiveData(102, "third", hcf->peer); + ASSERT(hcf->delivered.empty()); + if (scenario == 8) { + hcf->retireRecipientLocally(); + ASSERT(hcf->deletions == 1); + ASSERT(hcf->delbas == 1); + hcf->retireRecipientLocally(); + ASSERT(hcf->deletions == 1); + ASSERT(hcf->delbas == 1); + std::cout << "Block Ack lifecycle assertions passed.\n"; + } + else { + hcf->checkInactivityDeadline(SimTime(3, SIMTIME_MS)); + scheduleAt(SimTime(3000001, SIMTIME_NS), new cMessage("recipientExpiry")); + } + return; + } + if (scenario >= 6) { + if (scenario == 6) { + hcf->strictOpposite = false; + hcf->dynamicRole = true; + hcf->checkInactivityDeadline(SimTime(3, SIMTIME_MS)); + scheduleAt(SimTime(3000001, SIMTIME_NS), new cMessage("firstExpiry")); + } + else + scheduleAt(SimTime(6, SIMTIME_MS), new cMessage("zeroExpiry")); + return; + } + if (scenario <= 2 || scenario == 5) { + if (scenario == 2 || scenario == 5) { + hcf->requireRelease = true; + if (scenario == 5) + hcf->receiveData(4094, "incomplete-frag0", hcf->peer, true); + hcf->receiveData(scenario == 5 ? 4095 : 101, "second", hcf->peer); + hcf->receiveData(scenario == 5 ? 0 : 102, "third", hcf->peer); + ASSERT(hcf->delivered.empty()); + } + hcf->receiveDelba(scenario != 0, 20); + ASSERT(hcf->deletions == 1); + hcf->receiveDelba(scenario != 0, 21); + ASSERT(hcf->deletions == 1); + if (scenario == 2 || scenario == 5) + ASSERT((hcf->delivered == std::vector{"second", "third"})); + } + else { + const MacAddress absent("02:00:00:00:00:04"); + if (scenario == 4) { + hcf->receiveBar(absent, 1); + ASSERT(hcf->delbas == 0); + ASSERT(hcf->controlResponses == 0); + } + if (scenario == 3) + hcf->receiveData(100, "absent", absent); + else + hcf->receiveBar(absent); + ASSERT(hcf->delivered.empty()); + ASSERT(hcf->delbas == 1); + ASSERT(hcf->controlResponses == 0); + ASSERT(!hcf->hasRecipient(absent, 5)); + ASSERT(!hcf->hasOriginator(absent, 5)); + if (scenario == 3) + hcf->receiveData(101, "absent-again", absent); + else + hcf->receiveBar(absent); + ASSERT(hcf->delbas == 1); + ASSERT(hcf->delivered.empty()); + } + std::cout << "Block Ack lifecycle assertions passed.\n"; + } +}; +Define_Module(LifecycleTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module LifecycleHcf extends Hcf { parameters: @class(::inet::ieee80211::LifecycleHcf); } +simple LifecycleTest { parameters: int scenario; @class(::inet::ieee80211::LifecycleTest); } +network LifecycleNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: LifecycleTest; +} + +%inifile: omnetpp.ini +[General] +network = LifecycleNetwork +ned-path = .;../../../../src +sim-time-limit = 7ms +seed-set = 0 +*.test.scenario = ${0..9} +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "LifecycleHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m + +%contains: stdout +Block Ack lifecycle assertions passed. diff --git a/tests/module/Ieee80211BlockAckNegotiation_1.test b/tests/module/Ieee80211BlockAckNegotiation_1.test new file mode 100644 index 00000000000..3f8b9c11a56 --- /dev/null +++ b/tests/module/Ieee80211BlockAckNegotiation_1.test @@ -0,0 +1,83 @@ +%description: +Check recipient negotiation through the production agreement handler. +The recipient response determines buffer size and inactivity timeout. +The response copies the request dialog token. + +%extraargs: -r 0..3 + +%file: Negotiation.cc +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" + +namespace inet::ieee80211 { +class NegotiationPolicy : public IRecipientBlockAckAgreementPolicy { + public: + bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const override { + return variant == BlockAckVariant::BASIC || (localHt && peerHt); + } + bool isAddbaReqAccepted(const Ptr&) override { return true; } + bool isDelbaAccepted(const Ptr&) override { return true; } + simtime_t getBlockAckTimeoutValue() const override { return SimTime(20, SIMTIME_MS); } + bool aMsduSupported() const override { return false; } + bool delayedBlockAckPolicySupported() const override { return false; } + int getMaximumAllowedBufferSize() const override { return 64; } +}; +class NegotiationTest : public cSimpleModule, public IProcedureCallback { + protected: + RecipientBlockAckAgreementHandler handler; + NegotiationPolicy policy; + Ptr response; + void initialize() override { scheduleAt(SIMTIME_ZERO, new cMessage("test")); } + void handleMessage(cMessage *message) override { + delete message; + const MacAddress peer("02:00:00:00:00:02"); + auto request = makeShared(); + request->setTransmitterAddress(peer); + request->setTid(5); + request->setDialogToken(37); + request->setBlockAckPolicy(true); + request->setBufferSize(par("requestSize")); + request->setStartingSequenceNumber(SequenceNumberCyclic(100)); + request->setBlockAckTimeoutValue(SimTime(40, SIMTIME_MS)); + handler.processReceivedAddbaRequest(request, &policy, this); + ASSERT(response != nullptr); + ASSERT(response->getDialogToken() == 37); + ASSERT(response->getBufferSize() == 64); + ASSERT(response->getBlockAckTimeoutValue() == SimTime(20, SIMTIME_MS)); + auto agreement = handler.getAgreement(5, peer); + ASSERT(agreement != nullptr); + ASSERT(agreement->getBufferSize() == response->getBufferSize()); + ASSERT(agreement->getBlockAckTimeoutValue() == response->getBlockAckTimeoutValue()); + ASSERT(agreement->getStartingSequenceNumber() == SequenceNumberCyclic(100)); + std::cout << "Block Ack negotiation assertions passed.\n"; + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + response = dynamicPtrCast(header); + delete packet; + } + void transmitControlResponseFrame(Packet *, const Ptr&, + Packet *, const Ptr&) override { throw cRuntimeError("Unexpected control response"); } +}; +Define_Module(NegotiationTest); +} + +%file: test.ned +simple NegotiationTest { + parameters: + int requestSize; + @class(::inet::ieee80211::NegotiationTest); +} +network NegotiationNetwork { submodules: test: NegotiationTest; } + +%inifile: omnetpp.ini +[General] +network = NegotiationNetwork +ned-path = .;../../../../src +sim-time-limit = 1ms +seed-set = 0 +*.test.requestSize = ${0,8,64,128} +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false + +%contains: stdout +Block Ack negotiation assertions passed. diff --git a/tests/module/Ieee80211BlockAckResponseWait_1.test b/tests/module/Ieee80211BlockAckResponseWait_1.test new file mode 100644 index 00000000000..9fc88c204d4 --- /dev/null +++ b/tests/module/Ieee80211BlockAckResponseWait_1.test @@ -0,0 +1,242 @@ +%description: +Check Action reception during the final ADDBA Request ACK wait through initialized Basic HCF. The request uses production contention, transmission, and frame-sequence handling. The fixture supplies the initial request record and injects an incoming Action after transmission. Matching success and rejection must suppress obsolete request failure. Wrong-token and unrelated-Action controls must retain ordinary request failure. The test does not model wireless reception or peer contention. + +%extraargs: -r 0..3 + +%file: ResponseWait.cc +#include +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class ResponseWaitOriginator : public OriginatorBlockAckAgreementHandler { + public: + void prepare(const Ptr& request) { createAgreement(request); } +}; +class ResponseWaitHcf : public Hcf { + public: + const MacAddress peer = MacAddress("02:00:00:00:00:02"); + int attempts = 0; + int failures = 0; + int acknowledgments = 0; + int delbas = 0; + int linkBreaks = 0; + int requestOutcomes = 0; + bool injected = false; + bool dispatchingAction = false; + void begin() { + Enter_Method("begin"); + subscribe(linkBrokenSignal, this); + subscribe(Ieee80211Mac::frameTransmissionOutcomeSignal, this); + delete originatorBlockAckAgreementHandler; + auto handler = new ResponseWaitOriginator(); + originatorBlockAckAgreementHandler = handler; + auto request = makeShared(); + request->setTransmitterAddress(mac->getAddress()); + request->setReceiverAddress(peer); + request->setTid(5); + request->setDialogToken(37); + request->setBlockAckPolicy(true); + request->setBufferSize(64); + request->setStartingSequenceNumber(SequenceNumberCyclic(100)); + handler->prepare(request); + auto data = makeShared(); + data->setType(ST_DATA_WITH_QOS); + data->addChunkLength(QOSCONTROL_PART_LENGTH); + data->setTransmitterAddress(mac->getAddress()); + data->setReceiverAddress(peer); + data->setAddress3(peer); + data->setTid(5); + auto packet = new Packet("deferred-data", data); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, data); + Hcf::processMgmtFrame(new Packet("request", request), request); + } + void verify() { + Enter_Method("verify"); + ASSERT(injected); + ASSERT(attempts == 1); + ASSERT(acknowledgments == 1); + auto agreement = originatorBlockAckAgreementHandler->getAgreement(peer, 5); + int scenario = par("scenario"); + if (scenario < 2) { + ASSERT(failures == 0); + ASSERT(delbas == 0); + ASSERT(linkBreaks == 0); + ASSERT(requestOutcomes <= 1); + ASSERT(!addbaResponseTimer->isScheduled()); + ASSERT(!startRxTimer->isScheduled()); + if (scenario == 0) { + ASSERT(agreement != nullptr); + ASSERT(agreement->getIsAddbaResponseReceived()); + ASSERT(agreement->getBufferSize() == 32); + } + else + ASSERT(agreement == nullptr || !agreement->getIsAddbaResponseReceived()); + } + else { + ASSERT(failures == 1); + ASSERT(linkBreaks == 1); + ASSERT(requestOutcomes == 1); + ASSERT(agreement == nullptr || !agreement->getIsAddbaResponseReceived()); + } + std::cout << "Block Ack response-wait assertions passed.\n"; + endSimulation(); + } + protected: + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *details) override { + if (signal == linkBrokenSignal) + linkBreaks++; + else if (signal == Ieee80211Mac::frameTransmissionOutcomeSignal) { + auto packet = check_and_cast(object); + if (dynamicPtrCast(packet->peekAtFront())) + requestOutcomes++; + } + else + Hcf::receiveSignal(source, signal, object, details); + } + void handleMessage(cMessage *message) override { + if (message->isName("injectAction")) { + delete message; + ASSERT(frameSequenceHandler->isSequenceRunning()); + ASSERT(frameSequenceHandler->getContext()->getLastStep()->getType() == IFrameSequenceStep::Type::RECEIVE); + ASSERT(startRxTimer->isScheduled()); + int scenario = par("scenario"); + Ptr header; + if (scenario == 3) { + auto request = makeShared(); + request->setTid(6); + request->setDialogToken(91); + request->setBlockAckPolicy(true); + request->setBufferSize(64); + header = request; + } + else { + auto response = makeShared(); + response->setTid(5); + response->setDialogToken(scenario == 2 ? 38 : 37); + response->setStatusCode(scenario == 1 ? 37 : 0); + response->setBlockAckPolicy(true); + response->setBufferSize(32); + response->setBlockAckTimeoutValue(SIMTIME_ZERO); + header = response; + } + header->setTransmitterAddress(peer); + header->setReceiverAddress(mac->getAddress()); + header->setSequenceNumber(SequenceNumberCyclic(77)); + auto packet = new Packet("incoming-action", header); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + packet->insertAtBack(makeShared()); + injected = true; + dispatchingAction = true; + processLowerFrame(packet, header); + dispatchingAction = false; + scheduleAfter(SimTime(1, SIMTIME_NS), new cMessage("verify")); + } + else if (message->isName("verify")) { + delete message; + verify(); + } + else + Hcf::handleMessage(message); + } + void originatorProcessTransmittedFrame(Packet *packet) override { + auto request = dynamicPtrCast(packet->peekAtFront()); + Hcf::originatorProcessTransmittedFrame(packet); + if (request) { + attempts++; + scheduleAfter(SimTime(100, SIMTIME_US), new cMessage("injectAction")); + } + } + void originatorProcessFailedFrame(Packet *packet) override { + if (dynamicPtrCast(packet->peekAtFront())) + failures++; + Hcf::originatorProcessFailedFrame(packet); + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + if (dynamicPtrCast(packet->peekAtFront())) + ASSERT(!dispatchingAction); + return Hcf::transmitFrame(packet, ifs); + } + void transmitControlResponseFrame(Packet *packet, const Ptr&, + Packet *, const Ptr&) override { + acknowledgments++; + delete packet; + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) + delbas++; + delete packet; + } + void sendUp(const std::vector& frames) override { + for (auto packet : frames) { + take(packet); + delete packet; + } + } +}; +Define_Module(ResponseWaitHcf); +class ResponseWaitTest : public cSimpleModule { + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("test")); } + void handleMessage(cMessage *message) override { + delete message; + check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf"))->begin(); + } +}; +Define_Module(ResponseWaitTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module ResponseWaitHcf extends Hcf { + parameters: + int scenario; + @class(::inet::ieee80211::ResponseWaitHcf); +} +simple ResponseWaitTest { parameters: @class(::inet::ieee80211::ResponseWaitTest); } +network ResponseWaitNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: ResponseWaitTest; +} + +%inifile: omnetpp.ini +[General] +network = ResponseWaitNetwork +ned-path = .;../../../../src +sim-time-limit = 5ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "ResponseWaitHcf" +**.wlan[*].mac.hcf.scenario = ${0..3} +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.originatorAckPolicy.ackTimeout = 1ms +**.mgmtAndNonQoSRecoveryProcedure.shortRetryLimit = 1 +**.mgmtAndNonQoSRecoveryProcedure.longRetryLimit = 1 +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m + +%contains: stdout +Block Ack response-wait assertions passed. diff --git a/tests/module/Ieee80211BlockAckRetiredData_1.test b/tests/module/Ieee80211BlockAckRetiredData_1.test new file mode 100644 index 00000000000..0898ec6f565 --- /dev/null +++ b/tests/module/Ieee80211BlockAckRetiredData_1.test @@ -0,0 +1,325 @@ +%description: +Check peer reset during actual Normal Ack DATA exchanges through HCF and Tx. Reset occurs during ACK wait, transmission, or the SIFS before a second DATA frame. The accepted transmission retains safe ownership until completion. Each completed target transmission must emit one packetSentToPeer signal from its EDCAF. A late ACK must not restore ACK state or cause another DATA attempt. The test injects ACK frames at the HCF receive boundary and uses no peer radio. + +The late ACK must emit one packetReceivedFromPeer signal. Further cases reset during accepted RTS transmission or CTS wait. DATA and owned Actions must not return to transmission after CTS. The old management exchange must not select another peer's frame after reset. Another peer's DATA retains its lifetime record. + +%extraargs: -r 0..8 + +%file: RetiredData.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class RetiredOriginator : public OriginatorBlockAckAgreementHandler { + public: + void prepare(const Ptr& request) { createAgreement(request); } +}; +class RetiredDataHcf : public Hcf { + const MacAddress peer = MacAddress("02:00:00:00:00:02"); + Ptr retiredHeader; + int64_t retiredId = -1; + int attempts = 0; + int completions = 0; + bool reset = false; + bool targetCompleted = false; + int targetSentSignals = 0; + int lateAckSignals = 0; + int64_t lateAckId = -1; + int64_t otherId = -1; + bool rtsCompleted = false; + bool injectingCts = false; + public: + void begin() { + Enter_Method("begin"); + edca->getEdcaf(AC_VI)->subscribe("packetSentToPeer", this); + subscribe("packetReceivedFromPeer", this); + int scenario = par("scenario"); + if (scenario >= 5) { + delete originatorBlockAckAgreementHandler; + auto originator = new RetiredOriginator(); + originatorBlockAckAgreementHandler = originator; + auto request = makeShared(); + request->setTransmitterAddress(mac->getAddress()); + request->setReceiverAddress(peer); + request->setTid(5); + request->setDialogToken(37); + request->setBlockAckPolicy(true); + request->setBufferSize(64); + request->setStartingSequenceNumber(SequenceNumberCyclic(0)); + originator->prepare(request); + queueData("deferred"); + processMgmtFrame(new Packet("owned-request", request), request); + return; + } + queueData("first"); + if (par("scenario").intValue() == 2) + queueData("second"); + } + protected: + void receiveSignal(cComponent *source, simsignal_t signal, cObject *value, cObject *details) override { + if (signal == packetSentToPeerSignal) { + ASSERT(source == edca->getEdcaf(AC_VI)); + auto packet = check_and_cast(value); + if (packet->getId() == retiredId) + targetSentSignals++; + } + else if (signal == packetReceivedFromPeerSignal) { + if (check_and_cast(value)->getId() == lateAckId) + lateAckSignals++; + } + else + Hcf::receiveSignal(source, signal, value, details); + } + void queueData(const char *name, bool other = false) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTransmitterAddress(mac->getAddress()); + header->setReceiverAddress(other ? MacAddress("02:00:00:00:00:03") : peer); + header->setAddress3(peer); + header->setTid(5); + auto packet = new Packet(name, header); + if (other) + otherId = packet->getId(); + packet->insertAtBack(makeShared(B(1500))); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + } + void injectAck() { + auto header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + auto packet = new Packet("ack", header); + if (reset) + lateAckId = packet->getId(); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + processLowerFrame(packet, header); + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + ASSERT(packet != nullptr); + auto header = packet->peekAtFront(); + auto data = dynamicPtrCast(header); + int scenario = par("scenario"); + bool obsoleteSubmission = scenario >= 3 && reset && header->getReceiverAddress() == peer && header->getType() != ST_RTS; + bool substitutedSubmission = scenario >= 7 && injectingCts && header->getType() != ST_RTS; + bool accepted = Hcf::transmitFrame(packet, ifs); + if (obsoleteSubmission || substitutedSubmission) { + std::cout << "Post-reset protected frame accepted: " << accepted << std::endl; + ASSERT(!accepted); + return false; + } + if (scenario >= 3 && header->getType() == ST_RTS && accepted && header->getReceiverAddress() == peer) { + ASSERT(!reset); + ASSERT(tx->hasTransmission()); + if (scenario == 3 || scenario == 5 || scenario == 7) + scheduleAfter(SimTime(1, SIMTIME_NS), new cMessage("resetRts")); + return accepted; + } + if (data && accepted) { + attempts++; + int scenario = par("scenario"); + bool target = scenario == 2 ? attempts == 2 : attempts == 1; + if (target) { + retiredHeader = packet->peekAtFront(); + retiredId = packet->getId(); + ASSERT(retiredHeader->getAckPolicy() == NORMAL_ACK); + if (scenario != 0) { + if (scenario == 2) + ASSERT(ifs > SIMTIME_ZERO); + scheduleAfter(SimTime(1, SIMTIME_NS), new cMessage("reset")); + } + } + } + return accepted; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + Enter_Method("transmissionComplete"); + auto data = dynamicPtrCast(header); + bool isData = data != nullptr; + bool isTarget = data && retiredHeader && data->getSequenceNumber() == retiredHeader->getSequenceNumber(); + bool isRts = header->getType() == ST_RTS; + Hcf::transmissionComplete(packet, header); + if (par("scenario").intValue() >= 3 && isRts) { + rtsCompleted = true; + scheduleAfter(SimTime(60, SIMTIME_US), new cMessage(reset ? "cts" : "resetCtsWait")); + return; + } + if (isData) { + completions++; + int scenario = par("scenario"); + if (isTarget) { + targetCompleted = true; + if (scenario == 0) + scheduleAfter(SimTime(100, SIMTIME_US), new cMessage("reset")); + else + scheduleAfter(SimTime(60, SIMTIME_US), new cMessage("lateAck")); + } + else if (scenario == 2 && completions == 1) + scheduleAfter(SimTime(60, SIMTIME_US), new cMessage("firstAck")); + } + } + void handleMessage(cMessage *message) override { + if (message->isName("resetRts") || message->isName("resetCtsWait")) { + bool waiting = message->isName("resetCtsWait"); + delete message; + ASSERT(frameSequenceHandler->isSequenceRunning()); + ASSERT(rtsCompleted == waiting); + ASSERT(tx->hasTransmission() == !waiting); + queueData("other-peer", true); + if (par("scenario").intValue() >= 7) { + auto header = makeShared(); + header->setType(ST_PROBEREQUEST); + header->setReceiverAddress(MacAddress("02:00:00:00:00:03")); + auto packet = new Packet("other-management", header); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + } + ASSERT(edca->getLifetimeHandler()->findFrame(otherId) != nullptr); + resetPeer(peer); + reset = true; + ASSERT(edca->getLifetimeHandler()->findFrame(otherId) != nullptr); + ASSERT(!hasQueuedData(peer, 5)); + if (waiting) + scheduleAfter(SimTime(60, SIMTIME_US), new cMessage("cts")); + } + else if (message->isName("cts")) { + delete message; + ASSERT(reset && rtsCompleted); + auto header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + auto packet = new Packet("late-cts", header); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + injectingCts = true; + processLowerFrame(packet, header); + injectingCts = false; + scheduleAfter(SimTime(1, SIMTIME_NS), new cMessage("verifyRts")); + } + else if (message->isName("verifyRts")) { + delete message; + ASSERT(!hasQueuedData(peer, 5)); + ASSERT(edca->getLifetimeHandler()->findFrame(otherId) != nullptr); + ASSERT(originatorBlockAckAgreementHandler->getProcedures().count({peer, 5}) == 0); + ASSERT(ownedActions.empty()); + edca->getEdcaf(AC_VI)->unsubscribe("packetSentToPeer", this); + unsubscribe("packetReceivedFromPeer", this); + std::cout << "Block Ack retired-DATA assertions passed.\n"; + endSimulation(); + } + else if (message->isName("reset")) { + delete message; + ASSERT(!reset); + int scenario = par("scenario"); + ASSERT(frameSequenceHandler->isSequenceRunning()); + if (scenario == 0) { + ASSERT(targetCompleted); + ASSERT(frameSequenceHandler->getContext()->getLastStep()->getType() == IFrameSequenceStep::Type::RECEIVE); + } + else { + ASSERT(!targetCompleted); + ASSERT(tx->hasTransmission()); + ASSERT(frameSequenceHandler->getContext()->getLastStep()->getType() == IFrameSequenceStep::Type::TRANSMIT); + } + resetPeer(peer); + reset = true; + ASSERT(edca->getLifetimeHandler()->findFrame(retiredId) == nullptr); + if (scenario != 0) + ASSERT(tx->hasTransmission()); + else + scheduleAfter(SimTime(100, SIMTIME_US), new cMessage("lateAck")); + } + else if (message->isName("firstAck")) { + delete message; + injectAck(); + } + else if (message->isName("lateAck")) { + delete message; + ASSERT(reset); + ASSERT(targetCompleted); + injectAck(); + scheduleAfter(SimTime(2, SIMTIME_MS), new cMessage("verify")); + } + else if (message->isName("verify")) { + delete message; + ASSERT(reset && targetCompleted); + ASSERT(attempts == (par("scenario").intValue() == 2 ? 2 : 1)); + ASSERT(!tx->hasTransmission()); + ASSERT(!frameSequenceHandler->isSequenceRunning()); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 0); + ASSERT(edca->getEdcaf(AC_VI)->getAckHandler()->getQoSDataAckStatus(retiredHeader) == QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED); + edca->getEdcaf(AC_VI)->unsubscribe("packetSentToPeer", this); + std::cout << "Retired target sent signals: " << targetSentSignals << std::endl; + std::cout << "Late ACK received signals: " << lateAckSignals << std::endl; + unsubscribe("packetReceivedFromPeer", this); + ASSERT(targetSentSignals == 1); + ASSERT(lateAckSignals == 1); + std::cout << "Block Ack retired-DATA assertions passed.\n"; + endSimulation(); + } + else + Hcf::handleMessage(message); + } +}; +Define_Module(RetiredDataHcf); +class RetiredDataTest : public cSimpleModule { + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("test")); } + void handleMessage(cMessage *message) override { + delete message; + check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf"))->begin(); + } +}; +Define_Module(RetiredDataTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module RetiredDataHcf extends Hcf { parameters: int scenario; @class(::inet::ieee80211::RetiredDataHcf); } +simple RetiredDataTest { parameters: @class(::inet::ieee80211::RetiredDataTest); } +network RetiredDataNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: RetiredDataTest; +} + +%inifile: omnetpp.ini +[General] +network = RetiredDataNetwork +ned-path = .;../../../../src +sim-time-limit = 20ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].bitrate = 6Mbps +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "RetiredDataHcf" +**.wlan[*].mac.hcf.scenario = ${scenario=0..8} +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.originatorAckPolicy.ackTimeout = 1ms +**.wlan[*].mac.hcf.rtsPolicy.rtsThreshold = ${scenario} >= 3 ? 0B : 2346B +**.wlan[*].mac.hcf.rtsPolicy.ctsTimeout = 1ms +**.wlan[*].mac.hcf.edca.edcaf[2].txopProcedure.txopLimit = 10ms +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m + +%contains: stdout +Block Ack retired-DATA assertions passed. From 832dc3672c0233e47648423eaca191a0dece6f9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:44:26 +0200 Subject: [PATCH 03/41] ieee80211: refactor: let frame sequences own interruption outcomes Before this commit, HCF chooses completion or failure when an accepted Action interrupts a response wait. The frame-sequence handler owns the relevant exchange state, so receive dispatch duplicates that decision. After this commit, HCF requests interruption without an outcome argument. The frame-sequence handler checks whether recipient processing retires the outgoing frame. A retired frame completes without failure feedback. Other exchanges retain the ordinary failure path. HCF cancels the receive timer at sequence completion. For example, a correlated Action can retire outgoing management work during a response wait. The handler completes that retired exchange without failure feedback. Existing fixtures also cover refusals, unrelated Actions, and immediate ACK behavior. Custom handlers must implement the no-argument interruption operation. The migration guide explains this contract. Built-in packet behavior and event order remain unchanged. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | refactor | test migration | ieee80211-compressed-blockack-replacement --- doc/src/migration-guide/index.rst | 2 +- .../ieee80211/mac/contract/IFrameSequenceHandler.h | 4 ++-- .../ieee80211/mac/coordinationfunction/Hcf.cc | 8 ++------ .../mac/framesequence/FrameSequenceHandler.cc | 13 +++++++++---- .../mac/framesequence/FrameSequenceHandler.h | 2 +- 5 files changed, 15 insertions(+), 14 deletions(-) diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 138bc9d7fa1..47ead943f5f 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -201,7 +201,7 @@ The optional ``peekEligiblePacket(predicate)`` operation returns a borrowed pack Providers that cannot perform a selected operation must throw ``inet::queueing::UnsupportedPacketSelection``. This exception permits ordinary service and collection inspection without the optional capability. Genuine queue and predicate errors must retain their original type. -External frame-sequence handlers must implement ``interruptFrameSequence(notifyFailure)``. A false argument ends an exchange that an accepted Action already resolves, without obsolete failure feedback. Cleanup must destroy the exchange context before it deletes deferred frame copies. These repairs do not add MAC stop/start recovery or final-transfer teardown. +External frame-sequence handlers must implement ``interruptFrameSequence()``. The handler owns the interruption outcome after recipient processing. It suppresses failure feedback when the transmitted DATA or management frame no longer belongs to the in-progress queue. Other exchanges retain ordinary failure feedback. Cleanup must destroy the exchange context before it deletes deferred frame copies. These repairs do not add MAC stop/start recovery or final-transfer teardown. IEEE 802.11 Response Query Roles -------------------------------- diff --git a/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h b/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h index 0f61eaa9891..d2002a5ffdc 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h @@ -48,8 +48,8 @@ class INET_API IFrameSequenceHandler virtual void transmissionComplete() = 0; virtual bool isSequenceRunning() = 0; virtual void handleStartRxTimeout() = 0; - // The caller can suppress failure feedback for an exchange that its procedure already resolved. - virtual void interruptFrameSequence(bool notifyFailure) = 0; + // End a response wait after recipient processing. The sequence suppresses failure for retired DATA or management frames. + virtual void interruptFrameSequence() = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index 7deeca7ef0f..b75ddaa30eb 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -805,17 +805,12 @@ void Hcf::processLowerFrame(Packet *packet, const Ptr& handlingAgreementAction = true; emit(packetReceivedFromPeerSignal, packet); std::unique_ptr responseSource(packet->dup()); - auto outgoing = check_and_cast(frameSequenceHandler->getContext()->getStepBeforeLast())->getFrameToTransmit(); auto accepted = recipientDataService->managementFrameReceived(packet, action); for (auto frame : accepted) { take(frame); dispatchAgreementAction(frame->peekAtFront()); } - cancelEvent(startRxTimer); - bool resolved = obsoleteActions.count(outgoing->getId()) || - (dynamicPtrCast(outgoing->peekAtFront()) && - !edcaf->getInProgressFrames()->containsFrame(outgoing)); - frameSequenceHandler->interruptFrameSequence(!resolved); + frameSequenceHandler->interruptFrameSequence(); recipientAckProcedure->processReceivedFrame(responseSource.get(), action, check_and_cast(recipientAckPolicy), this); for (auto frame : accepted) delete frame; @@ -961,6 +956,7 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) void Hcf::frameSequenceFinished() { Enter_Method("frameSequenceFinished"); + cancelEvent(startRxTimer); finishingSequence = true; emit(IFrameSequenceHandler::frameSequenceFinishedSignal, frameSequenceHandler->getContext()); auto edcaf = edca->getChannelOwner(); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc index cc6450101f3..c01596ee2ab 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc @@ -14,15 +14,20 @@ namespace inet { namespace ieee80211 { -void FrameSequenceHandler::interruptFrameSequence(bool notifyFailure) +void FrameSequenceHandler::interruptFrameSequence() { ASSERT(isSequenceRunning()); ASSERT(dynamic_cast(context->getLastStep())); context->getLastStep()->setCompletion(IFrameSequenceStep::Completion::REJECTED); - if (notifyFailure) - abortFrameSequence(); - else + auto outgoing = check_and_cast(context->getStepBeforeLast())->getFrameToTransmit(); + // Retirement removes DATA and management frames from the queue before this transition. + // Control exchanges retain their ordinary failure path through the recovery callback. + bool retired = dynamicPtrCast(outgoing->peekAtFront()) && + !context->getInProgressFrames()->containsFrame(outgoing); + if (retired) finishFrameSequence(); + else + abortFrameSequence(); } void FrameSequenceHandler::handleStartRxTimeout() diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h index fa65175856a..a3d0d6f647b 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h @@ -35,7 +35,7 @@ class INET_API FrameSequenceHandler : public IFrameSequenceHandler virtual void processResponse(Packet *frame) override; virtual void transmissionComplete() override; virtual void handleStartRxTimeout() override; - virtual void interruptFrameSequence(bool notifyFailure) override; + virtual void interruptFrameSequence() override; virtual bool isSequenceRunning() override { return frameSequence != nullptr; } virtual ~FrameSequenceHandler(); From 0c234006883d25a5d47458bdf68abfc29d85f96d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:44:29 +0200 Subject: [PATCH 04/41] plan: add: record S3b agreement lifecycle completion Before this commit, the branch lacks committed S3b completion records. Reviewers need component responsibilities, scope limits, and verification results in one record. After this commit, plan/done/ contains the summary and execution record. The summary explains agreement setup, retirement, peer reset, and safe physical completion. The execution record explains allocation indices and separates results by original source revision. Those historical revision identifiers remain unchanged. The records describe debug and release compilation, focused module fixtures, and functional fingerprint checks for the original implementation and later retirement repair. This documentation commit changes no protocol behavior or recorded expectation. S4 and production Compressed exchanges remain outside the completed stage. Plan: plan/done/ieee80211-compressed-blockack-s3b-summary.md Change: plan | behavior.add | - --- ...80211-compressed-blockack-s3b-execution.md | 279 ++++++++++++++++++ ...ee80211-compressed-blockack-s3b-summary.md | 251 ++++++++++++++++ 2 files changed, 530 insertions(+) create mode 100644 plan/done/ieee80211-compressed-blockack-s3b-execution.md create mode 100644 plan/done/ieee80211-compressed-blockack-s3b-summary.md diff --git a/plan/done/ieee80211-compressed-blockack-s3b-execution.md b/plan/done/ieee80211-compressed-blockack-s3b-execution.md new file mode 100644 index 00000000000..b8076b55859 --- /dev/null +++ b/plan/done/ieee80211-compressed-blockack-s3b-execution.md @@ -0,0 +1,279 @@ +# S3b execution record + +## Completed S3b + +S3b is complete on branch `work/compressed-blockack-s3b` in [PR #1343](https://github.com/inet-framework/inet/pull/1343). The current source revision is `8646a9e6808ea8d21ac28bfc1271537469225fe9`, above PR base `bba1db4c8180a592894e0ab2a2dc056d9cb08082`. The broad verification below covers `8ba7c9e47bc3ded924cfa3917c8b899baccf789d`; a separate record covers the later allocation-index repair. Branch completion does not assert a merge into `master`. S4, A5, and production Compressed exchanges remain outside this completed stage. + +The six implementation commits supply optional selected extraction, lifecycle integration, first-DATA collision retirement, frame-sequence interruption ownership, fragment retirement, and allocation-index comparisons. A separate documentation commit records stage completion. The [S3b summary](ieee80211-compressed-blockack-s3b-summary.md) explains the resulting behavior. The [migration guide](../../doc/src/migration-guide/index.rst) defines custom-module changes. Basic remains the default; HCF rejects Compressed selection during initialization. + +The latest repair retains the highest transmitted allocation index in the agreement. The QoS data service assigns this local index before fragmentation; all fragments retain it in `Ieee80211DataSequenceTag`. Ordinary teardown discards unsent fragments through that index, even after ACK processing removes an earlier fragment. Older retransmissions cannot move the index backward, and wire sequence numbers remain unchanged. + +The fragment fixture transmits DATA with sequence 0. It allocates intervening DATA through the production data service and deletes that DATA without transmission. Fragment 0 of sequence 2048 then transmits. The index advances correctly; teardown removes unsent siblings of sequence 2048 and preserves later intact DATA. This case tests an allocation gap; it does not test lifetime expiry of the intervening DATA. + +| Verification at source revision `8ba7c9e47bc3ded924cfa3917c8b899baccf789d` | Result | Saved local artifact | +| --- | --- | --- | +| Debug compilation | Pass | `/tmp/pr1343-publish-debug.log` | +| Release compilation | Pass | `/tmp/pr1343-publish-release.log` | +| Selected debug module fixtures | 26 pass | `/tmp/pr1343-publish-modules.log` | +| Functional fingerprint cases, without graphical `tyf` ingredients | 19 pass | `/tmp/pr1343-publish-fingerprints.log` | +| Fragment reproduction against `53edefe95a6cc9671ef8d4864c913c2a5669306d` | Fails at the retirement assertion | `/tmp/pr1343-fragment-before.err` | +| Fragment fixture after the repair | Four scenarios pass | `/tmp/pr1343-fragment-after.log` | +| Commit, classification, include, parameter, and PR-description checks | Pass | `/tmp/pr1343-publish-mechanical.log` | +| Source-seal check | Pass | `/tmp/pr1343-publish-seals.log` | + +The commands for this earlier verification run from the repository root after environment setup: + +```sh +make MODE=debug -j12 +make MODE=release -j12 +inet_run_module_tests -m debug -f '(PacketSelectiveExtraction_1|Ieee80211BlockAck.*_1|Ieee80211EdcaDataLifetime.*|Ieee80211HcfInternalCollision_1)\.test$' +``` + +The functional fingerprint command runs from `tests/fingerprint`: + +```sh +./fingerprinttest -d -F tyf -t 4 -m 'showcases/wireless/(blockack|aggregation|fragmentation|qos|txop)/|examples/wireless/qos/.*MacQos|examples/adhoc/qos/.*MacQos' examples.csv showcases.csv +``` + +Seven approved functional fingerprint rows belong to the lifecycle implementation. Later repairs retain those values and add no baseline change. Twelve controls retain their functional expectations. Graphical expectations remain unchanged and outside this functional result. The earlier verification at `667ae51dc9fbfbfac9ea68122bf65bc4f2d3e1df` includes 37 module fixtures, six unit fixtures, and 13 Basic demonstrations. Its protocol selection records four passes and four declared expected failures. Those earlier results do not establish final-head coverage for the same selections. + +At `8ba7c9e47b`, whole-project architecture and naming checks retain the findings present at the PR base. The interface check retains 15 findings and nine review notes; the two new interfaces pass. The changed source paths are unsealed. Raw `/tmp` artifacts are local evidence; they are not part of the published repository. + +### Allocation-index repair at `ea20a2880e` + +The series now places the allocation-index repair before the final plan commit. The repair maps from `ea20a2880e0ca607e680def1a875c6702c4ef249` to `8646a9e6808ea8d21ac28bfc1271537469225fe9` without source or test changes. The results below retain their original revision. The history comparison establishes content equivalence; it is not a new behavioral test. + +Commit `ea20a2880e0ca607e680def1a875c6702c4ef249` replaces cyclic comparisons with allocation indices. It adds a MSG definition for local metadata, without a wire-format change. Custom QoS data services must supply the tag, as the migration guide requires. + +| Recorded verification for the allocation-index repair | Result | Saved local artifact | +| --- | --- | --- | +| Debug compilation | Pass | `/tmp/s3b-push-debug.log` | +| Release compilation | Pass | `/tmp/s3b-push-release.log` | +| Fragment-retirement, lifecycle, association-reset, and DATA-selection fixtures in debug mode | Four fixtures pass | `/tmp/s3b-push-tests.log` | + +The commit records 50 successful simulation runs across these four fixtures. The fragment fixture supplies 20 runs with these parameters: + +- The initial sequence is 0 or 4095. +- The allocation distance is 0, 2047, 2048, 2049, or 4096. +- Teardown occurs during transmission or after the first fragment receives its Normal Ack. + +The fixture supplies accepted agreements and ACKs; production code performs fragmentation, expiry, retirement, and transmission. Later intact DATA and unrelated-peer DATA remain controls. + +These archived results do not extend the earlier 26-fixture or 19-fingerprint results to this revision. Release-mode behavioral tests, sanitizers, and other platforms remain unverified at this revision. The later audit checks the repair and documentation claims through source inspection; it is not a full independent correctness audit. + +This document correction changes no production source or recorded expectation. It repeats no build or simulation test. The checkout's existing `AGENTS.md`, four pending plans, and planning history remain under their existing owners. + +## Earlier execution snapshot + +The sections below retain the earlier implementation record, before publication and later repairs. Their candidate numbers and source pins refer to that earlier work. Their statements about absent commits, release checks, or baseline approval apply only to that snapshot. The completed-stage results above supersede those status statements. + +The original implementation parent is `41eee1d61978d62cfaf9d0d9c242b9fee590c20e`. The branch is `work/compressed-blockack-s3b`. The working copies of replacement plan revision 39 and lifecycle plan revision 29 define that scope. The user authorized S3b execution on 15 October 2026. + +## Implementation contract + +[HCF](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) owns agreement coordination and frame exchange order. The [originator](../../src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc) and [recipient](../../src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc) handlers own their agreements and transient procedures. The MIB owns capability state. Management supplies an explicit peer reset before association replacement. The [recipient data service](../../src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc) owns duplicate checks and delivery. Queue components own extraction effects. + +The implementation retains Basic compatibility without an HT admission requirement. HCF continues to reject Compressed selection during initialization. Isolated policies verify Compressed admission with explicit capability inputs. S3b does not implement S4 BAR arbitration, A5 transfer completion, or Compressed exchanges. + +1. A1 returns complete accepted Block Ack Actions from the recipient data service. HCF dispatches each Action once after duplicate checks. A correlated Action resolves its procedure before obsolete exchange failure. +2. A2 passes the selected profile to admission policies. The handlers correlate peer, TID, and dialog token. Accepted response values determine both agreement owners' parameters. The data service enforces both A-MSDU flags. +3. A3a detaches the selected agreement before cleanup and deletion notification. Ordinary recipient teardown delivers complete buffered units in cyclic order. It discards incomplete units. HCF uses one absolute inactivity deadline across both roles. +4. A3b clears both roles and obsolete peer work before deletion notifications. Management supplies the old peer identity before association replacement. The MIB keeps its boolean notification and coherent committed state. +5. A3c routes Action disposal to its owner. HCF invalidates obsolete queued and in-progress Actions. An accepted transmission retains its context until safe completion. Valid DATA or BAR without an agreement causes recipient-role DELBA. +6. A4 defers extraction during setup and recovery. The data service supplies a non-consuming sequence query. Optional selected extraction preserves queue ownership, residence metadata, and pull events. Contention uses the same eligibility condition. + +HCF obtains both roles' earliest active absolute deadlines after each agreement mutation. It schedules their minimum. It cancels the timer when neither role has a finite deadline. Expiration detaches every overdue agreement before the next deadline calculation. + +The delayed-successor interpretation preserves the existing setup trigger across separate DATA arrivals. A completed eligible Normal Ack transmission supplies the first condition. A later unexpired unnumbered successor supplies the second condition. The handler retains the first condition in its procedure map without an Action or timer. HCF promotes that state to setup intent before successor extraction. A single frame without a successor therefore causes no ADDBA. + +The implementation checks peer, TID, direction, modulo-4096 sequence order, and absolute versus relative time at each changed boundary. Duplicate Actions retain immediate ACK behavior. Invalid responses cannot resolve setup. Queue disposal, retry failure, response timeout, inactivity, received DELBA, and association reset have separate terminal paths. No MAC stop/start recovery claim applies. + +## Source assessment + +The parent recipient data service deletes Actions before it returns its accepted frames. HCF nevertheless dispatches the original management header after that call. Thus, duplicate detection does not control agreement dispatch. During a response wait, HCF passes an addressed Action to the active receive step instead of its agreement handler. + +The parent policies accept unchecked setup parameters. The recipient stores request size and timeout before it builds a response. The response omits the request dialog token. The originator policy asserts that an agreement exists but performs no response correlation. + +Both handlers supply absolute inactivity deadlines. HCF passes those deadlines to `rescheduleAfter`. The handlers select expiration with equality instead of an overdue comparison. Recipient DATA reception does not refresh the stored deadline. Received recipient DELBA uses the local receiver address for removal. + +The parent collision controller tests frame counts. This test does not establish agreement eligibility. A4 requires a production reproduction or a cancellation trace before a shared arbitration change. + +## Verification status + +The separate lifecycle review accepted the A1–A4 scope against the pinned parent. It required the shared inactivity minimum and explicit peer reset before equal-state reassociation. The review supplied source evidence; it supplied no implementation or runtime verdict. + +The parent debug build passed with `make MODE=debug -j12`. The command ran from the repository root and returned zero. Its log is `/tmp/s3b-parent-build.log`. + +The parent reproduction command was `inet_run_module_tests -m debug -f 'Ieee80211BlockAck(ActionDelivery|ActionDispatch|Negotiation)_1.test'`. Its log is `/tmp/s3b-parent-reproductions.log`. The Action delivery fixture failed its returned-frame count assertion. The negotiation fixture failed its dialog-token assertion. Both failures reached the production component after test initialization. + +The HCF dispatch fixture initially lacked a received-mode indication and a valid request sequence number. Those fixture setup errors supplied no product evidence. After correction, `inet_run_module_tests -m debug -f 'Ieee80211BlockAckActionDispatch_1.test'` reproduced duplicate dispatch. The fixture required one dispatch after an original request and its MAC retry. The parent dispatched both. Its log is `/tmp/s3b-parent-dispatch.log`. + +The generated dispatch executable also ran independently with `-u Cmdenv -r 1` from `tests/module/work/Ieee80211BlockAckActionDispatch_1`. At 1 ms, the fixture supplied a 5 ms absolute deadline. The parent scheduled 6 ms. The arrival-time assertion failed with exit status one. Its log is `/tmp/s3b-parent-inactivity.log`. + +New fixtures cover directional cleanup, association reset, response-wait order, deferred extraction accounting, and contention. Existing Basic recipient, selector, header, queue-disposal, lifetime, capability, and exchange fixtures remain controls. The candidate results below identify their commands and evidence limits. + +The parent control command selected nine module fixtures and passed all nine. Its command was `inet_run_module_tests -m debug -f 'Ieee80211(BlockAck(Reordering|Variant)|HcfHeader|RecipientNav|HcfMultipleProtection_2|SingleProtectionGroup|MgmtApHcfQueueDrop|MgmtRatePublication|MgmtStateCommit|EdcaDataLifetimeArbitration)_.*test'`. Its log is `/tmp/s3b-parent-controls.log`. This expression did not select the multiple-protection fixture because that alternative already contained its suffix. + +A second command selected that fixture and the Basic exchange control: `inet_run_module_tests -m debug -f 'Ieee80211(HcfMultipleProtection_2|BasicCompatibility_1)\.test'`. Both fixtures passed. Its log is `/tmp/s3b-parent-basic-controls.log`. Together, these results cover eleven fixtures, including all eight S1 recipient scenarios. + +The parent library hash was `ed6af79596a80e6192f4ca1cb8bf91f8a5f682d508eef58e95603796aa384a6e`. The lifecycle and response-wait fixtures also reproduced nine parent failures with that library. Directional teardown emitted a null deletion payload. Absent-agreement DATA reached upper delivery. Absent-agreement BAR caused no DELBA. An incoming Action received no immediate ACK during an active request ACK wait. `/tmp/s3b-regression-parent/` retains the exact executables, inputs, hashes, and individual run logs. Later fixture changes require fresh compilation before candidate verification. + +The selected protocol command was `inet_run_protocol_tests -p inet -m debug -w '^tests/protocol/wifi$' -f '(N_BlockAck|N_CompressedBa|N_Amsdu|Ac_BlockAck|WifiQosDelayedBa|Ac_MultiTidBa|N_Ampdu|Ac_Ampdu)\.test$'`. It returned zero with four passes and four declared expected failures. Its log is `/tmp/s3b-parent-protocol.log`. This run used the unchanged parent library while source implementation began. The protocol support library includes no changed agreement or HCF declaration. A new unused timeout parameter declaration was present; this result does not establish candidate behavior. + +The delayed-policy fixture failed its immediate-ACK assertion after BAR. The Multi-TID fixture missed its response deadline. Both A-MPDU fixtures missed their subframe-header observation. `/tmp/s3b-parent-reproductions/protocol-failure-causes.json` preserves these first failure causes. These outcomes remain unresolved protocol obligations. + +## Additional production reproductions + +Candidate 6 exposed two A4 failures before the final contention change. A real VO transmission held an ADDBA Request in its queue. A later VO arrival evicted that Request. HCF cleared setup, but surviving BE DATA obtained no new contention request. Action-disposal case 6 reproduced this failure without another BE arrival. `/tmp/s3b-actiondisposal-build6-reproduction/` retains the evidence. + +A separate fixture expired a VI agreement at 33 microseconds. Its queued DATA became ineligible before coincident VI and BE grants at 34 microseconds. VO had its next grant at 70 microseconds. The controller still counted VI and charged BE a collision retry. With retry limit one, BE discarded its valid DATA. `/tmp/s3b-deferred-collision-before-isolated.log` records this isolated failure. + +The first contention trace also contained a legitimate VO grant at 34 microseconds. That trace supplies no evidence for the shared correction. The corrected fixture changes only VO AIFSN to six. Its eligible-VI control retains the real collision and retry disposal. Both corrected cases use seed zero and the same binary and library. + +HCF now supplies each EDCAF with a query for current frame eligibility. The collision controller uses this query before it selects contenders. The query performs no expiration, extraction, or protocol mutation. HCF retains the existing Basic readiness condition; S4 still owns BAR-only work. After an Action terminal outcome, HCF requests contention for every category with eligible work. + +Candidate 7 passes both corrected contention cases. The deferred-VI case transmits BE DATA without a collision or retry disposal. The eligible-VI control retains its collision and BE retry disposal. Late Request eviction and successful DELBA acknowledgment also release BE DATA without another BE arrival. `/tmp/s3b-deferral-selection-collision-final.log` and `/tmp/s3b-regression-build7-pass/` retain these results. + +Candidate 7 also reproduces an Action recovery-state defect. An owned ADDBA Request causes a real RTS transmission under a low RTS threshold. The missing CTS charges its short retry counter before any Action transmission. Peer reset then leaves that counter at one because Action-attempt state remains false. `/tmp/s3b-actiondisposal-build7-rts-reproduction/` retains the exact failure. Cleanup must distinguish an untouched Action from an Action whose RTS exchange owns retry state. + +The retained `MacQosWithBlockAck` demonstration exposes a separate setup trigger defect. A-MSDU aggregation drains all queued DATA for each AP transmission. The next same-TID arrival occurs after that transmission, so the immediate successor check never starts AP setup. Candidate 7 therefore supplies only the client-to-AP Basic link. The required AP-to-server link remains absent. The delayed-successor state addresses this condition without an empty setup request or changed traffic. + +## Controlled setup measurements + +The deferral fixture compares response timeouts of 100 ms and 250 ms under equal traffic, rates, seed, and response queue residence. It holds the real recipient response in its queue for approximately 150 ms. It does not inject a response directly. Both cases use three DATA packets and seed zero. DATA uses 6 Mbps; Actions use 24 Mbps. + +| Observed interval or count | 100 ms timeout | 250 ms timeout | +| --- | --- | --- | +| Request queue admission to PHY start | 34 microseconds | 34 microseconds | +| Request ACK reception | 0.000684020016 s | 0.000684020016 s | +| Request ACK to accepted response | No accepted response | 150.070003336 ms | +| Response queue residence | 100.080006672 ms before invalidation | 150.078003336 ms before transmission | +| DELBA queue admission to ACK completion | 80.006672 microseconds | No DELBA | +| Surviving DATA PHY start | 0.100780026688 s | 0.150832023352 s | +| Recipient MAC receives surviving DATA | 0.100980030024 s | 0.151032026688 s | +| Transmitted management frames | One Request and one DELBA | One Request and one Response | +| Management airtime | 72 microseconds | 72 microseconds | +| ACK airtime for management exchanges | 56 microseconds | 56 microseconds | + +The 100 ms deadline starts recovery before the queued response becomes eligible. The recipient invalidates that response when DELBA arrives. DELBA acknowledgment releases surviving DATA under Normal Ack. The 250 ms deadline permits the delayed response and releases DATA under Block Ack. That final DATA has no BAR within the fixture, so MAC reception does not establish upper delivery. + +`/tmp/s3b-build11-timing-100ms.log` and `/tmp/s3b-build11-timing-250ms.log` contain the exact events and PHY durations. `/tmp/s3b-build11-setup-timing.json` preserves source lines and event numbers. The fixture does not independently timestamp the transition into setup deferral. These observations establish timeout order and separate exchange costs; they establish no delivery guarantee or preferred timeout. + +Application measurements use the unchanged Block Ack showcase, General configuration, run zero, seed zero, and a fixed 0.5-second interval. The source sends 5,000 application packets of 700 bytes at 0.1 ms intervals. The debug parent delivers 330 packets, or 231,000 useful bytes. Final debug candidate 11 delivers 324 packets, or 226,800 useful bytes. Application goodput is therefore 3.696 Mbps and 3.6288 Mbps, respectively. + +Both application runs use `inet --debug -u Cmdenv -c General -r 0 --seed-set=0 --sim-time-limit=0.5s --record-vector-results=false --record-scalar-results=true --cmdenv-express-mode=true`. Their result directories are `/tmp/s3b-metric-parent-debug` and `/tmp/s3b-metric-candidate-11`. `opp_scavetool export -F CSV-R` exports both scalar files into `/tmp/s3b-metric-results-final.csv`. Useful bytes come from the destination application's `packetReceived:sum(packetBytes)` scalar. Earlier runs without an explicit mode supply no matched-mode comparison. + +The comparison parent checkout is `9b4b22258fff87401943d5046e0d18c18b70a558`. Its source and feature declarations equal the implementation parent. Its ignored build profile differs in unrelated optional features. This one fixed-seed comparison establishes only the observed application counts. It establishes no general performance improvement, optional-retry benefit, or agreement-reuse benefit. S4 retains transfer-completion and idle-gap comparisons. + +## Final source and focused verification + +Final candidate 11 contains A1, A2, A3a, A3b, A3c, and A4. HCF retains Basic as the default and rejects Compressed during initialization. The source review found no remaining correctness defect or unresolved architecture exception. No commit, publication, recorded baseline change, or seal change forms part of this execution. + +The final debug build command is `make MODE=debug -j12`. It returns zero; `/tmp/s3b-candidate-build-11.log` records the build. The library SHA256 is `f1ec379bd582e9c84b87e548059068231f9381d0dbd67bc6c4908f9e174e4608`. `/tmp/s3b-final-source-manifest.json` identifies all 72 changed source, test, and migration files, including untracked headers. Its parent remains `41eee1d61978d62cfaf9d0d9c242b9fee590c20e`. + +The final implementation separates Action transmission from ownership of RTS retry state. An RTS failure records ownership of the short retry counter. It does not mark the Action as transmitted. Invalidation and every terminal Action outcome clear that owned counter. A separate control preserves another peer's counter when an untouched Action uses the same Sequence Control field. The existing shared recovery map still uses that field without the peer address; this change does not redesign that map. + +The delayed-successor cases now defer later individual DATA and later A-MSDU batches before extraction. Both negotiate starting sequence number one and transmit first DATA with number one. The single-frame controls send no ADDBA. Real AP reassociation removes the waiting state under both legacy and HT configurations. A lone frame in the new association cannot inherit the old trigger. + +| Final debug selection | Result | Evidence | +| --- | --- | --- | +| Related module fixtures and existing controls | 29 fixtures pass | `/tmp/s3b-final-modules-6.log` | +| Lifecycle, response wait, association reset, Action disposal, retired DATA | Five fixtures; 50 scenarios pass | `/tmp/s3b-regression-build11-runner.log`, `/tmp/s3b-regression-build11-pass/` | +| Deferred selection, setup, lifetime, collision controls | Three fixtures; 18 scenarios pass | `/tmp/s3b-build11-deferral-selection-collision.log`, `/tmp/s3b-build11-*` | +| Related unit fixtures | Six fixtures pass | `/tmp/s3b-final-unit-4.log` | +| Retained Basic demonstrations | 13 cases pass | `/tmp/s3b-final-demonstrations-11/evidence.json` | +| Selected protocol requirements | Four pass; four declared expected failures | `/tmp/s3b-final-protocol-4.log` | + +The module selections total 37 distinct fixtures. The lifecycle and deferral snapshots retain generated code, configuration, executables, output, and hashes. Their simulation outputs contain no runtime warnings, errors, or undisposed objects. Runner notices about optional Python packages do not describe simulation failures. All cases use debug mode; deterministic new scenarios use seed zero. + +The [migration guide](../../doc/src/migration-guide/index.rst) explains the changed custom-module contracts. The [selected-extraction contract](../../src/inet/queueing/contract/ISelectivePacketCollection.h) defines queue ownership and pull effects. The [Action disposal fixture](../../tests/module/Ieee80211BlockAckActionDisposal_1.test) covers queue loss and RTS cleanup. The [deferral fixture](../../tests/module/Ieee80211BlockAckDeferral_1.test) covers timeout order and delayed successors. The [collision fixture](../../tests/module/Ieee80211BlockAckDeferredCollision_1.test) separates deferred contention from a genuine collision. + +The exact root module selector is: + +```sh +inet_run_module_tests -m debug -f '(Ieee80211BlockAck(ActionDelivery|ActionDispatch|Admission|Negotiation)_1|PacketSelectiveExtraction_1|Ieee80211(BasicCompatibility_1|BlockAckVariant_1|BlockAckReordering_1|HcfHeader_1|HcfMultipleProtection_[12]|SingleProtectionGroup_1|RecipientNav_1|PreparedCancellation_1|Txnav_1|HcfSingleProtection_1|VhtHtSupport_1|MgmtApHcfQueueDrop_1|MgmtRatePublication_1|MgmtStateCommit_1|EdcaDataLifetime.*))\.test$' +``` + +The additional module and unit selectors are: + +```sh +inet_run_module_tests -m debug -f 'Ieee80211BlockAck(Lifecycle|ResponseWait|AssociationReset|ActionDisposal|RetiredData)_1.test' +inet_run_module_tests -m debug -f 'Ieee80211BlockAck(DataSelection|Deferral|DeferredCollision)_1\.test' +inet_run_unit_tests -m debug -f 'Ieee80211(HtModeSet_1|VhtHtCapabilities_1|ResponseModeSelection_1|MibPeerTeardown_1|QosDuplicateRemoval_1|BlockAckActionWire_1)\.test$' +``` + +All category commands run from the repository root. The Basic observer command is `python3 tests/module/basic-compatibility-evidence.py --output /tmp/s3b-final-demonstrations-11`. It retains the original topologies, traffic, aggregation settings, fragmentation cases, parameter studies, and Basic assertions. The AP-to-server link now supplies real setup, DATA, BAR, and positive receipt bits. This result closes the two-hop regression without a weaker assertion. + +The final protocol command repeats the eight-case parent selector exactly. Its runner returns zero with four expected failures. Delayed-policy verification now fails at step one because admission refuses delayed policy. Its parent first failed at the later immediate-ACK requirement. Multi-TID still misses step two; both A-MPDU cases still miss the step-zero subframe-header requirement. + +`/tmp/s3b-final-protocol-failure-causes.json` preserves those first failure causes. Their expected-failure markers remain unchanged. These results establish no delayed, Multi-TID, A-MPDU, or Compressed support. The passing `N_CompressedBa` fixture still exercises the explicit Basic compatibility path in this stage. + +Scoped architecture checks pass for `src/inet/linklayer/ieee80211` and `src/inet/queueing`. Their logs are `/tmp/s3b-final-architecture-wifi.log` and `/tmp/s3b-final-architecture-queue.log`. `check-source-seals.sh --diff` passes; `/tmp/s3b-final-source-seals.log` records the result. Every changed source target is unsealed. `git diff --check` also passes for the owned changes. + +The independent gate comparison uses the actual implementation parent. Wi-Fi naming retains the same 32 findings; queue naming retains the same one finding. Wi-Fi interfaces retain the two existing findings under `AV-CONTRACT-02`; queue interfaces pass. New compliant interfaces increase those counts from 48 to 49 and from 24 to 25. `/tmp/s3b-review-{parent,candidate}-{naming,interfaces}-{0,1}.log` retains both sides; zero denotes Wi-Fi and one denotes queueing. No new mechanical finding or exception-ledger change is required. + +The C++ checker could not execute its analysis for either subtree. Both `check-cpp.sh` calls return two because this checkout has no `compile_commands.json`. `/tmp/s3b-final-cpp-wifi.log` and `/tmp/s3b-final-cpp-queue.log` retain that prerequisite error. These calls supply no clang-tidy verdict. This execution supplies debug compilation and source review; release compilation and the full pre-push gates remain outside this unpublished work. + +## Queue traversal cost + +Candidate 9 exceeded the CPU limit in both ten-second ad hoc fingerprint cases. A bounded Block Ack-disabled comparison reached the same event 104692 at 0.8 seconds. The parent used 3.56 CPU seconds; candidate 9 used 7.56 CPU seconds. Source inspection identified a new membership check that continued after it found each aggregation candidate. + +An external counter measured indexed queue reads without a repository edit. The captured production stack reached that membership check through the normal QoS extraction path. Each indexed read starts at the linked-list head. The full scan therefore repeated increasingly long walks for every candidate. This cost also affected traffic with Block Ack disabled. + +| Same-event profile | Parent | Candidate 9 | Candidate 10 | +| --- | --- | --- | --- | +| Indexed queue reads | 861 | 861,869 | 2,605 | +| Sum of requested indices | 1,285 | 775,865,982 | 2,142 | +| Largest requested index | 3 | 3,114 | 3 | + +Candidate 10 stops each membership search at its first match. The service still checks every candidate's presence, uniqueness, eligibility, and A-MSDU permission before any source removal. The repair adds no state or interface. The final profile retains event 104692 and removes high-index traversal from this run. Its plain run uses 4.24 CPU seconds; concurrent host load limits interpretation of that timing. + +`/tmp/s3b-baoff-profile-parent.log`, `/tmp/s3b-baoff-profile-candidate.log`, and `/tmp/s3b-baoff-profile-candidate10.log` retain the profiles. `/tmp/s3b-queue-profile.cc` supplies the external counter. The source review accepts the bounded early-break correction. Candidate 10 passed its focused checks after that correction. Candidate 11 retains the same early break. + +The Block Ack-enabled profile then found another repeated indexed scan in HCF's DATA existence query. At 0.8 seconds and event 102123, candidate 10 made 7,894,493 indexed reads. Candidate 11 makes 12,236 reads at the same event. Time inside high-index traversal falls from 14.37 seconds to 0.061 seconds. `/tmp/s3b-baon-profile-candidate10.log` and `/tmp/s3b-baon-profile-candidate11.log` retain these profiles. + +HCF now uses the optional predicate query to find unexpired DATA for a peer and TID. PacketQueue traverses its linked queue with an iterator. A composite reports `UnsupportedPacketSelection` when its provider cannot supply that query. HCF catches only that outcome and retains its collection fallback. Unrelated queue or predicate errors still propagate. This adds no capability cache or protocol state. + +The data service first checks the ordinary advertised head at both selection points. An eligible head therefore needs no selected-extraction capability. If all frames defer, the service waits without mutation. If a deferred head hides eligible work, the service requires selected extraction before it changes ownership or sequence state. The three new composite cases verify these distinctions through a provider without the optional interface. + +## Accepted exchanges across reset + +The final reset checks also repair physical statistics and RTS-protected identity. Candidate 10 omits EDCAF sent or received observations after logical retirement, although accepted DATA and its ACK complete physically. The final HCF emits each physical observation once before the retired-state guard. That guard still suppresses obsolete acknowledgment, recovery, agreement, and rate effects. The three DATA completion cases verify one sent observation and one received ACK observation. + +A separate reproduction resets the peer after RTS acceptance and before DATA submission. The old DATA and its lifetime leave active ownership. After CTS, candidate 10 nevertheless accepts that retired DATA because it checks no active-frame membership. Its management sequences instead select again, which can produce null or another peer's frame. `/tmp/s3b-retired-rts-build10-reproduction/` retains six clean failure cases. + +Candidate 11 retains the original protected management pointer after CTS, as the DATA sequence already does. HCF refuses DATA or management submission when that packet no longer belongs to active in-progress work. The accepted RTS exchange can finish safely, but it cannot authorize a retired packet or substitute another peer's packet. All six reset-during-RTS cases pass with no post-reset protected submission. They also preserve the other peer's DATA lifetime. + +The independent review closes every reported source finding in candidate 11. Its general checklist reports 20 passes and 14 inapplicable items. Its WLAN checklist reports 12 passes and one inapplicable item. Neither checklist retains a flag or question. The review adds no exception-ledger or seal change. + +## Final fingerprint comparison + +All 19 final debug cases complete without a CPU-limit error. The repository expectations yield one pass and 18 mismatches. The actual parent yields four passes and 15 graphical-only mismatches. Twelve final cases match every calculated parent ingredient. Seven Basic cases change functional ingredients; the table below identifies them. + +| Case | Calculated `tplx` | Calculated `~tNl` | Calculated `~tND` | Calculated `tyf` | +| --- | --- | --- | --- | --- | +| Ad hoc `MacQos`, run 1 | `5fbb-9fd9` | `c0a4-97f6` | `2373-df01` | `49b6-dbab` | +| Infrastructure `MacQosWithBlockAck`, run 0 | `f8a4-9474` | `1cba-cccc` | `538e-67df` | `69e0-5af3` | +| Block Ack `Fragmentation`, run 0 | `021a-d29a` | `1597-ec6a` | `feff-7e88` | Not selected | +| Block Ack `MixedTraffic`, run 0 | `5b9e-801f` | `8731-2504` | `9724-d1ce` | Not selected | +| Block Ack `NoFragmentation`, run 0 | `b828-6bd6` | `026f-2c6d` | `2cd4-4795` | Not selected | +| Fragmentation `HCFfragblockack`, run 0 | `f509-65f1` | `6b3a-0d65` | `c474-7174` | `4cfb-b3c7` | +| TXOP `General`, run 0 | `f58d-d2fd` | `38f7-f642` | Not selected | `e520-9a34` | + +Paired production traces confirm the first changed exchanges. In `NoFragmentation`, both versions transmit DATA 0 at 0.210 ms and complete it at 0.496 ms. Both also number DATA 1 through the existing successor forecast. The parent immediately requests starting number one. The candidate first resolves numbered DATA 1 under Normal Ack, then requests starting number two. This is A4's required drain-before-setup rule. + +The TXOP trace likewise changes the request number from two to three after numbered DATA resolves. The fragmentation trace completes the numbered fragmented unit before ADDBA. The parent starts setup after fragment zero. The ad hoc trace changes the request number from two to three after numbered Voice fragments resolve. The infrastructure trace suppresses empty-successor setup after ARP and starts setup when later WWW DATA arrives. The retained demonstrations still show successful Basic exchanges, positive receipt bits, and fragment bits where required. + +`/tmp/s3b-fp-first-divergences.json` and `/tmp/s3b-fp-qos-first-divergences.json` retain times, events, commands, fields, and source lines. These paired windows establish the changed setup boundaries. They do not attribute every later counter difference to one mechanism. The final 19 ingredients equal candidate 10 exactly, so the final cost and reset repairs add no further fingerprint change. + +The parent command ran from its own `tests/fingerprint` directory after its `setenv` file. It used debug mode, four threads, and the same 19-case selector. `/tmp/s3b-parent-fingerprints-2.log` retains its complete result. `/tmp/s3b-parent-fingerprint-inventory.json` preserves its calculated ingredients before later jobs overwrote shared result paths. Interrupted invocations and overwritten shared outputs supply no comparison evidence. + +The final candidate uses private copies of the unchanged input CSV files in `/tmp/s3b-final-fingerprint-inputs-11`. `input-hashes.json` records their byte hashes. Older jobs cannot replace these comparison inputs or outputs. The exact command runs from `tests/fingerprint`: + +```sh +PYTHONUNBUFFERED=1 ./fingerprinttest -d -t 4 -m 'showcases/wireless/(blockack|aggregation|fragmentation|qos|txop)/|examples/wireless/qos/.*MacQos|examples/adhoc/qos/.*MacQos' -l /tmp/s3b-final-fingerprint-inputs-11/runner.log /tmp/s3b-final-fingerprint-inputs-11/examples.csv /tmp/s3b-final-fingerprint-inputs-11/showcases.csv +``` + +`/tmp/s3b-candidate-fingerprints-6.log` records all 19 results and the nonzero mismatch status. `/tmp/s3b-fingerprint-comparison-build11.json` records the parent and candidate 10 comparisons. `/tmp/s3b-final-verification.md` supplies the regression analysis. The seven calculated rows above are evidence, not approved baseline values. Every recorded repository expectation remains unchanged. + +The separate capability observer also passes all eight inventory cases on candidate 11. Its command is `python3 tests/module/basic-compatibility-evidence.py --protocol-inventory --output /tmp/s3b-final-protocol-inventory-11`. The evidence file records actual HT state independently of the protocol assertions. Passing inventory observations do not convert the four expected protocol failures into supported features. diff --git a/plan/done/ieee80211-compressed-blockack-s3b-summary.md b/plan/done/ieee80211-compressed-blockack-s3b-summary.md new file mode 100644 index 00000000000..c09a1e343e9 --- /dev/null +++ b/plan/done/ieee80211-compressed-blockack-s3b-summary.md @@ -0,0 +1,251 @@ +# S3b: safe Block Ack agreement setup and teardown + +> **Kind:** reference · **Status:** snapshot 2026-10-15 · **Seal:** none · **Owns:** — · **Stands on:** [replacement summary](../pending/ieee80211-compressed-blockack-replacement-summary.md), [lifecycle plan](../pending/ieee80211-blockack-agreement-lifecycle.md), [execution record](ieee80211-compressed-blockack-s3b-execution.md) + +S3b repairs the agreement lifecycle that Compressed Block Ack will need. It controls when DATA can use an agreement, how agreement Actions change state, and how cleanup affects queued and received DATA. The immediate production target is Basic Block Ack. Production HCF still rejects Compressed selection at initialization. + +S3b is complete on branch `work/compressed-blockack-s3b` in [PR #1343](https://github.com/inet-framework/inet/pull/1343). The current source revision is `8646a9e6808ea8d21ac28bfc1271537469225fe9`, above base `bba1db4c8180a592894e0ab2a2dc056d9cb08082`. The [completion record](ieee80211-compressed-blockack-s3b-execution.md#completed-s3b) separates broad verification at `8ba7c9e47b` from focused verification of the later allocation-index repair. This status records branch completion; it does not assert a merge into `master`. The diagrams explain implemented behavior; they do not represent measured frame traces. + +## Why this stage exists + +A Block Ack agreement contains the shared parameters that permit Block Ack operation between an originator and a recipient. The originator sends DATA; the recipient receives DATA. ADDBA establishes the agreement through a request and response. DELBA ends the agreement through an Action frame. A BAR is a control frame that requests a Block Ack response. + +Safe DATA transmission requires more than a correct Block Ack bitmap. Both stations must agree on the parameters and on whether an agreement exists. Retries, lost responses, queue disposal, inactivity, and association replacement can change that state. S3b gives each event an owner and a defined effect on DATA. + +The parent reproductions expose concrete causes. The recipient service deletes accepted Actions, while HCF dispatches the original header without the duplicate result. The recipient response omits the dialog token that identifies its request. HCF also treats an absolute inactivity deadline as a relative delay. The [execution record](ieee80211-compressed-blockack-s3b-execution.md#source-assessment) gives the source assessment and reproduction limits. + +```mermaid +flowchart LR + P["S1, S2, R1, S3a
Recipient progress, DATA lifetime,
management rates, profile selection"] + L["S3b
Agreement lifecycle
A1 through A4"] + B["S4
BAR-only channel access
and transfer completion"] + C["S5: C1 through C4
Compressed frame format,
exchanges, timing checks, default"] + P --> L --> B --> C +``` + +S3b supplies the lifecycle foundation. S4 supplies the final BAR exchange and transfer-completion behavior. S5 supplies complete Compressed exchanges and their verification. The [replacement summary](../pending/ieee80211-compressed-blockack-replacement-summary.md) owns this stage order. The replacement and lifecycle plans remain pending because their S4 and S5 work remains incomplete. + +## Who owns the state + +Agreement identity includes the local role, peer, and traffic identifier (TID). One station can hold both roles for the same peer and TID. These records describe opposite DATA directions. Teardown of one role must preserve the other role. + +| Component | Responsibility in S3b | +| --- | --- | +| HCF, the hybrid coordination function | Coordinates agreement Actions, frame exchanges, timers, DATA eligibility, and cleanup order. | +| Originator agreement handler | Owns originator agreements, setup procedures, response deadlines, and recovery state. | +| Recipient agreement handler | Owns recipient agreements and recipient teardown procedures. | +| Agreement policies | Check setup parameters and profile admission. | +| Originator QoS data service | Selects eligible DATA, checks A-MSDU permission, and assigns sequence numbers after extraction. | +| Recipient QoS data service | Checks duplicates, returns accepted Actions, and prepares received DATA for delivery or disposal. | +| Reorder owner | Holds received DATA behind sequence gaps and supplies ordered complete units at teardown. | +| Queue components | Own extraction, ownership transfer, queue residence metadata, and pull events. | +| Management and the MIB | Management identifies association reset. The management information base (MIB) owns capability and rate state. | + +The [execution contract](ieee80211-compressed-blockack-s3b-execution.md#implementation-contract) defines these responsibilities. HCF coordinates the existing owners; queues do not keep a second copy of agreement state. + +## A1: apply each accepted Action once + +HCF must distinguish reception of an Action from acceptance of that Action for agreement processing. A valid MAC retry still needs its immediate ACK. It must not create another agreement or apply DELBA twice. The recipient data service therefore returns only complete, nonduplicate Actions for HCF dispatch. + +```mermaid +flowchart TD + RX["Addressed ADDBA or DELBA arrives"] --> ACK["Retain immediate ACK behavior
for valid received frames"] + ACK --> CHECK["Recipient data service checks
complete-frame state and duplicates"] + CHECK -->|Duplicate| STOP["No agreement dispatch"] + CHECK -->|Accepted complete Action| RETURN["Return Action to HCF"] + RETURN --> OWNER["Agreement owner checks identity
and applies the Action once"] +``` + +This diagram separates decisions; it does not prescribe ACK timing relative to dispatch. An Action during an active response wait needs an additional order rule. HCF first lets the agreement owner determine whether that Action resolves the pending procedure. HCF then ends the obsolete exchange without an obsolete terminal failure. The retained valid Action still receives its ACK. + +Hypothetical example: the peer receives ADDBA Request, but the request ACK is lost. A matched successful ADDBA Response arrives during the request's final ACK wait. The originator accepts the response before request-failure notification. Cleanup must not turn that success into teardown, DATA disposal, or another request retry. An unrelated Action does not suppress the interrupted exchange's ordinary failure result. + +The [Action contract](../pending/ieee80211-blockack-agreement-lifecycle.md#3-agreement-behavior) owns this order. The [HCF source](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) contains dispatch and response-wait integration. The frame-sequence handler owns the interruption outcome after recipient processing. It suppresses obsolete failure feedback for retired frames. An Action attempt that Tx already accepts retains its context until safe completion; logical retirement does not permit immediate destruction of that context. + +## A2: use the parameters that both stations accept + +An ACK for ADDBA Request confirms request reception. It does not establish that the originator accepted an agreement. The originator activates its agreement only after a matched successful ADDBA Response passes validation. The response must match the pending peer, TID, and dialog token. It must also specify immediate policy and supported parameters. + +```mermaid +sequenceDiagram + participant O as Originator + participant R as Recipient + O->>R: ADDBA Request: TID, token, first sequence number + R-->>O: Immediate ACK for request + Note over R: Validate request and build accepted response + Note over R: Create recipient agreement from response values + R->>O: ADDBA Response: same token, accepted parameters + Note over O: Match peer, TID, token, and parameters + Note over O: Activate originator agreement + O-->>R: Immediate ACK for response + O->>R: DATA under the accepted agreement +``` + +The built-in recipient policy chooses `min(64, maximumAllowedBufferSize)` as the accepted buffer size. The request size gives guidance; it does not cap that choice. Both agreement owners use the response timeout value for inactivity. A zero response timeout disables inactivity expiration. The recipient keeps the request's first sequence number for its reorder state. + +Hypothetical example: the request suggests eight positions, but the recipient configuration permits 64. The response advertises 64, so both agreement owners use 64. The recipient must not retain eight while the originator uses 64. A rejected modification request leaves the existing agreement unchanged. + +A-MSDU permission also belongs to negotiation. An A-MSDU combines multiple MSDUs within one MPDU. Both the request and response flags must permit it before the originator constructs an A-MSDU under the agreement. If either flag denies permission, individual DATA can still use Block Ack. Normal Ack must not bypass a denial for an A-MSDU that already exists. + +Basic admission preserves non-HT and legacy ad hoc compatibility. Compressed admission requires local HT operation and valid peer HT state for the relevant direction. S3b checks Compressed admission through isolated policies; this does not enable production Compressed exchanges. The [negotiation contract](../pending/ieee80211-blockack-agreement-lifecycle.md#3-agreement-behavior) defines these conditions and policy choices. + +## A3: end the correct agreement without stale work + +A3a covers directional teardown and inactivity. A3b covers peer reset. A3c covers Action disposal and recovery when no agreement exists. These are review units within one lifecycle contract. The first retirement path must also invalidate obsolete Actions that could later change the retired state. + +### Directional teardown preserves the opposite role + +For received DELBA, HCF uses the transmitter address as the peer. The Initiator field identifies which local role must end. If the peer sends DELBA as originator, the local recipient agreement ends. If the peer sends DELBA as recipient, the local originator agreement ends. + +Ordinary recipient teardown first removes the agreement from lookup. The recipient data service then preserves duplicate state and obtains complete buffered units in cyclic sequence order. HCF delivers those units before the deletion event and resource release. Incomplete Basic units undergo disposal. Association reset uses a different policy: it discards old buffered units. + +```mermaid +flowchart TD + START["Recipient agreement ends"] --> DETACH["Remove agreement from lookup
and invalidate obsolete Actions"] + DETACH --> KIND{"Association reset?"} + KIND -->|No| ORDER["Collect complete buffered units
in cyclic sequence order"] + ORDER --> DELIVER["Deliver complete units once
and discard incomplete units"] + KIND -->|Yes| DISCARD["Discard old buffered units
without upper delivery"] + DELIVER --> EVENT["Emit deletion event
and release agreement resources"] + DISCARD --> EVENT +``` + +Hypothetical Basic example: sequence 100 is absent, while complete units 101 and 102 remain behind the gap. Ordinary recipient teardown delivers 101 followed by 102 before cleanup. Acknowledgment of those units alone does not establish upper delivery. This release across a gap is an INET policy choice. The [migration guide](../../doc/src/migration-guide/index.rst) explains the implemented teardown policy. + +At ordinary originator teardown, HCF discards transmitted, unacknowledged DATA for the selected agreement. HCF also discards unsent fragments through the highest transmitted allocation index. The QoS data service assigns this local index before fragmentation; all fragments retain the same index. The agreement retains the highest transmitted index after ACK processing removes an earlier fragment. Allocation indices preserve order across large sequence gaps and wraparound; older retransmissions cannot move the boundary backward. Later intact DATA and another peer's DATA remain eligible. + +The fragment regression supplies a concrete example. Fragment 0 of sequence 4095 enters transmission before inactivity expires. HCF discards its unsent siblings at teardown and preserves the intact successor with sequence 0. The fixture also checks expiration after fragment 0 receives its Normal Ack. A separate collision regression checks disposal of the first DATA before transmission; HCF retires that agreement before its successor can use it. + +```mermaid +flowchart LR + F0["Sequence 4095, fragment 0
Transmission accepted"] --> E["Inactivity expires
Retire originator agreement"] + E --> D["Discard unsent fragments
of sequence 4095"] + E --> K["Keep intact successor
with sequence 0"] + E --> P["Keep another peer's DATA"] +``` + +### Two timers serve different purposes + +The ADDBA response timer bounds setup after the request receives its Normal Ack. The inactivity timer bounds an active agreement without relevant activity. S3b uses separate timers because setup uncertainty and agreement inactivity require different state transitions. + +| Timer | Start or refresh condition | Expiration effect | +| --- | --- | --- | +| ADDBA response timer | Request ACK starts that peer/TID deadline. The default INET interval is 100 ms. | HCF starts teardown because the peer can hold an agreement. | +| Agreement inactivity timer | Agreement activation starts its deadline. Relevant traffic refreshes it. | HCF retires each overdue agreement and starts DELBA. | + +HCF schedules the earliest absolute deadline across both agreement roles. It cancels the inactivity timer when no finite deadline exists. Expiration selects deadlines at or before the current time, so a late callback does not miss an agreement. + +```mermaid +flowchart LR + O["Originator role
earliest active deadline"] --> MIN["HCF selects the minimum
absolute deadline"] + R["Recipient role
earliest active deadline"] --> MIN + MIN -->|Finite deadline| AT["Schedule at that time
or now if overdue"] + MIN -->|No finite deadline| CANCEL["Cancel inactivity timer"] +``` + +Hypothetical timing example: the current time is 1 ms and the absolute deadline is 5 ms. HCF schedules expiration at 5 ms. A relative delay of 5 ms would incorrectly schedule 6 ms. The execution record reports this exact parent failure. The [timeout contract](../pending/ieee80211-blockack-agreement-lifecycle.md#response-timeout-and-data-lifetime) distinguishes the INET response timeout from DATA lifetime. + +### Peer reset clears both roles before callbacks + +Association replacement ends the old association even when the replacement publishes identical rates and HT capabilities. A rate-change notification alone cannot identify that event. Management therefore passes the peer identity to HCF before replacement. HCF clears both roles and old peer work before the first agreement deletion callback. + +```mermaid +sequenceDiagram + participant M as Management + participant H as HCF + participant A as Agreement owners + participant D as DATA and Action owners + participant V as Deletion observers + M->>H: Reset old peer before association replacement + H->>A: Detach both roles and pending procedures + H->>D: Invalidate old Actions and clear old peer DATA + H->>D: Discard old receive buffers and duplicate state + H->>V: Emit agreement deletion events + Note over V: Neither old role remains visible + M->>M: Complete association state replacement +``` + +With Block Ack enabled, reset discards the old peer's queued and in-progress QoS DATA, including unsent Normal Ack DATA without an agreement. Another peer retains its agreements, DATA, and lifetime records. The MIB continues to publish coherent committed state through its existing boolean notification. The [association-reset contract](../pending/ieee80211-blockack-agreement-lifecycle.md#reassociation-consumers-and-callback-order) explains why the separate reset handoff is necessary. + +An accepted physical exchange retains its context until completion. Physical statistics still record that exchange, but its callbacks cannot submit retired DATA after CTS. The frame-sequence handler destroys the context before it deletes deferred frame copies. + +### Queue loss and uncertain setup require explicit recovery + +HCF tracks each locally generated ADDBA or DELBA Action by frame identity, peer, TID, and role. Queue rejection, eviction, retry failure, and acknowledgment reach that Action's owner. Each Action produces one terminal transition. Intentional invalidation removes its procedure identity before queue disposal can report a second failure. + +If Tx never accepts a request attempt, local cancellation can release DATA under Normal Ack. After a possible request transmission, no response does not prove that the peer lacks an agreement. HCF must defer DATA until teardown confirms a common state. A successful recipient agreement remains active if its response suffers disposal; response loss does not undo recipient acceptance. + +```mermaid +flowchart TD + P["ADDBA pending
DATA deferred"] -->|Matching success| A["Active agreement
release eligible DATA"] + P -->|Initial rejection or cancellation
before any accepted request attempt| N["No agreement
Normal Ack DATA can resume"] + P -->|Attempted request fails
or response deadline expires| T["DELBA pending
DATA remains deferred"] + T -->|DELBA receives ACK| N + T -->|Originator DELBA fails
or suffers queue disposal| R["Drop deferred batch
retain recovery-needed state"] + R -->|New DATA arrives| T +``` + +S3b treats a DELBA ACK as teardown confirmation for this INET profile. This policy assumes that the peer processes a valid DELBA. Failed originator DELBA drops the current deferred batch and leaves recovery-needed state without a periodic retry timer. New DATA triggers one fresh DELBA exchange; DATA that arrives during that exchange shares its result. + +Failed recipient-role DELBA clears its teardown procedure without an originator recovery record or disposal of opposite-direction DATA. Valid Block Ack-policy DATA or a valid BAR without an agreement triggers recipient-role DELBA. That DATA does not reach upper delivery, and that BAR does not create receive state. Malformed BAR input does not trigger this recovery path. The [lifecycle contract](../pending/ieee80211-blockack-agreement-lifecycle.md#3-agreement-behavior) owns these separate outcomes. + +## A4: preserve the first sequence number and unrelated DATA access + +The ADDBA request specifies the first sequence number for the agreement. Setup must not consume that number through premature extraction. After the first eligible DATA transmission, more unnumbered DATA for that peer and TID can trigger setup intent. Already numbered DATA first completes or drops under its existing policy. HCF then queries the next sequence number without consumption and creates ADDBA Request. + +Hypothetical example: the next unassigned number is 100. HCF requests an agreement with first number 100 while the affected DATA remains queued. After a matching response, extraction assigns 100 to the first DATA. If DATA 100 suffers terminal disposal before transmission, HCF starts teardown before DATA 101 can use that agreement. Extraction alone does not count as first transmission. + +Deferral applies to one peer and TID. It must not prevent another peer, another TID, or eligible management traffic from access. The data service selects the first eligible frame in the configured queue service order. HCF uses the same eligibility condition for DATA contention. A nonempty queue that contains only deferred DATA does not justify a new DATA contention request. + +```mermaid +flowchart LR + subgraph Q["Configured queue service order"] + A["Peer A, TID 2
setup pending
deferred"] + B["Peer B, TID 5
eligible"] + C["Peer A, TID 2
deferred"] + A --- B --- C + end + B --> X["Extract B through its queue owner
and assign its sequence number"] + A -.-> W["Remain queued
with existing lifetime state"] + C -.-> W +``` + +Selected extraction must preserve ownership, queue residence metadata, pull events, and compound queue accounting. Arbitrary removal has different effects and cannot replace extraction. The optional `ISelectivePacketCollection` interface supplies an eligibility query and extraction of the selected frame. Built-in support covers `PacketQueue`, `PriorityScheduler`, and `CompoundPacketQueueBase`. + +An external queue needs this interface only when deferred head DATA hides eligible work. Its ordinary dequeue path remains usable when its next frame is eligible. If every frame is deferred, the service waits. If eligible work requires an unsupported bypass, the service reports a diagnostic before mutation. The [selected-extraction contract](../../src/inet/queueing/contract/ISelectivePacketCollection.h) defines these operations. + +Before A-MSDU construction, the service checks one proposed source list. The first source must match the selected frame; every source must remain eligible and have permission. An invalid list causes individual extraction of the selected frame. Other sources retain their queue, lifetime, and sequence state. This prevents aggregation that bypasses deferral or the configured service order. + +## Completed verification + +The [completion record](ieee80211-compressed-blockack-s3b-execution.md#completed-s3b) reports broad results for source revision `8ba7c9e47bc3ded924cfa3917c8b899baccf789d`. Debug and release compilation pass at that revision. All 26 selected debug module fixtures and 19 functional fingerprint cases pass at that revision. The functional selection excludes graphical `tyf` expectations. + +The later allocation-index repair records debug and release compilation and four debug fixtures with 50 successful simulation runs. Those fixtures cover fragment retirement, lifecycle behavior, association reset, and DATA selection. The fragment fixture supplies 20 runs across sequence gaps, wraparound, and teardown before or after ACK reception. These results belong to original revision `ea20a2880e`, which maps to `8646a9e680` without source or test changes. The history comparison establishes content equivalence; it is not new behavioral evidence. This document correction repeats no build or simulation test. + +| Verified behavior | Relevant fixtures in this checkout | +| --- | --- | +| Accepted Actions return once; duplicates retain ACK behavior | [Action delivery](../../tests/module/Ieee80211BlockAckActionDelivery_1.test), [Action dispatch](../../tests/module/Ieee80211BlockAckActionDispatch_1.test) | +| A matching Action resolves setup before obsolete exchange failure | [Response wait](../../tests/module/Ieee80211BlockAckResponseWait_1.test) | +| Accepted parameters and profile admission reach their owners | [Negotiation](../../tests/module/Ieee80211BlockAckNegotiation_1.test), [Admission](../../tests/module/Ieee80211BlockAckAdmission_1.test) | +| Directional cleanup and absent-agreement recovery preserve other state | [Lifecycle](../../tests/module/Ieee80211BlockAckLifecycle_1.test) | +| Association replacement clears both roles before observers run | [Association reset](../../tests/module/Ieee80211BlockAckAssociationReset_1.test) | +| Setup deferral preserves sequence state and unrelated progress | [Deferral](../../tests/module/Ieee80211BlockAckDeferral_1.test), [DATA selection](../../tests/module/Ieee80211BlockAckDataSelection_1.test) | +| Selected extraction preserves queue effects | [Selective extraction](../../tests/module/PacketSelectiveExtraction_1.test) | +| First-DATA disposal retires the agreement before successor transmission | [Deferred collision](../../tests/module/Ieee80211BlockAckDeferredCollision_1.test) | +| Teardown removes unsent fragments through the highest transmitted allocation index | [Fragment retirement](../../tests/module/Ieee80211BlockAckFragmentRetirement_1.test) | + +The earlier source revision `667ae51dc9fbfbfac9ea68122bf65bc4f2d3e1df` supplies broader module, unit, protocol, and Basic demonstration results. Those results remain separate from verification of the allocation-index repair. The later focused results also do not extend the earlier 26-fixture or 19-fingerprint results to the current source revision. Seven approved functional fingerprint rows belong to the lifecycle implementation; the later repairs change no baseline. Graphical expectations remain unchanged. + +The later audits inspect the repair and documentation claims; they do not establish a full independent correctness audit. The archived local results establish no release-mode behavioral tests, sanitizer results, or other-platform results for the allocation-index repair. CI results remain separate from these local records. + +## Scope limits + +S3b does not establish these later capabilities: + +- Production Compressed BAR and Block Ack exchanges, serialization, or receipt-state behavior. +- S4 BAR arbitration, BAR-only channel access, or teardown after the final Block Ack exchange. +- Compressed response-rate and airtime correctness. +- General MAC stop/start recovery. +- A performance guarantee across repeated setup and teardown. + +S3b supplies a defined agreement lifecycle with safe DATA eligibility and cleanup. Later stages can add Compressed exchanges without a separate lifecycle mechanism. Their own production evidence remains necessary. From 23c1939f27cbf8bb449772a2da64a49f9ecad5d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:44:56 +0200 Subject: [PATCH 05/41] ieee80211: refactor: expose DATA preview without extraction Before this commit, the shared in-progress queue can obtain a successor only through extraction. The QoS data service already supports preview, but the generic contract does not expose it. BAR selection needs the candidate before queue ownership or sequence state changes. After this commit, the contract exposes preview, sequence lookup, and aggregation capability. The in-progress queue can return a borrowed candidate and prospective sequence number. The ordinary successor query retains extraction as its default. For example, a queued frame retains sequence 77 while preview reports prospective sequence 0. Preview leaves the frame in its queue. The DATA-selection fixture checks this result, ownership, and an empty in-progress set. Existing transmission behavior remains unchanged. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | refactor | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 +++ doc/src/migration-guide/index.rst | 7 +++++ .../contract/IOriginatorQosMacDataService.h | 28 +++++++++++++++++++ .../originator/OriginatorQosMacDataService.h | 10 +++---- .../ieee80211/mac/queue/InProgressFrames.cc | 25 +++++++++++++++-- .../ieee80211/mac/queue/InProgressFrames.h | 4 ++- .../Ieee80211BlockAckDataSelection_1.test | 8 ++++++ 7 files changed, 78 insertions(+), 8 deletions(-) create mode 100644 src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h diff --git a/WHATSNEW b/WHATSNEW index 097c0d79b9e..40cf987fb24 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -444,6 +444,10 @@ Notable backward incompatible changes are the following: Basic remains the default. Compressed selection still stops initialization. Custom agreement handlers, recipient services, and management implementations require the changes in the migration guide. External queues need the optional selected-extraction contract only when deferred DATA hides eligible work. Built-in queues preserve ordinary pull accounting for that extraction. +51. IEEE 802.11 QoS DATA preview contract + + The QoS data service now exposes candidate preview through IOriginatorQosMacDataService. The in-progress queue can preview DATA without extraction or sequence assignment. Ordinary successor queries retain extraction as their default. Custom in-progress queues must accept the extract argument in getPendingFrameFor(). The migration guide describes this interface change. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 47ead943f5f..cee7afc4edb 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -14,6 +14,13 @@ retransmissions do (``synRetries``). When they run out, the connection raises th ``TCP_E_TIMEOUT_CONN_ESTAB``, as the timer did before, so a subclass that handles this event needs no change. +IEEE 802.11 Basic Block Ack extension points +------------------------------------------ + +HCF previews the next eligible DATA before BAR selection. Preview must preserve queue ownership and the next sequence number. Custom QoS data services must implement ``IOriginatorQosMacDataService``. This contract extends ``IOriginatorMacDataService`` with ``peekEligibleFrame()``, ``getNextSequenceNumber()``, and ``hasAMsduAggregation()``. + +Custom ``InProgressFrames`` classes must add ``bool extract = true`` to their ``getPendingFrameFor()`` override. When ``extract`` is false, the method must return a borrowed candidate without extraction or sequence assignment. The default value preserves ordinary extraction. Custom candidate sources must also implement ``peekFrameToTransmit()`` without extraction. + TCP Algorithms -------------- diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h new file mode 100644 index 00000000000..e66fa555666 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h @@ -0,0 +1,28 @@ +// +// Copyright (C) 2026 OpenSim Ltd. +// +// SPDX-License-Identifier: LGPL-3.0-or-later +// + +#ifndef __INET_IORIGINATORQOSMACDATASERVICE_H +#define __INET_IORIGINATORQOSMACDATASERVICE_H + +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h" + +namespace inet { +namespace ieee80211 { + +class INET_API IOriginatorQosMacDataService : public IOriginatorMacDataService +{ + public: + // Preview borrows the frame without extraction or sequence assignment. + virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const = 0; + virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const = 0; + virtual bool hasAMsduAggregation() const = 0; +}; + +} // namespace ieee80211 +} // namespace inet + +#endif diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h index 40366a32b9c..f6590365817 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h @@ -16,14 +16,14 @@ #include "inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h" #include "inet/linklayer/ieee80211/mac/contract/IMsduAggregation.h" #include "inet/linklayer/ieee80211/mac/contract/IMsduAggregationPolicy.h" -#include "inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h" +#include "inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h" #include "inet/linklayer/ieee80211/mac/contract/ISequenceNumberAssignment.h" #include "inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h" namespace inet { namespace ieee80211 { -class INET_API OriginatorQosMacDataService : public IOriginatorMacDataService, public SimpleModule +class INET_API OriginatorQosMacDataService : public IOriginatorQosMacDataService, public SimpleModule { protected: // Figure 5-1—MAC data plane architecture @@ -58,9 +58,9 @@ class INET_API OriginatorQosMacDataService : public IOriginatorMacDataService, p extractionEligible = eligible; aMsduPermitted = permission; } - Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const; - SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const; - bool hasAMsduAggregation() const { return aMsduAggregationPolicy != nullptr; } + virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const override; + virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const override; + virtual bool hasAMsduAggregation() const override { return aMsduAggregationPolicy != nullptr; } virtual ~OriginatorQosMacDataService(); void setLifetimeHandler(EdcaTransmitLifetimeHandler *handler, std::function expiration) { lifetimeHandler = handler; diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc index e9918ee20f7..81ec8985ddc 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc @@ -9,6 +9,8 @@ #include +#include "inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h" + namespace inet { namespace ieee80211 { @@ -95,9 +97,26 @@ Packet *InProgressFrames::getFrameToTransmit() return nullptr; } -Packet *InProgressFrames::getPendingFrameFor(Packet *frame) +Packet *InProgressFrames::peekFrameToTransmit() +{ + for (auto frame : inProgressFrames) { + if (isEligibleToTransmit(frame)) + return frame; + } + return check_and_cast(dataService)->peekEligibleFrame(pendingQueue); +} + +SequenceNumberCyclic InProgressFrames::getCandidateSequenceNumber(Packet *packet) const +{ + auto header = packet->peekAtFront(); + if (containsFrame(packet)) + return header->getSequenceNumber(); + return check_and_cast(dataService)->getNextSequenceNumber(header->getReceiverAddress(), header->getTid()); +} + +Packet *InProgressFrames::getPendingFrameFor(Packet *frame, bool extract) { - auto frameToTransmit = getFrameToTransmit(); + auto frameToTransmit = extract ? getFrameToTransmit() : peekFrameToTransmit(); if (dynamicPtrCast(frame->peekAtFront())) return frameToTransmit; else { @@ -105,6 +124,8 @@ Packet *InProgressFrames::getPendingFrameFor(Packet *frame) if (isEligibleToTransmit(frame) && frameToTransmit != frame) return frame; } + if (!extract) + return check_and_cast(dataService)->peekEligibleFrame(pendingQueue); auto frames = dataService->extractFramesToTransmit(pendingQueue); if (frames) { auto firstFrame = (*frames)[0]; diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h index 293aebfc3a3..65b13b67aa7 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h @@ -53,7 +53,9 @@ class INET_API InProgressFrames : public SimpleModule virtual Packet *getFrames(int i) const { return inProgressFrames[i]; } bool containsFrame(const Packet *packet) const; virtual Packet *getFrameToTransmit(); - virtual Packet *getPendingFrameFor(Packet *frame); + virtual Packet *peekFrameToTransmit(); + SequenceNumberCyclic getCandidateSequenceNumber(Packet *packet) const; + virtual Packet *getPendingFrameFor(Packet *frame, bool extract = true); virtual void dropFrame(Packet *packet); virtual void dropFrames(std::set>> seqAndFragNums); diff --git a/tests/module/Ieee80211BlockAckDataSelection_1.test b/tests/module/Ieee80211BlockAckDataSelection_1.test index d1b8c948262..534e93fb524 100644 --- a/tests/module/Ieee80211BlockAckDataSelection_1.test +++ b/tests/module/Ieee80211BlockAckDataSelection_1.test @@ -177,6 +177,14 @@ class DataSelectionTest : public cSimpleModule, public cListener { ASSERT(queue->getPacket(0) == first); ASSERT(service->peekEligibleFrame(queue) == selected); ASSERT(service->getNextSequenceNumber(MacAddress("02:00:00:00:00:02"), 0) == SequenceNumberCyclic(0)); + auto previewService = check_and_cast(service); + auto frames = edca->getEdcaf(AC_BE)->getInProgressFrames(); + auto owner = selected->getOwner(); + ASSERT(previewService->peekEligibleFrame(queue) == selected); + ASSERT(frames->peekFrameToTransmit() == selected); + ASSERT(frames->getCandidateSequenceNumber(selected) == SequenceNumberCyclic(0)); + ASSERT(frames->getLength() == 0 && selected->getOwner() == owner); + ASSERT(selected->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); wait(SimTime(100, SIMTIME_MS)); auto extracted = service->extractFramesToTransmit(queue); ASSERT(extracted != nullptr && extracted->size() == 1); From 429223850f5cf9eaa4d68d4315eae013c9cb519d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:46:58 +0200 Subject: [PATCH 06/41] ieee80211: fix: complete Basic BAR transfer resolution Before this commit, BAR selection can extract DATA and combine counts across peers or TIDs. A short burst can lack a final response when its length remains below the BAR threshold. Duration forecasts can extract or incorrectly reserve an unprepared successor. After this commit, HCF selects BAR work before DATA extraction. The ACK policy groups outstanding DATA by peer and TID within the accepted window. Below the threshold, it defers BAR only for the next DATA within that group and window. EDCA can contend for BAR without a DATA candidate. Matched responses resolve only the selected peer and TID. Resolved DATA advances the window; the response starting sequence number alone cannot advance it. BAR policy calls require an explicit agreement-handler argument. Transmitted-BAR processing also requires an explicit originator agreement. Omitted arguments fail compilation. Explicit null arguments retain their documented behavior. BAR collision and failure update contention state without a DATA retry entry. Retransmitted DATA sets Retry after failed Block Ack feedback. At a safe exchange boundary, final resolution or expiration triggers completion DELBA. HCF first checks queued DATA in the TID category to avoid repeated unrelated scans. Basic single protection reserves only an already prepared successor. The sequence ends the TXOP before further extraction can change aggregation, fragmentation, or setup. Final zero-limit DATA reserves only its immediate required response. Prepared fragments can continue; unprepared successors require another TXOP. This policy can require more contention. Multiple protection retains its successor policy. For example, a window of one and BAR threshold of five require BAR before the next sequence leaves the window. Direct fixtures also cover separate peers and TIDs, timeout, collision, expiration, final Duration, and later-BAR admission. The timing fixture checks the former 40-microsecond overrun and the permitted initial Control-frame exception. Seven previously approved non-graphical fingerprint rows accompany their causal source change. Final ACK reservations, setup order, Retry feedback, and extraction boundaries explain those values. The execution record retains each exact value and its original approval. Graphical values remain unchanged and unverified. BAR selection, Duration forecasts, and continuation share one candidate contract without extraction. They stay together so each recorded expectation describes the complete behavior. Production Compressed exchanges, general Basic DATA admission, and complete NAV conformance remain outside this commit. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.change.fix | test whatsnew migration fingerprint | ieee80211-compressed-blockack-replacement --- WHATSNEW | 10 +- doc/src/migration-guide/index.rst | 8 + doc/src/users-guide/ch-80211.rst | 10 +- ...e80211-compressed-blockack-s4-execution.md | 178 +++++++ .../blockack/OriginatorBlockAckAgreement.h | 5 + .../OriginatorBlockAckAgreementHandler.cc | 1 - .../ieee80211/mac/channelaccess/Edca.h | 3 +- .../mac/contract/IOriginatorQoSAckPolicy.h | 5 +- .../ieee80211/mac/coordinationfunction/Hcf.cc | 112 ++++- .../ieee80211/mac/coordinationfunction/Hcf.h | 2 + .../ieee80211/mac/framesequence/HcfFs.cc | 27 +- .../framesequence/PrimitiveFrameSequences.cc | 10 +- .../ieee80211/mac/framesequence/TxOpFs.cc | 5 +- .../mac/originator/OriginatorQosAckPolicy.cc | 97 ++-- .../mac/originator/OriginatorQosAckPolicy.h | 7 +- .../ieee80211/mac/originator/QosAckHandler.cc | 18 +- .../ieee80211/mac/originator/QosAckHandler.h | 3 +- .../mac/originator/QosRecoveryProcedure.cc | 14 + .../mac/originator/QosRecoveryProcedure.h | 1 + .../ieee80211/mac/queue/InProgressFrames.cc | 3 +- tests/fingerprint/examples.csv | 4 +- tests/fingerprint/showcases.csv | 10 +- .../Ieee80211BlockAckCompletionCost_1.test | 210 ++++++++ tests/module/Ieee80211BlockAckDeferral_1.test | 34 +- ...Ieee80211BlockAckFragmentRetirement_1.test | 57 ++- .../module/Ieee80211BlockAckScheduling_1.test | 455 ++++++++++++++++++ tests/module/Ieee80211HcfHeader_1.test | 2 +- .../Ieee80211HcfMultipleProtection_2.test | 11 +- tests/unit/Ieee80211BlockAckScheduling_1.test | 153 ++++++ tests/unit/Ieee80211MultipleProtection_1.test | 3 +- 30 files changed, 1342 insertions(+), 116 deletions(-) create mode 100644 plan/pending/ieee80211-compressed-blockack-s4-execution.md create mode 100644 tests/module/Ieee80211BlockAckCompletionCost_1.test create mode 100644 tests/module/Ieee80211BlockAckScheduling_1.test create mode 100644 tests/unit/Ieee80211BlockAckScheduling_1.test diff --git a/WHATSNEW b/WHATSNEW index 40cf987fb24..eecb155d1e0 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -444,9 +444,15 @@ Notable backward incompatible changes are the following: Basic remains the default. Compressed selection still stops initialization. Custom agreement handlers, recipient services, and management implementations require the changes in the migration guide. External queues need the optional selected-extraction contract only when deferred DATA hides eligible work. Built-in queues preserve ordinary pull accounting for that extraction. -51. IEEE 802.11 QoS DATA preview contract +51. IEEE 802.11 Basic Block Ack transfer completion - The QoS data service now exposes candidate preview through IOriginatorQosMacDataService. The in-progress queue can preview DATA without extraction or sequence assignment. Ordinary successor queries retain extraction as their default. Custom in-progress queues must accept the extract argument in getPendingFrameFor(). The migration guide describes this interface change. + Callers must supply agreement arguments explicitly for BAR selection and transmitted-BAR processing. An omitted argument now fails compilation instead of silently selecting behavior without agreement state. + + Basic BAR selection now separates each peer and TID. Short bursts and small negotiated windows can cause BAR below the configured threshold. BAR can obtain channel access without queued DATA. After final completion or final DATA expiration, the originator sends DELBA even with zero inactivity timeout. Later bursts can require another ADDBA exchange. These changes affect exchange order, airtime, simulation results, and fingerprints for Basic Block Ack configurations. + + Basic single protection now reserves only an already prepared successor. Further DATA extraction starts a new TXOP and can require more contention. Final DATA in a zero-limit TXOP reserves only its immediate response. These corrections can change Duration fields, airtime, and fingerprints. + + Custom QoS ACK policies must accept the agreement-handler argument in isBlockAckReqNeeded() and computeBlockAckReqParameters(). Custom in-progress queues must preserve the extract argument in getPendingFrameFor(). QoS data services must implement IOriginatorQosMacDataService for candidate preview without extraction. Notable backward compatible changes are the following: diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index cee7afc4edb..a3d5e9cb492 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -19,6 +19,14 @@ IEEE 802.11 Basic Block Ack extension points HCF previews the next eligible DATA before BAR selection. Preview must preserve queue ownership and the next sequence number. Custom QoS data services must implement ``IOriginatorQosMacDataService``. This contract extends ``IOriginatorMacDataService`` with ``peekEligibleFrame()``, ``getNextSequenceNumber()``, and ``hasAMsduAggregation()``. +Basic single protection reserves only an already prepared successor. HCF ends the TXOP before further DATA extraction. A queued unit can change size or require agreement setup before transmission. Custom frame sequences must preserve this boundary when they use the same forecast. + +Custom QoS ACK policies must add ``IOriginatorBlockAckAgreementHandler *agreements`` to ``isBlockAckReqNeeded()`` and ``computeBlockAckReqParameters()``. The argument supplies current agreement windows. Policies must keep peer and TID identities separate. The supplied policy can request BAR without a DATA candidate. + +Callers must supply the agreement handler explicitly through both the interface and concrete policy types. An omitted argument fails compilation. Pass ``nullptr`` explicitly when no agreement handler is available; the supplied policy then requests no BAR. Custom overrides must also require the argument. + +Calls to ``QosAckHandler::processTransmittedBlockAckReq()`` must supply the originator agreement explicitly. The agreement restricts processing to the negotiated window. An explicit ``nullptr`` retains bitmap-only coverage without that restriction. Production HCF always supplies the active agreement. + Custom ``InProgressFrames`` classes must add ``bool extract = true`` to their ``getPendingFrameFor()`` override. When ``extract`` is false, the method must return a borrowed candidate without extraction or sequence assignment. The default value preserves ordinary extraction. Custom candidate sources must also implement ``peekFrameToTransmit()`` without extraction. TCP Algorithms diff --git a/doc/src/users-guide/ch-80211.rst b/doc/src/users-guide/ch-80211.rst index f4569882f96..b526cdbf248 100644 --- a/doc/src/users-guide/ch-80211.rst +++ b/doc/src/users-guide/ch-80211.rst @@ -700,9 +700,13 @@ station then sets up an agreement with its peer automatically (with ADDBA frames) when it sends a QoS data frame shorter than :par:`maxBlockAckPolicyFrameLength` (default 1000 bytes). After that, the frames of that traffic class go out without an immediate acknowledgement, -and the station sends a Block Ack Request after :par:`blockAckReqThreshold` -(default 5) unacknowledged frames. Both parameters are on -``mac.hcf.originatorAckPolicy``. +and the station normally sends BAR after :par:`blockAckReqThreshold` unacknowledged frames. The default threshold is five. Both parameters are on ``mac.hcf.originatorAckPolicy``. + +The station applies the threshold separately to each peer and TID. It sends BAR below the threshold when the next eligible DATA belongs to another agreement or cannot fit the transmit window. The station also sends BAR when no eligible DATA remains. For example, a burst of four frames ends with BAR even with the default threshold of five. A negotiated buffer size of one requires BAR before the second sequence number. + +BAR can obtain channel access without a queued DATA frame. A later BAR within a TXOP must fit the applicable TXOP and TXNAV bounds with its response. If BAR cannot fit, the station retains that work for another contention. + +After the final exchange, the originator sends DELBA when its agreement has no queued DATA, in-progress DATA, or active BAR exchange. A zero inactivity timeout does not disable this transfer-completion rule. DATA that arrives after this boundary waits for DELBA completion. A later transfer can require another ADDBA exchange. If the last unresolved DATA expires, the originator uses the same teardown path. Ordinary recipient teardown releases complete units behind a receive gap before it releases agreement resources. The agreement policies, ``mac.hcf.originatorBlockAckAgreementPolicy`` and ``mac.hcf.recipientBlockAckAgreementPolicy``, set the buffer size diff --git a/plan/pending/ieee80211-compressed-blockack-s4-execution.md b/plan/pending/ieee80211-compressed-blockack-s4-execution.md new file mode 100644 index 00000000000..dc83901f766 --- /dev/null +++ b/plan/pending/ieee80211-compressed-blockack-s4-execution.md @@ -0,0 +1,178 @@ +# S4 execution record + +S4 completes Basic BAR work independently of DATA extraction. The initial source parent is `b29151fc8b`. The user authorized S4 implementation on 15 October 2026. Existing local edits to `AGENTS.md` and the prerequisite plans remain outside this change. + +## Implementation contract + +HCF previews the next eligible frame before a frame sequence extracts DATA. The originator ACK policy selects outstanding frames by peer and TID. The policy permits threshold deferral only for a candidate within that agreement's transmit window. The agreement owns the window start and size. Resolved DATA permits window progress; a received response number alone does not. + +HCF treats BAR work as contention work for its access category. Frame sequences permit BAR without a DATA pointer. Internal collision retains BAR work without DATA retry feedback. At an exchange boundary, HCF queues DELBA when an accepted agreement has no queued DATA, in-progress DATA, or active BAR exchange. Expiration uses the same teardown path after unresolved DATA disappears. + +The affected components are HCF, the QoS ACK policy, the ACK handler, the originator agreement, the in-progress queue, and HCF frame sequences. The optional QoS data-service contract exposes preview without a concrete dependency from the shared queue. Queue preview borrows a Packet pointer. Extraction retains the existing ownership transfer and sequence assignment. DCF extraction remains unchanged. S5 owns Compressed response validation and integration. + +The checks use focused module fixtures through HCF, frame sequences, Tx, and production response callbacks. They cover small windows, short bursts, peer/TID isolation, failed BAR recovery, collision, final expiration, and transfer completion. Timing checks compare Basic BAR exchanges with the pinned parent under single and multiple protection. A new unlawful continuation requires an admission correction before completion. + +The initial contract review checked source, ownership, protection, and callers before the first source edit. The affected source paths have no seal. S1 recipient progress and S3b teardown exist in the pinned parent. + +## Standards evidence + +The local corpus supplies IEEE Std 802.11-2024 normative Clauses 10.25.4, 10.25.6.7.1, and 10.23.2.9. Their canonical identifiers are `ieee80211-2024:clause:`. Their physical PDF pages are 2056, 2068–2070, and 2012–2014. Corpus status reports fresh input. The corpus linter result is `/tmp/s4-standard-lint.json`. Direct PDF inspection was unnecessary. + +## Verification + +Failed BAR recovery also requires the Retry bit on the next DATA attempt. Source inspection found that the old BAR failure path only changed ACK status. HCF now derives that bit from the failed Block Ack status before retransmission. IEEE Std 802.11-2024, Clause 9.2.4.1.6, physical PDF page 665, supplies this requirement for individual DATA. + +### Direct behavior checks + +The fresh debug build passes. The final focused selection passes 31 module fixtures and six unit fixtures. The module log is `/tmp/s4-module-final-limit.log`. The unit log is `/tmp/s4-unit-final-limit.log`. The new BAR fixture executes 30 scenarios across single and multiple protection. These results establish the recorded Basic paths. They do not establish Compressed support. + +The unit fixture checks peer/TID selection, sequence wrap, window boundaries, response identity, failed-response release, and exact lifetime eligibility. The production fixture exercises HCF, EDCA, frame sequences, Tx, and response callbacks. Its cases cover thresholds below five, accepted windows one and four, unrelated peers, negative bitmaps, timeout, and final expiration. The collision cases require BAR contention without a DATA retry entry. The nonzero contention-window case requires contention-window growth after collision. The short-limit case permits the initial Control-frame exception. + +BAR failure updates the access category's short retry counter and contention window. The one-failure limit case requires growth on the first failure. The unit fixture requires reset on the next failure. A successful Block Ack response resets both values. These checks require no DATA retry entry. + +The final-expiration case creates an incomplete fragment unit before two complete units. The production recipient retains those complete units behind the gap. Final expiration triggers DELBA. The recipient delivers both complete units before it deletes the agreement. This connects A5 to the existing recipient teardown path. + +Three existing fixtures require changed expectations because a short burst now resolves its final BAR and DELBA. The deferral fixture checks both remaining original DATA frames. Both retain their lifetime obligation after unsent disposal. The fragment-retirement fixture answers the unrelated peer's final BAR before its successor DATA. The multiple-protection fixture separates the DELBA management ACK from DATA ACKs. + +### Basic timing comparison + +The comparison parent is `b29151fc8b8953564dbbf61b48ece12658a1475c`. A detached checkout at `/tmp/inet-s4-parent` supplies its separately built debug library. The timing observer records actual transmit modes, preceding IFS, response airtime, TXOP deadline, and DATA count. The parent fixtures supply observations without S4 assertions. Their successful runner result alone supplies no S4 behavior proof. + +For the 1160-microsecond TXOP, the parent transmits a final BAR after five DATA frames. That BAR exchange ends at 2.270 ms. The deadline is 2.230 ms. This 40-microsecond overrun occurs with both protection modes. The S4 admission check rejects that continuation. EDCA later contends for a standalone BAR. The direct fixture requires every later BAR exchange to fit its applicable bounds. + +A separate case gives a standalone BAR a 50-microsecond TXOP limit. The initial BAR exchange takes 120 microseconds. Its 70-microsecond overrun uses the permitted initial Control-frame exception. It has no preceding DATA or Management frame. The admission check preserves this case. + +The diagnostic showcase traces also find DATA continuations beyond the TXOP bound in both parent and candidate. Each recorded violation ends with DATA. S4 does not repair general DATA admission. These observations limit the result to the changed Basic BAR paths. They do not establish general TXOP or NAV conformance. + +### Completion cost + +The cost fixture sends twelve UDP payloads of 700 bytes over a fixed 100-ms observation interval. One configuration sends one continuous burst. The other sends three bursts of four, with 20-ms gaps. Both configurations deliver all twelve payloads without a MAC drop. The payload goodput is 672000 bit/s in each configuration. + +| Candidate measurement | Continuous burst | Three bursts | +| --- | ---: | ---: | +| ADDBA requests / responses / DELBA frames | 1 / 1 / 1 | 3 / 3 / 3 | +| Management airtime | 108 microseconds | 324 microseconds | +| Total measured deferral | 280.133424 microseconds | 822.400272 microseconds | +| Request contention | 61 microseconds | 156 microseconds | +| Response time after request | 159.066712 microseconds | 486.200136 microseconds | +| DELBA completion time | 114.066712 microseconds | 387.200136 microseconds | +| Sum of payload delivery delays | 147.632334920 ms | 43.933601088 ms | + +The parent sends one request and one response in each configuration. It sends no completion DELBA. Its management airtime is 72 microseconds in each configuration. Both parent configurations deliver the same payload total. The parent and candidate also differ in extraction and BAR behavior. Thus, this comparison does not isolate an agreement-reuse cost. It supplies no general throughput or latency claim. + +### Regression and source checks + +The parent matches all nineteen original fingerprint rows. The evidence is `/tmp/s4-parent-fingerprints.log` and `/tmp/s4-parent-fingerprints-retry.log`. The selection preserves each original configuration, run number, simulation limit, and requested fingerprint ingredient. The final candidate run completes all nineteen rows in 227.330 seconds. Twelve rows match their baselines. Seven rows report fingerprint differences in configurations with Basic Block Ack enabled. + +The final log is `/tmp/s4-fingerprints-final-limit.log`. Its runner exits with status 1 because the seven recorded baselines differ. Every simulation reaches its required limit, including the enabled ad hoc row at ten seconds. Earlier attempts hit its 600-second CPU limit. Those partial attempts supply no replacement baseline. The final retry-limit correction preserves all nineteen results from the preceding full run. + +The following values are review candidates only. This execution does not approve or change a recorded baseline. + +| Configuration | Candidate fingerprint values | +| --- | --- | +| `NoFragmentation` | `4a83-1e6f/tplx;09db-9f72/~tNl;0596-3a23/~tND` | +| `Fragmentation` | `91a8-1fb6/tplx;f43e-1f17/~tNl;aaae-de01/~tND` | +| `MixedTraffic` | `202c-1e73/tplx;4e7c-be6a/~tNl;5544-6a00/~tND` | +| `HCFfragblockack` | `140a-28bf/tplx;233d-c918/~tNl;5890-e570/~tND` | +| TXOP `General` | `06db-3079/tplx;3727-bbbd/~tNl` | +| Ad hoc `MacQos`, run 1 | `491a-01b6/tplx;9558-1598/~tNl;6970-8509/~tND` | +| `MacQosWithBlockAck` | `cdb0-57dc/tplx;aa99-d171/~tNl;1368-030c/~tND` | + +The architecture check passes. The source-seal check permits every changed source path. The naming check reports the same 32 findings as the parent. The interface check retains the parent's two frame-step findings. The new QoS service interface passes that check. The logs use the `/tmp/s4-` prefix. No recorded fingerprint baseline changes belong to this implementation. + +The protocol selection executes eight fixtures. Four pass. Delayed Block Ack, Multi-TID Block Ack, and both A-MPDU fixtures retain four declared expected failures. `N_CompressedBa` selects Basic in this branch. Its pass does not establish Compressed behavior. The log is `/tmp/s4-protocol-final-limit.log`. + +The frame observer compares the first changed transmission in each affected configuration. It preserves actual bytes, sequence, TID, Retry, Duration, and selected mode. Its configuration adds an observer and a shorter observation limit. Thus, these observations explain local mechanisms; they do not replace the full fingerprint runs. + +| Configuration | First observed change | Confirmed mechanism | +| --- | --- | --- | +| `NoFragmentation` | ADDBA request replaces the next Normal Ack DATA at sequence 1. | Preview avoids speculative DATA extraction before setup. | +| `MixedTraffic` | ADDBA request replaces the next large Normal Ack DATA at sequence 1. | The same extraction change permits setup before the successor. | +| `Txop` | ADDBA request precedes the next large DATA at sequence 2. | The same extraction change preserves the setup boundary. | +| `Fragmentation` | Final fragment 15 of sequence 1 reserves 464 instead of 116 microseconds. | Preview reads the queued unit before aggregation or fragmentation. | +| `HCFfragblockack` | Retransmitted fragment 2 of sequence 1 sets Retry. | Failed Block Ack status now sets the DATA Retry bit. | +| `MacQosWithBlockAck` | The first changed DATA has a 332-byte A-MSDU instead of a 166-byte unit. | Later extraction changes the available aggregation set. | +| Ad hoc `MacQos`, run 1 | Fragment 2 of sequence 1 reserves 484 instead of 628 microseconds. | Preview no longer extracts the next aggregate for the Duration estimate. | + +These Duration observations do not prove complete NAV correctness. The existing Basic forecast does not model every BAR boundary. The direct timing assertions establish the separate BAR admission result. + +The saturated ad hoc case also exposes a host execution cost in transfer-completion checks. A temporary queue observer records 5120 predicate checks in each unrelated queue. Its stack trace identifies `completeTransfers` through `hasQueuedData`. HCF now checks the category from EDCA's existing TID mapping first. It retains the other categories as a fallback for custom classification. This changes search order without new persistent state or a different existence predicate. + +The temporary HCF observer records the same event count and fingerprint values before and after that search-order change. Its observed time in `processLowerFrame` falls from 41.0384 to 4.68354 seconds. Its observed time in `frameSequenceFinished` falls from 8.56017 to 0.226506 seconds. Host load differs between these observations. These values locate the cost; they supply no controlled speed benchmark. + +### Reproduction and retained evidence + +The local evidence directory is `audit/2026-10-15-s4/`. It retains the raw logs, parent observations, fingerprint selection, and temporary diagnostic sources. The diagnostic sources remain outside the delivered test suite. The directory also retains source hashes for this result. The build uses OMNeT++ from `/home/user/omnetpp-6.4.0aipre2` and the checkout's `setenv`. + +The category runners use these selections from the repository root: + +```sh +make MODE=debug -j8 +inet_run_unit_tests -m debug -f 'Ieee80211(BlockAckScheduling|MultipleProtection|HtModeSet|HtModeCache|VhtHtCapabilities|ResponseModeSelection)_1\.test' +inet_run_module_tests -m debug -f 'Ieee80211(BlockAck(ActionDelivery|ActionDisposal|ActionDispatch|AssociationReset|DataSelection|Deferral|DeferredCollision|FragmentRetirement|Lifecycle|Negotiation|RetiredData|Reordering|ResponseWait|Admission|Variant|Scheduling|CompletionCost)|EdcaDataLifetime(Arbitration|Aggregation|Congestion|Defaults)?|Hcf(Header|SingleProtection|MultipleProtection|InternalCollision)|BasicCompatibility|RecipientNav|SingleProtectionGroup|VhtHtSupport)_[12]\.test' +inet_run_protocol_tests -p inet -m debug -w wifi -f '(N_BlockAck|Ac_BlockAck|N_Amsdu|N_CompressedBa|WifiQosDelayedBa|Ac_MultiTidBa|N_Ampdu|Ac_Ampdu)\.test$' +``` + +The fingerprint command runs from `tests/fingerprint`. The retained CSV contains the exact nineteen original rows. + +```sh +./fingerprinttest -d -t4 -m '^/(showcases/wireless/(blockack|aggregation|fragmentation|qos|txop)|examples/(wireless|adhoc)/qos)/ ' -f tplx -f '~tNl' -f '~tND' -l /tmp/s4-fingerprints-final-limit.out /tmp/s4-fingerprint-final-limit.csv +``` + +### Scope limits + +S5 owns Compressed response integration. Delayed Block Ack, Multi-TID Block Ack, and A-MPDU remain outside this result. Recorded fingerprint baselines remain unchanged. The existing prerequisite plans and unrelated local files retain their prior edits. The initial implementation checks precede the commit and push request. The publication checks extend that initial evidence. + +## Initial checks before publication + +The user authorized commit and push on 15 October 2026. The series separates DATA preview from its first BAR selection consumer. The preview commit is `e2d20d6be6`. Its isolated debug build passes. Five focused module fixtures pass, including the direct preview checks for ownership and sequence assignment. The behavior commit contains BAR selection, window progress, transfer completion, and their direct fixtures. + +The final debug build passes. Its fresh selection passes 31 module fixtures and six unit fixtures. A separate scheduling run also passes after removal of the temporary parent-comparison directive. These checks retain the same runtime assertions. The logs are `/tmp/s4-publish-debug-build.log`, `/tmp/s4-publish-modules.log`, `/tmp/s4-publish-units.log`, and `/tmp/s4-publish-scheduling-clean.log`. + +The preview commit matches all nineteen retained fingerprint rows. Its log is `/tmp/s4-preview-fingerprints.log`. The final protocol rerun returns four passes and four declared expected failures across eight fixtures. Its log is `/tmp/s4-publish-protocol.log`. + +The final release compilation also passes. Its log is `/tmp/s4-publish-release-build.log`. The final fingerprint rerun completes nineteen rows. Twelve match their baselines; seven retain exactly the candidate values in this record. Its runner exits with status 1 for those differences. Its log is `/tmp/s4-publish-fingerprints.log`. + +The whole-tree architecture gate reports 36 findings. The whole-tree naming gate reports 23 findings. The interface gate reports 15 findings. Each sorted finding set matches the selected parent. The source-seal check passes. + +The series gates pass against `origin/master`; their two notes concern the earlier lifecycle commit `667ae51dc`. No pull request description check runs because this task creates no pull request. + +The C++ quality gate does not run because this checkout lacks `src/compile_commands.json`. Its setup exits with status 2. The log is `/tmp/s4-publish-cpp.log`. The compiler checks and the other gates do not replace this static analysis. + +## Rebase onto the updated S3b branch + +The user authorized this rebase after the initial publication. The pinned S3b target is `f6f12c5c9fed341f5834d4ccdeedeec7a562e102`. The original S4 head is `65804c762e524f64d07cfa336da0ceeb0d2bd425`. The backup ref is `refs/backup/compressed-blockack-s4-before-s3b-rebase-20261015`. The two S4 commits retain their order and purpose. + +The target adds local allocation indices for DATA retirement across large sequence gaps. The rebase retains that production mechanism alongside S4 window progress and completion DELBA. The collision fixture now records the extracted frame's allocation index. The fragment-retirement fixture retains all twenty gap scenarios and the Basic response path. A deferred successor keeps the earlier transfer open until the fixture advances the allocator. This prevents completion DELBA before the intended inactivity check. + +The user permits builds and tests only at the final commit. No intermediate commit receives a build or test. The earlier results above remain historical evidence. Final verification uses the last rebased commit. Its results and preserved-file hashes belong to `audit/2026-10-15-s4-rebase/`. + +## Approved fingerprints and final Basic boundary + +The user approved the seven final fingerprint changes on 2026-10-15 after review of their causes in PR #1344. This approval covers the non-graphical ingredients in the table below. Graphical `tyf` values remain unchanged and unverified. This section supersedes the earlier candidate values and the statements that S4 includes no baseline update. + +The final correction limits Basic single protection to an already prepared successor. HCF ends the TXOP before further DATA extraction can change aggregation, fragmentation, or agreement setup. Prepared fragments retain their continuation path. Final DATA in a zero-limit TXOP reserves only an immediate response when required. The policy can require more contention; it preserves standalone BAR progress. + +The source and tests at `8745330c1cc398f3dbc0a43be0c60cd7c2d5c529` contain this correction. Debug and release builds pass at that revision. All 31 module fixtures and six unit fixtures pass. Protocol execution reports four passes and four declared expected failures. The nineteen fingerprint simulations complete; twelve match the previous baselines and seven produce the approved values below. The raw evidence belongs to `audit/2026-10-15-s4-duration/`. + +The final observer shows zero Duration for sequence 1, fragment 15, in the fragmentation showcase. The TXOP ends with that DATA; BAR follows in a separate TXOP. The ad hoc observer shows 44 microseconds for sequence 1, fragment 2. Its ACK advertises zero Duration, and the TXOP ends. These observations replace the earlier unverified 464- and 484-microsecond forecasts. They do not establish general Basic DATA admission or complete NAV conformance. + +| Configuration | Approved fingerprints | Cause of the movement | +| --- | --- | --- | +| Block Ack `NoFragmentation`, run 0 | `9161-625d/tplx;6a02-09aa/~tNl;cbc0-3b0a/~tND` | Final Normal Ack DATA reserves only its ACK; setup and BAR exchange order also change. | +| Block Ack `Fragmentation`, run 0 | `36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND` | Final Block Ack DATA reserves zero; BAR obtains another TXOP. | +| Block Ack `MixedTraffic`, run 0 | `351b-d4ba/tplx;5c1f-69a8/~tNl;6182-6da3/~tND` | The current reservation excludes the unextracted large successor; setup can precede that DATA. | +| Fragmentation `HCFfragblockack`, run 0 | `2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND` | Failed Block Ack feedback sets Retry on retransmitted DATA; the final burst boundary also changes. | +| TXOP `General`, run 0 | `ab91-87f3/tplx;f30c-6aa4/~tNl` | The reservation excludes an unextracted successor, and the frame sequence enforces that boundary. | +| Ad hoc `MacQos`, run 1 | `4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND` | Final Normal Ack DATA reserves SIFS plus ACK; further extraction requires another TXOP. | +| Wireless `MacQosWithBlockAck`, run 0 | `6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND` | ADDBA reserves its immediate ACK without unrelated queued DATA; later extraction can change aggregation. | + +The final history keeps the preview preparation separate. One behavior commit contains BAR selection, the final Duration boundary, and these seven baseline rows. Its production source and tests match `8745330c1c`. This placement avoids an intermediate behavior commit with obsolete expectations. Final verification after the baseline update uses only the final commit, as requested. + +## Explicit agreement arguments + +BAR policy calls now require an explicit agreement handler through both the interface and concrete policy types. Transmitted-BAR processing also requires an explicit originator agreement. An omitted argument fails compilation instead of silently selecting behavior without agreement state. Explicit null values retain their documented behavior. Production callers already supply these arguments, so their runtime behavior stays unchanged. + +Compile-time checks cover omitted arguments through both policy types and the ACK handler. The scheduling fixture also checks explicit null policy calls with outstanding DATA. Custom test policies follow the same explicit contract. The migration guide describes the source compatibility change. The seven approved fingerprint rows stay unchanged. + +The source-equivalence statement in the preceding section describes baseline acceptance at `fcedba79e3`. This later correction changes API declarations, compile-time checks, and documentation. It changes no production C++ function body. diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h index 8ef73652db3..adc12872b27 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h @@ -47,6 +47,11 @@ class INET_API OriginatorBlockAckAgreement : public cObject virtual ~OriginatorBlockAckAgreement() {} virtual int getBufferSize() const { return bufferSize; } + int getWindowSize() const { return std::min(bufferSize, 64); } + bool containsSequence(SequenceNumberCyclic sequence) const + { + return (sequence.get() - startingSequenceNumber.get() + 4096) % 4096 < getWindowSize(); + } virtual SequenceNumberCyclic getStartingSequenceNumber() { return startingSequenceNumber; } virtual void setStartingSequenceNumber(SequenceNumberCyclic sequenceNumber) { startingSequenceNumber = sequenceNumber; } virtual bool getIsAddbaResponseReceived() const { return isAddbaResponseReceived; } diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc index fdc8c44dd1e..e136518a229 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc @@ -170,7 +170,6 @@ void OriginatorBlockAckAgreementHandler::processReceivedBlockAck(const Ptr(blockAck)) { auto agreement = getAgreement(basicBlockAck->getTransmitterAddress(), basicBlockAck->getTidInfo()); if (agreement) { - agreement->setStartingSequenceNumber(basicBlockAck->getStartingSequenceNumber()); agreement->calculateExpirationTime(); scheduleInactivityTimer(callback); } diff --git a/src/inet/linklayer/ieee80211/mac/channelaccess/Edca.h b/src/inet/linklayer/ieee80211/mac/channelaccess/Edca.h index b7b9e4d6bc2..4b038c0c914 100644 --- a/src/inet/linklayer/ieee80211/mac/channelaccess/Edca.h +++ b/src/inet/linklayer/ieee80211/mac/channelaccess/Edca.h @@ -30,11 +30,10 @@ class INET_API Edca : public SimpleModule virtual int numInitStages() const override { return NUM_INIT_STAGES; } virtual void initialize(int stage) override; - virtual AccessCategory mapTidToAc(Tid tid); - public: virtual ~Edca(); + virtual AccessCategory mapTidToAc(Tid tid); virtual AccessCategory classifyFrame(const Ptr& header); virtual Edcaf *getEdcaf(AccessCategory ac) const { return edcafs[ac]; } EdcaTransmitLifetimeHandler *getLifetimeHandler() const { return lifetimeHandler; } diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h index 94a583a111a..641e21e8ecd 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h @@ -10,6 +10,7 @@ #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" #include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" +#include "inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/originator/TxopProcedure.h" #include "inet/linklayer/ieee80211/mac/queue/InProgressFrames.h" @@ -23,9 +24,9 @@ class INET_API IOriginatorQoSAckPolicy virtual bool isAckNeeded(const Ptr& header) const = 0; virtual AckPolicy computeAckPolicy(Packet *packet, const Ptr& header, OriginatorBlockAckAgreement *agreement) const = 0; - virtual bool isBlockAckReqNeeded(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure) const = 0; + virtual bool isBlockAckReqNeeded(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure, IOriginatorBlockAckAgreementHandler *agreements) const = 0; virtual bool isBlockAckPolicyEligibleFrame(Packet *packet, const Ptr& header) const = 0; - virtual std::tuple computeBlockAckReqParameters(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure) const = 0; + virtual std::tuple computeBlockAckReqParameters(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure, IOriginatorBlockAckAgreementHandler *agreements) const = 0; virtual simtime_t getAckTimeout(Packet *packet, const Ptr& dataOrMgmtHeader) const = 0; virtual simtime_t getBlockAckTimeout(Packet *packet, const Ptr& blockAckReq) const = 0; diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index b75ddaa30eb..7c87cbc0622 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -204,6 +204,7 @@ void Hcf::expireDataFrames(bool preserveSequence) frames->clearDroppedFrames(); } scheduleDataLifetimeTimer(); + advanceOriginatorWindows(); } void Hcf::forEachChild(cVisitor *v) @@ -228,6 +229,8 @@ void Hcf::handleMessage(cMessage *msg) } else if (msg == dataLifetimeTimer) { expireDataFrames(); + if (!frameSequenceHandler->isSequenceRunning()) + completeTransfers(); updateAgreementProcedures(); updateContention(); } @@ -433,7 +436,10 @@ bool Hcf::hasQueuedData(MacAddress peer, Tid tid) const return data && data->getType() == ST_DATA_WITH_QOS && data->getReceiverAddress() == peer && data->getTid() == tid && !edca->getLifetimeHandler()->isExpired(packet); }; - for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + // Check the TID's category first. Other categories retain support for custom classification. + int first = edca->mapTidToAc(tid); + for (int offset = 0; offset < AC_NUMCATEGORIES; offset++) { + int ac = (first + offset) % AC_NUMCATEGORIES; auto queue = edca->getEdcaf(static_cast(ac))->getPendingQueue(); if (auto selected = dynamic_cast(queue)) { try { @@ -522,6 +528,48 @@ void Hcf::updateContention() } } +void Hcf::advanceOriginatorWindows() +{ + if (!originatorBlockAckAgreementHandler) + return; + auto service = check_and_cast(originatorDataService); + for (const auto& entry : originatorBlockAckAgreementHandler->getAgreements()) { + auto agreement = entry.second; + if (!agreement->getIsAddbaResponseReceived()) + continue; + auto start = agreement->getStartingSequenceNumber(); + auto next = service->getNextSequenceNumber(entry.first.first, entry.first.second); + int distance = (next.get() - start.get() + 4096) % 4096; + for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { + auto frames = edca->getEdcaf(static_cast(ac))->getInProgressFrames(); + for (int i = 0; i < frames->getLength(); i++) { + auto data = dynamicPtrCast(frames->getFrames(i)->peekAtFront()); + if (data && data->getType() == ST_DATA_WITH_QOS && + data->getReceiverAddress() == entry.first.first && data->getTid() == entry.first.second) + distance = std::min(distance, (data->getSequenceNumber().get() - start.get() + 4096) % 4096); + } + } + // IEEE Std 802.11-2024, 10.25.6.7.1: resolved positions permit transmit-window progress. + agreement->setStartingSequenceNumber(start + distance); + } +} + +void Hcf::completeTransfers() +{ + if (!originatorBlockAckAgreementHandler) + return; + std::vector> completed; + for (const auto& entry : originatorBlockAckAgreementHandler->getAgreements()) { + auto agreement = entry.second; + if (agreement->getIsAddbaResponseReceived() && agreement->getFirstDataTransmitted() && + !hasNumberedData(entry.first.first, entry.first.second) && !hasQueuedData(entry.first.first, entry.first.second)) + completed.push_back(entry.first); + } + // IEEE Std 802.11-2024, 10.25.4; INET uses the accepted queue predicate at an exchange boundary. + for (const auto& id : completed) + beginTeardown(id.first, id.second, true, 37); +} + void Hcf::discardAgreementData(MacAddress peer, Tid tid, bool all, int64_t highestTransmittedDataIndex) { for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { @@ -902,6 +950,11 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) for (auto edcaf : internallyCollidedEdcafs) { AccessCategory ac = edcaf->getAccessCategory(); auto dataRecoveryProcedure = edcaf->getRecoveryProcedure(); + if (originatorAckPolicy->isBlockAckReqNeeded(edcaf->getInProgressFrames(), edcaf->getTxopProcedure(), originatorBlockAckAgreementHandler)) { + dataRecoveryProcedure->controlFrameTransmissionFailed(); + edcaf->requestChannel(this); + continue; + } Packet *internallyCollidedFrame = edcaf->getInProgressFrames()->getFrameToTransmit(); if (internallyCollidedFrame == nullptr) continue; @@ -963,6 +1016,8 @@ void Hcf::frameSequenceFinished() if (edcaf) { // The context still owns references. dropFrame defers deletion until context disposal. expireDataFrames(false); + advanceOriginatorWindows(); + completeTransfers(); updateAgreementProcedures(); bool startContention = !handlingAgreementAction && hasFrameToTransmit(); edcaf->releaseChannel(this); @@ -1291,8 +1346,12 @@ void Hcf::originatorProcessTransmittedManagementFrame(const Ptr& controlHeader, AccessCategory ac) { auto edcaf = edca->getEdcaf(ac); - if (auto blockAckReq = dynamicPtrCast(controlHeader)) - edcaf->getAckHandler()->processTransmittedBlockAckReq(blockAckReq); + if (auto blockAckReq = dynamicPtrCast(controlHeader)) { + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(blockAckReq->getReceiverAddress(), blockAckReq->getTidInfo()) : nullptr; + if (agreement) + edcaf->getAckHandler()->processTransmittedBlockAckReq(blockAckReq, agreement); + } else if (auto rtsFrame = dynamicPtrCast(controlHeader)) rtsProcedure->processTransmittedRts(rtsFrame); else @@ -1332,6 +1391,7 @@ void Hcf::originatorProcessFailedFrame(Packet *failedPacket) } else if (auto blockAckReq = dynamicPtrCast(failedHeader)) { edcaf->getAckHandler()->processFailedBlockAckReq(blockAckReq); + edcaf->getRecoveryProcedure()->controlFrameTransmissionFailed(); return; } else @@ -1426,6 +1486,7 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const Ptr(lastTransmittedHeader); edcaf->getAckHandler()->processReceivedAck(ackFrame, lastTransmittedDataOrMgmtHeader); edcaf->getInProgressFrames()->dropFrame(lastTransmittedPacket); + advanceOriginatorWindows(); edcaf->getAckHandler()->dropFrame(lastTransmittedDataOrMgmtHeader); if (dynamicPtrCast(lastTransmittedHeader)) { actionTerminated(lastTransmittedPacket, true); @@ -1433,8 +1494,12 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const Ptr(header)) { + if (!originatorBlockAckAgreementHandler || + !originatorBlockAckAgreementHandler->getAgreement(blockAck->getTransmitterAddress(), blockAck->getTidInfo())) + return; EV_INFO << "BasicBlockAck has arrived" << std::endl; edcaf->getRecoveryProcedure()->blockAckFrameReceived(); auto ackedSeqAndFragNums = edcaf->getAckHandler()->processReceivedBlockAck(blockAck); @@ -1444,7 +1509,9 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const Ptr(header)) { + auto status = channelOwner->getAckHandler()->getQoSDataAckStatus(dataHeader); + if (dataHeader->getType() == ST_DATA_WITH_QOS && + (status == QosAckHandler::Status::BLOCK_ACK_NOT_ARRIVED || status == QosAckHandler::Status::BLOCK_ACK_ARRIVED_UNACKED)) { + // IEEE Std 802.11-2024, 9.2.4.1.6: DATA after a failed Block Ack exchange is a retransmission. + auto updated = packet->removeAtFront(); + updated->setRetry(true); + packet->insertAtFront(updated); + header = updated; + } + } auto lifetimeHandler = edca->getLifetimeHandler(); auto step = frameSequenceHandler->getContext()->getLastStep(); auto protectedPacket = dynamic_cast(step); @@ -1652,6 +1732,19 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) } auto mode = dataAfterCts ? packet->getTag()->getMode() : rateSelection->computeMode(packet, header, txop); setFrameMode(packet, header, mode); + if (auto bar = dynamicPtrCast(header)) { + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(bar->getReceiverAddress(), bar->getTidInfo()) : nullptr; + if (!agreement || !agreement->getIsAddbaResponseReceived()) + return false; + auto response = rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT)->getDuration(LENGTH_BASIC_BLOCKACK); + auto cost = mode->getDuration(packet->getDataLength()) + modeSet->getSifsTime() + response; + // IEEE Std 802.11-2024, 10.23.2.8 and 10.23.2.9: a later BAR must fit both bounds. + if (context->getNumSteps() > 1 && + ((txop->getLimit() > 0 && ifs + cost > txop->getRemaining()) || + (txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && cost >= rx->getTxnavRemaining()))) + return false; + } if (scopedSingle) { auto sifs = modeSet->getSifsTime(); auto cost = mode->getDuration(packet->getDataLength()); @@ -1704,7 +1797,16 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) packet->insertAtFront(updated); } else if (txop->getProtectionMechanism() == TxopProcedure::ProtectionMechanism::SINGLE_PROTECTION) { - auto pendingPacket = channelOwner->getInProgressFrames()->getPendingFrameFor(packet); + auto pendingPacket = dynamicPtrCast(header) ? nullptr : + channelOwner->getInProgressFrames()->getPendingFrameFor(packet, false); + if (dynamicPtrCast(header) && txop->getLimit() == 0) { + // The zero-limit frame sequence ends after this exchange; it has no successor reservation. + pendingPacket = nullptr; + } + else if (pendingPacket && !channelOwner->getInProgressFrames()->containsFrame(pendingPacket)) { + // HcfFs ends this TXOP before extraction can change the successor's size or setup state. + pendingPacket = nullptr; + } const auto& pendingHeader = pendingPacket == nullptr ? nullptr : pendingPacket->peekAtFront(); auto duration = singleProtectionMechanism->computeDurationField(packet, header, pendingPacket, pendingHeader, txop, recipientAckPolicy); auto header = packet->removeAtFront(); diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h index aaa5c20cad6..03d7bb93a45 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h @@ -159,6 +159,8 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: bool hasNumberedData(MacAddress peer, Tid tid) const; bool hasObsoleteActionInFlight(MacAddress peer, Tid tid, bool originator) const; void updateAgreementProcedures(); + void advanceOriginatorWindows(); + void completeTransfers(); void updateContention(); void scheduleAddbaResponseTimer(); void actionTerminated(Packet *packet, bool acknowledged); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc b/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc index b12ce4d54f4..7a49e0ece7c 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc @@ -34,8 +34,12 @@ HcfFs::HcfFs() : int HcfFs::selectHcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context) { - auto frameToTransmit = context->getInProgressFrames()->getFrameToTransmit(); - return frameToTransmit->peekAtFront()->getReceiverAddress().isMulticast() ? 0 : 1; + auto qos = context->getQoSContext(); + auto frameToTransmit = qos->blockAckAgreementHandler ? context->getInProgressFrames()->peekFrameToTransmit() : + context->getInProgressFrames()->getFrameToTransmit(); + if (qos->ackPolicy->isBlockAckReqNeeded(context->getInProgressFrames(), qos->txopProcedure, qos->blockAckAgreementHandler)) + return 1; + return frameToTransmit && frameToTransmit->peekAtFront()->getReceiverAddress().isMulticast() ? 0 : 1; } int HcfFs::selectDataOrManagementSequence(AlternativesFs *frameSequence, FrameSequenceContext *context) @@ -57,15 +61,21 @@ bool HcfFs::isSelfCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *con bool HcfFs::hasMoreTxOps(RepeatingFs *frameSequence, FrameSequenceContext *context) { - bool hasFrameToTransmit = context->getInProgressFrames()->hasInProgressFrames(); + auto frames = context->getInProgressFrames(); + auto qos = context->getQoSContext(); + bool bar = qos->ackPolicy->isBlockAckReqNeeded(frames, qos->txopProcedure, qos->blockAckAgreementHandler); + bool hasFrameToTransmit = qos->blockAckAgreementHandler ? + bar || frames->peekFrameToTransmit() != nullptr : frames->hasInProgressFrames(); if (hasFrameToTransmit) { - auto nextFrameToTransmit = context->getInProgressFrames()->getFrameToTransmit(); - const auto& nextHeader = nextFrameToTransmit->peekAtFront(); + auto nextFrameToTransmit = qos->blockAckAgreementHandler ? frames->peekFrameToTransmit() : frames->getFrameToTransmit(); if (frameSequence->getCount() == 0) return true; - auto qos = context->getQoSContext(); auto txop = qos->txopProcedure; - if (nextHeader->getReceiverAddress().isMulticast() || txop->getRemaining() <= 0) + // Basic single protection reserves only prepared MPDUs. Unextracted DATA starts a new TXOP. + if (qos->blockAckAgreementHandler && txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && + !bar && !frames->containsFrame(nextFrameToTransmit)) + return false; + if ((!bar && nextFrameToTransmit->peekAtFront()->getReceiverAddress().isMulticast()) || txop->getRemaining() <= 0) return false; if (txop->getProtectionMechanism() == TxopProcedure::MULTIPLE_PROTECTION) { auto deadline = txop->getStart() + txop->getLimit(); @@ -77,8 +87,7 @@ bool HcfFs::hasMoreTxOps(RepeatingFs *frameSequence, FrameSequenceContext *conte if (projectedStart >= deadline) return false; // BAR precedes DATA in TxOpFs and does not use RTS. - if (!qos->ackPolicy->isBlockAckReqNeeded(context->getInProgressFrames(), txop) && - context->getRtsPolicy()->isRtsNeeded(nextFrameToTransmit, nextHeader)) + if (!bar && context->getRtsPolicy()->isRtsNeeded(nextFrameToTransmit, nextFrameToTransmit->peekAtFront())) { // Integer legacy RTS airtime requires its start on the deadline's microsecond grid. if ((projectedStart - deadline).raw() % SimTime(1, SIMTIME_US).raw() != 0) diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc index 3fda1fcd52c..f9a3de4a6e5 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc @@ -412,7 +412,8 @@ IFrameSequenceStep *BlockAckReqBlockAckFs::prepareStep(FrameSequenceContext *con { switch (step) { case 0: { - auto blockAckReqParams = context->getQoSContext()->ackPolicy->computeBlockAckReqParameters(context->getInProgressFrames(), context->getQoSContext()->txopProcedure); + auto qos = context->getQoSContext(); + auto blockAckReqParams = qos->ackPolicy->computeBlockAckReqParameters(context->getInProgressFrames(), qos->txopProcedure, qos->blockAckAgreementHandler); auto receiverAddr = std::get<0>(blockAckReqParams); auto startingSequenceNumber = std::get<1>(blockAckReqParams); auto tid = std::get<2>(blockAckReqParams); @@ -445,7 +446,12 @@ bool BlockAckReqBlockAckFs::completeStep(FrameSequenceContext *context) step++; auto receivedPacket = receiveStep->getReceivedFrame(); const auto& receivedHeader = receivedPacket->peekAtFront(); - return context->isForUs(receivedHeader) && receivedHeader->getType() == ST_BLOCKACK; + auto response = dynamicPtrCast(receivedHeader); + auto requestStep = check_and_cast(context->getStep(firstStep)); + auto request = requestStep->getFrameToTransmit()->peekAtFront(); + return context->isForUs(receivedHeader) && response && + response->getTransmitterAddress() == request->getReceiverAddress() && + response->getTidInfo() == request->getTidInfo(); } default: throw cRuntimeError("Unknown step"); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc index 02420634437..e0daefabaa7 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc @@ -44,10 +44,11 @@ int TxOpFs::selectMgmtOrDataQap(AlternativesFs *frameSequence, FrameSequenceCont int TxOpFs::selectTxOpSequence(AlternativesFs *frameSequence, FrameSequenceContext *context) { + auto qos = context->getQoSContext(); + if (qos->ackPolicy->isBlockAckReqNeeded(context->getInProgressFrames(), qos->txopProcedure, qos->blockAckAgreementHandler)) + return 2; auto frameToTransmit = context->getInProgressFrames()->getFrameToTransmit(); const auto& macHeader = frameToTransmit->peekAtFront(); - if (context->getQoSContext()->ackPolicy->isBlockAckReqNeeded(context->getInProgressFrames(), context->getQoSContext()->txopProcedure)) - return 2; if (dynamicPtrCast(macHeader)) return 3; else { diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc index b99e0a3339b..bf624914ed6 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc @@ -31,67 +31,55 @@ bool OriginatorQosAckPolicy::isAckNeeded(const Ptr& h return !header->getReceiverAddress().isMulticast(); } -std::map> OriginatorQosAckPolicy::getOutstandingFramesPerReceiver(InProgressFrames *inProgressFrames) const +bool OriginatorQosAckPolicy::isBlockAckReqNeeded(InProgressFrames *frames, TxopProcedure *txop, IOriginatorBlockAckAgreementHandler *agreements) const { - auto outstandingFrames = inProgressFrames->getOutstandingFrames(); - std::map> outstandingFramesPerReceiver; - for (auto frame : outstandingFrames) - outstandingFramesPerReceiver[frame->peekAtFront()->getReceiverAddress()].push_back(frame); - return outstandingFramesPerReceiver; + return std::get<2>(computeBlockAckReqParameters(frames, txop, agreements)) != -1; } -SequenceNumberCyclic OriginatorQosAckPolicy::computeStartingSequenceNumber(const std::vector& outstandingFrames) const +std::tuple OriginatorQosAckPolicy::computeBlockAckReqParameters(InProgressFrames *frames, TxopProcedure *txop, IOriginatorBlockAckAgreementHandler *agreements) const { - ASSERT(outstandingFrames.size() > 0); - auto startingSequenceNumber = outstandingFrames[0]->peekAtFront()->getSequenceNumber(); - for (size_t i = 1; i < outstandingFrames.size(); i++) { - auto seqNum = outstandingFrames[i]->peekAtFront()->getSequenceNumber(); - if (seqNum < startingSequenceNumber) - startingSequenceNumber = seqNum; + using Id = std::pair; + std::map> groups; + for (auto frame : frames->getOutstandingFrames()) { + auto header = frame->peekAtFront(); + auto agreement = agreements ? agreements->getAgreement(header->getReceiverAddress(), header->getTid()) : nullptr; + if (agreement && agreement->getIsAddbaResponseReceived() && agreement->containsSequence(header->getSequenceNumber())) + groups[{header->getReceiverAddress(), header->getTid()}].push_back(frame); } - return startingSequenceNumber; -} - -bool OriginatorQosAckPolicy::isCompressedBlockAckReq(const std::vector& outstandingFrames, int startingSequenceNumber) const -{ - // The Compressed Bitmap subfield of the BA Control field or BAR Control field shall be set to 1 in all - // BlockAck and BlockAckReq frames sent from one HT STA to another HT STA and shall be set to 0 otherwise. - return false; // non-HT STA -// for (auto frame : outstandingFrames) -// if (frame->getSequenceNumber() >= startingSequenceNumber && frame->getFragmentNumber() > 0) -// return false; -// return true; -} - -// FIXME -bool OriginatorQosAckPolicy::isBlockAckReqNeeded(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure) const -{ - auto outstandingFramesPerReceiver = getOutstandingFramesPerReceiver(inProgressFrames); - for (auto outstandingFrames : outstandingFramesPerReceiver) { - if ((int)outstandingFrames.second.size() >= blockAckReqThreshold) - return true; - } - return false; -} - -// FIXME -std::tuple OriginatorQosAckPolicy::computeBlockAckReqParameters(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure) const -{ - auto outstandingFramesPerReceiver = getOutstandingFramesPerReceiver(inProgressFrames); - for (auto outstandingFrames : outstandingFramesPerReceiver) { - if ((int)outstandingFrames.second.size() >= blockAckReqThreshold) { - auto largestOutstandingFrames = outstandingFramesPerReceiver.begin(); - for (auto it = outstandingFramesPerReceiver.begin(); it != outstandingFramesPerReceiver.end(); it++) { - if (it->second.size() > largestOutstandingFrames->second.size()) - largestOutstandingFrames = it; + if (groups.empty()) + return std::make_tuple(MacAddress::UNSPECIFIED_ADDRESS, SequenceNumberCyclic(0), Tid(-1)); + auto candidate = frames->peekFrameToTransmit(); + auto data = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; + auto result = std::make_tuple(MacAddress::UNSPECIFIED_ADDRESS, SequenceNumberCyclic(0), Tid(-1)); + simtime_t oldestArrival = SIMTIME_MAX; + for (const auto& entry : groups) { + const auto& id = entry.first; + auto agreement = agreements->getAgreement(id.first, id.second); + // INET BAR policy defers a short group only for DATA within that group's window. + if ((int)entry.second.size() < blockAckReqThreshold && data && + data->getReceiverAddress() == id.first && data->getTid() == id.second && + agreement->containsSequence(frames->getCandidateSequenceNumber(candidate))) + continue; + auto start = agreement->getStartingSequenceNumber(); + int oldestOffset = 4096; + simtime_t arrival = SIMTIME_MAX; + for (auto frame : entry.second) { + auto sequence = frame->peekAtFront()->getSequenceNumber(); + int offset = (sequence.get() - start.get() + 4096) % 4096; + if (offset < oldestOffset) { + oldestOffset = offset; + arrival = frame->getArrivalTime(); } - MacAddress receiverAddress = largestOutstandingFrames->first; - SequenceNumberCyclic startingSequenceNumber = computeStartingSequenceNumber(largestOutstandingFrames->second); - Tid tid = largestOutstandingFrames->second.at(0)->peekAtFront()->getTid(); - return std::make_tuple(receiverAddress, startingSequenceNumber, tid); + else if (offset == oldestOffset) + arrival = std::min(arrival, frame->getArrivalTime()); + } + // Map order supplies the peer/TID tie break. + if (std::get<2>(result) == -1 || arrival < oldestArrival) { + oldestArrival = arrival; + result = std::make_tuple(id.first, start + oldestOffset, id.second); } } - return std::make_tuple(MacAddress::UNSPECIFIED_ADDRESS, SequenceNumberCyclic(), -1); + return result; } AckPolicy OriginatorQosAckPolicy::computeAckPolicy(Packet *packet, const Ptr& header, OriginatorBlockAckAgreement *agreement) const @@ -117,10 +105,9 @@ bool OriginatorQosAckPolicy::isBlockAckPolicyEligibleFrame(Packet *packet, const bool OriginatorQosAckPolicy::checkAgreementPolicy(const Ptr& header, OriginatorBlockAckAgreement *agreement) const { - bool bufferFull = agreement->getBufferSize() == agreement->getNumSentBaPolicyFrames(); bool aMsduOk = agreement->isAMsduPermitted() || !header->getAMsduPresent(); // TODO bool baPolicy = agreement->getIsDelayedBlockAckPolicySupported() || !frame->getAckPolicy(); - return !bufferFull && aMsduOk && (header->getSequenceNumber() >= agreement->getStartingSequenceNumber()); // TODO && baPolicy + return aMsduOk && agreement->containsSequence(header->getSequenceNumber()); } // diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h index bcd9f1b2ae7..cefd7008567 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h @@ -31,16 +31,13 @@ class INET_API OriginatorQosAckPolicy : public ModeSetListener, public IOriginat virtual void initialize(int stage) override; virtual bool checkAgreementPolicy(const Ptr& header, OriginatorBlockAckAgreement *agreement) const; - virtual std::map> getOutstandingFramesPerReceiver(InProgressFrames *inProgressFrames) const; - virtual SequenceNumberCyclic computeStartingSequenceNumber(const std::vector& outstandingFrames) const; - virtual bool isCompressedBlockAckReq(const std::vector& outstandingFrames, int startingSequenceNumber) const; public: virtual bool isAckNeeded(const Ptr& header) const override; virtual AckPolicy computeAckPolicy(Packet *packet, const Ptr& header, OriginatorBlockAckAgreement *agreement) const override; virtual bool isBlockAckPolicyEligibleFrame(Packet *packet, const Ptr& header) const override; - virtual bool isBlockAckReqNeeded(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure) const override; - virtual std::tuple computeBlockAckReqParameters(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure) const override; + virtual bool isBlockAckReqNeeded(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure, IOriginatorBlockAckAgreementHandler *agreements) const override; + virtual std::tuple computeBlockAckReqParameters(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure, IOriginatorBlockAckAgreementHandler *agreements) const override; virtual simtime_t getAckTimeout(Packet *packet, const Ptr& dataOrMgmtHeader) const override; virtual simtime_t getBlockAckTimeout(Packet *packet, const Ptr& blockAckReq) const override; diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc index 2fa02655743..fbd5c8d624b 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc @@ -147,6 +147,13 @@ std::set>> QosAckHand else { throw cRuntimeError("Multi-TID BlockReq is unimplemented"); } + auto basic = dynamicPtrCast(blockAck); + auto compressed = dynamicPtrCast(blockAck); + auto tid = basic ? basic->getTidInfo() : compressed->getTidInfo(); + for (auto& entry : ackStatuses) { + if (entry.first.first == receiverAddr && entry.first.second.first == tid && entry.second == Status::WAITING_FOR_BLOCK_ACK) + entry.second = Status::BLOCK_ACK_ARRIVED_UNACKED; + } return ackedFrames; } @@ -195,23 +202,28 @@ void QosAckHandler::processTransmittedDataOrMgmtFrame(const PtrgetReceiverAddress(), SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()))] = Status::WAITING_FOR_NORMAL_ACK; } -void QosAckHandler::processTransmittedBlockAckReq(const Ptr& blockAckReq) +void QosAckHandler::processTransmittedBlockAckReq(const Ptr& blockAckReq, const OriginatorBlockAckAgreement *agreement) { for (auto& ackStatus : ackStatuses) { + if (ackStatus.first.first != blockAckReq->getReceiverAddress()) + continue; auto tid = ackStatus.first.second.first; auto seqCtrlField = ackStatus.first.second.second; + auto sequence = SequenceNumberCyclic(seqCtrlField.getSequenceNumber()); + if (agreement && !agreement->containsSequence(sequence)) + continue; auto& status = ackStatus.second; if (auto basicBlockAckReq = dynamicPtrCast(blockAckReq)) { if (basicBlockAckReq->getTidInfo() == tid) { auto startingSeqNum = basicBlockAckReq->getStartingSequenceNumber(); - if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && SequenceNumberCyclic(seqCtrlField.getSequenceNumber()) >= startingSeqNum) + if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && (sequence.get() - startingSeqNum.get() + 4096) % 4096 < 64) status = Status::WAITING_FOR_BLOCK_ACK; } } else if (auto compressedBlockAckReq = dynamicPtrCast(blockAckReq)) { if (compressedBlockAckReq->getTidInfo() == tid) { auto startingSeqNum = compressedBlockAckReq->getStartingSequenceNumber(); - if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && SequenceNumberCyclic(seqCtrlField.getSequenceNumber()) >= startingSeqNum && seqCtrlField.getFragmentNumber() == 0) // TODO ASSERT(seqCtrlField.second == 0)? + if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && (sequence.get() - startingSeqNum.get() + 4096) % 4096 < 64 && seqCtrlField.getFragmentNumber() == 0) status = Status::WAITING_FOR_BLOCK_ACK; } } diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h index 7c1e0bce61c..96f1026d85f 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h @@ -13,6 +13,7 @@ #include "inet/linklayer/ieee80211/mac/common/SequenceControlField.h" #include "inet/linklayer/ieee80211/mac/contract/IAckHandler.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" namespace inet { namespace ieee80211 { @@ -60,7 +61,7 @@ class INET_API QosAckHandler : public SimpleModule, public IAckHandler virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) override; virtual void processTransmittedDataOrMgmtFrame(const Ptr& header); - virtual void processTransmittedBlockAckReq(const Ptr& blockAckReq); + virtual void processTransmittedBlockAckReq(const Ptr& blockAckReq, const OriginatorBlockAckAgreement *agreement); virtual void processFailedFrame(const Ptr& dataOrMgmtHeader); virtual void dropFrame(const Ptr& dataOrMgmtHeader); virtual void dropFrames(std::set>> seqAndFragNums); diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc index e0b177a94b2..e52f6b72652 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc @@ -110,6 +110,20 @@ void QosRecoveryProcedure::ctsFrameReceived() void QosRecoveryProcedure::blockAckFrameReceived() { resetStationSrc(); + resetContentionWindow(); +} + +void QosRecoveryProcedure::controlFrameTransmissionFailed() +{ + // IEEE Std 802.11-2024, 10.23.2.2: control failures update EDCA backoff without DATA retry feedback. + if (stationShortRetryCounter < shortRetryLimit) { + stationShortRetryCounter++; + incrementContentionWindow(); + } + else { + resetStationSrc(); + resetContentionWindow(); + } } // diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h index 69435073efc..e1804fcc323 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h +++ b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h @@ -66,6 +66,7 @@ class INET_API QosRecoveryProcedure : public SimpleModule, public IRecoveryProce virtual void ctsFrameReceived(); virtual void ackFrameReceived(Packet *packet, const Ptr& ackedHeader); virtual void blockAckFrameReceived(); + virtual void controlFrameTransmissionFailed(); virtual void rtsFrameTransmissionFailed(const Ptr& protectedHeader); virtual void dataFrameTransmissionFailed(Packet *packet, const Ptr& failedHeader); diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc index 81ec8985ddc..416e9709ad3 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc @@ -179,7 +179,8 @@ std::vector InProgressFrames::getOutstandingFrames() { std::vector outstandingFrames; for (auto frame : inProgressFrames) { - if (ackHandler->isOutstandingFrame(frame->peekAtFront())) + if ((!lifetimeHandler || !lifetimeHandler->isExpired(frame)) && + ackHandler->isOutstandingFrame(frame->peekAtFront())) outstandingFrames.push_back(frame); } return outstandingFrames; diff --git a/tests/fingerprint/examples.csv b/tests/fingerprint/examples.csv index 88293c812bb..175356337e3 100644 --- a/tests/fingerprint/examples.csv +++ b/tests/fingerprint/examples.csv @@ -7,7 +7,7 @@ # /examples/adhoc/ieee80211/, -f omnetpp.ini -c Ping2 -r 0, 100s, 0000-0000/tplx;0000-0000/~tNl;0000-0000/~tND, ERROR, wireless adhoc # [Config Ping2] # interactive config, needed a *.numHosts parameter /examples/adhoc/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 5749-0281/tplx;f38a-cb93/~tNl;c2ed-b352/~tND;0eb8-3e3b/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;2c1e-66e5/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 5fbb-9fd9/tplx;c0a4-97f6/~tNl;2373-df01/~tND;a587-3a4d/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;a587-3a4d/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;33b7-00f9/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, 2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;df04-18f7/tyf, PASS, wireless adhoc Ipv4 @@ -658,7 +658,7 @@ /examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, d929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;9f3c-4512/tyf, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;317d-aa4f/~tND;a4c3-19bf/tyf, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;b2d6-1329/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, f8a4-9474/tplx;1cba-cccc/~tNl;538e-67df/~tND;08b5-d005/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;08b5-d005/tyf, PASS, wireless Ipv4 /examples/wireless/ratecontrol/, -f omnetpp.ini -c Mac -r 0, 100s, bf30-2f13/tplx;7b2f-653d/~tNl;6f09-d8eb/~tND;19fe-8b0e/tyf, PASS, wireless diff --git a/tests/fingerprint/showcases.csv b/tests/fingerprint/showcases.csv index 836d42b5183..9baf2771fb6 100644 --- a/tests/fingerprint/showcases.csv +++ b/tests/fingerprint/showcases.csv @@ -199,9 +199,9 @@ /showcases/wireless/analogmodel/, -f omnetpp.ini -c Distance -r 0, 2.5s, 1e75-270e/tplx;6d7a-d84c/~tNl;7b7c-2bfb/~tND;5575-fd8f/tyf, PASS, wireless Ipv4 /showcases/wireless/analogmodel/, -f omnetpp.ini -c Noise -r 0, 0.1s, dd08-a63c/tplx;e167-9c84/~tNl;d680-b8ad/~tND;0d1f-df73/tyf, PASS, wireless Ipv4 -/showcases/wireless/blockack/, -f omnetpp.ini -c NoFragmentation -r 0, 1s, b828-6bd6/tplx;026f-2c6d/~tNl;2cd4-4795/~tND, PASS, wireless Ipv4 -/showcases/wireless/blockack/, -f omnetpp.ini -c Fragmentation -r 0, 1s, 021a-d29a/tplx;1597-ec6a/~tNl;feff-7e88/~tND, PASS, wireless Ipv4 -/showcases/wireless/blockack/, -f omnetpp.ini -c MixedTraffic -r 0, 1s, 5b9e-801f/tplx;8731-2504/~tNl;9724-d1ce/~tND, PASS, wireless Ipv4 +/showcases/wireless/blockack/, -f omnetpp.ini -c NoFragmentation -r 0, 1s, 9161-625d/tplx;6a02-09aa/~tNl;cbc0-3b0a/~tND, PASS, wireless Ipv4 +/showcases/wireless/blockack/, -f omnetpp.ini -c Fragmentation -r 0, 1s, 36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND, PASS, wireless Ipv4 +/showcases/wireless/blockack/, -f omnetpp.ini -c MixedTraffic -r 0, 1s, 351b-d4ba/tplx;5c1f-69a8/~tNl;6182-6da3/~tND, PASS, wireless Ipv4 /showcases/wireless/crosstalk/, -f omnetpp.ini -c CompletelyOverlappingFrequencyBands -r 0, 1s, d0d7-43e0/tplx;867a-07a4/~tNl;fc60-7eb7/~tND;3ea3-43da/tyf, PASS, wireless Ipv4 /showcases/wireless/crosstalk/, -f omnetpp.ini -c IndependentFrequencyBandsOneRadioMediumModule -r 0, 1s, 70c6-72b6/tplx;cf96-5e4d/~tNl;6f3a-074a/~tND;d1b2-9fd4/tyf, PASS, wireless Ipv4 @@ -267,7 +267,7 @@ /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFnofrag -r 0, 1s, 52b9-628f/tplx;3fec-74a2/~tNl;dbb5-67b0/~tND;8871-1dd1/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;f985-34fb/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;335d-6687/tyf, PASS, wireless Ipv4 -/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, f509-65f1/tplx;6b3a-0d65/~tNl;c474-7174/~tND;6f6e-b101/tyf, PASS, wireless Ipv4 +/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;6f6e-b101/tyf, PASS, wireless Ipv4 /showcases/wireless/handover/, -f omnetpp.ini -c General -r 0, 250s, 6150-7a8b/tplx;bcc9-11d2/~tNl;99fd-923d/~tND;02e9-9ad3/tyf, PASS, wireless @@ -341,5 +341,5 @@ /showcases/wireless/throughput/, -f omnetpp.ini -c General -r 0, 1s, 030e-c416/tplx;66e6-0bca/~tNl;3cb5-d354/~tND;e6a5-bde0/tyf, PASS, wireless Ipv4 -/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, f58d-d2fd/tplx;38f7-f642/~tNl;c87d-3f3a/tyf, PASS, wireless Ipv4 +/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, ab91-87f3/tplx;f30c-6aa4/~tNl;c87d-3f3a/tyf, PASS, wireless Ipv4 diff --git a/tests/module/Ieee80211BlockAckCompletionCost_1.test b/tests/module/Ieee80211BlockAckCompletionCost_1.test new file mode 100644 index 00000000000..358aee3883e --- /dev/null +++ b/tests/module/Ieee80211BlockAckCompletionCost_1.test @@ -0,0 +1,210 @@ +%description: +Measure production Basic setup and transfer completion with equal UDP payload totals. +One run sends twelve packets continuously. The other run sends three bursts of four packets. +Both runs use seed zero, 6 Mbit/s, zero inactivity timeout, and a fixed 100 ms interval. +The measurements describe these traffic shapes. They do not estimate agreement-reuse performance. + +%extraargs: -r 0..1 + +%file: CompletionCost.cc +#include +#include "inet/common/Simsignals.h" +#include "inet/common/packet/Packet.h" +#include "inet/common/TimeTag_m.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class CompletionCostHcf : public Hcf { + simtime_t deferredAt = -1; + simtime_t requestQueuedAt = -1; + simtime_t requestSentAt = -1; + simtime_t delbaQueuedAt = -1; + public: + simtime_t deferral; + simtime_t requestContention; + simtime_t responseAfterRequest; + simtime_t delbaCompletion; + protected: + void originatorProcessTransmittedDataFrame(Packet *packet, const Ptr& header, AccessCategory ac) override { + Hcf::originatorProcessTransmittedDataFrame(packet, header, ac); + const auto& procedures = originatorBlockAckAgreementHandler->getProcedures(); + if (procedures.count({header->getReceiverAddress(), header->getTid()}) && deferredAt < 0) + deferredAt = simTime(); + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) + requestQueuedAt = simTime(); + if (dynamicPtrCast(header)) + delbaQueuedAt = simTime(); + Hcf::processMgmtFrame(packet, header); + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + auto request = dynamicPtrCast(packet->peekAtFront()); + bool accepted = Hcf::transmitFrame(packet, ifs); + if (accepted && request) { + requestContention += simTime() + ifs - requestQueuedAt; + requestSentAt = simTime() + ifs; + } + return accepted; + } + void processLowerFrame(Packet *packet, const Ptr& header) override { + bool response = dynamicPtrCast(header) != nullptr; + Hcf::processLowerFrame(packet, header); + if (response && deferredAt >= 0) { + deferral += simTime() - deferredAt; + responseAfterRequest += simTime() - requestSentAt; + deferredAt = -1; + } + } + void originatorProcessReceivedFrame(Packet *packet, Packet *transmitted) override { + bool delba = dynamicPtrCast(transmitted->peekAtFront()) != nullptr; + Hcf::originatorProcessReceivedFrame(packet, transmitted); + if (delba) + delbaCompletion += simTime() - delbaQueuedAt; + } +}; +Define_Module(CompletionCostHcf); +class CompletionCostTest : public cSimpleModule, public cListener { + cModule *sender = nullptr; + cModule *sink = nullptr; + int sent = 0; + int received = 0; + int requests = 0; + int responses = 0; + int delbas = 0; + int drops = 0; + int64_t payloadBytes = 0; + simtime_t managementAirtime; + simtime_t deliveryDelay; + protected: + void initialize() override { + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("subscribe")); + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *value, cObject *details) override { + auto packet = check_and_cast(value); + if (source == sender) { + sent++; + return; + } + if (source == sink) { + received++; + payloadBytes += packet->getByteLength(); + auto creation = packet->peekAtFront()->getTag()->getCreationTime(); + deliveryDelay += simTime() - creation; + return; + } + if (signal == packetDroppedSignal) { + drops++; + return; + } + auto header = packet->peekAtFront(); + if (dynamicPtrCast(header)) + requests++; + if (dynamicPtrCast(header)) + responses++; + if (dynamicPtrCast(header)) + delbas++; + if (dynamicPtrCast(header)) + managementAirtime += packet->getTag()->getMode()->getDuration(packet->getDataLength()); + } + void handleMessage(cMessage *message) override { + if (message->isName("subscribe")) { + delete message; + sender = getModuleByPath("^.host1.app[0]"); + sink = getModuleByPath("^.host2.app[0]"); + sender->subscribe(packetSentSignal, this); + sink->subscribe(packetReceivedSignal, this); + for (const char *path : {"^.host1.wlan[0].mac.hcf", "^.host2.wlan[0].mac.hcf"}) { + getModuleByPath(path)->subscribe(packetSentToPeerSignal, this); + getModuleByPath(path)->subscribe(packetDroppedSignal, this); + } + scheduleAt(SimTime(99, SIMTIME_MS), new cMessage("verify")); + return; + } + delete message; + auto hcf = check_and_cast(getModuleByPath("^.host1.wlan[0].mac.hcf")); + std::cout << "Completion cost: gaps=" << par("gaps").boolValue() << " sent=" << sent + << " received=" << received << " bytes=" << payloadBytes << " requests=" << requests + << " responses=" << responses << " delbas=" << delbas << " drops=" << drops + << " managementAirtime=" << managementAirtime << " deferral=" << hcf->deferral + << " requestContention=" << hcf->requestContention << " responseAfterRequest=" << hcf->responseAfterRequest + << " delbaCompletion=" << hcf->delbaCompletion << " deliveryDelaySum=" << deliveryDelay + << " goodputBps=" << payloadBytes * 8 / 0.1 << "\n"; + ASSERT(sent == 12 && received == 12 && payloadBytes == 8400 && drops == 0); + ASSERT(requests == (par("gaps").boolValue() ? 3 : 1)); + ASSERT(responses == requests && delbas == requests); + std::cout << "Block Ack completion cost assertions passed.\n"; + endSimulation(); + } +}; +Define_Module(CompletionCostTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.AdhocHost; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module CompletionCostHcf extends Hcf { parameters: @class(::inet::ieee80211::CompletionCostHcf); } +simple CompletionCostTest { parameters: bool gaps; @class(::inet::ieee80211::CompletionCostTest); } +network CompletionCostNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: Ieee80211ScalarRadioMedium; + host1: AdhocHost; + host2: AdhocHost; + test: CompletionCostTest; +} + +%inifile: omnetpp.ini +[General] +network = CompletionCostNetwork +ned-path = .;../../../../src +sim-time-limit = 100ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.test.gaps = ${gaps=false,true} +*.host1.numApps = 1 +*.host1.app[0].typename = "UdpBasicBurst" +*.host1.app[0].destAddresses = "host2" +*.host1.app[0].destPort = 1000 +*.host1.app[0].messageLength = 700B +*.host1.app[0].chooseDestAddrMode = "once" +*.host1.app[0].startTime = 10ms +*.host1.app[0].stopTime = ${gaps} ? 52ms : 11.15ms +*.host1.app[0].sendInterval = 100us +*.host1.app[0].burstDuration = ${gaps} ? 350us : 0s +*.host1.app[0].sleepDuration = ${gaps} ? 20ms : 0s +*.host2.numApps = 1 +*.host2.app[0].typename = "UdpSink" +*.host2.app[0].localPort = 1000 +*.host*.ipv4.arp.typename = "GlobalArp" +*.host*.wlan[*].opMode = "a" +*.host*.wlan[*].bitrate = 6Mbps +*.host*.wlan[*].classifier.typename = "QosClassifier" +*.host*.wlan[*].mac.qosStation = true +*.host*.wlan[*].mac.hcf.typename = "CompletionCostHcf" +*.host*.wlan[*].mac.hcf.isBlockAckSupported = true +*.host*.wlan[*].mac.hcf.blockAckVariant = "basic" +**.originatorMacDataService.msduAggregationPolicy.typename = "" +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 2346B +*.host*.wlan[*].radio.receiver.energyDetection = -105dBm +*.host*.wlan[*].radio.receiver.sensitivity = -105dBm +*.host*.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.host1.mobility.initialX = 0m +*.host2.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Block Ack completion cost assertions passed. diff --git a/tests/module/Ieee80211BlockAckDeferral_1.test b/tests/module/Ieee80211BlockAckDeferral_1.test index 89da8e14084..58f6614bc96 100644 --- a/tests/module/Ieee80211BlockAckDeferral_1.test +++ b/tests/module/Ieee80211BlockAckDeferral_1.test @@ -29,6 +29,8 @@ class DeferralHcf : public Hcf { int dataVoice = 0; int dataVideo = 0; int dataAfterRequest = 0; + int dataWithAgreement = 0; + int dataAfterDelba = 0; int aggregatesAccepted = 0; int requestStart = -1; int firstData = -1; @@ -118,6 +120,12 @@ class DeferralHcf : public Hcf { if (data->getTid() == 6) dataVoice++; if (data->getTid() == 5) dataVideo++; if (requestStart >= 0 && data->getTid() == 6) { + if (hasAgreement(6)) + dataWithAgreement++; + if (delbas > 0 && !hasAgreement(6)) { + ASSERT(data->getAckPolicy() == NORMAL_ACK); + dataAfterDelba++; + } if (firstData < 0) firstData = data->getSequenceNumber().get(); dataAfterRequest++; } @@ -203,7 +211,7 @@ class DeferralTest : public cSimpleModule, public cListener { << ", aggregates=" << sender->aggregatesAccepted << ", request start=" << sender->requestStart << ", first DATA=" << sender->firstData << ".\n"; ASSERT(deferredBeforeExtraction); - ASSERT(sender->requests == 1 && sender->hasAgreement(6)); + ASSERT(sender->requests == 1 && !sender->hasAgreement(6) && sender->delbas == 1); ASSERT(sender->requestStart == 1 && sender->firstData == sender->requestStart); ASSERT(sender->dataAfterRequest == 1); ASSERT(sender->aggregatesAccepted == (scenario == 11 ? 2 : 0)); @@ -249,10 +257,16 @@ class DeferralTest : public cSimpleModule, public cListener { wait(SimTime(560, SIMTIME_MS) - simTime()); ASSERT(sender->rtsFailures >= 1); ASSERT(sender->firstRtsSequence == sender->requestStart); - ASSERT(sender->dataAfterRequest == 0 && sender->firstData == -1); + ASSERT(sender->dataWithAgreement == 0); + if (scenario == 8) { + ASSERT(sender->dataAfterRequest == 1 && sender->dataAfterDelba == 1); + ASSERT(sender->firstData == (sender->requestStart + 1) % 4096); + } + else + ASSERT(sender->dataAfterRequest == 0 && sender->firstData == -1); ASSERT(!sender->hasAgreement(6)); ASSERT(sender->delbas == 1); - ASSERT(lifetimeDrops == (scenario == 9 ? 1 : 0)); + ASSERT(lifetimeDrops == (scenario == 9 ? 2 : 0)); } else if (scenario >= 5) { auto edca = check_and_cast(sender->getSubmodule("edca")); @@ -271,7 +285,8 @@ class DeferralTest : public cSimpleModule, public cListener { accept(sender, 6); } wait(SimTime(513, SIMTIME_MS) - simTime()); - ASSERT(lifetimeDrops == 1 && lifetime->findFrame(deferredId) == nullptr); + // Preview leaves both unsent frames under their original lifetime deadlines. + ASSERT(lifetimeDrops == 2 && lifetime->findFrame(deferredId) == nullptr); if (scenario == 6) ASSERT(sender->delbas == 1 && sender->dataAfterRequest == 0); else { @@ -284,7 +299,7 @@ class DeferralTest : public cSimpleModule, public cListener { << ", response deadline=" << sender->observedDeadline << ", original DATA deadline=0.512.\n"; } else if (scenario == 2) { - ASSERT(sender->dataAfterRequest == 1); + ASSERT(sender->dataAfterRequest == 2); ASSERT(sender->firstData == sender->requestStart); } else { @@ -315,9 +330,12 @@ class DeferralTest : public cSimpleModule, public cListener { ASSERT(!sender->hasAgreement(6)); } else { - ASSERT(sender->delbas == 0); - ASSERT(sender->hasAgreement(6)); - ASSERT(sender->dataAfterRequest == 1); + // The accepted response releases the final DATA before completion causes DELBA. + ASSERT(simTime() < sender->observedDeadline); + ASSERT(sender->delbas == 1); + ASSERT(!sender->hasAgreement(6)); + std::cout << "Completed deferred DATA: " << sender->dataAfterRequest << ".\n"; + ASSERT(sender->dataAfterRequest == 2); ASSERT(sender->firstData == sender->requestStart); } } diff --git a/tests/module/Ieee80211BlockAckFragmentRetirement_1.test b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test index 33429c70e6a..90b92add024 100644 --- a/tests/module/Ieee80211BlockAckFragmentRetirement_1.test +++ b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test @@ -2,7 +2,7 @@ Check the sequence boundary after ordinary originator teardown of fragmented DATA. IEEE Std 802.11-2024, 11.5.3.4 requires the next MPDU to use a later sequence when the originator discards the last transmitted MPDU. -The fixture supplies accepted Basic agreements and injects immediate ACKs. +The fixture supplies accepted Basic agreements and injects immediate ACKs and Basic Block Ack responses. Production fragmentation, inactivity expiry, retirement, and transmission remain active. Runs cover sequence 0 and wraparound at 4095, with expiry during transmission or after the first fragment receives its Normal Ack. @@ -10,6 +10,7 @@ Later intact DATA and an unrelated peer must retain their transmissions. Additional runs transmit an earlier DATA unit before a gap in sequence allocation. The fixture extracts and disposes of the skipped DATA through the production allocator. Distances 2047, 2048, 2049, and 4096 cover the half-range boundary and a full wrap. +A deferred successor keeps the transfer open while the fixture advances the allocator. %extraargs: -r 0..19 @@ -45,6 +46,9 @@ class FragmentRetirementHcf : public Hcf { bool retired = false; bool successorSent = false; bool otherSent = false; + bool otherRetired = false; + Ptr pendingBar; + Packet *deferredSuccessor = nullptr; int delbas = 0; void skipData(int count) { @@ -75,7 +79,7 @@ class FragmentRetirementHcf : public Hcf { scheduleAfter(SimTime(acknowledgedFirst ? 650 : 974, SIMTIME_US), new cMessage("queue-data")); } - void queueData(const char *name, MacAddress address, int length) { + Packet *queueData(const char *name, MacAddress address, int length) { auto header = makeShared(); header->setType(ST_DATA_WITH_QOS); header->addChunkLength(QOSCONTROL_PART_LENGTH); @@ -87,6 +91,7 @@ class FragmentRetirementHcf : public Hcf { packet->insertAtBack(makeShared(B(length))); packet->insertAtBack(makeShared()); processUpperFrame(packet, header); + return packet; } public: @@ -106,9 +111,13 @@ class FragmentRetirementHcf : public Hcf { if (distance == 0) startRetirement(); else { + check_and_cast(originatorDataService)->setEligibility( + [this](Packet *packet) { return !packet->isName("deferred-successor") && isFrameEligible(packet, false); }, + [this](Packet *packet) { return isAMsduPermitted(packet); }); // Force Normal Ack for the earlier DATA, independent of the fragment ACK policy. handler->getAgreement(peer, 5)->setStartingSequenceNumber(SequenceNumberCyclic(start) + 1); queueData("earlier-data", peer, 20); + deferredSuccessor = queueData("deferred-successor", peer, 20); } scheduleAfter(SimTime(10, SIMTIME_MS), new cMessage("verify")); } @@ -119,6 +128,13 @@ class FragmentRetirementHcf : public Hcf { Hcf::receiveSignal(source, signal, object, details); return; } + auto agreement = check_and_cast(object); + if (agreement->getReceiverAddr() == other) { + ASSERT(otherSent); + ASSERT(!hasQueuedData(other, 5) && !hasNumberedData(other, 5)); + otherRetired = true; + return; + } ASSERT(!retired); retired = true; ASSERT(firstCompleted == acknowledgedFirst); @@ -164,6 +180,11 @@ class FragmentRetirementHcf : public Hcf { void transmissionComplete(Packet *packet, const Ptr& header) override { Enter_Method("transmissionComplete"); auto data = dynamicPtrCast(header); + auto bar = dynamicPtrCast(header); + if (bar) { + ASSERT(bar->getReceiverAddress() == other); + pendingBar = bar; + } bool earlier = packet->isName("earlier-data"); bool first = !earlier && data && data->getReceiverAddress() == peer && data->getSequenceNumber() == SequenceNumberCyclic(start); bool ack = dynamicPtrCast(header) || (data && data->getAckPolicy() == NORMAL_ACK); @@ -174,6 +195,8 @@ class FragmentRetirementHcf : public Hcf { Hcf::transmissionComplete(packet, header); if (ack) scheduleAfter(SimTime(20, SIMTIME_US), new cMessage(earlier ? "ack-earlier" : first ? "ack-first" : "ack")); + if (bar) + scheduleAfter(SimTime(20, SIMTIME_US), new cMessage("block-ack")); } void handleMessage(cMessage *message) override { @@ -183,6 +206,24 @@ class FragmentRetirementHcf : public Hcf { queueData("intact-successor", peer, 20); queueData("other-peer", other, 20); } + else if (message->isName("block-ack")) { + delete message; + auto header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + header->setTransmitterAddress(other); + header->setTidInfo(5); + header->setStartingSequenceNumber(pendingBar->getStartingSequenceNumber()); + BitVector bits; + bits.appendBit(true); + for (int i = 1; i < 16; i++) + bits.appendBit(false); + header->setBlockAckBitmap(0, bits); + auto packet = new Packet("block-ack", header); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getMode(bps(24000000))); + pendingBar = nullptr; + processLowerFrame(packet, header); + } else if (message->isName("ack") || message->isName("ack-first") || message->isName("ack-earlier")) { bool first = message->isName("ack-first"); bool earlier = message->isName("ack-earlier"); @@ -196,6 +237,12 @@ class FragmentRetirementHcf : public Hcf { if (first) firstAcknowledged = true; if (earlier) { + auto queue = edca->getEdcaf(AC_VI)->getPendingQueue(); + queue->removePacket(deferredSuccessor); + take(deferredSuccessor); + edca->getLifetimeHandler()->forgetFrame(deferredSuccessor->getId()); + delete deferredSuccessor; + deferredSuccessor = nullptr; skipData(distance - 1); start = (start + distance) % 4096; startRetirement(); @@ -203,9 +250,11 @@ class FragmentRetirementHcf : public Hcf { } else if (message->isName("verify")) { delete message; + std::cout << "Fragment retirement state: retired=" << retired << " firstCompleted=" << firstCompleted + << " successorSent=" << successorSent << " otherSent=" << otherSent << " delbas=" << delbas << "\n"; ASSERT(retired && firstCompleted && successorSent && otherSent); - ASSERT(delbas == 1); - ASSERT(originatorBlockAckAgreementHandler->getAgreement(other, 5) != nullptr); + ASSERT(delbas == 2 && otherRetired); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(other, 5) == nullptr); unsubscribe(blockAckAgreementDeletedSignal, this); std::cout << "Fragment retirement passed: start=" << start << ", acknowledgedFirst=" << acknowledgedFirst << ", distance=" << distance << std::endl; diff --git a/tests/module/Ieee80211BlockAckScheduling_1.test b/tests/module/Ieee80211BlockAckScheduling_1.test new file mode 100644 index 00000000000..3fe472f6f68 --- /dev/null +++ b/tests/module/Ieee80211BlockAckScheduling_1.test @@ -0,0 +1,455 @@ +%description: +Exercise Basic BAR selection and final DELBA through HCF, frame sequences, EDCA, and Tx. +The fixture supplies accepted agreements and injects responses at the HCF receive boundary. +Response events include SIFS and the selected response airtime. +Cases cover short bursts, windows smaller than the threshold, two peers, BAR timeout, +negative bitmap bits, Normal Ack window progress, and late BAR admission. + +%extraargs: -r 0..29 + +%file: Scheduling.cc +#include +#include "inet/common/Simsignals.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class SchedulingRecipientAgreements : public RecipientBlockAckAgreementHandler { + public: + void accept(MacAddress peer) { + auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(0), 64, SIMTIME_ZERO); + agreement->addbaResposneSent(); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + } +}; +class SchedulingRecipient : public Hcf { + public: + std::vector delivered; + bool checkedBitmap = false; + void prepare() { + Enter_Method("prepare"); + delete recipientBlockAckAgreementHandler; + auto agreements = new SchedulingRecipientAgreements(); + recipientBlockAckAgreementHandler = agreements; + agreements->accept(MacAddress("02:00:00:00:00:01")); + subscribe(blockAckAgreementDeletedSignal, this); + } + void receive(Packet *packet) { + Enter_Method("receive"); + auto header = packet->peekAtFront(); + if (auto data = dynamicPtrCast(header)) { + if (data->getSequenceNumber() == SequenceNumberCyclic(0) && data->getFragmentNumber() != 0) { + delete packet; + return; + } + } + auto mode = packet->getTag()->getMode(); + packet->addTagIfAbsent()->setMode(mode); + processLowerFrame(packet, header); + } + bool retired() const { return recipientBlockAckAgreementHandler->getAgreements().empty(); } + protected: + void receiveSignal(cComponent *source, simsignal_t signal, cObject *value, cObject *details) override { + if (signal == blockAckAgreementDeletedSignal) + ASSERT((delivered == std::vector{1, 2})); + else + Hcf::receiveSignal(source, signal, value, details); + } + void sendUp(const std::vector& frames) override { + for (auto frame : frames) { + delivered.push_back(frame->peekAtFront()->getSequenceNumber().get()); + take(frame); + delete frame; + } + } + void transmitControlResponseFrame(Packet *packet, const Ptr& header, + Packet *, const Ptr&) override { + if (auto response = dynamicPtrCast(header)) { + ASSERT(response->getStartingSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(response->getBlockAckBitmap(0).getBit(0)); + ASSERT(!response->getBlockAckBitmap(0).getBit(1)); + if (response->getBlockAckBitmap(1).getBit(0) && response->getBlockAckBitmap(2).getBit(0)) { + checkedBitmap = true; + ASSERT(delivered.empty()); + } + } + delete packet; + } +}; +Define_Module(SchedulingRecipient); +class SchedulingAgreements : public OriginatorBlockAckAgreementHandler { + public: + void accept(MacAddress peer, int size) { + auto request = makeShared(); + request->setReceiverAddress(peer); + request->setTid(5); + request->setStartingSequenceNumber(SequenceNumberCyclic(0)); + request->setBufferSize(size); + request->setBlockAckPolicy(true); + createAgreement(request); + auto agreement = getAgreement(peer, 5); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(SIMTIME_ZERO); + agreement->calculateExpirationTime(); + finishProcedure(peer, 5); + } +}; +class SchedulingHcf : public Hcf { + const MacAddress peer{"02:00:00:00:00:02"}; + const MacAddress other{"02:00:00:00:00:03"}; + int dataCount = 0; + int bars = 0; + int delbas = 0; + int refusedBars = 0; + int retries = 0; + int dataInTxop = 0; + bool responsePending = false; + Ptr pendingBar; + const physicallayer::IIeee80211Mode *pendingResponseMode = nullptr; + bool firstBarWasStandalone = false; + int expired = 0; + int collisions = 0; + SchedulingRecipient *recipient = nullptr; + simtime_t responseEnd; + simtime_t txopDeadline; + int scenario() const { return par("scenario"); } + int burst() const { + switch (scenario()) { + case 0: return 1; + case 1: return 4; + case 2: return 6; + case 3: return 9; + case 4: return 4; + case 5: return 1; + case 6: return 1; + case 7: return 2; + case 9: return 3; + case 10: return 1; + case 11: return 8; + case 12: return 1; + case 13: return 1; + case 14: return 1; + default: return 4; + } + } + int window() const { return scenario() == 2 || scenario() == 7 ? 1 : scenario() == 3 ? 4 : 64; } + public: + void begin() { + Enter_Method("begin"); + delete originatorBlockAckAgreementHandler; + auto agreements = new SchedulingAgreements(); + originatorBlockAckAgreementHandler = agreements; + agreements->accept(peer, window()); + if (scenario() == 9) { + recipient = check_and_cast(getModuleByPath("^.^.^.^.recipient.wlan[0].mac.hcf")); + recipient->prepare(); + subscribe(packetDroppedSignal, this); + } + if (scenario() == 4) + agreements->accept(other, 64); + rx->setContentionBlocked(true); + for (int i = 0; i < burst(); i++) + queueData(peer, scenario() == 9 ? (i == 0 ? 200 : 10) : scenario() == 7 && i == 0 ? 1100 : 100); + if (scenario() == 12 || scenario() == 14) { + auto frames = edca->getEdcaf(AC_VI)->getInProgressFrames(); + auto frame = frames->getFrameToTransmit(); + auto header = frame->removeAtFront(); + header->setAckPolicy(BLOCK_ACK); + frame->insertAtFront(header); + edca->getEdcaf(AC_VI)->getAckHandler()->processTransmittedDataOrMgmtFrame(header); + originatorBlockAckAgreementHandler->getAgreement(peer, 5)->recordTransmittedData( + frame->getTag()->getAllocationIndex()); + dataCount = 1; + queueData(other, 1100, 6); + } + if (scenario() == 4) { + for (int i = 0; i < 8; i++) + queueData(other, 100); + } + rx->setContentionBlocked(false); + scheduleAfter(SimTime(40, SIMTIME_MS), new cMessage("verify")); + } + protected: + void receiveSignal(cComponent *source, simsignal_t signal, cObject *value, cObject *details) override { + if (signal == packetDroppedSignal) { + auto drop = dynamic_cast(details); + if (drop && drop->getReason() == LIFETIME_EXPIRED) + expired++; + if (source == this) + return; + } + Hcf::receiveSignal(source, signal, value, details); + } + void queueData(MacAddress receiver, int length, Tid tid = 5) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTid(tid); + header->setSequenceNumber(SequenceNumberCyclic(77)); + header->setReceiverAddress(receiver); + header->setTransmitterAddress(mac->getAddress()); + header->setAddress3(receiver); + auto packet = new Packet("data", header); + packet->insertAtBack(makeShared(B(length))); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + } + void frameSequenceStarted() override { + dataInTxop = 0; + Hcf::frameSequenceStarted(); + } + void channelGranted(IChannelAccess *access) override { + auto collided = edca->getInternallyCollidedEdcafs(); + if (scenario() == 12 || scenario() == 14) + collisions += collided.size(); + Hcf::channelGranted(access); + if (scenario() == 14 && !collided.empty()) { + auto edcaf = edca->getEdcaf(AC_VI); + ASSERT(edcaf->getCw() == 1); + auto frame = edcaf->getInProgressFrames()->getFrames(0); + bool absent = false; + try { + edcaf->getRecoveryProcedure()->getRetryCount(frame, frame->peekAtFront()); + } + catch (const cRuntimeError& error) { + absent = std::string(error.what()).find("retry counter entry doesn't exist") != std::string::npos; + } + ASSERT(absent); + } + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + auto header = packet->peekAtFront(); + auto bar = dynamicPtrCast(header); + if (bar) { + auto frames = edca->getChannelOwner()->getInProgressFrames(); + auto candidate = frames->peekFrameToTransmit(); + if (candidate && !frames->containsFrame(candidate)) { + auto sequence = candidate->peekAtFront()->getSequenceNumber(); + auto size = frames->getLength(); + ASSERT(frames->peekFrameToTransmit() == candidate); + ASSERT(frames->getLength() == size); + ASSERT(candidate->peekAtFront()->getSequenceNumber() == sequence); + } + } + bool accepted = Hcf::transmitFrame(packet, ifs); + if (bar && !accepted) { + refusedBars++; + return false; + } + if (!accepted) + return false; + header = packet->peekAtFront(); + if (auto data = dynamicPtrCast(header)) { + auto txop = edca->getChannelOwner()->getTxopProcedure(); + if (!par("multiple").boolValue() && txop->getLimit() == 0 && data->getAckPolicy() == BLOCK_ACK) + ASSERT(data->getDurationField() == SIMTIME_ZERO); + if (!par("multiple").boolValue() && scenario() == 3) { + ASSERT(dataInTxop == 0); + ASSERT(data->getDurationField() == SIMTIME_ZERO); + } + if (scenario() == 4 && data->getReceiverAddress() == other) + ASSERT(bars >= 1); + auto agreement = originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()); + if ((scenario() == 12 || scenario() == 14) && data->getTid() == 6) + ASSERT(!data->getRetry()); + else + ASSERT(agreement != nullptr && agreement->containsSequence(data->getSequenceNumber())); + if (scenario() != 7 && data->getSequenceNumber().get() >= window() && data->getReceiverAddress() == peer) + ASSERT(bars >= 1); + if (data->getRetry()) + retries++; + dataCount++; + dataInTxop++; + } + if (bar) { + bars++; + if (bars == 1) { + firstBarWasStandalone = dataInTxop == 0; + ASSERT(bar->getReceiverAddress() == peer); + ASSERT(bar->getTidInfo() == 5); + if (scenario() != 9) + ASSERT(dataCount == (scenario() == 2 ? 1 : scenario() == 3 ? 4 : scenario() == 7 || scenario() == 12 || scenario() == 14 ? 2 : scenario() == 11 ? 5 : burst())); + } + auto mode = packet->getTag()->getMode(); + auto responseMode = rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT); + auto cost = mode->getDuration(packet->getDataLength()) + modeSet->getSifsTime() + responseMode->getDuration(LENGTH_BASIC_BLOCKACK); + auto txop = edca->getChannelOwner()->getTxopProcedure(); + auto end = simTime() + ifs + cost; + if (dataInTxop > 1 && txop->getLimit() > 0) + ASSERT(end <= txop->getStart() + txop->getLimit()); + std::cout << "BAR timing: scenario=" << scenario() << " multiple=" << par("multiple").boolValue() + << " start=" << simTime() << " ifs=" << ifs << " bytes=" << packet->getByteLength() + << " rate=" << mode->getDataMode()->getNetBitrate() << " responseRate=" << responseMode->getDataMode()->getNetBitrate() + << " response=" << responseMode->getDuration(LENGTH_BASIC_BLOCKACK) << " end=" << end + << " deadline=" << txop->getStart() + txop->getLimit() << " data=" << dataInTxop << "\n"; + } + if (auto delba = dynamicPtrCast(header)) { + ASSERT(delba->getInitiator()); + ASSERT(!hasQueuedData(delba->getReceiverAddress(), delba->getTid())); + ASSERT(!hasNumberedData(delba->getReceiverAddress(), delba->getTid())); + delbas++; + } + return true; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + Enter_Method("transmissionComplete"); + auto bar = dynamicPtrCast(header); + auto data = dynamicPtrCast(header); + if (recipient && (data || bar || dynamicPtrCast(header))) + recipient->receive(packet->dup()); + bool ack = dynamicPtrCast(header) || (data && data->getAckPolicy() == NORMAL_ACK); + if (bar || ack) { + if (!(bar && scenario() == 5 && bars == 1)) { + pendingBar = bar; + responsePending = true; + pendingResponseMode = bar ? + rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT) : + rateSelection->computeResponseAckFrameMode(packet, dynamicPtrCast(header), ResponseQueryRole::PREDICT); + auto duration = pendingResponseMode->getDuration(bar ? LENGTH_BASIC_BLOCKACK : LENGTH_ACK); + responseEnd = simTime() + modeSet->getSifsTime() + duration; + txopDeadline = edca->getChannelOwner()->getTxopProcedure()->getStart() + edca->getChannelOwner()->getTxopProcedure()->getLimit(); + scheduleAt(responseEnd, new cMessage("response")); + } + } + Hcf::transmissionComplete(packet, header); + } + bool isReceptionInProgress() override { return responsePending || Hcf::isReceptionInProgress(); } + void handleMessage(cMessage *message) override { + if (message->isName("response")) { + delete message; + responsePending = false; + Ptr header; + if (pendingBar) { + auto response = makeShared(); + response->setTransmitterAddress(pendingBar->getReceiverAddress()); + response->setTidInfo(pendingBar->getTidInfo()); + response->setStartingSequenceNumber(pendingBar->getStartingSequenceNumber()); + for (int i = 0; i < 64; i++) { + BitVector bits; + for (int j = 0; j < 16; j++) + bits.appendBit(scenario() == 9 ? (i != 0 || j == 0) : !(scenario() == 6 && bars == 1)); + response->setBlockAckBitmap(i, bits); + } + header = response; + } + else + header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + auto packet = new Packet("response", header); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(pendingResponseMode); + pendingBar = nullptr; + processLowerFrame(packet, header); + } + else if (message->isName("verify")) { + delete message; + std::cout << "Scheduling totals: data=" << dataCount << " bars=" << bars << " delbas=" << delbas << " refused=" << refusedBars << "\n"; + ASSERT(bars > 0); + ASSERT(delbas == (scenario() == 4 ? 2 : 1)); + if (scenario() != 9) + ASSERT(dataCount == burst() + (scenario() == 4 ? 8 : scenario() == 5 || scenario() == 6 || scenario() == 12 || scenario() == 14 ? 1 : 0)); + else { + ASSERT(recipient->checkedBitmap && recipient->retired()); + ASSERT((recipient->delivered == std::vector{1, 2})); + ASSERT(dataCount > 3); + ASSERT(expired > 0); + } + ASSERT(originatorBlockAckAgreementHandler->getAgreements().empty()); + ASSERT(originatorBlockAckAgreementHandler->getProcedures().empty()); + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 0); + ASSERT(!frameSequenceHandler->isSequenceRunning()); + if (scenario() == 5 || scenario() == 6) + ASSERT(retries == 1 && bars == 2); + if (scenario() == 8 || scenario() == 10 || scenario() == 13) + ASSERT(firstBarWasStandalone); + if (scenario() == 12 || scenario() == 14) + ASSERT(collisions == 1 && retries == 0); + std::cout << "Block Ack scheduling assertions passed.\n"; + endSimulation(); + } + else + Hcf::handleMessage(message); + } +}; +Define_Module(SchedulingHcf); +class SchedulingTest : public cSimpleModule { + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("begin")); } + void handleMessage(cMessage *message) override { + delete message; + check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf"))->begin(); + } +}; +Define_Module(SchedulingTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module SchedulingHcf extends Hcf { parameters: int scenario; bool multiple; @class(::inet::ieee80211::SchedulingHcf); } +module SchedulingRecipient extends Hcf { parameters: @class(::inet::ieee80211::SchedulingRecipient); } +simple SchedulingTest { parameters: @class(::inet::ieee80211::SchedulingTest); } +network SchedulingNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + recipient: WirelessHost; + test: SchedulingTest; +} + +%inifile: omnetpp.ini +[General] +network = SchedulingNetwork +ned-path = .;../../../../src +sim-time-limit = 50ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "a" +**.wlan[*].bitrate = 6Mbps +*.host.wlan[*].address = "02:00:00:00:00:01" +*.recipient.wlan[*].address = "02:00:00:00:00:02" +**.wlan[*].mac.qosStation = true +*.recipient.wlan[*].mac.hcf.typename = "SchedulingRecipient" +*.host.wlan[*].mac.hcf.typename = "SchedulingHcf" +**.wlan[*].mac.hcf.scenario = ${scenario=0..14} +**.wlan[*].mac.hcf.multiple = ${multiple=false,true} +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.originatorAckPolicy.ackTimeout = 1ms +**.wlan[*].mac.hcf.originatorAckPolicy.blockAckTimeout = 1ms +**.wlan[*].mac.hcf.rtsPolicy.rtsThreshold = 2346B +**.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +**.wlan[*].mac.hcf.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = ${scenario} == 9 ? 128B : 2346B +**.wlan[*].mac.hcf.edca.edcaf[*].msduLifetime = ${scenario} == 9 ? 10ms : 512ms +**.wlan[*].mac.hcf.edca.edcaf[*].cwMin = ${scenario} == 12 || ${scenario} == 14 ? 0 : -1 +**.wlan[*].mac.hcf.edca.edcaf[2].cwMax = ${scenario} == 14 ? 3 : ${scenario} == 12 ? 0 : -1 +**.wlan[*].mac.hcf.edca.edcaf[2].recoveryProcedure.shortRetryLimit = ${scenario} == 14 ? 1 : 7 +**.wlan[*].mac.hcf.edca.edcaf[*].cwMax = ${scenario} == 12 || ${scenario} == 14 ? 0 : -1 +**.wlan[*].mac.hcf.edca.edcaf[*].txopProcedure.protectionMechanism = ${multiple} ? "multiple" : "single" +**.wlan[*].mac.hcf.edca.edcaf[2].txopProcedure.txopLimit = ${scenario} == 8 ? 900us : ${scenario} == 10 ? 0s : ${scenario} == 11 ? 1160us : ${scenario} == 13 ? 50us : 10ms +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 2000000m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.recipient.mobility.initialX = 1000000m +*.host.mobility.initialX = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Block Ack scheduling assertions passed. diff --git a/tests/module/Ieee80211HcfHeader_1.test b/tests/module/Ieee80211HcfHeader_1.test index 81703858adf..595c2b1b6b7 100644 --- a/tests/module/Ieee80211HcfHeader_1.test +++ b/tests/module/Ieee80211HcfHeader_1.test @@ -20,7 +20,7 @@ class HeaderAckPolicy : public OriginatorQosAckPolicy { selections++; return BLOCK_ACK; } - bool isBlockAckReqNeeded(InProgressFrames *, TxopProcedure *) const override { return false; } + bool isBlockAckReqNeeded(InProgressFrames *, TxopProcedure *, IOriginatorBlockAckAgreementHandler *) const override { return false; } }; Define_Module(HeaderAckPolicy); class HeaderAgreementHandler : public OriginatorBlockAckAgreementHandler { diff --git a/tests/module/Ieee80211HcfMultipleProtection_2.test b/tests/module/Ieee80211HcfMultipleProtection_2.test index 748c19d83ef..1d278478756 100644 --- a/tests/module/Ieee80211HcfMultipleProtection_2.test +++ b/tests/module/Ieee80211HcfMultipleProtection_2.test @@ -116,6 +116,7 @@ Define_Module(RateProtectionMac); class RateProtectionHcf : public Hcf { public: int acknowledgments = 0; + int managementAcknowledgments = 0; int blockAcks = 0; int failures = 0; void seedOriginator() { @@ -168,7 +169,12 @@ class RateProtectionHcf : public Hcf { } void originatorProcessReceivedFrame(Packet *packet, Packet *request) override { auto type = packet->peekAtFront()->getType(); - if (type == ST_ACK) acknowledgments++; + if (type == ST_ACK) { + if (dynamicPtrCast(request->peekAtFront())) + acknowledgments++; + else + managementAcknowledgments++; + } if (type == ST_BLOCKACK) blockAcks++; Hcf::originatorProcessReceivedFrame(packet, request); } @@ -208,12 +214,13 @@ class RateProtectionTest : public cSimpleModule { else { sender->inject(66, scenario == 6); if (scenario == 0 || scenario == 1) - sender->inject(); // The existing BAR branch needs a next selected frame. + sender->inject(); } wait(SimTime(5, SIMTIME_MS)); if (scenario == 0 || scenario == 1) { ASSERT(sender->blockAcks >= 1); ASSERT(sender->acknowledgments == 0); + ASSERT(sender->managementAcknowledgments == 1); ASSERT(std::find(senderMac->types.begin(), senderMac->types.end(), ST_BLOCKACK_REQ) != senderMac->types.end()); ASSERT(receiverMac->types[0] == ST_CTS); auto firstRtsEndpoint = senderMac->ends[0] + senderMac->durations[0]; diff --git a/tests/unit/Ieee80211BlockAckScheduling_1.test b/tests/unit/Ieee80211BlockAckScheduling_1.test new file mode 100644 index 00000000000..c0fd4049ab9 --- /dev/null +++ b/tests/unit/Ieee80211BlockAckScheduling_1.test @@ -0,0 +1,153 @@ +%description: +Check peer/TID BAR arbitration, window boundaries, cyclic sequence order, and ACK-state isolation. +The production policy reads the production ACK handler through an in-progress queue. +These helper checks supplement the HCF module fixture. + +%includes: +#include +#include +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h" +#include "inet/linklayer/ieee80211/mac/originator/QosAckHandler.h" +#include "inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +using namespace inet; +using namespace inet::ieee80211; + +namespace Ieee80211BlockAckScheduling_1 { +template struct ImplicitBarQuery : std::false_type {}; +template struct ImplicitBarQuery().isBlockAckReqNeeded(nullptr, nullptr))>> : std::true_type {}; +template struct ImplicitBarParameters : std::false_type {}; +template struct ImplicitBarParameters().computeBlockAckReqParameters(nullptr, nullptr))>> : std::true_type {}; +template struct ImplicitBarWindow : std::false_type {}; +template struct ImplicitBarWindow().processTransmittedBlockAckReq(std::declval>()))>> : std::true_type {}; + +static_assert(!ImplicitBarQuery::value, "The interface requires an explicit agreement handler"); +static_assert(!ImplicitBarQuery::value, "The concrete policy requires an explicit agreement handler"); +static_assert(!ImplicitBarParameters::value, "The interface requires an explicit agreement handler"); +static_assert(!ImplicitBarParameters::value, "The concrete policy requires an explicit agreement handler"); +static_assert(!ImplicitBarWindow::value, "The ACK handler requires an explicit agreement window"); + +class SchedulingCw : public IRecoveryProcedure::ICwCalculator { + public: + int cw = 0; + void incrementCw() override { cw = std::min(7, 2 * cw + 1); } + void resetCw() override { cw = 0; } + int getCw() override { return cw; } +}; +class SchedulingRecovery : public QosRecoveryProcedure { + public: + void configure(ICwCalculator *calculator) { cwCalculator = calculator; shortRetryLimit = 1; } + int getStationSrc() const { return stationShortRetryCounter; } + bool hasDataRetry() const { return !shortRetryCounter.empty() || !longRetryCounter.empty(); } +}; +class SchedulingPolicy : public OriginatorQosAckPolicy { + public: + SchedulingPolicy() { blockAckReqThreshold = 5; } +}; +class SchedulingAgreements : public OriginatorBlockAckAgreementHandler { + public: + OriginatorBlockAckAgreement *accept(MacAddress peer, Tid tid, int start, int size) { + auto agreement = new OriginatorBlockAckAgreement(peer, tid, SequenceNumberCyclic(start), size, false, false); + agreement->setIsAddbaResponseReceived(true); + blockAckAgreements[{peer, tid}] = agreement; + return agreement; + } +}; +class SchedulingFrames : public InProgressFrames { + public: + Packet *candidate = nullptr; + void configure(QosAckHandler *handler) { ackHandler = handler; } + Packet *peekFrameToTransmit() override { return candidate; } + Ptr add(MacAddress peer, Tid tid, int sequence, bool sent = true) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->setReceiverAddress(peer); + header->setTid(tid); + header->setSequenceNumber(SequenceNumberCyclic(sequence)); + header->setAckPolicy(BLOCK_ACK); + auto packet = new Packet("data", header); + take(packet); + packet->setArrivalTime(simTime()); + inProgressFrames.push_back(packet); + ackHandler->frameGotInProgress(header); + if (sent) + check_and_cast(ackHandler)->processTransmittedDataOrMgmtFrame(header); + return header; + } +}; +} + +%activity: +SchedulingCw cw; +SchedulingRecovery recovery; +recovery.configure(&cw); +recovery.controlFrameTransmissionFailed(); +ASSERT(recovery.getStationSrc() == 1 && cw.getCw() == 1); +recovery.controlFrameTransmissionFailed(); +ASSERT(recovery.getStationSrc() == 0 && cw.getCw() == 0); +recovery.controlFrameTransmissionFailed(); +recovery.blockAckFrameReceived(); +ASSERT(recovery.getStationSrc() == 0 && cw.getCw() == 0 && !recovery.hasDataRetry()); +const MacAddress peer("02:00:00:00:00:02"); +const MacAddress other("02:00:00:00:00:03"); +SchedulingPolicy policy; +SchedulingAgreements agreements; +QosAckHandler ack; +SchedulingFrames frames; +frames.configure(&ack); +agreements.accept(peer, 2, 100, 8); +auto selectedAgreement = agreements.accept(peer, 5, 4094, 4); +auto otherAgreement = agreements.accept(other, 5, 4094, 4); +std::vector> unrelated; +for (int i = 100; i < 104; i++) + unrelated.push_back(frames.add(peer, 2, i)); +auto selected = frames.add(peer, 5, 4095); +auto wrap = frames.add(peer, 5, 0); +auto outside = frames.add(peer, 5, 2); +auto separatePeer = frames.add(other, 5, 4095); +// A candidate inside TID 2 defers only that group. +frames.add(peer, 2, 104, false); +frames.candidate = frames.getFrames(frames.getLength() - 1); +ASSERT(!policy.isBlockAckReqNeeded(&frames, nullptr, nullptr)); +ASSERT(std::get<2>(policy.computeBlockAckReqParameters(&frames, nullptr, nullptr)) == -1); +auto choice = policy.computeBlockAckReqParameters(&frames, nullptr, &agreements); +ASSERT(std::get<0>(choice) == peer && std::get<2>(choice) == 5); +ASSERT(std::get<1>(choice) == SequenceNumberCyclic(4095)); +ASSERT(selectedAgreement->containsSequence(SequenceNumberCyclic(1))); +ASSERT(!selectedAgreement->containsSequence(SequenceNumberCyclic(2))); +auto bar = makeShared(); +bar->setReceiverAddress(peer); +bar->setTidInfo(5); +bar->setStartingSequenceNumber(SequenceNumberCyclic(4095)); +ack.processTransmittedBlockAckReq(bar, selectedAgreement); +ASSERT(ack.getQoSDataAckStatus(selected) == QosAckHandler::Status::WAITING_FOR_BLOCK_ACK); +ASSERT(ack.getQoSDataAckStatus(wrap) == QosAckHandler::Status::WAITING_FOR_BLOCK_ACK); +for (auto header : unrelated) + ASSERT(ack.getQoSDataAckStatus(header) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); +ASSERT(ack.getQoSDataAckStatus(outside) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); +ASSERT(ack.getQoSDataAckStatus(separatePeer) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); +ack.processFailedBlockAckReq(bar); +ASSERT(ack.isEligibleToTransmit(selected)); +ASSERT(ack.isEligibleToTransmit(wrap)); +ASSERT(ack.getQoSDataAckStatus(separatePeer) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); +frames.candidate = nullptr; +choice = policy.computeBlockAckReqParameters(&frames, nullptr, &agreements); +ASSERT(std::get<0>(choice) == peer && std::get<2>(choice) == 2); +ASSERT(std::get<1>(choice) == SequenceNumberCyclic(100)); +ASSERT(otherAgreement->getStartingSequenceNumber() == SequenceNumberCyclic(4094)); +auto duration = SimTime(1, SIMTIME_US); +EdcaTransmitLifetimeHandler lifetime(duration, duration, duration, duration); +frames.setLifetimeHandler(&lifetime); +for (int i = 0; i < frames.getLength(); i++) + lifetime.registerFrame(frames.getFrames(i), AC_VI); +ASSERT(policy.isBlockAckReqNeeded(&frames, nullptr, &agreements)); +wait(duration); +ASSERT(!policy.isBlockAckReqNeeded(&frames, nullptr, &agreements)); +ASSERT(ack.getQoSDataAckStatus(unrelated.front()) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); +std::cout << "Block Ack scheduling isolation assertions passed.\n"; + +%contains: stdout +Block Ack scheduling isolation assertions passed. diff --git a/tests/unit/Ieee80211MultipleProtection_1.test b/tests/unit/Ieee80211MultipleProtection_1.test index 1867858da01..d777b2e0e56 100644 --- a/tests/unit/Ieee80211MultipleProtection_1.test +++ b/tests/unit/Ieee80211MultipleProtection_1.test @@ -39,11 +39,12 @@ class PredicateFrames : public InProgressFrames { int reads = 0; bool hasInProgressFrames() override { return true; } Packet *getFrameToTransmit() override { reads++; return selected; } + Packet *peekFrameToTransmit() override { reads++; return selected; } }; class PredicateAckPolicy : public OriginatorQosAckPolicy { public: bool bar = false; - bool isBlockAckReqNeeded(InProgressFrames *, TxopProcedure *) const override { return bar; } + bool isBlockAckReqNeeded(InProgressFrames *, TxopProcedure *, IOriginatorBlockAckAgreementHandler *) const override { return bar; } }; class PredicateRtsPolicy : public IRtsPolicy { public: From b2a1bd06c74d54306b51b17392350a7aafae1aee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:47:24 +0200 Subject: [PATCH 07/41] ieee80211: refactor: centralize originator window operations Before this commit, HCF calculates window advancement, while ACK callers repeat modulo-4096 distance calculations. Their results are correct, but separate definitions make later maintenance harder. After this commit, OriginatorBlockAckAgreement owns sequence distance, bitmap membership, and window advancement. HCF supplies unresolved sequence numbers for the same peer and TID. ACK policy and feedback use the shared operations. Existing virtual window accessors remain in the advancement path. For example, a window at 4094 advances to unresolved sequence 4095 and next to sequence 0 after resolution. With no unresolved DATA, it advances to the next allocation. Boundary tests also check the distinct 64-position bitmap range. Packet behavior, ownership, event order, and recorded expectations remain unchanged. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | refactor | test | ieee80211-compressed-blockack-replacement --- .../blockack/OriginatorBlockAckAgreement.h | 22 ++++++++++++++++++- .../ieee80211/mac/coordinationfunction/Hcf.cc | 7 +++--- .../mac/originator/OriginatorQosAckPolicy.cc | 6 ++--- .../ieee80211/mac/originator/QosAckHandler.cc | 4 ++-- tests/unit/Ieee80211BlockAckScheduling_1.test | 11 ++++++++++ 5 files changed, 40 insertions(+), 10 deletions(-) diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h index adc12872b27..c760205173a 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h @@ -8,6 +8,8 @@ #ifndef __INET_ORIGINATORBLOCKACKAGREEMENT_H #define __INET_ORIGINATORBLOCKACKAGREEMENT_H +#include + #include "inet/linklayer/ieee80211/mac/common/SequenceControlField.h" namespace inet { @@ -48,9 +50,27 @@ class INET_API OriginatorBlockAckAgreement : public cObject virtual int getBufferSize() const { return bufferSize; } int getWindowSize() const { return std::min(bufferSize, 64); } + static int computeSequenceDistance(SequenceNumberCyclic start, SequenceNumberCyclic sequence) + { + return (sequence.get() - start.get() + 4096) % 4096; + } bool containsSequence(SequenceNumberCyclic sequence) const { - return (sequence.get() - startingSequenceNumber.get() + 4096) % 4096 < getWindowSize(); + return computeSequenceDistance(startingSequenceNumber, sequence) < getWindowSize(); + } + // The Basic and Compressed bitmaps cover 64 sequence positions, independent of the accepted window size. + static bool isInBitmap(SequenceNumberCyclic sequence, SequenceNumberCyclic bitmapStart) + { + return computeSequenceDistance(bitmapStart, sequence) < 64; + } + // Preserve the earliest unresolved position, or advance to the next allocation when none remains. + void advanceWindow(SequenceNumberCyclic nextSequence, const std::vector& unresolvedSequences) + { + auto start = getStartingSequenceNumber(); + int distance = computeSequenceDistance(start, nextSequence); + for (auto sequence : unresolvedSequences) + distance = std::min(distance, computeSequenceDistance(start, sequence)); + setStartingSequenceNumber(start + distance); } virtual SequenceNumberCyclic getStartingSequenceNumber() { return startingSequenceNumber; } virtual void setStartingSequenceNumber(SequenceNumberCyclic sequenceNumber) { startingSequenceNumber = sequenceNumber; } diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index 7c87cbc0622..e968aabbee7 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -537,20 +537,19 @@ void Hcf::advanceOriginatorWindows() auto agreement = entry.second; if (!agreement->getIsAddbaResponseReceived()) continue; - auto start = agreement->getStartingSequenceNumber(); auto next = service->getNextSequenceNumber(entry.first.first, entry.first.second); - int distance = (next.get() - start.get() + 4096) % 4096; + std::vector unresolvedSequences; for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { auto frames = edca->getEdcaf(static_cast(ac))->getInProgressFrames(); for (int i = 0; i < frames->getLength(); i++) { auto data = dynamicPtrCast(frames->getFrames(i)->peekAtFront()); if (data && data->getType() == ST_DATA_WITH_QOS && data->getReceiverAddress() == entry.first.first && data->getTid() == entry.first.second) - distance = std::min(distance, (data->getSequenceNumber().get() - start.get() + 4096) % 4096); + unresolvedSequences.push_back(data->getSequenceNumber()); } } // IEEE Std 802.11-2024, 10.25.6.7.1: resolved positions permit transmit-window progress. - agreement->setStartingSequenceNumber(start + distance); + agreement->advanceWindow(next, unresolvedSequences); } } diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc index bf624914ed6..dbdfdf50d0b 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc @@ -61,12 +61,12 @@ std::tuple OriginatorQosAckPolicy::comput agreement->containsSequence(frames->getCandidateSequenceNumber(candidate))) continue; auto start = agreement->getStartingSequenceNumber(); - int oldestOffset = 4096; + int oldestOffset = -1; simtime_t arrival = SIMTIME_MAX; for (auto frame : entry.second) { auto sequence = frame->peekAtFront()->getSequenceNumber(); - int offset = (sequence.get() - start.get() + 4096) % 4096; - if (offset < oldestOffset) { + int offset = OriginatorBlockAckAgreement::computeSequenceDistance(start, sequence); + if (oldestOffset == -1 || offset < oldestOffset) { oldestOffset = offset; arrival = frame->getArrivalTime(); } diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc index fbd5c8d624b..c79877d4a72 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc @@ -216,14 +216,14 @@ void QosAckHandler::processTransmittedBlockAckReq(const Ptr(blockAckReq)) { if (basicBlockAckReq->getTidInfo() == tid) { auto startingSeqNum = basicBlockAckReq->getStartingSequenceNumber(); - if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && (sequence.get() - startingSeqNum.get() + 4096) % 4096 < 64) + if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && OriginatorBlockAckAgreement::isInBitmap(sequence, startingSeqNum)) status = Status::WAITING_FOR_BLOCK_ACK; } } else if (auto compressedBlockAckReq = dynamicPtrCast(blockAckReq)) { if (compressedBlockAckReq->getTidInfo() == tid) { auto startingSeqNum = compressedBlockAckReq->getStartingSequenceNumber(); - if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && (sequence.get() - startingSeqNum.get() + 4096) % 4096 < 64 && seqCtrlField.getFragmentNumber() == 0) + if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && OriginatorBlockAckAgreement::isInBitmap(sequence, startingSeqNum) && seqCtrlField.getFragmentNumber() == 0) status = Status::WAITING_FOR_BLOCK_ACK; } } diff --git a/tests/unit/Ieee80211BlockAckScheduling_1.test b/tests/unit/Ieee80211BlockAckScheduling_1.test index c0fd4049ab9..aeb1b29a0f3 100644 --- a/tests/unit/Ieee80211BlockAckScheduling_1.test +++ b/tests/unit/Ieee80211BlockAckScheduling_1.test @@ -93,6 +93,17 @@ recovery.blockAckFrameReceived(); ASSERT(recovery.getStationSrc() == 0 && cw.getCw() == 0 && !recovery.hasDataRetry()); const MacAddress peer("02:00:00:00:00:02"); const MacAddress other("02:00:00:00:00:03"); +OriginatorBlockAckAgreement window(peer, 5, SequenceNumberCyclic(4094), 4, false, false); +window.advanceWindow(SequenceNumberCyclic(2), {SequenceNumberCyclic(0), SequenceNumberCyclic(4095)}); +ASSERT(window.getStartingSequenceNumber() == SequenceNumberCyclic(4095)); +window.advanceWindow(SequenceNumberCyclic(2), {SequenceNumberCyclic(0)}); +ASSERT(window.getStartingSequenceNumber() == SequenceNumberCyclic(0)); +window.advanceWindow(SequenceNumberCyclic(2), {}); +ASSERT(window.getStartingSequenceNumber() == SequenceNumberCyclic(2)); +ASSERT(OriginatorBlockAckAgreement::isInBitmap(SequenceNumberCyclic(62), SequenceNumberCyclic(4095))); +ASSERT(!OriginatorBlockAckAgreement::isInBitmap(SequenceNumberCyclic(63), SequenceNumberCyclic(4095))); +ASSERT(!OriginatorBlockAckAgreement::isInBitmap(SequenceNumberCyclic(4094), SequenceNumberCyclic(4095))); +ASSERT(!window.containsSequence(SequenceNumberCyclic(62))); SchedulingPolicy policy; SchedulingAgreements agreements; QosAckHandler ack; From aff989c34dc834cc80246bb41177a969f62fd995 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:48:05 +0200 Subject: [PATCH 08/41] physicallayer: add: retain copied physical timing evidence Before this commit, interval consumers need retained transmission pointers or new propagation calculations. Cache expiry removes the relevant objects, so later MAC decisions cannot safely use those pointers. After this commit, radio media supply copied transmission endpoints and cached arrival endpoints. A snapshot survives cache expiry without object pointers. The receiver includes the transmission identifier in its local signal-time indication. Later delivery can use that identity to locate the evidence. For example, a recipient can retain arrival endpoints after the medium removes the reception. Const cache queries return absent results without insertion. Missing or identical transmission identities supply no interval evidence. The direct fixture checks copied values and absent states. The shared mechanism supplies no protocol-specific interval decision. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.physicallayer.wireless.common | behavior.add | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 + doc/src/migration-guide/index.rst | 7 + .../common/base/packetlevel/ReceiverBase.cc | 1 + .../MapCommunicationCache.cc | 10 ++ .../MapCommunicationCache.h | 1 + .../ReferenceCommunicationCache.cc | 10 ++ .../ReferenceCommunicationCache.h | 1 + .../VectorCommunicationCache.cc | 14 +- .../VectorCommunicationCache.h | 1 + .../packetlevel/ICommunicationCache.h | 2 + .../contract/packetlevel/IRadioMedium.h | 21 +++ .../common/contract/packetlevel/SignalTag.msg | 1 + .../packetlevel/TransmissionTimingSnapshot.h | 31 ++++ .../wireless/common/medium/RadioMedium.cc | 34 +++++ .../wireless/common/medium/RadioMedium.h | 3 + tests/unit/TransmissionTimingSnapshot_1.test | 138 ++++++++++++++++++ 16 files changed, 278 insertions(+), 1 deletion(-) create mode 100644 src/inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h create mode 100644 tests/unit/TransmissionTimingSnapshot_1.test diff --git a/WHATSNEW b/WHATSNEW index eecb155d1e0..95420dffc08 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -454,6 +454,10 @@ Notable backward incompatible changes are the following: Custom QoS ACK policies must accept the agreement-handler argument in isBlockAckReqNeeded() and computeBlockAckReqParameters(). Custom in-progress queues must preserve the extract argument in getPendingFrameFor(). QoS data services must implement IOriginatorQosMacDataService for candidate preview without extraction. +53. Radio medium timing queries + + Radio media now expose copied transmission endpoints and cached arrival endpoints. Consumers can preserve physical timing evidence after cache expiry without retained transmission pointers or new propagation calculations. Receivers attach the transmission identifier to SignalTimeInd so later frame delivery can identify that evidence. Custom radio media and communication caches must implement the new query methods described in the migration guide. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index a3d5e9cb492..7dc296dc880 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -14,6 +14,13 @@ retransmissions do (``synRetries``). When they run out, the connection raises th ``TCP_E_TIMEOUT_CONN_ESTAB``, as the timer did before, so a subclass that handles this event needs no change. +Radio medium timing queries +-------------------------- + +Custom radio media must implement ``getTransmissionTimingSnapshot()`` and ``computePrecedingSignalGap()``. These queries supply copied physical endpoints from actual transmissions and cached arrivals. Unavailable endpoints produce an absent result. The snapshot must not retain transmission, arrival, or radio pointers. Communication caches must implement the const ``findCachedArrival()`` query without insertion or other mutation. + +``SignalTimeInd`` now carries the medium's transmission identifier. The receiver supplies this local indication when it accepts a transmission. Consumers can associate later frame delivery with the corresponding physical timing evidence. The identifier is local metadata; it adds no transmitted field. + IEEE 802.11 Basic Block Ack extension points ------------------------------------------ diff --git a/src/inet/physicallayer/wireless/common/base/packetlevel/ReceiverBase.cc b/src/inet/physicallayer/wireless/common/base/packetlevel/ReceiverBase.cc index a3c828e2457..e1aceee6450 100644 --- a/src/inet/physicallayer/wireless/common/base/packetlevel/ReceiverBase.cc +++ b/src/inet/physicallayer/wireless/common/base/packetlevel/ReceiverBase.cc @@ -102,6 +102,7 @@ const IReceptionResult *ReceiverBase::computeReceptionResult(const IListening *l auto signalTimeInd = packet->addTagIfAbsent(); signalTimeInd->setStartTime(reception->getStartTime()); signalTimeInd->setEndTime(reception->getEndTime()); + signalTimeInd->setTransmissionId(reception->getTransmission()->getId()); if (snir->getMax() == 0) { auto errorRateInd = packet->addTagIfAbsent(); errorRateInd->setSymbolErrorRate(1); diff --git a/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.cc b/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.cc index b5632d21994..c5032d10a4d 100644 --- a/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.cc +++ b/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.cc @@ -14,6 +14,16 @@ namespace physicallayer { Define_Module(MapCommunicationCache); +const IArrival *MapCommunicationCache::findCachedArrival(const IRadio *receiver, const ITransmission *transmission) const +{ + auto entry = transmissionCache.find(transmission->getId()); + if (entry == transmissionCache.end() || !entry->second.receptionCacheEntries) + return nullptr; + const auto& receptions = *entry->second.receptionCacheEntries; + auto reception = receptions.find(receiver->getId()); + return reception == receptions.end() ? nullptr : reception->second.arrival; +} + MapCommunicationCache::~MapCommunicationCache() { for (auto& it : transmissionCache) diff --git a/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.h b/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.h index e9d9c8fa0e5..8ea9821446c 100644 --- a/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.h +++ b/src/inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.h @@ -47,6 +47,7 @@ class INET_API MapCommunicationCache : public CommunicationCacheBase public: virtual ~MapCommunicationCache(); + virtual const IArrival *findCachedArrival(const IRadio *receiver, const ITransmission *transmission) const override; virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "MapCommunicationCache"; } diff --git a/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.cc b/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.cc index b735ca369e3..2fa4300abc4 100644 --- a/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.cc +++ b/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.cc @@ -14,6 +14,16 @@ namespace physicallayer { Define_Module(ReferenceCommunicationCache); +const IArrival *ReferenceCommunicationCache::findCachedArrival(const IRadio *receiver, const ITransmission *transmission) const +{ + int transmissionIndex = transmission->getId(); + int radioIndex = receiver->getId(); + if (transmissionIndex < 0 || transmissionIndex >= int(transmissionCache.size()) || radioIndex < 0) + return nullptr; + auto receptions = transmissionCache[transmissionIndex].receptionCacheEntries; + return receptions && radioIndex < int(receptions->size()) ? receptions->at(radioIndex).arrival : nullptr; +} + ReferenceCommunicationCache::~ReferenceCommunicationCache() { for (auto& transmissionCacheEntry : transmissionCache) diff --git a/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.h b/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.h index 8c27a6322ad..b4de8fa4887 100644 --- a/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.h +++ b/src/inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.h @@ -42,6 +42,7 @@ class INET_API ReferenceCommunicationCache : public CommunicationCacheBase public: virtual ~ReferenceCommunicationCache(); + virtual const IArrival *findCachedArrival(const IRadio *receiver, const ITransmission *transmission) const override; virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "ReferenceCommunicationCache"; } diff --git a/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.cc b/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.cc index 3351dc55b87..5e2f96da7b2 100644 --- a/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.cc +++ b/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.cc @@ -14,6 +14,17 @@ namespace physicallayer { Define_Module(VectorCommunicationCache); +const IArrival *VectorCommunicationCache::findCachedArrival(const IRadio *receiver, const ITransmission *transmission) const +{ + int transmissionIndex = transmission->getId() - baseTransmissionId; + int radioIndex = receiver->getId() - baseRadioId; + if (baseTransmissionId < 0 || baseRadioId < 0 || transmissionIndex < 0 || + transmissionIndex >= int(transmissionCache.size()) || radioIndex < 0) + return nullptr; + auto receptions = transmissionCache[transmissionIndex].receptionCacheEntries; + return receptions && radioIndex < int(receptions->size()) ? receptions->at(radioIndex).arrival : nullptr; +} + VectorCommunicationCache::~VectorCommunicationCache() { for (auto& transmissionCacheEntry : transmissionCache) @@ -141,7 +152,8 @@ void VectorCommunicationCache::removeTransmission(const ITransmission *transmiss const ITransmission *VectorCommunicationCache::getTransmission(int id) const { - ASSERT(baseTransmissionId != -1); + if (baseTransmissionId == -1) + return nullptr; int transmissionIndex = id - baseTransmissionId; if (0 <= transmissionIndex && transmissionIndex < (int)transmissionCache.size()) return transmissionCache[transmissionIndex].transmission; diff --git a/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.h b/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.h index 3b40aee60bf..3f8e0dbeea0 100644 --- a/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.h +++ b/src/inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.h @@ -60,6 +60,7 @@ class INET_API VectorCommunicationCache : public CommunicationCacheBase public: virtual ~VectorCommunicationCache(); + virtual const IArrival *findCachedArrival(const IRadio *receiver, const ITransmission *transmission) const override; virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "VectorCommunicationCache"; } diff --git a/src/inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h b/src/inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h index 8688c8d06e0..55f2385206c 100644 --- a/src/inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h +++ b/src/inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h @@ -65,6 +65,8 @@ class INET_API ICommunicationCache : public virtual IPrintableObject /** @name Reception Cache */ //@{ virtual const IArrival *getCachedArrival(const IRadio *receiver, const ITransmission *transmission) = 0; + // This lookup returns nullptr for absent state. It allocates no cache entry. + virtual const IArrival *findCachedArrival(const IRadio *receiver, const ITransmission *transmission) const = 0; virtual void setCachedArrival(const IRadio *receiver, const ITransmission *transmission, const IArrival *arrival) = 0; virtual void removeCachedArrival(const IRadio *receiver, const ITransmission *transmission) = 0; diff --git a/src/inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h b/src/inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h index a56ffb5d8af..0a70986456a 100644 --- a/src/inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h +++ b/src/inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h @@ -8,6 +8,8 @@ #ifndef __INET_IRADIOMEDIUM_H #define __INET_IRADIOMEDIUM_H +#include + #include "inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h" #include "inet/common/packet/Packet.h" #include "inet/environment/contract/IMaterial.h" @@ -25,6 +27,7 @@ #include "inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h" namespace inet { namespace physicallayer { @@ -171,6 +174,24 @@ class INET_API IRadioMedium : public virtual IPrintableObject */ virtual const ITransmission *getTransmission(int id) const = 0; + /** + * Copies the physical endpoints of a live transmission without new propagation calculations. + * An absent transmission returns a snapshot with transmissionId equal to -1. + * An absent radio entry means that the medium has no cached arrival for that radio. + * The caller owns the returned value. Later cache removal does not change it. + */ + virtual TransmissionTimingSnapshot getTransmissionTimingSnapshot(int id) const = 0; + + /** + * Returns the interval before the current transmission at its transmitter. + * For the same transmitter, the interval starts at the previous transmission end. + * For different transmitters, it starts at the previous signal arrival end at the current transmitter. + * Missing current transmission or arrival data returns no value. + * The method uses the supplied snapshot and changes no cache or propagation state. + */ + virtual std::optional computePrecedingSignalGap(int currentTransmissionId, + const TransmissionTimingSnapshot& preceding) const = 0; + /** * Returns the listening decision that describes what the receiver detects * on the medium. diff --git a/src/inet/physicallayer/wireless/common/contract/packetlevel/SignalTag.msg b/src/inet/physicallayer/wireless/common/contract/packetlevel/SignalTag.msg index abca21a254b..cf9802507b8 100644 --- a/src/inet/physicallayer/wireless/common/contract/packetlevel/SignalTag.msg +++ b/src/inet/physicallayer/wireless/common/contract/packetlevel/SignalTag.msg @@ -126,4 +126,5 @@ class SignalTimeInd extends SignalTagBase { simtime_t startTime; simtime_t endTime; + int transmissionId = -1; // Medium transmission identity; -1 means unavailable. } diff --git a/src/inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h b/src/inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h new file mode 100644 index 00000000000..312e9bc7476 --- /dev/null +++ b/src/inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_TRANSMISSIONTIMINGSNAPSHOT_H +#define __INET_TRANSMISSIONTIMINGSNAPSHOT_H + +#include + +#include "inet/common/INETDefs.h" + +namespace inet { +namespace physicallayer { + +/** + * This value copies the physical endpoints of one transmission from the medium cache. + * The endpoints retain the propagation result that the medium used for each radio. + * No packet, transmission, arrival, or radio pointer remains in this value. + * A transmissionId of -1 means that the medium no longer has the transmission. + */ +struct INET_API TransmissionTimingSnapshot +{ + int transmissionId = -1; + int transmitterRadioId = -1; + simtime_t startTime = -1; // First transmitted bit, in seconds. + simtime_t endTime = -1; // Last transmitted bit, in seconds. + std::map arrivalEndTimes; // Radio ID to last received bit, in seconds. +}; + +} // namespace physicallayer +} // namespace inet + +#endif diff --git a/src/inet/physicallayer/wireless/common/medium/RadioMedium.cc b/src/inet/physicallayer/wireless/common/medium/RadioMedium.cc index 1366587e9fb..48fe60a49d6 100644 --- a/src/inet/physicallayer/wireless/common/medium/RadioMedium.cc +++ b/src/inet/physicallayer/wireless/common/medium/RadioMedium.cc @@ -656,6 +656,40 @@ const ITransmission *RadioMedium::getTransmission(int id) const return communicationCache->getTransmission(id); } +TransmissionTimingSnapshot RadioMedium::getTransmissionTimingSnapshot(int id) const +{ + TransmissionTimingSnapshot snapshot; + auto transmission = communicationCache->getTransmission(id); + if (!transmission) + return snapshot; + snapshot.transmissionId = transmission->getId(); + snapshot.transmitterRadioId = transmission->getTransmitterRadioId(); + snapshot.startTime = transmission->getStartTime(); + snapshot.endTime = transmission->getEndTime(); + communicationCache->mapRadios([&](const IRadio *radio) { + if (!radio || !radio->getReceiver() || radio->getId() == snapshot.transmitterRadioId) + return; + auto arrival = communicationCache->findCachedArrival(radio, transmission); + if (arrival) + snapshot.arrivalEndTimes[radio->getId()] = arrival->getEndTime(); + }); + return snapshot; +} + +std::optional RadioMedium::computePrecedingSignalGap(int currentTransmissionId, + const TransmissionTimingSnapshot& preceding) const +{ + auto current = communicationCache->getTransmission(currentTransmissionId); + if (!current || preceding.transmissionId < 0 || preceding.transmissionId == currentTransmissionId) + return std::nullopt; + if (current->getTransmitterRadioId() == preceding.transmitterRadioId) + return current->getStartTime() - preceding.endTime; + auto arrival = preceding.arrivalEndTimes.find(current->getTransmitterRadioId()); + if (arrival == preceding.arrivalEndTimes.end()) + return std::nullopt; + return current->getStartTime() - arrival->second; +} + const IListeningDecision *RadioMedium::listenOnMedium(const IRadio *radio, const IListening *listening) const { Enter_Method("listenOnMedium"); diff --git a/src/inet/physicallayer/wireless/common/medium/RadioMedium.h b/src/inet/physicallayer/wireless/common/medium/RadioMedium.h index 3952b247ddd..659b86c067e 100644 --- a/src/inet/physicallayer/wireless/common/medium/RadioMedium.h +++ b/src/inet/physicallayer/wireless/common/medium/RadioMedium.h @@ -337,6 +337,9 @@ class INET_API RadioMedium : public SimpleModule, public cListener, public IRadi virtual IWirelessSignal *transmitPacket(const IRadio *transmitter, Packet *packet) override; virtual Packet *receivePacket(const IRadio *receiver, IWirelessSignal *signal) override; virtual const ITransmission *getTransmission(int id) const override; + virtual TransmissionTimingSnapshot getTransmissionTimingSnapshot(int id) const override; + virtual std::optional computePrecedingSignalGap(int currentTransmissionId, + const TransmissionTimingSnapshot& preceding) const override; virtual const IListeningDecision *listenOnMedium(const IRadio *receiver, const IListening *listening) const override; diff --git a/tests/unit/TransmissionTimingSnapshot_1.test b/tests/unit/TransmissionTimingSnapshot_1.test new file mode 100644 index 00000000000..ff99ca1b5e5 --- /dev/null +++ b/tests/unit/TransmissionTimingSnapshot_1.test @@ -0,0 +1,138 @@ +%description: +Check shared transmission timing without a WLAN consumer or a propagation model. +Use generic transmissions and cached arrivals with exact endpoints. +Require snapshots to retain their values after cache expiry deletes the original objects. +Check positive, zero, and negative gaps for the same transmitter and different transmitters. +Check missing transmissions, missing arrivals, and the same transmission identity. +Require absent arrival queries to leave all three cache implementations unchanged before their first transmission. +This unit test does not establish physical reception or interframe protocol behavior. + +%includes: +#include +#include "inet/physicallayer/wireless/common/antenna/IsotropicAntenna.h" +#include "inet/physicallayer/wireless/common/base/packetlevel/FlatReceiverBase.h" +#include "inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h" +#include "inet/physicallayer/wireless/common/communicationcache/MapCommunicationCache.h" +#include "inet/physicallayer/wireless/common/communicationcache/ReferenceCommunicationCache.h" +#include "inet/physicallayer/wireless/common/communicationcache/VectorCommunicationCache.h" +#include "inet/physicallayer/wireless/common/medium/RadioMedium.h" +#include "inet/physicallayer/wireless/common/radio/packetlevel/Radio.h" +#include "inet/physicallayer/wireless/common/signal/Arrival.h" + +%global: +using namespace inet; +using namespace inet::physicallayer; + +class TimingMedium : public RadioMedium { + public: + void attach(ICommunicationCache *cache) { communicationCache = cache; } +}; + +// These adapters supply identity and component references. No radio procedure executes. +class TimingRadio : public Radio { + int identity; + const IRadioMedium *attachedMedium; + const IAntenna *attachedAntenna; + const IReceiver *attachedReceiver; + public: + TimingRadio(int identity, const IRadioMedium *medium, const IAntenna *antenna, const IReceiver *receiver) : + identity(identity), attachedMedium(medium), attachedAntenna(antenna), attachedReceiver(receiver) {} + int getId() const override { return identity; } + const IRadioMedium *getMedium() const override { return attachedMedium; } + const IAntenna *getAntenna() const override { return attachedAntenna; } + const IReceiver *getReceiver() const override { return attachedReceiver; } +}; + +class TimingCache : public MapCommunicationCache { + public: + size_t receptionSlots() const { + size_t count = 0; + for (const auto& entry : transmissionCache) + if (entry.second.receptionCacheEntries) + count += entry.second.receptionCacheEntries->size(); + return count; + } +}; + +static TransmissionBase *makeTiming(const IRadio *radio, const Packet *packet, int startUs, int endUs) +{ + return new TransmissionBase(radio, packet, SimTime(startUs, SIMTIME_US), SimTime(endUs, SIMTIME_US), + SIMTIME_ZERO, SIMTIME_ZERO, SimTime(endUs - startUs, SIMTIME_US), Coord(), Coord(), + Quaternion(), Quaternion(), nullptr, nullptr, nullptr, nullptr, nullptr); +} + +template +static void checkAbsentArrival(const IRadio *radio, const ITransmission *transmission) +{ + Cache cache; + ASSERT(cache.getNumRadios() == 0 && cache.getNumTransmissions() == 0); + for (int i = 0; i < 3; i++) + ASSERT(cache.findCachedArrival(radio, transmission) == nullptr); + ASSERT(cache.getNumRadios() == 0 && cache.getNumTransmissions() == 0); +} + +%activity: +Packet packet("timing-input"); +IsotropicAntenna antenna; +FlatReceiverBase receiver; +TimingMedium medium; +TimingRadio transmitter(1, &medium, &antenna, &receiver); +TimingRadio recipient(2, &medium, &antenna, &receiver); +TimingRadio absentArrival(3, &medium, &antenna, &receiver); +TimingCache cache; +medium.attach(&cache); +auto previous = std::unique_ptr(makeTiming(&transmitter, &packet, 100, 140)); +checkAbsentArrival(&recipient, previous.get()); +checkAbsentArrival(&recipient, previous.get()); +checkAbsentArrival(&recipient, previous.get()); +int previousId = previous->getId(); +ASSERT(medium.getTransmissionTimingSnapshot(previousId).transmissionId == -1); +ASSERT(!medium.computePrecedingSignalGap(previousId, TransmissionTimingSnapshot()).has_value()); +cache.addRadio(&transmitter); +cache.addRadio(&recipient); +cache.addRadio(&absentArrival); +auto previousPointer = previous.release(); +cache.addTransmission(previousPointer); +cache.setCachedArrival(&recipient, previousPointer, new Arrival(SimTime(7, SIMTIME_US), SimTime(7, SIMTIME_US), + SimTime(107, SIMTIME_US), SimTime(147, SIMTIME_US), SIMTIME_ZERO, SIMTIME_ZERO, + SimTime(40, SIMTIME_US), Coord(), Coord(), Quaternion(), Quaternion())); +auto snapshot = medium.getTransmissionTimingSnapshot(previousId); +ASSERT(snapshot.transmissionId == previousId && snapshot.transmitterRadioId == 1); +ASSERT(snapshot.startTime == SimTime(100, SIMTIME_US) && snapshot.endTime == SimTime(140, SIMTIME_US)); +ASSERT(snapshot.arrivalEndTimes.size() == 1 && snapshot.arrivalEndTimes.at(2) == SimTime(147, SIMTIME_US)); +ASSERT(cache.findCachedArrival(&absentArrival, previousPointer) == nullptr); +ASSERT(cache.receptionSlots() == 1); +cache.setCachedInterferenceEndTime(previousPointer, SimTime(160, SIMTIME_US)); +wait(SimTime(200, SIMTIME_US)); +int expired = 0; +cache.removeNonInterferingTransmissions([&](const ITransmission *transmission) { + ASSERT(transmission->getId() == previousId); + expired++; +}); +ASSERT(expired == 1 && cache.getNumTransmissions() == 0); +ASSERT(medium.getTransmissionTimingSnapshot(previousId).transmissionId == -1); +ASSERT(!medium.computePrecedingSignalGap(previousId, snapshot).has_value()); +ASSERT(snapshot.endTime == SimTime(140, SIMTIME_US) && snapshot.arrivalEndTimes.at(2) == SimTime(147, SIMTIME_US)); +for (const TimingRadio *source : {&transmitter, &recipient}) { + int precedingEndUs = source == &transmitter ? 140 : 147; + for (int gapUs : {10, 0, -5}) { + auto current = makeTiming(source, &packet, precedingEndUs + gapUs, precedingEndUs + gapUs + 10); + cache.addTransmission(current); + auto gap = medium.computePrecedingSignalGap(current->getId(), snapshot); + ASSERT(gap.has_value() && *gap == SimTime(gapUs, SIMTIME_US)); + ASSERT(!medium.computePrecedingSignalGap(current->getId(), TransmissionTimingSnapshot()).has_value()); + auto sameId = snapshot; + sameId.transmissionId = current->getId(); + ASSERT(!medium.computePrecedingSignalGap(current->getId(), sameId).has_value()); + auto noArrival = snapshot; + noArrival.arrivalEndTimes.clear(); + auto withoutArrival = medium.computePrecedingSignalGap(current->getId(), noArrival); + ASSERT(source == &transmitter ? withoutArrival.has_value() : !withoutArrival.has_value()); + cache.removeTransmission(current); + } +} +ASSERT(snapshot.transmissionId == previousId && snapshot.arrivalEndTimes.at(2) == SimTime(147, SIMTIME_US)); +EV << "Shared transmission timing snapshot checks passed\n"; + +%contains: stdout +Shared transmission timing snapshot checks passed From aa9cb61cdf13fd451d067d506842e6114ba41e62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:48:34 +0200 Subject: [PATCH 09/41] ieee80211: fix: include the HT signal extension at 2.4 GHz Before this commit, HT duration omits the six-microsecond signal extension at 2.4 GHz. A waveform therefore ends early and supplies incorrect airtime and interval evidence. After this commit, HT duration includes that extension. Mode queries supply its nominal duration. Transmission queries derive the actual extension from the waveform so interval consumers cannot count it twice. The mode fixture checks the 2.4 GHz extension and the other-band control. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.physicallayer.wireless.ieee80211 | behavior.change.fix | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 ++++ doc/src/migration-guide/index.rst | 5 +++++ .../wireless/ieee80211/mode/IIeee80211Mode.h | 2 ++ .../wireless/ieee80211/mode/IIeee80211Mode.msg | 1 + .../wireless/ieee80211/mode/Ieee80211ErpOfdmMode.h | 3 ++- .../wireless/ieee80211/mode/Ieee80211HtMode.h | 4 +++- .../wireless/ieee80211/mode/Ieee80211ModeBase.h | 1 + .../ieee80211/packetlevel/Ieee80211Transmission.cc | 12 ++++++++++++ .../ieee80211/packetlevel/Ieee80211Transmission.h | 5 +++++ tests/unit/Ieee80211HtModeSet_1.test | 8 ++++++++ 10 files changed, 43 insertions(+), 2 deletions(-) diff --git a/WHATSNEW b/WHATSNEW index 95420dffc08..4b922a488bc 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -458,6 +458,10 @@ Notable backward incompatible changes are the following: Radio media now expose copied transmission endpoints and cached arrival endpoints. Consumers can preserve physical timing evidence after cache expiry without retained transmission pointers or new propagation calculations. Receivers attach the transmission identifier to SignalTimeInd so later frame delivery can identify that evidence. Custom radio media and communication caches must implement the new query methods described in the migration guide. +54. IEEE 802.11 signal extension + + HT duration at 2.4 GHz now includes its six-microsecond signal extension. Previously, that waveform ended early, which could change interframe recognition and airtime. Custom IEEE 802.11 modes must supply the new nominal-extension query. A transmission query supplies the actual extension from its waveform so consumers do not count it twice. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 7dc296dc880..9dde89f3b3b 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -21,6 +21,11 @@ Custom radio media must implement ``getTransmissionTimingSnapshot()`` and ``comp ``SignalTimeInd`` now carries the medium's transmission identifier. The receiver supplies this local indication when it accepts a transmission. Consumers can associate later frame delivery with the corresponding physical timing evidence. The identifier is local metadata; it adds no transmitted field. +IEEE 802.11 signal extension +--------------------------- + +Custom IEEE 802.11 modes must implement ``getSignalExtensionTime()``. ``Ieee80211ModeBase`` supplies zero. ERP and 2.4 GHz HT modes supply their six-microsecond extension. HT duration now includes that extension, which can change airtime and simulation results. The transmission query derives the actual extension from its waveform, so consumers must not add the nominal value again. + IEEE 802.11 Basic Block Ack extension points ------------------------------------------ diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h b/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h index cecad21b7ad..4224c730c4e 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h +++ b/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h @@ -83,6 +83,8 @@ class INET_API IIeee80211Mode : public cObject, public IPrintableObject virtual const simtime_t getSlotTime() const = 0; virtual const simtime_t getSifsTime() const = 0; virtual const simtime_t getRifsTime() const = 0; + // Default extension after the PPDU, in seconds. A received waveform can omit it for RIFS. + virtual const simtime_t getSignalExtensionTime() const = 0; virtual const simtime_t getCcaTime() const = 0; virtual const simtime_t getPhyRxStartDelay() const = 0; virtual const simtime_t getRxTxTurnaroundTime() const = 0; diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.msg b/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.msg index 52c42112f65..425faaaa0cd 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.msg +++ b/src/inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.msg @@ -57,6 +57,7 @@ class IIeee80211Mode extends cObject simtime_t slotTime; simtime_t sifsTime; simtime_t rifsTime; + simtime_t signalExtensionTime; simtime_t ccaTime; simtime_t phyRxStartDelay; simtime_t rxTxTurnaroundTime; diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ErpOfdmMode.h b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ErpOfdmMode.h index e5c644ff0fc..e0f11ce9eba 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ErpOfdmMode.h +++ b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ErpOfdmMode.h @@ -33,7 +33,8 @@ class INET_API Ieee80211ErpOfdmMode : public Ieee80211OfdmMode virtual const simtime_t getSifsTime() const override { return 10E-6; } // For ERP-OFDM modes, an ERP packet is followed by a period of no transmission // with a length of 6 μs called the signal extension. - virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + signalMode->getDuration() + dataMode->getDuration(dataLength) + 6E-6; } + virtual const simtime_t getSignalExtensionTime() const override { return SimTime(6, SIMTIME_US); } + virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + signalMode->getDuration() + dataMode->getDuration(dataLength) + getSignalExtensionTime(); } }; class INET_API Ieee80211ErpOfdmCompliantModes diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h index 62bc6aa98c0..ee6c0a76685 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h +++ b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h @@ -258,6 +258,8 @@ class INET_API Ieee80211HtMode : public Ieee80211ModeBase virtual const simtime_t getShortSlotTime() const; virtual const simtime_t getSifsTime() const override; virtual const simtime_t getRifsTime() const override { return 2E-6; } + // IEEE Std 802.11-2024, Table 19-25: the 2.4 GHz HT PPDU includes a 6 us extension. + virtual const simtime_t getSignalExtensionTime() const override { return centerFrequencyMode == BAND_2_4GHZ ? SimTime(6, SIMTIME_US) : SIMTIME_ZERO; } virtual const simtime_t getCcaTime() const override { return 4E-6; } // < 4 virtual const simtime_t getPhyRxStartDelay() const override { return 24E-6; } virtual const simtime_t getRxTxTurnaroundTime() const override { return 2E-6; } // < 2 @@ -266,7 +268,7 @@ class INET_API Ieee80211HtMode : public Ieee80211ModeBase virtual int getMpduMaxLength() const override { return 65535; } // in octets virtual BandMode getCenterFrequencyMode() const { return centerFrequencyMode; } - virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + dataMode->getDuration(dataLength); } + virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + dataMode->getDuration(dataLength) + getSignalExtensionTime(); } }; // A specification of the high-throughput (HT) physical layer (PHY) diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h index 36edd5ba0e7..39b7af724dd 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h +++ b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h @@ -29,6 +29,7 @@ class INET_API Ieee80211ModeBase : public IIeee80211Mode virtual PreambleType getLegacyPreambleType() const override { return PreambleType::UNKNOWN; } virtual int getHtMcsIndex() const override { return -1; } virtual bool isHtShortGuardInterval() const override { return false; } + virtual const simtime_t getSignalExtensionTime() const override { return SIMTIME_ZERO; } virtual const char *getName() const override { return name.c_str(); } }; diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.cc b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.cc index 4f1be224443..a5eac8b7868 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.cc +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.cc @@ -6,6 +6,7 @@ #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" namespace inet { @@ -27,6 +28,17 @@ std::ostream& Ieee80211Transmission::printToStream(std::ostream& stream, int lev return TransmissionBase::printToStream(stream, level); } +std::optional Ieee80211Transmission::getSignalExtensionDuration() const +{ + auto header = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(getPacket()); + auto defaultExtension = mode->getSignalExtensionTime(); + // The PHY Length field contains MAC octets. The mode duration already includes PHY headers and padding. + auto extension = getEndTime() - getStartTime() - mode->getDuration(B(header->getLengthField())) + defaultExtension; + if (extension == SIMTIME_ZERO || extension == defaultExtension) + return extension; + return std::nullopt; +} + } // namespace physicallayer } // namespace inet diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h index 2bf3eae2a82..f1a9e9bbce1 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h @@ -8,6 +8,8 @@ #ifndef __INET_IEEE80211TRANSMISSION_H #define __INET_IEEE80211TRANSMISSION_H +#include + #include "inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h" #include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h" @@ -30,6 +32,9 @@ class INET_API Ieee80211Transmission : public TransmissionBase virtual const IIeee80211Mode *getMode() const { return mode; } virtual const Ieee80211Channel *getChannel() const { return channel; } + // The actual waveform can omit the default extension through NO_SIG_EXTN for RIFS. + // An unsupported duration returns no value; the method changes no state. + std::optional getSignalExtensionDuration() const; }; } // namespace physicallayer diff --git a/tests/unit/Ieee80211HtModeSet_1.test b/tests/unit/Ieee80211HtModeSet_1.test index 0dc059d2d40..552c8f54549 100644 --- a/tests/unit/Ieee80211HtModeSet_1.test +++ b/tests/unit/Ieee80211HtModeSet_1.test @@ -235,6 +235,14 @@ for (int mcs = 0; mcs < 32; mcs++) { ASSERT(typedHt->getSlotTime() == SimTime(20, SIMTIME_US)); ASSERT(typedAcHt->getSifsTime() == SimTime(16, SIMTIME_US)); ASSERT(typedAcHt->getSlotTime() == SimTime(9, SIMTIME_US)); + ASSERT(typedHt->getSignalExtensionTime() == SimTime(6, SIMTIME_US)); + ASSERT(typedAcHt->getSignalExtensionTime() == SIMTIME_ZERO); + ASSERT(typedHt->getDuration(B(100)) - typedAcHt->getDuration(B(100)) == SimTime(6, SIMTIME_US)); + if (mcs == 0 && width == MHz(20) && gi == Ieee80211HtModeBase::HT_GUARD_INTERVAL_LONG) { + // MCS 0: 36 us preamble + ceil((16 + 800 + 6) / 26) * 4 us + band extension. + ASSERT(typedHt->getDuration(B(100)) == SimTime(170, SIMTIME_US)); + ASSERT(typedAcHt->getDuration(B(100)) == SimTime(164, SIMTIME_US)); + } ASSERT(acHt->getDataMode()->getNetBitrate() == ht->getDataMode()->getNetBitrate()); ASSERT(acHt->getDataMode()->getNumberOfSpatialStreams() == ht->getDataMode()->getNumberOfSpatialStreams()); ASSERT(vhtOnlyModeSet->getIsMandatory(acHt) == htModeSet->getIsMandatory(ht)); From 81417fb0f56b54bc7d2d1367aa1b786e36310cb4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:48:50 +0200 Subject: [PATCH 10/41] ieee80211: fix: preserve advertised RIFS permission Before this commit, HT management conversion loses RIFS Mode. A recipient therefore cannot use received permission to identify a permitted RIFS relation. After this commit, HT Operation retains RIFS Mode through conversion and equality checks. The MIB permits RIFS for unprotected HT operation and clears the permission for VHT. For example, an unprotected HT operation survives conversion with permission intact. The capability fixture checks these states. This commit adds no RIFS transmission scheduler. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.change.fix | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 ++++ doc/src/migration-guide/index.rst | 5 +++++ .../ieee80211/mgmt/Ieee80211HtMgmtElements.h | 2 ++ .../ieee80211/mib/Ieee80211HtCapabilities.h | 3 ++- src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc | 6 ++++++ tests/unit/Ieee80211HtCapabilities_1.test | 12 ++++++++++++ 6 files changed, 31 insertions(+), 1 deletion(-) diff --git a/WHATSNEW b/WHATSNEW index 4b922a488bc..748f4369c4f 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -462,6 +462,10 @@ Notable backward incompatible changes are the following: HT duration at 2.4 GHz now includes its six-microsecond signal extension. Previously, that waveform ended early, which could change interframe recognition and airtime. Custom IEEE 802.11 modes must supply the new nominal-extension query. A transmission query supplies the actual extension from its waveform so consumers do not count it twice. +56. IEEE 802.11 RIFS permission + + HT Operation now preserves RIFS Mode through management conversion and equality checks. The MIB permits RIFS under unprotected HT operation and clears the permission for VHT. A recipient can therefore check the actual advertised permission before it recognizes a RIFS relation. This change adds no RIFS transmission scheduler. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 9dde89f3b3b..475339b9164 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -26,6 +26,11 @@ IEEE 802.11 signal extension Custom IEEE 802.11 modes must implement ``getSignalExtensionTime()``. ``Ieee80211ModeBase`` supplies zero. ERP and 2.4 GHz HT modes supply their six-microsecond extension. HT duration now includes that extension, which can change airtime and simulation results. The transmission query derives the actual extension from its waveform, so consumers must not add the nominal value again. +IEEE 802.11 RIFS permission +-------------------------- + +HT Operation now preserves RIFS Mode through management conversion and equality checks. VHT operation clears that permission. The change preserves the received permission for a consumer that checks RIFS relations; it adds no RIFS transmission scheduler. + IEEE 802.11 Basic Block Ack extension points ------------------------------------------ diff --git a/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h b/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h index 6a851b507e4..fb62285460e 100644 --- a/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h +++ b/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h @@ -101,6 +101,7 @@ inline Ieee80211HtOperationElement makeHtOperationElement(const physicallayer::I element.secondaryChannelOffset = operation.secondaryChannelOffset; element.staChannelWidth40Mhz = operation.operatingChannelWidth == MHz(40); element.protectionMode = static_cast(operation.protectionMode); + element.rifsMode = operation.rifsMode; for (int i = 0; i < 77; i++) element.basicMcsSupported[i] = operation.basicMcsSupported[i]; return element; @@ -119,6 +120,7 @@ inline Ieee80211HtOperation makeHtOperation(const physicallayer::IIeee80211Band operation.secondaryChannelOffset = element.secondaryChannelOffset; operation.operatingChannelWidth = element.staChannelWidth40Mhz ? MHz(40) : MHz(20); operation.protectionMode = static_cast(element.protectionMode); + operation.rifsMode = element.rifsMode; for (int i = 0; i < 77; i++) operation.basicMcsSupported[i] = element.basicMcsSupported[i]; return operation; diff --git a/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h b/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h index b2b02ad5a4d..26a27315c11 100644 --- a/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h +++ b/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h @@ -70,12 +70,13 @@ struct Ieee80211HtOperation int primaryChannel = 0; int secondaryChannelOffset = 0; Ieee80211HtProtectionMode protectionMode = Ieee80211HtProtectionMode::NO_PROTECTION; + bool rifsMode = false; std::array basicMcsSupported = {}; bool operator==(const Ieee80211HtOperation& other) const { return operatingChannelWidth == other.operatingChannelWidth && primaryChannel == other.primaryChannel && secondaryChannelOffset == other.secondaryChannelOffset && protectionMode == other.protectionMode && - basicMcsSupported == other.basicMcsSupported; + rifsMode == other.rifsMode && basicMcsSupported == other.basicMcsSupported; } }; diff --git a/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc b/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc index 9c4db7b2026..f57837295d2 100644 --- a/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc +++ b/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc @@ -162,8 +162,10 @@ void Ieee80211Mib::updateLocalHtCapabilities(const physicallayer::Ieee80211ModeS modeSet->isHtShortGuardIntervalSupported(MHz(20)); localHtCapabilities.shortGi40 = localHtCapabilities.supportedChannelWidths.count(MHz(40)) != 0 && modeSet->isHtShortGuardIntervalSupported(MHz(40)); + bool vhtSupported = false; for (int index = 0; index < modeSet->getNumModes(); index++) { const auto *mode = modeSet->getMode(index); + vhtSupported |= mode->getModulationClass() == physicallayer::IIeee80211Mode::ModulationClass::VHT; int mcs = mode->getHtMcsIndex(); if (mcs >= 0 && mcs < 77 && operationalChannelWidths.count(mode->getDataMode()->getBandwidth()) != 0 && mode->getDataMode()->getNumberOfSpatialStreams() <= operationalHtSpatialStreamLimit) @@ -199,6 +201,10 @@ void Ieee80211Mib::updateLocalHtCapabilities(const physicallayer::Ieee80211ModeS if (protectionMode < 0 || protectionMode > 3) throw cRuntimeError("htProtectionMode must be between 0 and 3"); htOperation.protectionMode = static_cast(protectionMode); + // IEEE Std 802.11-2024, 10.27.3.3: the protected modes permit the conservative zero policy. + // IEEE Std 802.11-2024, 11.38.1: a VHT AP advertises zero. + htOperation.rifsMode = !vhtSupported && (htOperation.protectionMode == Ieee80211HtProtectionMode::NO_PROTECTION || + htOperation.protectionMode == Ieee80211HtProtectionMode::TWENTY_MHZ_PROTECTION); bool peerStateChanged = false; for (auto& entry : peerHtStates) { if (entry.second.valid) { diff --git a/tests/unit/Ieee80211HtCapabilities_1.test b/tests/unit/Ieee80211HtCapabilities_1.test index dee6a669f79..455332ef964 100644 --- a/tests/unit/Ieee80211HtCapabilities_1.test +++ b/tests/unit/Ieee80211HtCapabilities_1.test @@ -33,6 +33,18 @@ peer.maxAmpduLengthExponent = 3; Ieee80211HtOperation operation; operation.operatingChannelWidth = MHz(20); +for (bool permitted : {false, true}) { + auto advertised = operation; + advertised.primaryChannel = 0; + advertised.rifsMode = permitted; + auto band = physicallayer::Ieee80211CompliantBands::getBand("2.4 GHz"); + auto element = makeHtOperationElement(band, advertised); + ASSERT(element.rifsMode == permitted); + auto received = makeHtOperation(band, element); + ASSERT(received == advertised); + received.rifsMode = !permitted; + ASSERT(!(received == advertised)); +} operation.basicMcsSupported[0] = true; auto negotiated = negotiateHtCapabilities(local, peer, operation); From 9b601af37074230df5abe948f711d351bd78eed6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:49:00 +0200 Subject: [PATCH 11/41] ieee80211: fix: release temporary Block Ack bitmap allocations Before this commit, Basic and Compressed decoders allocate temporary BitVector objects and copy their values without deletion. Repeated Block Ack decode therefore loses those allocations. After this commit, the decoders construct bitmap values directly. The generated fields retain their own values without an unowned temporary. For example, independent Basic and Compressed octets retain the same bitmap bits after decode. The direct wire check covers both paths. Type interpretation and frame acceptance remain unchanged. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.change.fix | test whatsnew | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 +++ .../mac/Ieee80211MacHeaderSerializer.cc | 5 ++- tests/unit/Ieee80211BlockAckWire_1.test | 36 +++++++++++++++++++ 3 files changed, 42 insertions(+), 3 deletions(-) create mode 100644 tests/unit/Ieee80211BlockAckWire_1.test diff --git a/WHATSNEW b/WHATSNEW index 748f4369c4f..bb72a72d652 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -466,6 +466,10 @@ Notable backward incompatible changes are the following: HT Operation now preserves RIFS Mode through management conversion and equality checks. The MIB permits RIFS under unprotected HT operation and clears the permission for VHT. A recipient can therefore check the actual advertised permission before it recognizes a RIFS relation. This change adds no RIFS transmission scheduler. +57. Block Ack bitmap ownership + + Block Ack decoders now use bitmap values without unowned temporary allocations. Repeated Basic and Compressed decode no longer loses those temporary objects. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc b/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc index 2a482cded2f..d841c8be5aa 100644 --- a/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc @@ -664,8 +664,7 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre std::vector bytes; bytes.push_back(stream.readByte()); bytes.push_back(stream.readByte()); - BitVector *blockAckBitmap = new BitVector(bytes); - basicBlockAck->setBlockAckBitmap(i, *blockAckBitmap); + basicBlockAck->setBlockAckBitmap(i, BitVector(bytes)); } return basicBlockAck; } @@ -684,7 +683,7 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre for (size_t i = 0; i < 8; ++i) { bytes.push_back(stream.readByte()); } - compressedBlockAck->setBlockAckBitmap(*(new BitVector(bytes))); + compressedBlockAck->setBlockAckBitmap(BitVector(bytes)); return compressedBlockAck; } else { diff --git a/tests/unit/Ieee80211BlockAckWire_1.test b/tests/unit/Ieee80211BlockAckWire_1.test new file mode 100644 index 00000000000..0cd32ee3a46 --- /dev/null +++ b/tests/unit/Ieee80211BlockAckWire_1.test @@ -0,0 +1,36 @@ +%description: +Check Basic and Compressed bitmap values after independent byte decode. +The decoder must preserve the same bitmap contents without unowned temporary objects. +Type validation remains outside this prerequisite. + +%includes: +#include "inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.h" + +using namespace inet; +using namespace inet::ieee80211; + +%activity: +for (bool compressed : {false, true}) { + std::vector bytes(compressed ? 28 : 148, 0); + bytes[0] = 0x94; + bytes[16] = compressed ? 4 : 0; + bytes[20] = 1; + MemoryInputStream stream(bytes); + auto decoded = Chunk::deserialize(stream, typeid(Ieee80211MacHeader)); + if (compressed) { + auto response = dynamicPtrCast(decoded); + ASSERT(response && response->getBlockAckBitmap().getSize() == 64); + ASSERT(response->getBlockAckBitmap().getBit(0)); + ASSERT(!response->getBlockAckBitmap().getBit(63)); + } + else { + auto response = dynamicPtrCast(decoded); + ASSERT(response && response->getBlockAckBitmapArraySize() == 64); + ASSERT(response->getBlockAckBitmap(0).getBit(0)); + ASSERT(!response->getBlockAckBitmap(63).getBit(15)); + } +} +EV << "Bitmap decode checks passed.\n"; + +%contains: stdout +Bitmap decode checks passed. From 1ab742b9eb57218ca34b66209520303971c92576 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:49:54 +0200 Subject: [PATCH 12/41] ieee80211: add: serialize Basic and Compressed Block Ack Types Before this commit, Block Ack serialization decodes only part of the Type field. Compressed bitmap and fragment fields lack complete wire validation. The preceding prerequisite already removes the unowned bitmap temporaries. After this commit, the serializer decodes all four Type bits. Type 0 retains Basic compatibility. Type 2 supplies a 64-bit Compressed bitmap and a 32-byte response with FCS. Both BAR profiles occupy 24 bytes with FCS. Invalid Types and malformed fragment fields fail validation. For example, Type 2 with a nonzero fragment field fails validation instead of entering the supported Compressed profile. Independent octets cover both Types, malformed fields, reserved bits, lengths, and sequence wrap. The existing Compressed BAR builder supplies its complete header. Synthetic fixtures provide valid FCS lengths and every Basic bitmap entry. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.add | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 8 +- doc/src/migration-guide/index.rst | 7 + .../ieee80211/mac/Ieee80211Frame.msg | 8 +- .../mac/Ieee80211MacHeaderSerializer.cc | 40 ++- .../blockack/OriginatorBlockAckProcedure.cc | 12 +- .../Ieee80211BlockAckActionDispatch_1.test | 1 + ...Ieee80211BlockAckFragmentRetirement_1.test | 2 + tests/serializer/REMAINING_GAPS.md | 4 + .../lib/fillers/ChunkFillers_ieee80211.cc | 25 +- .../serializer_chunk_roundtrip.test | 13 +- tests/unit/Ieee80211BlockAckWire_1.test | 238 ++++++++++++++++-- 11 files changed, 290 insertions(+), 68 deletions(-) diff --git a/WHATSNEW b/WHATSNEW index bb72a72d652..ec626754ce9 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -462,13 +462,13 @@ Notable backward incompatible changes are the following: HT duration at 2.4 GHz now includes its six-microsecond signal extension. Previously, that waveform ended early, which could change interframe recognition and airtime. Custom IEEE 802.11 modes must supply the new nominal-extension query. A transmission query supplies the actual extension from its waveform so consumers do not count it twice. -56. IEEE 802.11 RIFS permission +55. IEEE 802.11 Block Ack wire types - HT Operation now preserves RIFS Mode through management conversion and equality checks. The MIB permits RIFS under unprotected HT operation and clears the permission for VHT. A recipient can therefore check the actual advertised permission before it recognizes a RIFS relation. This change adds no RIFS transmission scheduler. + The serializer supports the complete four-bit Type field for Basic compatibility and Compressed frames. Compressed responses contain a 64-bit bitmap and occupy 32 bytes with FCS. Both BAR profiles occupy 24 bytes with FCS. Basic producers must keep reserved bits that overlap Type zero. Invalid Types and malformed fragment fields now fail validation instead of ambiguous decoding. -57. Block Ack bitmap ownership +56. IEEE 802.11 RIFS permission - Block Ack decoders now use bitmap values without unowned temporary allocations. Repeated Basic and Compressed decode no longer loses those temporary objects. + HT Operation now preserves RIFS Mode through management conversion and equality checks. The MIB permits RIFS under unprotected HT operation and clears the permission for VHT. A recipient can therefore check the actual advertised permission before it recognizes a RIFS relation. This change adds no RIFS transmission scheduler. Notable backward compatible changes are the following: diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 475339b9164..7a2be4ab354 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -31,6 +31,13 @@ IEEE 802.11 RIFS permission HT Operation now preserves RIFS Mode through management conversion and equality checks. VHT operation clears that permission. The change preserves the received permission for a consumer that checks RIFS relations; it adds no RIFS transmission scheduler. +IEEE 802.11 Block Ack wire producers +----------------------------------- + +The serializer decodes the complete four-bit Type field. Type 0 retains Basic compatibility; Type 2 selects Compressed. Other Types produce invalid input. Basic producers must keep the two low bits of their reserved field zero because those bits overlap Type. The serializer rejects inconsistent Basic objects. Compressed reserved fields write zero; received reserved values do not affect the decoded result. + +Compressed producers must supply Fragment Number zero and a 64-bit bitmap. A Compressed Block Ack header chunk contains 28 bytes before FCS. Both BAR profiles occupy 24 bytes with FCS. Keep the corresponding header chunk and trailer lengths consistent. The serializer rejects malformed wire fields before runtime processing. + IEEE 802.11 Basic Block Ack extension points ------------------------------------------ diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211Frame.msg b/src/inet/linklayer/ieee80211/mac/Ieee80211Frame.msg index e139deaf75d..7d1367944d4 100644 --- a/src/inet/linklayer/ieee80211/mac/Ieee80211Frame.msg +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211Frame.msg @@ -43,6 +43,8 @@ const b LENGTH_ADDBAREQ = LENGTH_MGMT + B(9); // mgmt length + action body lengt const b LENGTH_ADDBARESP = LENGTH_MGMT + B(9); // mgmt length + action body length const b LENGTH_DELBA = LENGTH_MGMT + B(6); // mgmt length + action body length const b LENGTH_BASIC_BLOCKACK = B(16 + 2 + (2 + 128) + 4); // header + ba control + ba information + fcs +const b LENGTH_COMPRESSED_BLOCKACK = B(16 + 2 + 2 + 8 + 4); // header + control + sequence + bitmap + FCS +const b LENGTH_BLOCKACKREQ = B(16 + 2 + 2 + 4); // header + control + sequence + FCS const b DATAFRAME_HEADER_MINLENGTH = B(2 + 2 + 3 * 6 + 2); //bits without QoS, without Address4: 2 + 2 + 3*6(addresses) + 2 const b QOSCONTROL_PART_LENGTH = b(2 * 8); // QoS Control field length (bits) const short int MAX_NUM_FRAGMENTS = 16; @@ -356,7 +358,7 @@ class Ieee80211BlockAckReq extends Ieee80211TwoAddressHeader class Ieee80211BasicBlockAckReq extends Ieee80211BlockAckReq { - chunkLength = B(16 + 2 + 2); // header + BAR control + BAR information + chunkLength = LENGTH_BLOCKACKREQ - B(4); int tidInfo @bit(4); // The TID_INFO subfield of the BAR Control field of the Basic BlockAckReq frame contains the TID for which a Basic BlockAck frame is requested. @@ -373,7 +375,7 @@ class Ieee80211BasicBlockAckReq extends Ieee80211BlockAckReq class Ieee80211CompressedBlockAckReq extends Ieee80211BlockAckReq { - chunkLength = B(16 + 2 + 2); // header + BAR control + BAR information + chunkLength = LENGTH_BLOCKACKREQ - B(4); int tidInfo @bit(4); // The TID_INFO subfield of the BAR Control field of the Compressed BlockAckReq frame contains the TID for which a BlockAck frame is requested. // The BAR Information field of the Compressed BlockAckReq frame contains the Block Ack Starting @@ -455,7 +457,7 @@ class Ieee80211BasicBlockAck extends Ieee80211BlockAck // class Ieee80211CompressedBlockAck extends Ieee80211BlockAck { - // chunkLength TODO + chunkLength = LENGTH_COMPRESSED_BLOCKACK - B(4); multiTid = 0; compressedBitmap = 1; diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc b/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc index d841c8be5aa..d2b1ae642fe 100644 --- a/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.cc @@ -331,10 +331,13 @@ void Ieee80211MacHeaderSerializer::serializeFields(MemoryOutputStream& stream, c stream.writeMacAddress(blockAckReq->getTransmitterAddress()); bool multiTid = blockAckReq->getMultiTid(); bool compressedBitmap = blockAckReq->getCompressedBitmap(); - // BAR Control is a 16-bit little-endian field: bit 0 BAR Ack Policy, bit 1 - // Multi-TID, bit 2 Compressed Bitmap, bits 3-11 reserved, bits 12-15 TID_INFO + // IEEE Std 802.11-2024, 9.3.1.7: B1-B4 encode the complete BAR Type. + if (!multiTid && !compressedBitmap && (blockAckReq->getReserved() & 3)) + throw cRuntimeError("Basic BAR reserved fields must encode Type 0"); uint16_t barControl = (blockAckReq->getBarAckPolicy() ? 1 : 0) | ((multiTid ? 1 : 0) << 1) | ((compressedBitmap ? 1 : 0) << 2) | ((blockAckReq->getReserved() & 0x1FF) << 3); + if (!multiTid && compressedBitmap) + barControl = 2 << 1; if (!multiTid && !compressedBitmap) { auto basicBlockAckReq = CHK(dynamicPtrCast(chunk)); stream.writeUint16Le(barControl | ((basicBlockAckReq->getTidInfo() & 0xF) << 12)); @@ -347,6 +350,8 @@ void Ieee80211MacHeaderSerializer::serializeFields(MemoryOutputStream& stream, c } else if (!multiTid && compressedBitmap) { auto compressedBlockAckReq = CHK(dynamicPtrCast(chunk)); + if (compressedBlockAckReq->getFragmentNumber() != 0) + throw cRuntimeError("Compressed BAR Fragment Number must be zero"); stream.writeUint16Le(barControl | ((compressedBlockAckReq->getTidInfo() & 0xF) << 12)); writeSequenceControl(stream, compressedBlockAckReq->getFragmentNumber(), compressedBlockAckReq->getStartingSequenceNumber().get()); if (stream.getLength() - startPos != compressedBlockAckReq->getChunkLength()) @@ -367,10 +372,13 @@ void Ieee80211MacHeaderSerializer::serializeFields(MemoryOutputStream& stream, c stream.writeMacAddress(blockAck->getTransmitterAddress()); bool multiTid = blockAck->getMultiTid(); bool compressedBitmap = blockAck->getCompressedBitmap(); - // BA Control is a 16-bit little-endian field: bit 0 Ack Policy, bit 1 Multi-TID, - // bit 2 Compressed Bitmap, bits 3-11 reserved, bits 12-15 TID_INFO + // IEEE Std 802.11-2024, 9.3.1.8: B1-B4 encode the complete BA Type. + if (!multiTid && !compressedBitmap && (blockAck->getReserved() & 3)) + throw cRuntimeError("Basic Block Ack reserved fields must encode Type 0"); uint16_t baControl = (blockAck->getBlockAckPolicy() ? 1 : 0) | ((multiTid ? 1 : 0) << 1) | ((compressedBitmap ? 1 : 0) << 2) | ((blockAck->getReserved() & 0x1FF) << 3); + if (!multiTid && compressedBitmap) + baControl = 2 << 1; if (!multiTid && !compressedBitmap) { auto basicBlockAck = CHK(dynamicPtrCast(chunk)); stream.writeUint16Le(baControl | ((basicBlockAck->getTidInfo() & 0xF) << 12)); @@ -386,6 +394,10 @@ void Ieee80211MacHeaderSerializer::serializeFields(MemoryOutputStream& stream, c } else if (!multiTid && compressedBitmap) { auto compressedBlockAck = CHK(dynamicPtrCast(chunk)); + if (compressedBlockAck->getFragmentNumber() != 0) + throw cRuntimeError("Compressed Block Ack Fragment Number must be zero"); + if (compressedBlockAck->getBlockAckBitmap().getSize() != 64) + throw cRuntimeError("Compressed Block Ack bitmap must contain 64 bits"); stream.writeUint16Le(baControl | ((compressedBlockAck->getTidInfo() & 0xF) << 12)); // Block Ack Starting Sequence Control = 4-bit Fragment Number (reserved) + 12-bit sequence number writeSequenceControl(stream, compressedBlockAck->getFragmentNumber(), compressedBlockAck->getStartingSequenceNumber().get()); @@ -600,6 +612,7 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre blockAckReq->setReceiverAddress(stream.readMacAddress()); blockAckReq->setTransmitterAddress(stream.readMacAddress()); uint16_t barControl = stream.readUint16Le(); + auto barType = (barControl >> 1) & 0xF; bool multiTid = (barControl >> 1) & 1; bool compressedBitmap = (barControl >> 2) & 1; blockAckReq->setBarAckPolicy(barControl & 1); @@ -608,7 +621,7 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre blockAckReq->setReserved((barControl >> 3) & 0x1FF); int fragmentNumber = 0; SequenceNumberCyclic startingSequenceNumber; - if (!multiTid && !compressedBitmap) { + if (barType == 0) { auto basicBlockAckReq = makeShared(); copyBasicFields(basicBlockAckReq, macHeader); copyBlockAckReqFrameFields(basicBlockAckReq, blockAckReq); @@ -618,14 +631,18 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre basicBlockAckReq->setStartingSequenceNumber(startingSequenceNumber); return basicBlockAckReq; } - else if (!multiTid && compressedBitmap) { + else if (barType == 2) { auto compressedBlockAckReq = makeShared(); copyBasicFields(compressedBlockAckReq, macHeader); copyBlockAckReqFrameFields(compressedBlockAckReq, blockAckReq); + compressedBlockAckReq->setBarAckPolicy(false); + compressedBlockAckReq->setReserved(0); compressedBlockAckReq->setTidInfo((barControl >> 12) & 0xF); readSequenceControl(stream, fragmentNumber, startingSequenceNumber); compressedBlockAckReq->setFragmentNumber(fragmentNumber); compressedBlockAckReq->setStartingSequenceNumber(startingSequenceNumber); + if (fragmentNumber != 0) + compressedBlockAckReq->markIncorrect(); return compressedBlockAckReq; } else @@ -640,9 +657,8 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre blockAck->setDurationField(SimTime(stream.readUint16Le(), SIMTIME_US)); blockAck->setReceiverAddress(stream.readMacAddress()); blockAck->setTransmitterAddress(stream.readMacAddress()); - // BA Control is a 16-bit little-endian field: bit 0 Ack Policy, bit 1 Multi-TID, - // bit 2 Compressed Bitmap, bits 3-11 reserved, bits 12-15 TID_INFO uint16_t baControl = stream.readUint16Le(); + auto baType = (baControl >> 1) & 0xF; bool multiTid = (baControl >> 1) & 1; bool compressedBitmap = (baControl >> 2) & 1; uint8_t tidInfo = (baControl >> 12) & 0xF; @@ -650,7 +666,7 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre blockAck->setMultiTid(multiTid); blockAck->setCompressedBitmap(compressedBitmap); blockAck->setReserved((baControl >> 3) & 0x1FF); - if (!multiTid && !compressedBitmap) { + if (baType == 0) { auto basicBlockAck = makeShared(); copyBasicFields(basicBlockAck, macHeader); copyBlockAckFrameFields(basicBlockAck, blockAck); @@ -668,10 +684,12 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre } return basicBlockAck; } - else if (!multiTid && compressedBitmap) { + else if (baType == 2) { auto compressedBlockAck = makeShared(); copyBasicFields(compressedBlockAck, macHeader); copyBlockAckFrameFields(compressedBlockAck, blockAck); + compressedBlockAck->setBlockAckPolicy(false); + compressedBlockAck->setReserved(0); compressedBlockAck->setTidInfo(tidInfo); // Block Ack Starting Sequence Control = 4-bit Fragment Number (reserved) + 12-bit @@ -684,6 +702,8 @@ const Ptr Ieee80211MacHeaderSerializer::deserializeFields(MemoryInputStre bytes.push_back(stream.readByte()); } compressedBlockAck->setBlockAckBitmap(BitVector(bytes)); + if (fragmentNumber != 0) + compressedBlockAck->markIncorrect(); return compressedBlockAck; } else { diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.cc b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.cc index d02e412b644..ee1960c3fb0 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.cc @@ -12,13 +12,11 @@ namespace ieee80211 { const Ptr OriginatorBlockAckProcedure::buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const { - throw cRuntimeError("Unsupported feature"); - // TODO implement - // auto blockAckReq = makeShared(); - // blockAckReq->setReceiverAddress(receiverAddress); - // blockAckReq->setStartingSequenceNumber(startingSequenceNumber); - // blockAckReq->setTidInfo(tid); - // return blockAckReq; + auto blockAckReq = makeShared(); + blockAckReq->setReceiverAddress(receiverAddress); + blockAckReq->setStartingSequenceNumber(startingSequenceNumber); + blockAckReq->setTidInfo(tid); + return blockAckReq; } const Ptr OriginatorBlockAckProcedure::buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const diff --git a/tests/module/Ieee80211BlockAckActionDispatch_1.test b/tests/module/Ieee80211BlockAckActionDispatch_1.test index 1ec9db351e9..e09a34d1ab8 100644 --- a/tests/module/Ieee80211BlockAckActionDispatch_1.test +++ b/tests/module/Ieee80211BlockAckActionDispatch_1.test @@ -62,6 +62,7 @@ class ActionDispatchHcf : public Hcf { bar->setStartingSequenceNumber(SequenceNumberCyclic(104)); bar->setFragmentNumber(0); auto request = new Packet("bar-before-data", bar); + request->insertAtBack(makeShared()); request->addTag()->setMode(modeSet->getMode(bps(6000000))); processLowerFrame(request, bar); ASSERT(delivered == 0); diff --git a/tests/module/Ieee80211BlockAckFragmentRetirement_1.test b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test index 90b92add024..5a15b2b964a 100644 --- a/tests/module/Ieee80211BlockAckFragmentRetirement_1.test +++ b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test @@ -218,6 +218,8 @@ class FragmentRetirementHcf : public Hcf { for (int i = 1; i < 16; i++) bits.appendBit(false); header->setBlockAckBitmap(0, bits); + for (int position = 1; position < 64; position++) + header->setBlockAckBitmap(position, BitVector(std::vector{0, 0})); auto packet = new Packet("block-ack", header); packet->insertAtBack(makeShared()); packet->addTag()->setMode(modeSet->getMode(bps(24000000))); diff --git a/tests/serializer/REMAINING_GAPS.md b/tests/serializer/REMAINING_GAPS.md index c112225ab8d..78180de2e35 100644 --- a/tests/serializer/REMAINING_GAPS.md +++ b/tests/serializer/REMAINING_GAPS.md @@ -432,6 +432,10 @@ anyway. ## Untested serializers (registered, but no real-capture coverage) +The Block Ack producers retain Basic BAR and Block Ack with Type 0. Their `reserved` fields clear the two bits that overlap Type. The Compressed producers use Type 2 and leave ACK-policy and `reserved` fields at zero. These Compressed fields have no field-preserving wire contract. The serializer writes zero for reserved bits B0 and B5–B11 and ignores their received values. + +`Ieee80211BlockAckWire_1.test` checks independent octets for both variants and both frame types. It also checks unsupported Types, malformed Compressed fragment subfields, and response lengths. Basic response headers contain 148 bytes; Compressed response headers contain 28 bytes. The four-byte FCS gives MPDU lengths of 152 and 32 bytes. These checks do not establish a complete frame exchange or complete historical Basic conformance. + The tests cover different things. `serializer_chunk_roundtrip` **constructs** an instance of every registered chunk type — from hand-written typed fillers in `tests/serializer/lib/fillers/`, one or more per type, a variant per branch the serializer takes diff --git a/tests/serializer/lib/fillers/ChunkFillers_ieee80211.cc b/tests/serializer/lib/fillers/ChunkFillers_ieee80211.cc index 158b12c5620..163bfaa38c3 100644 --- a/tests/serializer/lib/fillers/ChunkFillers_ieee80211.cc +++ b/tests/serializer/lib/fillers/ChunkFillers_ieee80211.cc @@ -432,13 +432,8 @@ void addFillers_ieee80211(std::vector& fillers) setChunkLength(c, LENGTH_DELBA); }}); - // --- Block Ack request / response, Basic and Compressed variants: multiTid and - // compressedBitmap are the serializer's variant discriminator (see - // Ieee80211MacHeaderSerializer's ST_BLOCKACK_REQ/ST_BLOCKACK cases), pinned per - // subclass by the .msg -- kept at that pinned pair. fragmentNumber is the Fragment - // Number subfield of the Block Ack (Req) Starting Sequence Control, which 802.11 - // always sets to 0 in a Block Ack context (no fragmentation) -- kept at the .msg - // default in all four subtypes. + // The concrete classes fix the Type bits. Basic reserved values must retain Type 0. + // Compressed reserved fields write zero. All producers retain fragmentNumber = 0. fillers.push_back({"inet::ieee80211::Ieee80211BasicBlockAckReq", "", [](Chunk *c) { auto h = check_and_cast(c); FillValues v; @@ -451,7 +446,7 @@ void addFillers_ieee80211(std::vector& fillers) h->setMultiTid(false); // pinned by the class: selects the (non-multi-TID) Basic/Compressed branch h->setCompressedBitmap(false); // pinned by the class: selects the Basic (non-compressed) branch h->setBarAckPolicy(true); - h->setReserved(v.uint(9)); + h->setReserved(v.uint(9) & ~3u); h->setTidInfo((int)v.uint(4)); h->setStartingSequenceNumber(SequenceNumberCyclic(v.uint(12))); }}); @@ -466,8 +461,8 @@ void addFillers_ieee80211(std::vector& fillers) h->setType(ST_BLOCKACK_REQ); h->setMultiTid(false); // pinned by the class h->setCompressedBitmap(true); // pinned by the class: selects the Compressed branch - h->setBarAckPolicy(true); - h->setReserved(v.uint(9)); + h->setBarAckPolicy(false); + h->setReserved(0); h->setTidInfo((int)v.uint(4)); h->setStartingSequenceNumber(SequenceNumberCyclic(v.uint(12))); }}); @@ -483,7 +478,7 @@ void addFillers_ieee80211(std::vector& fillers) h->setMultiTid(false); // pinned by the class h->setCompressedBitmap(false); // pinned by the class: selects the Basic bitmap branch h->setBlockAckPolicy(true); - h->setReserved(v.uint(9)); + h->setReserved(v.uint(9) & ~3u); h->setStartingSequenceNumber(SequenceNumberCyclic(v.uint(12))); // The Block Ack bitmap: 64 elements of 2 bytes (16 bits) each; never leave any at // the default empty BitVector -- getBytes()[0]/[1] would read out of bounds. @@ -502,15 +497,11 @@ void addFillers_ieee80211(std::vector& fillers) h->setType(ST_BLOCKACK); h->setMultiTid(false); // pinned by the class h->setCompressedBitmap(true); // pinned by the class: selects the Compressed bitmap branch - h->setBlockAckPolicy(true); - h->setReserved(v.uint(9)); + h->setBlockAckPolicy(false); + h->setReserved(0); h->setStartingSequenceNumber(SequenceNumberCyclic(v.uint(12))); h->setBlockAckBitmap(BitVector(std::vector{v.u8(), v.u8(), v.u8(), v.u8(), v.u8(), v.u8(), v.u8(), v.u8()})); h->setTidInfo((int)v.uint(4)); - // the .msg leaves chunkLength unset ("TODO"); the wire layout is fixed at - // 16 (header) + 2 (BA control) + 2 (starting-sequence control) + 8 (compressed - // bitmap) = 28 bytes. - setChunkLength(c, B(28)); }}); // --- management frame bodies. Each is content-length-dependent (SSID, rates, the diff --git a/tests/serializer/serializer_chunk_roundtrip.test b/tests/serializer/serializer_chunk_roundtrip.test index 18fa3f2e235..3ab712fe87c 100644 --- a/tests/serializer/serializer_chunk_roundtrip.test +++ b/tests/serializer/serializer_chunk_roundtrip.test @@ -420,11 +420,10 @@ inet::ieee80211::Ieee80211ProbeResponseFrame::handoverParameters.avgBackoffTime inet::ieee80211::Ieee80211ProbeResponseFrame::handoverParameters.avgErrorRate inet::ieee80211::Ieee80211ProbeResponseFrame::handoverParameters.avgWaitTime inet::ieee80211::Ieee80211ProbeResponseFrame::handoverParameters.estAvailBW -// -- 802.11 Block Ack: multiTid/compressedBitmap are the pair of bits that select -// the concrete Basic/Compressed/MultiTid variant, so each concrete class pins them; -// the Starting Sequence Control fragment-number subfield is always 0 (802.11 does -// not fragment the frames a Block Ack covers), and ADDBA's blockAckAction is the -// action code its own class fixes +// The concrete Block Ack classes fix their Type bits. These producers use fragmentNumber = 0. +// Compressed ACK-policy and reserved fields have no field-preserving wire contract. +// The serializer writes zero for these fields and ignores received reserved bits. +// ADDBA fixes its action code through its concrete class. inet::ieee80211::Ieee80211AddbaRequest::_fragmentNumber inet::ieee80211::Ieee80211AddbaRequest::blockAckAction inet::ieee80211::Ieee80211BasicBlockAck::compressedBitmap @@ -434,11 +433,15 @@ inet::ieee80211::Ieee80211BasicBlockAckReq::compressedBitmap inet::ieee80211::Ieee80211BasicBlockAckReq::fragmentNumber inet::ieee80211::Ieee80211BasicBlockAckReq::multiTid inet::ieee80211::Ieee80211CompressedBlockAck::compressedBitmap +inet::ieee80211::Ieee80211CompressedBlockAck::blockAckPolicy inet::ieee80211::Ieee80211CompressedBlockAck::fragmentNumber inet::ieee80211::Ieee80211CompressedBlockAck::multiTid +inet::ieee80211::Ieee80211CompressedBlockAck::reserved +inet::ieee80211::Ieee80211CompressedBlockAckReq::barAckPolicy inet::ieee80211::Ieee80211CompressedBlockAckReq::compressedBitmap inet::ieee80211::Ieee80211CompressedBlockAckReq::fragmentNumber inet::ieee80211::Ieee80211CompressedBlockAckReq::multiTid +inet::ieee80211::Ieee80211CompressedBlockAckReq::reserved // -- MRP TLV length bytes: the serializer derives them from what it writes, so // the model field is not the value on the wire inet::MrpEnd::valueLength diff --git a/tests/unit/Ieee80211BlockAckWire_1.test b/tests/unit/Ieee80211BlockAckWire_1.test index 0cd32ee3a46..41c8138da32 100644 --- a/tests/unit/Ieee80211BlockAckWire_1.test +++ b/tests/unit/Ieee80211BlockAckWire_1.test @@ -1,36 +1,230 @@ %description: -Check Basic and Compressed bitmap values after independent byte decode. -The decoder must preserve the same bitmap contents without unowned temporary objects. -Type validation remains outside this prerequisite. +Check Basic Type 0 and Compressed Type 2 BAR and Block Ack against independent octets. +Check reserved bits, unsupported Types, malformed fragment subfields, and fixed lengths. +The wire oracle follows the C1 contract in the Compressed Block Ack replacement plan. +Basic fields preserve the retained Type 0 compatibility contract. +Compressed uses the non-HE, 64-position format from IEEE Std 802.11-2024, 9.3.1.7.2 and 9.3.1.8.2. +This test does not establish complete exchanges or response airtime. %includes: #include "inet/linklayer/ieee80211/mac/Ieee80211MacHeaderSerializer.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h" +%global: using namespace inet; using namespace inet::ieee80211; -%activity: -for (bool compressed : {false, true}) { - std::vector bytes(compressed ? 28 : 148, 0); - bytes[0] = 0x94; - bytes[16] = compressed ? 4 : 0; - bytes[20] = 1; +class BlockAckWireSerializer : public Ieee80211MacHeaderSerializer +{ + public: + using Ieee80211MacHeaderSerializer::serializeFields; + using Ieee80211MacHeaderSerializer::deserializeFields; +}; + +static std::vector encode(const Ptr& header) +{ + BlockAckWireSerializer serializer; + MemoryOutputStream stream; + serializer.serializeFields(stream, header); + return stream.getData(); +} + +static Ptr decode(const std::vector& bytes) +{ MemoryInputStream stream(bytes); - auto decoded = Chunk::deserialize(stream, typeid(Ieee80211MacHeader)); - if (compressed) { - auto response = dynamicPtrCast(decoded); - ASSERT(response && response->getBlockAckBitmap().getSize() == 64); - ASSERT(response->getBlockAckBitmap().getBit(0)); - ASSERT(!response->getBlockAckBitmap().getBit(63)); + return Chunk::deserialize(stream, typeid(Ieee80211MacHeader)); +} + +static void requireWriteFailure(const Ptr& header) +{ + bool rejected = false; + try { encode(header); } + catch (const cRuntimeError&) { rejected = true; } + ASSERT(rejected); +} + +static void addresses(const Ptr& header) +{ + header->setReceiverAddress(MacAddress("02:11:22:33:44:55")); + header->setTransmitterAddress(MacAddress("06:aa:bb:cc:dd:ee")); + header->setDurationField(SimTime(0x1234, SIMTIME_US)); +} + +// Each vector is independent of the serializer output. +static std::vector golden(bool response, bool compressed) +{ + std::vector bytes = { + uint8_t(response ? 0x94 : 0x84), 0x00, 0x34, 0x12, + 0x02, 0x11, 0x22, 0x33, 0x44, 0x55, + 0x06, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, + uint8_t(compressed ? 0x04 : 0x21), 0x50, 0xe0, 0xff + }; + if (response) { + bytes.resize(compressed ? 28 : 148, 0); + // SSN 4094: positions 0, 1, 2, and 63 represent 4094, 4095, 0, and 61. + if (compressed) { + bytes[20] = 0x07; + bytes[27] = 0x80; + } + else { + // Basic position 0 reports fragments 0 and 15; position 63 reports fragment 8. + bytes[20] = 0x01; + bytes[21] = 0x80; + bytes[147] = 0x01; + } + } + return bytes; +} + +%activity: +OriginatorBlockAckProcedure procedure; +auto built = dynamicPtrCast( + procedure.buildCompressedBlockAckReqFrame(MacAddress("02:11:22:33:44:55"), 5, SequenceNumberCyclic(4094))); +ASSERT(built && built->getReceiverAddress() == MacAddress("02:11:22:33:44:55")); +ASSERT(built->getTidInfo() == 5 && built->getStartingSequenceNumber().get() == 4094); +ASSERT(built->getFragmentNumber() == 0 && built->getChunkLength() == B(20)); +addresses(built); +ASSERT(encode(built) == golden(false, true)); + +for (bool response : {false, true}) { + for (bool compressed : {false, true}) { + Ptr header; + if (response) { + if (compressed) { + auto ba = makeShared(); + ba->setBlockAckPolicy(true); + ba->setReserved(0x1ff); + ba->setTidInfo(5); + ba->setStartingSequenceNumber(SequenceNumberCyclic(4094)); + ba->setBlockAckBitmap(BitVector(std::vector{7, 0, 0, 0, 0, 0, 0, 0x80})); + ASSERT(ba->getChunkLength() == B(28)); + header = ba; + } + else { + auto ba = makeShared(); + ba->setBlockAckPolicy(true); + ba->setReserved(4); + ba->setTidInfo(5); + ba->setStartingSequenceNumber(SequenceNumberCyclic(4094)); + for (int i = 0; i < 64; i++) + ba->setBlockAckBitmap(i, BitVector(std::vector{uint8_t(i == 0), uint8_t(i == 0 ? 0x80 : i == 63 ? 1 : 0)})); + ASSERT(ba->getChunkLength() == B(148)); + header = ba; + } + } + else { + if (compressed) { + auto bar = makeShared(); + bar->setBarAckPolicy(true); + bar->setReserved(0x1ff); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(4094)); + header = bar; + } + else { + auto bar = makeShared(); + bar->setBarAckPolicy(true); + bar->setReserved(4); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(4094)); + header = bar; + } + } + addresses(header); + auto expected = golden(response, compressed); + ASSERT(encode(header) == expected); + ASSERT(header->getChunkLength() == B(expected.size())); + if (response) { + auto fcs = makeShared(); + ASSERT(header->getChunkLength() + fcs->getChunkLength() == B(compressed ? 32 : 152)); + } + auto result = decode(expected); + ASSERT(result->isCorrect()); + ASSERT(result->isComplete()); + ASSERT(encode(result) == expected); + if (response) { + if (compressed) { + auto ba = dynamicPtrCast(result); + ASSERT(ba && ba->getTidInfo() == 5 && ba->getStartingSequenceNumber().get() == 4094); + ASSERT(ba->getBlockAckBitmap().getSize() == 64); + ASSERT(ba->getBlockAckBitmap().getBit(0) && ba->getBlockAckBitmap().getBit(2)); + ASSERT(ba->getBlockAckBitmap().getBit(63) && !ba->getBlockAckBitmap().getBit(62)); + } + else { + auto ba = dynamicPtrCast(result); + ASSERT(ba && ba->getReserved() == 4 && ba->getBlockAckPolicy()); + ASSERT(ba->getBlockAckBitmap(0).getBit(15)); + ASSERT(ba->getBlockAckBitmap(63).getBit(8)); + } + } + else { + if (compressed) { + auto bar = dynamicPtrCast(result); + ASSERT(bar && bar->getTidInfo() == 5 && bar->getStartingSequenceNumber().get() == 4094); + } + else { + auto bar = dynamicPtrCast(result); + ASSERT(bar && bar->getReserved() == 4 && bar->getBarAckPolicy()); + } + } + if (compressed) { + auto reserved = expected; + reserved[16] |= 0xe1; + reserved[17] |= 0x0f; + auto ignored = decode(reserved); + ASSERT(ignored->isCorrect()); + ASSERT(encode(ignored) == expected); + if (response) { + auto ba = dynamicPtrCast(ignored); + ASSERT(ba && !ba->getBlockAckPolicy() && ba->getReserved() == 0); + } + else { + auto bar = dynamicPtrCast(ignored); + ASSERT(bar && !bar->getBarAckPolicy() && bar->getReserved() == 0); + } + auto malformed = expected; + malformed[18] |= 1; + ASSERT(!decode(malformed)->isCorrect()); + if (response) + dynamicPtrCast(header)->setFragmentNumber(1); + else + dynamicPtrCast(header)->setFragmentNumber(1); + requireWriteFailure(header); + } + else { + for (int reserved : {1, 2, 3}) { + if (response) + dynamicPtrCast(header)->setReserved(reserved); + else + dynamicPtrCast(header)->setReserved(reserved); + requireWriteFailure(header); + } + } + for (size_t length : {size_t(17), expected.size() - 1}) { + auto shortFrame = expected; + shortFrame.resize(length); + ASSERT(!decode(shortFrame)->isComplete()); + } } - else { - auto response = dynamicPtrCast(decoded); - ASSERT(response && response->getBlockAckBitmapArraySize() == 64); - ASSERT(response->getBlockAckBitmap(0).getBit(0)); - ASSERT(!response->getBlockAckBitmap(63).getBit(15)); + for (int type = 0; type < 16; type++) { + if (type == 0 || type == 2) + continue; + auto unsupported = golden(response, true); + unsupported[16] = type << 1; + auto result = decode(unsupported); + ASSERT(!result->isCorrect()); + ASSERT(!dynamicPtrCast(result)); + ASSERT(!dynamicPtrCast(result)); + ASSERT(!dynamicPtrCast(result)); + ASSERT(!dynamicPtrCast(result)); } } -EV << "Bitmap decode checks passed.\n"; +for (int bits : {0, 63, 65}) { + auto ba = makeShared(); + ba->setBlockAckBitmap(bits == 0 ? BitVector() : BitVector(0u, bits)); + requireWriteFailure(ba); +} +EV << "Block Ack wire checks passed\n"; %contains: stdout -Bitmap decode checks passed. +Block Ack wire checks passed From 9a1d6ac5623926d697c4a8873819deccc4ad177b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:50:08 +0200 Subject: [PATCH 13/41] ieee80211: add: prepare QoS DATA without queue extraction Before this commit, QoS data services must extract source frames before they can create an aggregate. A caller cannot inspect that aggregate before queue removal and sequence assignment. After this commit, the service creates an owned preview while original MSDUs remain in their queue. Preparation copies the next sequence value without consumption. Successful commitment validates source identity, eligibility, lifetime, aggregation permission, and sequence state. It transfers the same preview and assigns its sequence number. Refusal preserves the preview and all source frames. Ordinary commitment uses normal dequeue for the head or selected extraction for a later eligible frame. The service copies completed region metadata into the preview before source deletion. Queue service effects occur once. Aggregation retains its existing source-removal behavior. For example, ordinary DATA that waits 2 ms retains 2 ms of queueing time and one queue departure after commitment. Direct service tests cover head and non-head commitment, refusal, stale state, and cancellation. Existing extraction remains available. Later runtime activation uses this contract to admit the complete DATA exchange before destructive preparation. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.add | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 6 + doc/src/migration-guide/index.rst | 5 + .../contract/IOriginatorQosMacDataService.h | 20 ++ .../originator/OriginatorQosMacDataService.cc | 155 +++++++++ .../originator/OriginatorQosMacDataService.h | 3 + tests/module/Ieee80211PreparedQosData_1.test | 294 ++++++++++++++++++ 6 files changed, 483 insertions(+) create mode 100644 tests/module/Ieee80211PreparedQosData_1.test diff --git a/WHATSNEW b/WHATSNEW index ec626754ce9..47096b8c45d 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -470,6 +470,12 @@ Notable backward incompatible changes are the following: HT Operation now preserves RIFS Mode through management conversion and equality checks. The MIB permits RIFS under unprotected HT operation and clears the permission for VHT. A recipient can therefore check the actual advertised permission before it recognizes a RIFS relation. This change adds no RIFS transmission scheduler. +57. IEEE 802.11 reversible DATA preparation + + QoS data services now supply an owned DATA preview before queue extraction or sequence assignment. A successful commit transfers that same preview to the caller. A refused commit preserves the preview and original queue frames. Custom services must implement the preparation contract in the migration guide. The existing extraction path remains available. + + Commitment of ordinary DATA now preserves normal queue service effects. Queue output statistics count the departure, and the retained preview includes elapsed queueing time and queue events. This also applies when a deferred head causes selection of a later eligible frame. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 7a2be4ab354..5a2ce312bea 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -38,6 +38,11 @@ The serializer decodes the complete four-bit Type field. Type 0 retains Basic co Compressed producers must supply Fragment Number zero and a 64-bit bitmap. A Compressed Block Ack header chunk contains 28 bytes before FCS. Both BAR profiles occupy 24 bytes with FCS. Keep the corresponding header chunk and trailer lengths consistent. The serializer rejects malformed wire fields before runtime processing. +IEEE 802.11 reversible DATA preparation +------------------------------------- + +Custom QoS data services must implement the reversible preparation operations in ``IOriginatorQosMacDataService``. ``prepareFrame()`` creates an owned preview and retains original MSDUs in their queue. ``isPreparationValid()`` checks current source identity, eligibility, lifetime, sequence state, and aggregation permission. ``commitPreparedFrame()`` transfers the same preview pointer only after successful validation. Failure must preserve the preview and all original queue frames. + IEEE 802.11 Basic Block Ack extension points ------------------------------------------ diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h index e66fa555666..04f0ecda71b 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h @@ -7,12 +7,27 @@ #ifndef __INET_IORIGINATORQOSMACDATASERVICE_H #define __INET_IORIGINATORQOSMACDATASERVICE_H +#include + #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h" namespace inet { namespace ieee80211 { +/** Owns a reversible DATA preview. Source packet identities refer to frames still owned by the queue. */ +struct INET_API PreparedQosData : public cObject +{ + std::unique_ptr packet; + queueing::IPacketQueue *queue = nullptr; + std::vector sourceIds; + bool aggregate = false; + + ~PreparedQosData() override; + void setPacket(Packet *value); + Packet *releasePacket(); +}; + class INET_API IOriginatorQosMacDataService : public IOriginatorMacDataService { public: @@ -20,6 +35,11 @@ class INET_API IOriginatorQosMacDataService : public IOriginatorMacDataService virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const = 0; virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const = 0; virtual bool hasAMsduAggregation() const = 0; + // These QoS DATA methods separate reversible preparation from extraction and sequence assignment. + virtual std::unique_ptr prepareFrame(queueing::IPacketQueue *queue, bool allowAggregation) = 0; + virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const = 0; + // Success transfers the preview to the caller. Failure retains the preview and all queued sources. + virtual Packet *commitPreparedFrame(PreparedQosData& preparation) = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc index 40f7e33106c..7986ca4f13c 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc @@ -22,6 +22,27 @@ namespace ieee80211 { Define_Module(OriginatorQosMacDataService); +PreparedQosData::~PreparedQosData() +{ + if (packet) + drop(packet.get()); +} + +void PreparedQosData::setPacket(Packet *value) +{ + if (packet) + drop(packet.get()); + packet.reset(value); + if (packet) + take(packet.get()); +} + +Packet *PreparedQosData::releasePacket() +{ + drop(packet.get()); + return packet.release(); +} + void OriginatorQosMacDataService::initialize() { aMsduAggregationPolicy = dynamic_cast(getSubmodule("msduAggregationPolicy")); @@ -35,6 +56,140 @@ void OriginatorQosMacDataService::initialize() fragmentation = new Fragmentation(); } +std::unique_ptr OriginatorQosMacDataService::prepareFrame(queueing::IPacketQueue *queue, bool allowAggregation) +{ + Enter_Method("prepareFrame"); + if (expireFrames) + expireFrames(); + auto selected = peekEligibleFrame(queue); + if (!selected) + return nullptr; + auto selectedHeader = dynamicPtrCast(selected->peekAtFront()); + if (!selectedHeader || selectedHeader->getType() != ST_DATA_WITH_QOS) + return nullptr; + auto result = std::make_unique(); + result->queue = queue; + std::vector sources{selected}; + auto module = dynamic_cast(queue); + auto head = queue->canPullPacket(module ? module->gate("out") : nullptr); + if (allowAggregation && selected == head && aMsduAggregationPolicy && (!aMsduPermitted || aMsduPermitted(selected))) { + std::unique_ptr> proposed(aMsduAggregationPolicy->computeAggregateFrames(queue)); + bool valid = proposed && !proposed->empty() && proposed->front() == selected; + std::set unique; + if (proposed) { + for (auto frame : *proposed) { + bool present = false; + for (int i = 0; i < queue->getNumPackets(); i++) + present |= queue->getPacket(i) == frame; + valid &= present && unique.insert(frame).second && + (!extractionEligible || extractionEligible(frame)) && (!aMsduPermitted || aMsduPermitted(frame)); + } + } + if (valid) { + sources = *proposed; + result->aggregate = true; + } + } + for (auto source : sources) + result->sourceIds.push_back(source->getId()); + if (result->aggregate) { + std::vector duplicates; + for (auto source : sources) + duplicates.push_back(source->dup()); + result->setPacket(aMsduAggregation->aggregateFrames(&duplicates)); + } + else + result->setPacket(selected->dup()); + // The preview carries the next value without consuming the sequence counter. + auto header = result->packet->removeAtFront(); + header->setSequenceNumber(getNextSequenceNumber(header->getReceiverAddress(), header->getTid())); + result->packet->insertAtFront(header); + return result; +} + +bool OriginatorQosMacDataService::isPreparationValid(const PreparedQosData& preparation, simtime_t start) const +{ + if (!preparation.packet || !preparation.queue || preparation.sourceIds.empty()) + return false; + auto header = preparation.packet->peekAtFront(); + if (header->getSequenceNumber() != getNextSequenceNumber(header->getReceiverAddress(), header->getTid())) + return false; + for (auto id : preparation.sourceIds) { + Packet *source = nullptr; + for (int i = 0; i < preparation.queue->getNumPackets(); i++) { + auto candidate = preparation.queue->getPacket(i); + if (candidate->getId() == id) { + source = candidate; + break; + } + } + if (!source || (lifetimeHandler && lifetimeHandler->isExpired(source, start)) || + (extractionEligible && !extractionEligible(source)) || + (preparation.aggregate && aMsduPermitted && !aMsduPermitted(source))) + return false; + } + return true; +} + +Packet *OriginatorQosMacDataService::commitPreparedFrame(PreparedQosData& preparation) +{ + Enter_Method("commitPreparedFrame"); + if (!isPreparationValid(preparation, simTime())) + return nullptr; + std::vector sources; + std::vector trackedIds; + simtime_t deadline = SIMTIME_MAX; + for (auto id : preparation.sourceIds) { + for (int i = 0; i < preparation.queue->getNumPackets(); i++) { + auto source = preparation.queue->getPacket(i); + if (source->getId() == id) { + sources.push_back(source); + if (lifetimeHandler && lifetimeHandler->getDeadline(source) != SIMTIME_MAX) { + trackedIds.push_back(id); + deadline = lifetimeHandler->getDeadline(source); + } + break; + } + } + } + for (auto source : sources) { + if (preparation.aggregate) + preparation.queue->removePacket(source); + else { + auto module = dynamic_cast(preparation.queue); + auto next = preparation.queue->canPullPacket(module ? module->gate("out") : nullptr); + auto extracted = source == next ? preparation.queue->dequeuePacket() : + check_and_cast(preparation.queue)->extractPacket(source); + ASSERT(extracted == source); + // The preview predates extraction. Preserve the queue's completed service metadata. + preparation.packet->copyRegionTags(*source, source->getFrontOffset(), + preparation.packet->getFrontOffset(), source->getDataLength()); + } + take(source); + } + if (lifetimeHandler) + lifetimeHandler->prepareFrameReplacement(trackedIds); + for (auto source : sources) + delete source; + auto packet = preparation.releasePacket(); + take(packet); + if (lifetimeHandler) { + if (preparation.aggregate) { + auto edca = check_and_cast(getParentModule()->getSubmodule("edca")); + lifetimeHandler->registerFrame(packet, edca->classifyFrame(packet->peekAtFront())); + } + else if (deadline != SIMTIME_MAX) + lifetimeHandler->registerFragments({packet}, deadline); + } + auto header = packet->removeAtFront(); + assignSequenceNumber(header); + packet->insertAtFront(header); + packet->addTagIfAbsent()->setAllocationIndex(nextDataAllocationIndex++); + if (preparation.aggregate) + emit(packetAggregatedSignal, packet); + return packet; +} + Packet *OriginatorQosMacDataService::aMsduAggregateIfNeeded(queueing::IPacketQueue *pendingQueue, Packet *selected) { auto subframes = aMsduAggregationPolicy->computeAggregateFrames(pendingQueue); diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h index f6590365817..73bda528989 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h @@ -61,6 +61,9 @@ class INET_API OriginatorQosMacDataService : public IOriginatorQosMacDataService virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const override; virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const override; virtual bool hasAMsduAggregation() const override { return aMsduAggregationPolicy != nullptr; } + virtual std::unique_ptr prepareFrame(queueing::IPacketQueue *queue, bool allowAggregation) override; + virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const override; + virtual Packet *commitPreparedFrame(PreparedQosData& preparation) override; virtual ~OriginatorQosMacDataService(); void setLifetimeHandler(EdcaTransmitLifetimeHandler *handler, std::function expiration) { lifetimeHandler = handler; diff --git a/tests/module/Ieee80211PreparedQosData_1.test b/tests/module/Ieee80211PreparedQosData_1.test new file mode 100644 index 00000000000..6c7bc79a9b6 --- /dev/null +++ b/tests/module/Ieee80211PreparedQosData_1.test @@ -0,0 +1,294 @@ +%description: +Check reversible QoS DATA preparation through the production data service and PacketQueue. +Ten runs combine ordinary and aggregate previews with cancellation, commitment, stale sources, and stale sequence state. +Preparation must preserve source identities, ownership, deadlines, and sequence counters. +Commitment must return the same preview pointer and consume one sequence number and allocation index. +Ordinary commitment preserves queue service signals, elapsed queueing time, and queue events for head and selected non-head frames. +Refusal must preserve the preview and the queue state that follows the explicit invalidation. +The fixture uses no HCF runtime path. Its Edca subclass supplies only the production access-category mapping for aggregate lifetime registration. + +%extraargs: -r 0..9 + +%file: PreparedData.cc +#include + +#include "inet/common/Simsignals.h" +#include "inet/common/TimeTag_m.h" +#include "inet/common/PacketEventTag.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/channelaccess/Edca.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h" +#include "inet/queueing/queue/PacketQueue.h" + +using namespace inet; +using namespace inet::ieee80211; + +// Aggregate commitment uses classifyFrame(). This fixture does not exercise channel access. +class PreparedEdca : public Edca { + protected: + void initialize(int) override {} +}; +Define_Module(PreparedEdca); + +class PreparedService : public OriginatorQosMacDataService { + std::unique_ptr ownedLifetime; + protected: + void initialize() override { + OriginatorQosMacDataService::initialize(); + auto lifetime = SimTime(1, SIMTIME_S); + ownedLifetime = std::make_unique(lifetime, lifetime, lifetime, lifetime); + setLifetimeHandler(ownedLifetime.get(), {}); + setEligibility([](Packet *) { return true; }, [](Packet *) { return true; }); + } + public: + EdcaTransmitLifetimeHandler *lifetime() const { return ownedLifetime.get(); } + int64_t allocations() const { return nextDataAllocationIndex; } +}; +Define_Module(PreparedService); + +class PreparedDataTest : public cSimpleModule, public cListener { + const MacAddress peer{"02:00:00:00:00:02"}; + PreparedService *service = nullptr; + queueing::PacketQueue *queue = nullptr; + queueing::PacketQueue *otherQueue = nullptr; + std::vector sources; + std::vector sourceIds; + std::vector sourceOwners; + std::vector deadlines; + std::unique_ptr preparation; + Packet *preview = nullptr; + int removals = 0; + int pulls = 0; + int aggregates = 0; + + bool aggregate() const { return par("aggregate") && operation() != "selectedCommit"; } + std::string operation() const { return par("operation").stdstringValue(); } + + Packet *enqueue(queueing::PacketQueue *destination, const char *name) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(peer); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:01")); + header->setAddress3(peer); + header->setTid(0); + header->setSequenceNumber(SequenceNumberCyclic(77)); + auto packet = new Packet(name, header); + packet->insertAtBack(makeShared(B(100))); + packet->insertAtBack(makeShared()); + auto time = packet->addRegionTag(header->getChunkLength(), B(100)); + time->setPacketTotalTimesArraySize(1); + time->setPacketTotalTimes(0, SIMTIME_ZERO); + packet->addRegionTag(header->getChunkLength(), B(100)); + packet->setArrivalTime(simTime()); + destination->enqueuePacket(packet); + service->lifetime()->registerFrame(packet, AC_BE); + return packet; + } + + void assertSources(int first, int expectedSequence = 0, int expectedAllocations = 0) const { + ASSERT(queue->getNumPackets() == int(sources.size()) - first); + ASSERT(service->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(expectedSequence)); + ASSERT(service->allocations() == expectedAllocations); + int index = 0; + for (int i = 0; i < int(sources.size()); i++) { + if (first && (operation() == "selectedCommit" ? i == 1 : i < first)) + continue; + auto packet = queue->getPacket(index++); + ASSERT(packet == sources[i] && packet->getId() == sourceIds[i]); + ASSERT(packet->getOwner() == sourceOwners[i]); + ASSERT(packet->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(!packet->findTag()); + ASSERT(service->lifetime()->findFrame(sourceIds[i]) == packet); + ASSERT(service->lifetime()->getDeadline(packet) == deadlines[i]); + ASSERT(packet->findRegionTag(packet->peekAtFront()->getChunkLength(), B(100))->getPacketTotalTimes(0) == SIMTIME_ZERO); + } + } + + void deleteCommitted(Packet *packet) { + service->lifetime()->forgetFrame(packet->getId()); + take(packet); + delete packet; + } + + void cancelPreview() { + ASSERT(preparation->packet.get() == preview && preview->getOwner() == preparation.get()); + auto live = cOwnedObject::getLiveObjectCount(); + preparation.reset(); + ASSERT(cOwnedObject::getLiveObjectCount() == live - 1); + preview = nullptr; + } + + void prepare() { + for (const char *name : {"first-msdu", "second-msdu"}) { + auto packet = enqueue(queue, name); + sources.push_back(packet); + sourceIds.push_back(packet->getId()); + sourceOwners.push_back(packet->getOwner()); + deadlines.push_back(service->lifetime()->getDeadline(packet)); + } + if (operation() == "selectedCommit") + service->setEligibility([](Packet *packet) { return !packet->isName("first-msdu"); }, [](Packet *) { return true; }); + preparation = service->prepareFrame(queue, aggregate()); + ASSERT(preparation && preparation->packet); + preview = preparation->packet.get(); + ASSERT(preview != sources[0] && preview != sources[1]); + ASSERT(preview->getOwner() == preparation.get()); + ASSERT(preparation->queue == queue && preparation->aggregate == aggregate()); + ASSERT(preparation->sourceIds.size() == (aggregate() ? 2 : 1)); + for (size_t i = 0; i < preparation->sourceIds.size(); i++) + ASSERT(preparation->sourceIds[i] == sourceIds[operation() == "selectedCommit" ? 1 : i]); + auto header = preview->peekAtFront(); + ASSERT(header->getAMsduPresent() == aggregate()); + ASSERT(header->getSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(!preview->findTag()); + ASSERT(service->lifetime()->findFrame(preview->getId()) == nullptr); + ASSERT(service->isPreparationValid(*preparation, simTime())); + ASSERT(removals == 0 && pulls == 0 && aggregates == 0); + assertSources(0); + scheduleAt(SimTime(3, SIMTIME_MS), new cMessage("check")); + } + + void check() { + assertSources(0); + ASSERT(service->isPreparationValid(*preparation, simTime())); + if (operation() == "commit" || operation() == "selectedCommit") { + auto committed = service->commitPreparedFrame(*preparation); + ASSERT(committed == preview && !preparation->packet); + ASSERT(committed->getOwner() == service); + ASSERT(committed->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(committed->getTag()->getAllocationIndex() == 0); + ASSERT(!service->isPreparationValid(*preparation, simTime())); + int consumed = aggregate() ? 2 : 1; + for (int i = 0; i < consumed; i++) + ASSERT(service->lifetime()->findFrame(sourceIds[operation() == "selectedCommit" ? 1 : i]) == nullptr); + auto expectedDeadline = aggregate() ? simTime() + SimTime(1, SIMTIME_S) : deadlines[operation() == "selectedCommit" ? 1 : 0]; + ASSERT(service->lifetime()->getDeadline(committed) == expectedDeadline); + ASSERT(removals == (aggregate() ? consumed : 0) && pulls == (aggregate() ? 0 : 1) && aggregates == (aggregate() ? 1 : 0)); + if (!aggregate()) { + auto offset = committed->peekAtFront()->getChunkLength(); + auto time = committed->findRegionTag(offset, B(100)); + ASSERT(time && time->getPacketTotalTimes(0) == SimTime(2, SIMTIME_MS)); + auto events = committed->findRegionTag(offset, B(100)); + ASSERT(events && events->getPacketEventsArraySize() == 1); + ASSERT(events->getPacketEvents(0)->getKind() == PEK_QUEUED); + ASSERT(events->getPacketEvents(0)->getPacketDuration() == SimTime(2, SIMTIME_MS)); + } + assertSources(consumed, 1, 1); + deleteCommitted(committed); + preparation.reset(); + preview = nullptr; + } + else if (operation() == "staleSource") { + auto removed = queue->getPacket(0); + queue->removePacket(removed); + service->lifetime()->forgetFrame(removed->getId()); + take(removed); + delete removed; + ASSERT(!service->isPreparationValid(*preparation, simTime())); + ASSERT(service->commitPreparedFrame(*preparation) == nullptr); + assertSources(1); + ASSERT(removals == 1 && pulls == 0 && aggregates == 0); + cancelPreview(); + assertSources(1); + } + else if (operation() == "staleSequence") { + enqueue(otherQueue, "independent-msdu"); + auto other = service->prepareFrame(otherQueue, false); + ASSERT(other && service->isPreparationValid(*other, simTime())); + auto otherPreview = other->packet.get(); + auto committed = service->commitPreparedFrame(*other); + ASSERT(committed == otherPreview && otherQueue->isEmpty()); + ASSERT(!service->isPreparationValid(*preparation, simTime())); + ASSERT(service->commitPreparedFrame(*preparation) == nullptr); + assertSources(0, 1, 1); + ASSERT(removals == 0 && pulls == 0 && aggregates == 0); + deleteCommitted(committed); + cancelPreview(); + assertSources(0, 1, 1); + } + else { + ASSERT(operation() == "cancel"); + cancelPreview(); + assertSources(0); + ASSERT(removals == 0 && pulls == 0 && aggregates == 0); + } + while (!queue->isEmpty()) { + auto packet = queue->getPacket(0); + queue->removePacket(packet); + deleteCommitted(packet); + } + ASSERT(otherQueue->isEmpty() && service->lifetime()->getNumFrames() == 0); + std::cout << "Prepared QoS DATA assertions passed: aggregate=" << aggregate() + << " operation=" << operation() << ".\n"; + endSimulation(); + } + + protected: + void initialize() override { + service = check_and_cast(getModuleByPath("^.service")); + queue = check_and_cast(getModuleByPath("^.queue")); + otherQueue = check_and_cast(getModuleByPath("^.otherQueue")); + queue->subscribe(packetRemovedSignal, this); + queue->subscribe(packetPulledSignal, this); + service->subscribe(IOriginatorMacDataService::packetAggregatedSignal, this); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("prepare")); + } + void receiveSignal(cComponent *, simsignal_t signal, cObject *, cObject *) override { + if (signal == packetRemovedSignal) removals++; + if (signal == packetPulledSignal) pulls++; + if (signal == IOriginatorMacDataService::packetAggregatedSignal) aggregates++; + } + void handleMessage(cMessage *message) override { + bool first = message->isName("prepare"); + delete message; + if (first) + prepare(); + else + check(); + } +}; +Define_Module(PreparedDataTest); + +%file: test.ned +import inet.common.SimpleModule; +import inet.linklayer.ieee80211.mac.originator.OriginatorQosMacDataService; +import inet.queueing.queue.PacketQueue; + +simple PreparedEdca extends SimpleModule { parameters: @class(::PreparedEdca); } +module PreparedService extends OriginatorQosMacDataService { parameters: @class(::PreparedService); } +simple PreparedDataTest { + parameters: + bool aggregate; + string operation; + @class(::PreparedDataTest); +} +network PreparedDataNetwork { + submodules: + edca: PreparedEdca; + service: PreparedService; + queue: PacketQueue; + otherQueue: PacketQueue; + test: PreparedDataTest; + connections allowunconnected: +} + +%inifile: omnetpp.ini +[General] +network = PreparedDataNetwork +ned-path = .;../../../../src;../../lib +sim-time-limit = 10ms +seed-set = 0 +cmdenv-express-mode = true +record-scalar-results = false +record-vector-results = false +*.test.aggregate = ${aggregate=false,true} +*.test.operation = ${operation="cancel","commit","staleSource","staleSequence","selectedCommit"} +*.service.msduAggregationPolicy.subframeNumThreshold = 2 +*.service.msduAggregationPolicy.maxAMsduSize = 1000 +*.service.mpduAggregationPolicy.typename = "" +*.service.fragmentationPolicy.typename = "" + +%contains: stdout +Prepared QoS DATA assertions passed: From 30afc0aaa3e68fd5462a94f8a4bd70568ec633c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:50:34 +0200 Subject: [PATCH 14/41] ieee80211: add: retain explicit Compressed receipt state Before this commit, recipient receipt state uses the Basic fragment bitmap. Delivery cleanup cannot supply the independent complete-MPDU receipt evidence that a Compressed response needs. After this commit, the record retains explicit complete receipts within its Compressed window. The agreement selects that record profile. The response builder copies receipt truth into a 64-bit bitmap. Positive receipts survive delivery cleanup, while absent positions remain zero. For example, a window at 4094 retains sequence 4094 after delivery and moves across sequence wrap without false positive bits. The direct record fixture checks window movement, the preceding receipt, absent positions, and response construction. HCF still refuses Compressed selection. This prerequisite activates no incomplete exchange. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.add | test whatsnew | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 ++ .../ieee80211/mac/blockack/BlockAckRecord.cc | 44 ++++++++++++ .../ieee80211/mac/blockack/BlockAckRecord.h | 9 +++ .../mac/blockack/RecipientBlockAckAgreement.h | 8 +++ .../blockack/RecipientBlockAckProcedure.cc | 14 ++++ .../Ieee80211CompressedBlockAckRecord_1.test | 71 +++++++++++++++++++ 6 files changed, 150 insertions(+) create mode 100644 tests/unit/Ieee80211CompressedBlockAckRecord_1.test diff --git a/WHATSNEW b/WHATSNEW index 47096b8c45d..0c95bd28073 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -476,6 +476,10 @@ Notable backward incompatible changes are the following: Commitment of ordinary DATA now preserves normal queue service effects. Queue output statistics count the departure, and the retained preview includes elapsed queueing time and queue events. This also applies when a deferred head causes selection of a later eligible frame. +58. Compressed receipt helpers + + Compressed receipt helpers now retain positive receipt state independently of delivery. HCF still refuses the Compressed profile until complete exchange support exists. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.cc b/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.cc index 919bd813a6f..fa285580703 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.cc @@ -53,6 +53,50 @@ void BlockAckRecord::removeAckStates(SequenceNumberCyclic sequenceNumber) } } +void BlockAckRecord::initializeCompressedWindow(SequenceNumberCyclic start, int size) +{ + ASSERT(start.isSpecified() && size > 0 && size <= 64); + windowStart = start; + windowSize = size; + completeReceipts.clear(); +} + +void BlockAckRecord::advanceCompressedWindow(SequenceNumberCyclic start) +{ + // IEEE Std 802.11-2024, 10.25.6.3: retain explicit receipt truth at WinStartR - 1. + if (!(windowStart < start)) + return; + windowStart = start; + for (auto it = completeReceipts.begin(); it != completeReceipts.end();) { + auto distance = (*it - windowStart.get() + 4096) % 4096; + if (distance >= windowSize && distance != 4095) + it = completeReceipts.erase(it); + else + ++it; + } +} + +void BlockAckRecord::compressedFrameReceived(const Ptr& header) +{ + ASSERT(header->getFragmentNumber() == 0 && !header->getMoreFragments()); + auto sequence = header->getSequenceNumber(); + // IEEE Std 802.11-2024, 10.25.6.3: advance before duplicate removal or reorder insertion. + if (windowStart <= sequence && !(sequence < windowStart + windowSize)) + advanceCompressedWindow(sequence - windowSize + 1); + if (windowStart <= sequence && sequence < windowStart + windowSize) + completeReceipts.insert(sequence.get()); +} + +bool BlockAckRecord::hasCompleteReceipt(SequenceNumberCyclic sequenceNumber) const +{ + return completeReceipts.count(sequenceNumber.get()) != 0; +} + +bool BlockAckRecord::getCompressedAckState(SequenceNumberCyclic sequenceNumber) const +{ + return windowStart <= sequenceNumber && sequenceNumber < windowStart + windowSize && hasCompleteReceipt(sequenceNumber); +} + } /* namespace ieee80211 */ } /* namespace inet */ diff --git a/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h b/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h index 971be8a8af9..1c90bf392dc 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h @@ -25,6 +25,9 @@ class INET_API BlockAckRecord MacAddress originatorAddress = MacAddress::UNSPECIFIED_ADDRESS; Tid tid = -1; std::map acknowledgmentState; + SequenceNumberCyclic windowStart; + int windowSize = 64; // Sequence positions; the Compressed profile permits 1..64. + std::set completeReceipts; public: BlockAckRecord(MacAddress originatorAddress, Tid tid); @@ -33,6 +36,12 @@ class INET_API BlockAckRecord void blockAckPolicyFrameReceived(const Ptr& header); bool getAckState(SequenceNumberCyclic sequenceNumber, FragmentNumber fragmentNumber); void removeAckStates(SequenceNumberCyclic sequenceNumber); + void initializeCompressedWindow(SequenceNumberCyclic start, int size); + void compressedFrameReceived(const Ptr& header); + void advanceCompressedWindow(SequenceNumberCyclic start); + bool getCompressedAckState(SequenceNumberCyclic sequenceNumber) const; + bool hasCompleteReceipt(SequenceNumberCyclic sequenceNumber) const; + SequenceNumberCyclic getWindowStart() const { return windowStart; } MacAddress getOriginatorAddress() { return originatorAddress; } Tid getTid() { return tid; } diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h index 6e9634cae6f..db10d2d489b 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h @@ -9,6 +9,7 @@ #define __INET_RECIPIENTBLOCKACKAGREEMENT_H #include "inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h" +#include "inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h" namespace inet { namespace ieee80211 { @@ -25,6 +26,7 @@ class INET_API RecipientBlockAckAgreement : public cObject simtime_t expirationTime = -1; SequenceNumberCyclic highestReceivedSequence; int highestReceivedFragment = 0; + BlockAckVariant variant = BlockAckVariant::BASIC; public: RecipientBlockAckAgreement(MacAddress originatorAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber, int bufferSize, simtime_t blockAckTimeoutValue); @@ -35,6 +37,12 @@ class INET_API RecipientBlockAckAgreement : public cObject virtual BlockAckRecord *getBlockAckRecord() const { return blockAckRecord; } virtual simtime_t getBlockAckTimeoutValue() const { return blockAckTimeoutValue; } virtual int getBufferSize() const { return bufferSize; } + BlockAckVariant getVariant() const { return variant; } + void setVariant(BlockAckVariant value) { + variant = value; + if (variant == BlockAckVariant::COMPRESSED) + blockAckRecord->initializeCompressedWindow(startingSequenceNumber, bufferSize); + } void recordReceived(const Ptr& header) { auto sequence = header->getSequenceNumber(); if (!highestReceivedSequence.isSpecified() || highestReceivedSequence < sequence) { diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc index ab7cb050e5f..7573552b754 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc @@ -65,6 +65,20 @@ const Ptr RecipientBlockAckProcedure::buildBlockAck(const Ptr blockAck->setTidInfo(basicBlockAckReq->getTidInfo()); return blockAck; } + else if (auto compressed = dynamicPtrCast(blockAckReq)) { + ASSERT(agreement != nullptr); + auto blockAck = makeShared(); + auto record = agreement->getBlockAckRecord(); + auto start = record->getWindowStart(); + BitVector bitmap(0, 64); + for (int i = 0; i < 64; i++) + bitmap.setBit(i, record->getCompressedAckState(start + i)); + blockAck->setBlockAckBitmap(bitmap); + blockAck->setReceiverAddress(compressed->getTransmitterAddress()); + blockAck->setStartingSequenceNumber(start); + blockAck->setTidInfo(compressed->getTidInfo()); + return blockAck; + } else throw cRuntimeError("Unsupported Block Ack Request"); } diff --git a/tests/unit/Ieee80211CompressedBlockAckRecord_1.test b/tests/unit/Ieee80211CompressedBlockAckRecord_1.test new file mode 100644 index 00000000000..58daa02e92a --- /dev/null +++ b/tests/unit/Ieee80211CompressedBlockAckRecord_1.test @@ -0,0 +1,71 @@ +%description: +Check explicit Compressed receipt state independently of the delivery buffer. +Absent positions remain zero after delivery, window movement, and sequence wrap. +The preceding receipt remains available for the individual-MPDU release condition. +These checks do not establish HCF interframe recognition. + +%includes: +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h" +#include "inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h" + +using namespace inet; +using namespace inet::ieee80211; + +class ReceiptProcedure : public RecipientBlockAckProcedure { + public: + using RecipientBlockAckProcedure::buildBlockAck; +}; + +%activity: +const MacAddress peer("02:00:00:00:00:02"); +for (int start : {100, 4094}) { + RecipientBlockAckAgreement agreement(peer, 5, SequenceNumberCyclic(start), 4, SIMTIME_ZERO); + agreement.setVariant(BlockAckVariant::COMPRESSED); + auto record = agreement.getBlockAckRecord(); + auto bar = makeShared(); + bar->setTransmitterAddress(peer); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(start)); + ReceiptProcedure procedure; + auto response = dynamicPtrCast(procedure.buildBlockAck(bar, &agreement)); + ASSERT(response != nullptr && response->getChunkLength() == B(28)); + ASSERT(response->getBlockAckBitmap().getSize() == 64); + for (int bit = 0; bit < 64; bit++) + ASSERT(!response->getBlockAckBitmap().getBit(bit)); + auto data = makeShared(); + data->setType(ST_DATA_WITH_QOS); + data->setTransmitterAddress(peer); + data->setTid(5); + data->setAckPolicy(NORMAL_ACK); + data->setSequenceNumber(SequenceNumberCyclic(start)); + record->compressedFrameReceived(data); + ASSERT(record->getCompressedAckState(SequenceNumberCyclic(start))); + ASSERT(!record->getCompressedAckState(SequenceNumberCyclic(start) - 1)); + // Delivery and Basic compatibility cleanup must not erase Compressed receipt truth. + record->removeAckStates(SequenceNumberCyclic(start) + 1); + ASSERT(record->getCompressedAckState(SequenceNumberCyclic(start))); + data->setSequenceNumber(SequenceNumberCyclic(start) + 4); + record->compressedFrameReceived(data); + ASSERT(record->getWindowStart() == SequenceNumberCyclic(start) + 1); + ASSERT(record->hasCompleteReceipt(SequenceNumberCyclic(start))); + ASSERT(!record->getCompressedAckState(SequenceNumberCyclic(start))); + response = dynamicPtrCast(procedure.buildBlockAck(bar, &agreement)); + ASSERT(response->getStartingSequenceNumber() == SequenceNumberCyclic(start) + 1); + for (int bit = 0; bit < 64; bit++) + ASSERT(response->getBlockAckBitmap().getBit(bit) == (bit == 3)); + record->advanceCompressedWindow(SequenceNumberCyclic(start) + 5); + ASSERT(record->hasCompleteReceipt(SequenceNumberCyclic(start) + 4)); + ASSERT(!record->hasCompleteReceipt(SequenceNumberCyclic(start))); + record->advanceCompressedWindow(SequenceNumberCyclic(start) + 8); + ASSERT(!record->hasCompleteReceipt(SequenceNumberCyclic(start) + 4)); + for (int bit = 0; bit < 64; bit++) + ASSERT(!record->getCompressedAckState(SequenceNumberCyclic(start) + 8 + bit)); + // An old BAR must preserve the current scoreboard start. + record->advanceCompressedWindow(SequenceNumberCyclic(start)); + ASSERT(record->getWindowStart() == SequenceNumberCyclic(start) + 8); +} +EV << "Compressed receipt state checks passed.\n"; + +%contains: stdout +Compressed receipt state checks passed. From b8048fd5142535a88d8418002be5a8227c9250b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:51:17 +0200 Subject: [PATCH 15/41] ieee80211: add: select legal Compressed control rates Before this commit, QoS rate selection supports only the Basic Block Ack response contract. Compressed exchanges need distinct non-HT BAR selection and response-duration rules. After this commit, the selector uses the applicable local, BSS, and peer rate sets for initial and later BAR. Compressed responses use their non-HT reference rate and 32-byte airtime. Invalid configured overrides fail explicitly. The new pure interface operation requires matching custom implementations. For example, two peers with different operational rates can require different later-BAR rates. The direct rate fixture checks both peers, both response directions, Basic compatibility, and invalid overrides. HCF still refuses Compressed selection. This prerequisite activates no incomplete exchange. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.add | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 4 + doc/src/migration-guide/index.rst | 5 + .../mac/contract/IQosRateSelection.h | 3 + .../mac/rateselection/QosRateSelection.cc | 80 +++++++++ .../mac/rateselection/QosRateSelection.h | 2 + .../Ieee80211HcfMultipleProtection_1.test | 3 + .../Ieee80211HcfSingleProtection_1.test | 3 + .../Ieee80211SingleProtectionGroup_1.test | 1 + tests/module/Ieee80211Txnav_1.test | 1 + tests/module/Ieee80211VhtHtSupport_1.test | 3 + .../Ieee80211CompressedBlockAckRate_1.test | 169 ++++++++++++++++++ tests/unit/Ieee80211ResponseTimeout_1.test | 1 + 12 files changed, 275 insertions(+) create mode 100644 tests/unit/Ieee80211CompressedBlockAckRate_1.test diff --git a/WHATSNEW b/WHATSNEW index 0c95bd28073..c8a291bd77e 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -480,6 +480,10 @@ Notable backward incompatible changes are the following: Compressed receipt helpers now retain positive receipt state independently of delivery. HCF still refuses the Compressed profile until complete exchange support exists. +59. Compressed control-rate helpers + + QoS rate selection now supplies non-HT Compressed BAR and response modes. HCF still refuses the Compressed profile until complete exchange support exists. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 5a2ce312bea..536ee36a263 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -43,6 +43,11 @@ IEEE 802.11 reversible DATA preparation Custom QoS data services must implement the reversible preparation operations in ``IOriginatorQosMacDataService``. ``prepareFrame()`` creates an owned preview and retains original MSDUs in their queue. ``isPreparationValid()`` checks current source identity, eligibility, lifetime, sequence state, and aggregation permission. ``commitPreparedFrame()`` transfers the same preview pointer only after successful validation. Failure must preserve the preview and all original queue frames. +IEEE 802.11 Compressed control rates +------------------------------------ + +Custom QoS rate selectors must implement ``computeCompressedBlockAckReqMode(packet, header, startsTxop)``. This operation prepares legal non-HT BAR rate selection from the supplied TXOP position and applicable BSS or peer rates. HCF retains its Compressed-profile rejection in this prerequisite. Runtime activation will supply the request's actual TXOP position. Existing Basic methods retain their contracts. + IEEE 802.11 Basic Block Ack extension points ------------------------------------------ diff --git a/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h b/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h index 34a38ac1d9a..10c35f613a0 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h @@ -32,6 +32,9 @@ class INET_API IQosRateSelection virtual const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& rtsFrame, ResponseQueryRole role) = 0; virtual const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& dataOrMgmtHeader, ResponseQueryRole role) = 0; virtual const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& blockAckReq, ResponseQueryRole role) = 0; + // HCF derives startsTxop from the current frame sequence before this query. + virtual const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, + const Ptr& blockAckReq, bool startsTxop) = 0; virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txopProcedure) = 0; }; diff --git a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc index 82db4bbd06c..5c65ba9d116 100644 --- a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc +++ b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc @@ -144,10 +144,90 @@ const IIeee80211Mode *QosRateSelection::computeResponseBlockAckFrameMode(Packet auto mode = responseBlockAckFrameMode ? responseBlockAckFrameMode : getMode(packet, blockAckReq); return getPeerCompatibleResponseMode(blockAckReq, mode, role); } + else if (dynamicPtrCast(blockAckReq)) { + auto received = getMode(packet, blockAckReq); + auto referenceRate = received->getNonHtReferenceRate(); + auto receivedClass = received->getModulationClass(); + bool highThroughput = receivedClass == IIeee80211Mode::ModulationClass::HT || receivedClass == IIeee80211Mode::ModulationClass::VHT; + if (!std::isfinite(referenceRate.get())) + throw cRuntimeError("Compressed Block Ack has no non-HT reference rate for the BAR mode"); + const Ieee80211RateSet *basic = mib ? &mib->getBssRateSet().basic : nullptr; + auto matchesClass = [received, receivedClass, highThroughput](const IIeee80211Mode *candidate) { + auto modulation = candidate->getModulationClass(); + return highThroughput ? modulation == IIeee80211Mode::ModulationClass::OFDM || modulation == IIeee80211Mode::ModulationClass::ERP_OFDM : + modulation == receivedClass && candidate->getLegacyPreambleType() == received->getLegacyPreambleType(); + }; + const IIeee80211Mode *primary = nullptr; + // IEEE Std 802.11-2024, 10.6.6.5.2: prefer a qualifying BSS basic rate, then a mandatory rate. + for (bool useBasic : {true, false}) { + if (useBasic && (!basic || !basic->known)) + continue; // INET fallback for unknown BSS state uses the mandatory rate set. + for (int i = 0; i < modeSet->getNumModes(); i++) { + auto candidate = modeSet->getMode(i); + auto rate = candidate->getDataMode()->getNetBitrate(); + bool eligible = useBasic ? basic->legacyRates.count(rate) != 0 : modeSet->isMandatory(i); + if (eligible && matchesClass(candidate) && rate <= referenceRate && + (!primary || rate > primary->getDataMode()->getNetBitrate())) + primary = candidate; + } + if (primary) + break; + } + if (!primary) + throw cRuntimeError("Compressed Block Ack has no legal non-HT response mode"); + if (!responseBlockAckFrameMode || responseBlockAckFrameMode == primary) + return primary; + auto alternate = responseBlockAckFrameMode; + auto rate = alternate->getDataMode()->getNetBitrate(); + bool basicOrMandatory = (basic && basic->known && basic->legacyRates.count(rate)) || modeSet->getIsMandatory(alternate); + // IEEE Std 802.11-2024, 10.6.6.5.4: an alternate preserves modulation and actual response duration. + if (!matchesClass(alternate) || alternate->getModulationClass() != primary->getModulationClass() || !basicOrMandatory || + alternate->getDuration(LENGTH_COMPRESSED_BLOCKACK) != primary->getDuration(LENGTH_COMPRESSED_BLOCKACK)) + throw cRuntimeError("responseBlockAckFrameBitrate is not a legal alternate Compressed Block Ack response rate"); + return alternate; + } else throw cRuntimeError("Unknown BlockAckReq frame type"); } +const IIeee80211Mode *QosRateSelection::computeCompressedBlockAckReqMode(Packet *packet, + const Ptr& blockAckReq, bool startsTxop) +{ + const Ieee80211RateSet *local = mib ? &mib->getLocalRateSet().operational : nullptr; + const Ieee80211RateSet *basic = mib ? &mib->getBssRateSet().basic : nullptr; + auto peerState = mib ? mib->findPeerRateSet(blockAckReq->getReceiverAddress()) : nullptr; + const Ieee80211RateSet *peer = peerState ? &peerState->operational : nullptr; + auto eligible = [&](const IIeee80211Mode *candidate) { + auto modulation = candidate->getModulationClass(); + bool legacy = modulation == IIeee80211Mode::ModulationClass::DSSS_HRDSSS || + modulation == IIeee80211Mode::ModulationClass::OFDM || modulation == IIeee80211Mode::ModulationClass::ERP_OFDM; + auto rate = candidate->getDataMode()->getNetBitrate(); + if (!legacy || (local && local->known && !local->legacyRates.count(rate))) + return false; + // IEEE Std 802.11-2024, 10.6.6.2 and 10.6.6.4: initial BAR and later BAR use different sets. + if (!startsTxop && peer && peer->known) + return peer->legacyRates.count(rate) != 0; + if (basic && basic->known && !basic->legacyRates.empty()) + return basic->legacyRates.count(rate) != 0; + // INET uses mandatory rates when BSS rate state is unknown. + return modeSet->getIsMandatory(candidate); + }; + if (controlFrameMode) { + if (!eligible(controlFrameMode)) + throw cRuntimeError("controlFrameBitrate is not a legal non-HT Compressed BAR rate for this TXOP position"); + return controlFrameMode; + } + const IIeee80211Mode *selected = nullptr; + for (int i = 0; i < modeSet->getNumModes(); i++) { + auto candidate = modeSet->getMode(i); + if (eligible(candidate) && (!selected || candidate->getDataMode()->getNetBitrate() > selected->getDataMode()->getNetBitrate())) + selected = candidate; + } + if (!selected) + throw cRuntimeError("Compressed BAR has no legal local non-HT mode"); + return selected; +} + const IIeee80211Mode *QosRateSelection::computeDataOrMgmtFrameMode(const Ptr& dataOrMgmtHeader) { // Per-receiver override for originated unicast data frames (see dataFrameBitratePerReceiver). diff --git a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h index 5bc4647a89e..c0ecc61f8a1 100644 --- a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h +++ b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h @@ -84,6 +84,8 @@ class INET_API QosRateSelection : public IQosRateSelection, public ModeSetListen virtual const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& rtsFrame, ResponseQueryRole role) override; virtual const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& dataOrMgmtHeader, ResponseQueryRole role) override; virtual const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& blockAckReq, ResponseQueryRole role) override; + virtual const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, + const Ptr& blockAckReq, bool startsTxop) override; virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txopProcedure) override; diff --git a/tests/module/Ieee80211HcfMultipleProtection_1.test b/tests/module/Ieee80211HcfMultipleProtection_1.test index ea7991de3ee..852333eb985 100644 --- a/tests/module/Ieee80211HcfMultipleProtection_1.test +++ b/tests/module/Ieee80211HcfMultipleProtection_1.test @@ -109,6 +109,9 @@ class ProtectionRateSelection : public IQosRateSelection { const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseBlockAckFrameMode(packet, header, role); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { + return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); + } }; class ProtectionHcf : public Hcf { diff --git a/tests/module/Ieee80211HcfSingleProtection_1.test b/tests/module/Ieee80211HcfSingleProtection_1.test index bcf69e606b9..1ef31e67f3d 100644 --- a/tests/module/Ieee80211HcfSingleProtection_1.test +++ b/tests/module/Ieee80211HcfSingleProtection_1.test @@ -91,6 +91,9 @@ class SingleRateSelection : public IQosRateSelection { const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseBlockAckFrameMode(packet, header, role); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { + return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); + } }; class SingleRateControl : public IRateControl { public: diff --git a/tests/module/Ieee80211SingleProtectionGroup_1.test b/tests/module/Ieee80211SingleProtectionGroup_1.test index c5ff47f33c0..0bb495f62cf 100644 --- a/tests/module/Ieee80211SingleProtectionGroup_1.test +++ b/tests/module/Ieee80211SingleProtectionGroup_1.test @@ -28,6 +28,7 @@ class GroupRateSelection : public IQosRateSelection { const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txop) override { return delegate->computeMode(packet, header, txop); } const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseCtsFrameMode(packet, header, role); } const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseBlockAckFrameMode(packet, header, role); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); } }; class GroupMechanism : public SingleProtectionMechanism { public: diff --git a/tests/module/Ieee80211Txnav_1.test b/tests/module/Ieee80211Txnav_1.test index 452f1bc2091..0e23937594f 100644 --- a/tests/module/Ieee80211Txnav_1.test +++ b/tests/module/Ieee80211Txnav_1.test @@ -32,6 +32,7 @@ class TxnavSelection : public IQosRateSelection { const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseCtsFrameMode(packet, header, role); } const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseAckFrameMode(packet, header, role); } const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseBlockAckFrameMode(packet, header, role); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); } }; class TxnavRx : public Rx { public: diff --git a/tests/module/Ieee80211VhtHtSupport_1.test b/tests/module/Ieee80211VhtHtSupport_1.test index 72514a2b82b..f9b9501aada 100644 --- a/tests/module/Ieee80211VhtHtSupport_1.test +++ b/tests/module/Ieee80211VhtHtSupport_1.test @@ -68,6 +68,9 @@ class VhtHtSelection : public IQosRateSelection { const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseBlockAckFrameMode(packet, header, role); } + const IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { + return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); + } }; class VhtHtRx : public Rx { public: diff --git a/tests/unit/Ieee80211CompressedBlockAckRate_1.test b/tests/unit/Ieee80211CompressedBlockAckRate_1.test new file mode 100644 index 00000000000..1aa02ea3a16 --- /dev/null +++ b/tests/unit/Ieee80211CompressedBlockAckRate_1.test @@ -0,0 +1,169 @@ +%description: +Check Compressed response rates through the production QoS rate selector. +Use independent MIB rate sets for two peers and both response directions. +Retain the Basic response contract and reject an invalid Compressed override. + +%includes: +#include "inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +namespace Ieee80211CompressedBlockAckRate_1 { +class CompressedRateSelection : public QosRateSelection { + protected: + void initialize(int stage) override { + if (stage == INITSTAGE_LOCAL) + mib.reference(this, "mibModule", true); + } + public: + void configure(const Ieee80211ModeSet *catalog, const IIeee80211Mode *response) { + modeSet = catalog; + responseBlockAckFrameMode = response; + } + void controlOverride(const IIeee80211Mode *mode) { controlFrameMode = mode; } +}; +Define_Module(CompressedRateSelection); + +static Ieee80211RateSetState rates(std::initializer_list basic) { + Ieee80211RateSetState state; + state.supported.known = state.operational.known = state.basic.known = true; + for (int rate : {6, 9, 12, 18, 24, 36, 48, 54}) + state.supported.legacyRates.insert(Mbps(rate)); + state.operational = state.supported; + for (int rate : basic) + state.basic.legacyRates.insert(Mbps(rate)); + return state; +} +} + +%file: TestNetwork.ned +import inet.common.SimpleModule; +import inet.linklayer.ieee80211.mib.Ieee80211Mib; +simple CompressedRateSelection extends SimpleModule { + parameters: + @class(CompressedRateSelection); + string mibModule; +} +network TestNetwork { + submodules: + test: Test; + mib: Ieee80211Mib; + selector: CompressedRateSelection { parameters: mibModule = "^.mib"; } +} + +%inifile: omnetpp.ini +[General] +network = TestNetwork +ned-path = .;../../../../src;../../lib +seed-set = 0 +record-vector-results = false +record-scalar-results = false + +%activity: +using namespace Ieee80211CompressedBlockAckRate_1; +auto mib = check_and_cast(getModuleByPath("mib")); +auto selector = check_and_cast(getModuleByPath("selector")); +const MacAddress a("02:00:00:00:00:01"), b("02:00:00:00:00:02"); +for (const char *name : {"n(mixed-2.4Ghz)", "ac"}) { + auto catalog = Ieee80211ModeSet::getModeSet(name); + auto mode = [&](int rate) { return catalog->getMode(Mbps(rate)); }; + auto inputCatalog = Ieee80211ModeSet::getModeSet(name[0] == 'a' ? "a" : "g(mixed)"); + auto fastInput = inputCatalog->getMode(Mbps(54)); + mib->setLocalRateSet(rates({6, 12, 24})); + mib->setBssRateSet(rates({6, 12, 24})); + selector->configure(catalog, nullptr); + auto bar = makeShared(); + bar->setReceiverAddress(b); + bar->setTransmitterAddress(a); + auto check = [&](const IIeee80211Mode *input, int expected) { + Packet predict("predict"), respond("respond"); + predict.addTag()->setMode(input); + respond.addTag()->setMode(input); + auto predicted = selector->computeResponseBlockAckFrameMode(&predict, bar, ResponseQueryRole::PREDICT); + auto response = selector->computeResponseBlockAckFrameMode(&respond, bar, ResponseQueryRole::RESPOND); + ASSERT(predicted == mode(expected)); + ASSERT(response == predicted); + ASSERT(response->getHtMcsIndex() < 0); + ASSERT(response->getDuration(B(32)) < response->getDuration(LENGTH_BASIC_BLOCKACK)); + }; + check(fastInput, 24); + check(mode(6), 6); + mib->setBssRateSet(rates({48})); + check(mode(24), 24); + mib->clearBssRateSet(); + check(fastInput, 24); + mib->setBssRateSet(rates({})); + check(fastInput, 24); + mib->setBssRateSet(rates({6, 12, 24})); + for (int i = 0; i < catalog->getNumModes(); i++) { + auto ht = catalog->getMode(i); + auto family = ht->getModulationClass(); + if (family != IIeee80211Mode::ModulationClass::HT && family != IIeee80211Mode::ModulationClass::VHT) + continue; + auto reference = ht->getNonHtReferenceRate(); + int expected = reference >= Mbps(24) ? 24 : reference >= Mbps(12) ? 12 : 6; + check(ht, expected); + } + mib->setBssRateSet(rates({48})); + selector->configure(catalog, mode(6)); + bool refused = false; + try { check(fastInput, 6); } + catch (const cRuntimeError&) { refused = true; } + ASSERT(refused); + selector->configure(catalog, nullptr); + auto basic = makeShared(); + Packet packet("basic"); + packet.addTag()->setMode(mode(24)); + ASSERT(selector->computeResponseBlockAckFrameMode(&packet, basic, ResponseQueryRole::RESPOND) == mode(24)); + auto bss = rates({6, 12, 24}); + auto peer = rates({6}); + peer.operational.legacyRates = {Mbps(6), Mbps(12)}; + mib->installBssAndPeerRateSets(bss, b, peer); + Packet originated("originated"); + ASSERT(selector->computeCompressedBlockAckReqMode(&originated, bar, true) == mode(24)); + ASSERT(selector->computeCompressedBlockAckReqMode(&originated, bar, false) == mode(12)); + mib->removePeerRateSet(b); + ASSERT(selector->computeCompressedBlockAckReqMode(&originated, bar, false) == mode(24)); + mib->setBssRateSet(rates({})); + ASSERT(selector->computeCompressedBlockAckReqMode(&originated, bar, true) == mode(24)); + mib->clearBssRateSet(); + ASSERT(selector->computeCompressedBlockAckReqMode(&originated, bar, true) == mode(24)); + selector->controlOverride(mode(6)); + ASSERT(selector->computeCompressedBlockAckReqMode(&originated, bar, true) == mode(6)); + mib->setBssRateSet(rates({6})); + selector->controlOverride(mode(24)); + refused = false; + try { selector->computeCompressedBlockAckReqMode(&originated, bar, true); } + catch (const cRuntimeError&) { refused = true; } + ASSERT(refused); + for (int i = 0; i < catalog->getNumModes(); i++) { + auto ht = catalog->getMode(i); + if (ht->getModulationClass() != IIeee80211Mode::ModulationClass::HT) + continue; + selector->controlOverride(ht); + refused = false; + try { selector->computeCompressedBlockAckReqMode(&originated, bar, true); } + catch (const cRuntimeError&) { refused = true; } + ASSERT(refused); + break; + } + selector->controlOverride(nullptr); +} +// The full OFDM catalog supplies optional rates for the alternate-rate contract. +auto ofdm = Ieee80211ModeSet::getModeSet("a"); +auto primary = ofdm->getMode(Mbps(48)); +auto alternate = ofdm->getMode(Mbps(36)); +ASSERT(primary->getDuration(B(32)) == alternate->getDuration(B(32))); +mib->setBssRateSet(rates({36, 48})); +selector->configure(ofdm, alternate); +Packet alternatePacket("alternate"); +alternatePacket.addTag()->setMode(ofdm->getMode(Mbps(54))); +auto alternateBar = makeShared(); +ASSERT(selector->computeResponseBlockAckFrameMode(&alternatePacket, alternateBar, ResponseQueryRole::RESPOND) == alternate); +EV << "Compressed response rate checks passed.\n"; + +%contains: stdout +Compressed response rate checks passed. diff --git a/tests/unit/Ieee80211ResponseTimeout_1.test b/tests/unit/Ieee80211ResponseTimeout_1.test index dcafbffa653..c55f286bb21 100644 --- a/tests/unit/Ieee80211ResponseTimeout_1.test +++ b/tests/unit/Ieee80211ResponseTimeout_1.test @@ -49,6 +49,7 @@ class TestRateSelection : public SimpleModule, public IRateSelection, public IQo const Ptr& header) override { return responseMode; } virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txopProcedure) override { return responseMode; } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *, const Ptr&, bool) override { return responseMode; } }; Define_Module(TestRateSelection); From c00da39c26f913b54b703403d4dd9fd7e3a087dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:51:57 +0200 Subject: [PATCH 16/41] ieee80211: add: complete explicit immediate Compressed Block Ack Before this commit, HCF still rejects the Compressed profile. Wire support, explicit receipt state, and rate helpers exist, but production exchanges do not use them. After this commit, explicit Compressed profiles complete immediate exchanges on eligible HT links. Receipt bits survive delivery, absent receipts remain zero, and shifted responses apply only within the active window. Actual physical endpoints establish SIFS or permitted RIFS relations. Active Compressed agreements suppress fragmentation. HCF uses the prepared non-HT BAR rates and 32-byte response airtime. Both endpoints must select the same profile because ADDBA does not negotiate it. Conflicting addressed BAR stops the simulation before agreement updates. Delayed Compressed policy fails initialization. Basic remains the default. Active Compressed DATA checks complete exchange cost before destructive aggregation. Refusal preserves queue frames, deadlines, and sequence state. An oversized aggregate can fall back to its first ordinary MSDU. One selected mode survives RTS/CTS. Failed RTS updates category recovery without a provisional sequence counter. Original lifetimes bound repeated attempts. For example, an aggregate that exceeds the exchange limit leaves its sources intact. HCF can instead admit its first ordinary MSDU with the same selected mode. Commitment records one queue departure and retains its queueing time through retransmission. Direct exchange and admission fixtures check refusal, fallback, retry, and response behavior. Agreement activation, physical interval use, DATA admission, and frame sequences change together to expose a complete supported exchange. Shared queue, timing, permission, wire, preparation, receipt, and rate prerequisites precede activation. Single protection reserves only the current exchange. The following commit changes the default separately. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.add | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 30 +- doc/src/migration-guide/index.rst | 28 +- doc/src/users-guide/ch-80211.rst | 43 +- showcases/wireless/blockack/doc/index.rst | 2 +- .../OriginatorBlockAckAgreementHandler.cc | 7 + .../OriginatorBlockAckAgreementPolicy.cc | 2 + .../RecipientBlockAckAgreementPolicy.cc | 2 + .../blockack/RecipientBlockAckProcedure.cc | 8 + .../blockackreordering/BlockAckReordering.cc | 23 +- .../blockackreordering/BlockAckReordering.h | 2 +- .../mac/contract/IRecipientQosAckPolicy.h | 2 + .../contract/IRecipientQosMacDataService.h | 3 +- .../ieee80211/mac/coordinationfunction/Hcf.cc | 532 +++++++++++++- .../ieee80211/mac/coordinationfunction/Hcf.h | 38 +- .../mac/coordinationfunction/Hcf.ned | 2 +- .../mac/framesequence/FrameSequenceContext.cc | 20 + .../mac/framesequence/FrameSequenceContext.h | 37 +- .../ieee80211/mac/framesequence/HcfFs.cc | 10 +- .../framesequence/PrimitiveFrameSequences.cc | 43 +- .../ieee80211/mac/framesequence/TxOpFs.cc | 4 +- .../originator/OriginatorQosMacDataService.cc | 2 +- .../originator/OriginatorQosMacDataService.h | 2 + .../ieee80211/mac/originator/QosAckHandler.cc | 27 + .../ieee80211/mac/originator/QosAckHandler.h | 2 + .../SingleProtectionMechanism.cc | 5 +- .../ieee80211/mac/queue/InProgressFrames.cc | 10 + .../ieee80211/mac/queue/InProgressFrames.h | 2 + .../Ieee80211PeerModeSelection.cc | 11 + .../Ieee80211PeerModeSelection.h | 4 + .../mac/recipient/RecipientQosAckPolicy.cc | 9 +- .../mac/recipient/RecipientQosAckPolicy.h | 1 + .../recipient/RecipientQosMacDataService.cc | 20 +- .../recipient/RecipientQosMacDataService.h | 2 +- .../module/Ieee80211BlockAckReordering_1.test | 37 +- .../module/Ieee80211BlockAckScheduling_1.test | 176 ++++- tests/module/Ieee80211BlockAckVariant_1.test | 24 +- ...eee80211CompressedBlockAckAdmission_1.test | 665 ++++++++++++++++++ ...Ieee80211CompressedBlockAckExchange_1.test | 428 +++++++++++ .../Ieee80211CompressedBlockAckInput_1.test | 325 +++++++++ ...ee80211CompressedBlockAckInterframe_1.test | 542 ++++++++++++++ ...ee80211CompressedBlockAckOriginator_1.test | 175 +++++ .../Ieee80211HcfMultipleProtection_2.test | 121 +++- tests/module/Ieee80211RecipientNav_1.test | 97 ++- tests/protocol/wifi/11ac/Ac_BlockAck.test | 55 +- .../wifi/11ac/Ac_BlockAckFallback.test | 186 +++++ tests/protocol/wifi/11n/N_BlockAck.test | 55 +- tests/protocol/wifi/11n/N_CompressedBa.test | 22 +- tests/unit/Ieee80211BlockAckScheduling_1.test | 42 ++ 48 files changed, 3686 insertions(+), 199 deletions(-) create mode 100644 tests/module/Ieee80211CompressedBlockAckAdmission_1.test create mode 100644 tests/module/Ieee80211CompressedBlockAckExchange_1.test create mode 100644 tests/module/Ieee80211CompressedBlockAckInput_1.test create mode 100644 tests/module/Ieee80211CompressedBlockAckInterframe_1.test create mode 100644 tests/module/Ieee80211CompressedBlockAckOriginator_1.test create mode 100644 tests/protocol/wifi/11ac/Ac_BlockAckFallback.test diff --git a/WHATSNEW b/WHATSNEW index c8a291bd77e..a0646fd959e 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -442,7 +442,7 @@ Notable backward incompatible changes are the following: The recipient delivers complete buffered units in cyclic order across receive gaps before resource release. Association reset instead discards old buffered units in both directions. With Block Ack enabled, reset also discards queued and in-progress QoS DATA for the old peer, including unsent Normal Ack DATA. These changes can alter delivery, disposal, frame exchanges, and fingerprints. - Basic remains the default. Compressed selection still stops initialization. Custom agreement handlers, recipient services, and management implementations require the changes in the migration guide. External queues need the optional selected-extraction contract only when deferred DATA hides eligible work. Built-in queues preserve ordinary pull accounting for that extraction. + Custom agreement handlers, recipient services, and management implementations require the changes in the migration guide. External queues need the optional selected-extraction contract only when deferred DATA hides eligible work. Built-in queues preserve ordinary pull accounting for that extraction. 51. IEEE 802.11 Basic Block Ack transfer completion @@ -454,6 +454,24 @@ Notable backward incompatible changes are the following: Custom QoS ACK policies must accept the agreement-handler argument in isBlockAckReqNeeded() and computeBlockAckReqParameters(). Custom in-progress queues must preserve the extract argument in getPendingFrameFor(). QoS data services must implement IOriginatorQosMacDataService for candidate preview without extraction. +52. IEEE 802.11 immediate Compressed Block Ack + + HCF supports explicit immediate Compressed Block Ack. Basic remains the default. Eligible HT infrastructure links and the supported ac path use accepted agreements and 32-byte Compressed responses with FCS. Links without usable local or peer HT state retain Normal Ack. Select blockAckVariant = "basic" at both endpoints for historical Basic compatibility. An HT PHY mode alone does not supply peer capability state. + + Both endpoints must select the same blockAckVariant because ADDBA does not negotiate it. A valid addressed BAR with the other profile stops the simulation before agreement updates. The diagnostic identifies the peer, TID, and profiles. Compressed rejects delayedAckPolicySupported = true in either agreement policy at initialization. + + Compressed receipt state retains positive bits after delivery and reports zero for absent receipts. HCF recognizes the required SIFS or RIFS relation from actual physical endpoints. It can release individual MPDUs under that relation despite a receive gap. Compressed agreements suppress fragmentation for their peer and TID; Basic retains its fragment bitmap. + + Compressed BAR uses a legal non-HT rate. Initial and later BAR consume their applicable BSS and peer rate sets. A configured controlFrameBitrate must satisfy the applicable rule. Response duration, protection, and timeout calculations use the 32-byte response length. Basic retains its separate 152-byte response. + + Active Compressed agreements check complete DATA exchange cost before destructive aggregation. If an aggregate cannot qualify, HCF evaluates its first ordinary MSDU with the same selected mode. Refusal preserves original queue frames, deadlines, and sequence state. Single protection reserves only the current exchange; a later BAR can require fresh contention. These changes can alter airtime, contention, delivery times, and simulation results. Basic and traffic outside active Compressed agreements retain their existing admission limits. + + Before DATA commitment, failed RTS updates access-category retry state without a provisional sequence counter. Original DATA lifetimes bound repeated attempts. This changes the scoped path's former discard after a fixed number of RTS failures. + + Existing demonstrations retain explicit Basic settings, configurations, and result rows. IEEE Std 802.11e-2005 introduced Basic; IEEE Std 802.11-2024 reserves its Type 0 value. Retention does not establish complete historical conformance. A-MPDU requirements for n and ac remain deferred. Multi-TID Block Ack and the existing delayed Basic requirement also remain deferred. Compressed support does not establish complete VHT transfer support or MAC stop/start recovery. + + Custom QoS rate selectors, recipient ACK policies, recipient data services, and frame sequences require the interface changes in the migration guide. Custom radio media, communication caches, and IEEE 802.11 modes also require the new timing queries. Basic classes and methods remain available. + 53. Radio medium timing queries Radio media now expose copied transmission endpoints and cached arrival endpoints. Consumers can preserve physical timing evidence after cache expiry without retained transmission pointers or new propagation calculations. Receivers attach the transmission identifier to SignalTimeInd so later frame delivery can identify that evidence. Custom radio media and communication caches must implement the new query methods described in the migration guide. @@ -476,14 +494,6 @@ Notable backward incompatible changes are the following: Commitment of ordinary DATA now preserves normal queue service effects. Queue output statistics count the departure, and the retained preview includes elapsed queueing time and queue events. This also applies when a deferred head causes selection of a later eligible frame. -58. Compressed receipt helpers - - Compressed receipt helpers now retain positive receipt state independently of delivery. HCF still refuses the Compressed profile until complete exchange support exists. - -59. Compressed control-rate helpers - - QoS rate selection now supplies non-HT Compressed BAR and response modes. HCF still refuses the Compressed profile until complete exchange support exists. - Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics @@ -560,7 +570,7 @@ Notable backward compatible changes are the following: 14. Explicit historical Basic Block Ack selection - HCF adds blockAckVariant = "basic" for historical compatibility. Existing Block Ack, TXOP, QoS, and fragmentation demonstrations select it explicitly. Basic remains the default. HCF rejects unknown values and the reserved "compressed" value during initialization until Compressed exchanges exist. These checks also apply when Block Ack support is disabled. Basic originated in IEEE Std 802.11e-2005; IEEE Std 802.11-2024 reserves its type value. + HCF retains blockAckVariant = "basic" for historical compatibility. Existing Block Ack, TXOP, QoS, and fragmentation demonstrations select it explicitly. HCF rejects unknown selector values during initialization, also when Block Ack support is disabled. Basic originated in IEEE Std 802.11e-2005; IEEE Std 802.11-2024 reserves its type value. 15. IEEE 802.11 retry counters for each receiver diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 536ee36a263..49984769ef5 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -41,12 +41,30 @@ Compressed producers must supply Fragment Number zero and a 64-bit bitmap. A Com IEEE 802.11 reversible DATA preparation ------------------------------------- -Custom QoS data services must implement the reversible preparation operations in ``IOriginatorQosMacDataService``. ``prepareFrame()`` creates an owned preview and retains original MSDUs in their queue. ``isPreparationValid()`` checks current source identity, eligibility, lifetime, sequence state, and aggregation permission. ``commitPreparedFrame()`` transfers the same preview pointer only after successful validation. Failure must preserve the preview and all original queue frames. +Custom QoS data services must implement the reversible preparation operations in ``IOriginatorQosMacDataService``. ``prepareFrame()`` creates an owned preview and retains original MSDUs in their queue. ``isPreparationValid()`` checks current source identity, eligibility, lifetime, sequence state, and aggregation permission. ``commitPreparedFrame()`` transfers the same preview pointer only after successful validation. Failure must preserve the preview and all original queue frames. ``InProgressFrames::adoptPreparedFrame()`` accepts a committed frame without another extraction. -IEEE 802.11 Compressed control rates ------------------------------------- +IEEE 802.11 Compressed Block Ack extension points +------------------------------------------------ -Custom QoS rate selectors must implement ``computeCompressedBlockAckReqMode(packet, header, startsTxop)``. This operation prepares legal non-HT BAR rate selection from the supplied TXOP position and applicable BSS or peer rates. HCF retains its Compressed-profile rejection in this prerequisite. Runtime activation will supply the request's actual TXOP position. Existing Basic methods retain their contracts. +Select ``mac.hcf.blockAckVariant = "compressed"`` for immediate Compressed Block Ack. Basic remains the default. Both endpoints must select the same profile. ADDBA does not negotiate this selector. A valid addressed BAR with the other profile stops the simulation before agreement updates. The diagnostic identifies the peer, TID, local profile, and received profile. Configure the same selectors before a new run. + +Compressed agreements require usable local HT support and directional peer HT state. An HT PHY mode alone does not supply that state. Without it, HCF retains Normal Ack DATA. Explicit ``blockAckVariant = "basic"`` retains historical Basic compatibility without that HT requirement. Compressed agreements suppress fragmentation for their peer and TID. Fragmentation outside those agreements retains its existing threshold. + +Compressed supports immediate Block Ack only. Keep ``delayedAckPolicySupported = false`` in both agreement policies. HCF rejects either true value during initialization when Compressed support is enabled. Basic retains its existing delayed-policy configuration contract. + +Custom QoS rate selectors must implement ``computeCompressedBlockAckReqMode(packet, header, startsTxop)``. HCF supplies the request's actual position in the TXOP. Select a legal non-HT mode from the applicable BSS or peer rates. A configured ``controlFrameBitrate`` must satisfy that rule. The existing Basic rate-selection methods remain available. + +Custom recipient ACK policies must implement ``computeCompressedBlockAckDurationField()``. This operation subtracts SIFS and the actual Compressed response airtime from the request reservation. Compressed Block Ack contains 32 bytes with FCS; Basic contains 152 bytes. Retain the existing Basic operation. + +Custom recipient data services must accept ``bool interframe = false`` in ``dataFrameReceived()``. The value states whether HCF established the required SIFS or RIFS relation. A false value supplies no interval evidence. Preserve that value through the recipient reorder path. Custom callers that omit it retain false. + +Custom frame sequences must supply HCF's resolved profile to ``QoSContext``. Its constructor retains Basic for callers that omit the profile. Custom agreement creation must set the recipient agreement's variant before use. An agreement must retain that variant throughout its lifetime. + +Custom frame sequences must preserve BAR arbitration before DATA preparation. The HCF preparation callback distinguishes the legacy path, accepted preparation, and admission refusal. Refusal must end the sequence without a DATA failure. Keep the selected DATA mode through RTS/CTS. Validate that decision without another adaptive rate query. Admit the complete exchange before source removal. + +The active Compressed path reserves only the current exchange under single protection. A later BAR can require fresh contention. Before DATA commitment, failed RTS updates QSRC and the contention window without a provisional sequence counter. QSRC is the short retry counter for an access category. QSRC rollover does not discard queued DATA. Original lifetimes bound repeated RTS attempts. + +Basic and outside-agreement fallback retain their existing preparation and recovery paths. IEEE 802.11 Basic Block Ack extension points ------------------------------------------ @@ -210,7 +228,7 @@ No configuration change is necessary. Gap release, window movement, and BAR befo IEEE 802.11 Block Ack Agreement Lifecycle ------------------------------------------ -HCF now defers new DATA extraction for a peer and TID during Block Ack setup or recovery. Already numbered DATA resolves before HCF creates ADDBA. The first DATA under an accepted agreement therefore retains the request sequence number. Basic remains the default. Compressed selection still stops initialization. +HCF now defers new DATA extraction for a peer and TID during Block Ack setup or recovery. Already numbered DATA resolves before HCF creates ADDBA. The first DATA under an accepted agreement therefore retains the request sequence number. Both supported profiles use this lifecycle contract. The recipient response now determines the buffer size and inactivity timeout. The built-in recipient selects the smaller of 64 and its configured maximum. A request size of zero supplies no size guidance. The response copies the request dialog token. Both negotiated A-MSDU flags must permit aggregation under an active agreement. diff --git a/doc/src/users-guide/ch-80211.rst b/doc/src/users-guide/ch-80211.rst index b526cdbf248..e6f09b57bd6 100644 --- a/doc/src/users-guide/ch-80211.rst +++ b/doc/src/users-guide/ch-80211.rst @@ -533,7 +533,7 @@ The first exchange proceeds even when its cost exceeds a positive TXOP limit. Th A zero limit permits the initial exchange and its existing RTS/CTS and immediate response. Each later fragment or unrelated unit needs a fresh TXOP. Prepared fragments and A-MSDUs use the same complete-cost check under positive limits. -``isBlockAckSupported = true`` disables complete-cost continuation admission, even without a Block Ack agreement. Multiple protection also retains its separate admission policy. Both paths use shared TXNAV. Basic Block Ack admission, BAR forecasts, zero-limit companion rules, and optional overrun exceptions remain outside this repair. +With Block Ack support enabled, active Compressed agreements use the admission described in :ref:`ug:sec:80211:blockack`. Basic and traffic outside those agreements retain their existing admission policy. Those retained paths can exceed DATA exchange bounds. All paths use shared TXNAV. Basic Block Ack admission and BAR forecasts remain outside the Compressed correction. All single protection paths classify group frames before the current-frame ACK equation. With Block Ack support disabled, the current one-frame group sequence advertises zero. With support enabled, its legacy forecast can reserve a queued successor that the sequence cannot transmit. This limit applies to group management and non-QoS DATA too. @@ -607,13 +607,9 @@ The standard separately requires AIFSN of at least 1 for APs and at least 2 for example, a non-AP station with AIFSN 1 meets the ownership condition but violates the standard's minimum. -Multiple protection does not check a complete exchange against the remaining budget. -For example, its admission policy can start a 120 us exchange with only -100 us left. The reference scope assumes whole-microsecond positive limits, integral initial PPDU -airtime, and integral legacy RTS airtime. It adds no A-MPDU, Compressed Block Ack, new -fragmentation, CTS-to-self, dual CTS, PIFS recovery, or TXOP sharing. It also adds no reverse -direction, beamforming, S1G, multi-user, or general MAC lifecycle support. It does not repair -general rate selection, recipient response timing, or TXOP overruns. +Outside active Compressed agreements, multiple protection does not check complete exchange cost against the remaining budget. For example, that retained policy can start a 120 us exchange with only 100 us left. Active Compressed agreements use their separate complete-cost admission. The reference scope assumes whole-microsecond positive limits, integral initial PPDU airtime, and integral legacy RTS airtime. + +Multiple protection adds no A-MPDU, new fragmentation, CTS-to-self, dual CTS, PIFS recovery, or TXOP sharing. Reverse direction, beamforming, S1G, multi-user operation, and general MAC lifecycle support remain outside this implementation. General rate selection and recipient response timing retain their separate limits. .. _ug:sec:80211:fragmentation: @@ -708,12 +704,27 @@ BAR can obtain channel access without a queued DATA frame. A later BAR within a After the final exchange, the originator sends DELBA when its agreement has no queued DATA, in-progress DATA, or active BAR exchange. A zero inactivity timeout does not disable this transfer-completion rule. DATA that arrives after this boundary waits for DELBA completion. A later transfer can require another ADDBA exchange. If the last unresolved DATA expires, the originator uses the same teardown path. Ordinary recipient teardown releases complete units behind a receive gap before it releases agreement resources. -The agreement policies, ``mac.hcf.originatorBlockAckAgreementPolicy`` and -``mac.hcf.recipientBlockAckAgreementPolicy``, set the buffer size -(:par:`maximumAllowedBufferSize`, default 64), the A-MSDU support -(:par:`aMsduSupported`, default ``true``) and the inactivity timeout -(:par:`blockAckTimeoutValue`, default ``0s``, which means no timeout). Only -the basic Block Ack variant is modeled. +The agreement policies, ``mac.hcf.originatorBlockAckAgreementPolicy`` and ``mac.hcf.recipientBlockAckAgreementPolicy``, set the buffer size. ``maximumAllowedBufferSize`` defaults to 64. Both negotiated ``aMsduSupported`` flags control A-MSDU use; each defaults to ``true``. ``blockAckTimeoutValue`` defaults to ``0s``, which disables the inactivity timeout. Transfer completion and DATA lifetime expiry retain their separate teardown rules. + +Select ``mac.hcf.blockAckVariant = "compressed"`` for immediate Compressed Block Ack. Basic remains the default. Block Ack support itself remains disabled by default. The response contains a 64-bit bitmap and occupies 32 bytes with FCS. Each positive bit acknowledges one unfragmented MPDU. The recipient retains receipt bits after delivery, so a later BAR can still obtain those positive bits. Missing receipt evidence produces zero. + +Compressed agreements require usable local HT support and directional peer HT state. Infrastructure association supplies that peer state for eligible HT links and the supported ``ac`` path. An HT radio mode alone does not supply peer capabilities. Without usable state, DATA uses Normal Ack. Local non-HT operation produces a warning when Block Ack support is enabled. HT ad hoc links without peer state retain Normal Ack. + +Explicit ``blockAckVariant = "basic"`` selects historical Basic compatibility on both endpoints. Basic retains its 64 fragment bitmap entries and its 152-byte response with FCS. IEEE Std 802.11e-2005 introduced this format. IEEE Std 802.11-2024 reserves its Type 0 value. INET retains Basic for existing studies; this compatibility does not establish complete historical conformance. + +Both endpoints must select the same profile because ADDBA does not negotiate it. A valid addressed BAR with the other profile stops the simulation before agreement updates. The diagnostic identifies the peer, TID, and profiles. Configure matching profiles before a new run. Malformed frames follow input rejection instead of this configuration diagnostic. + +Compressed agreements suppress fragmentation for their peer and TID. The recipient rejects fragmented DATA under those agreements before receipt or reorder updates. Basic retains fragmentation. Outside a Compressed agreement, the configured fragmentation threshold retains its existing effect. + +Keep ``delayedAckPolicySupported = false`` in both agreement policies for Compressed support. HCF rejects true at initialization because the Compressed path supplies immediate responses only. Retained Basic delayed-policy configuration does not establish a complete delayed exchange implementation. + +The Compressed originator sends BAR with a non-HT PHY mode. Initial BAR uses the applicable BSS basic or mandatory rate rule. Later BAR uses the peer operational rate rule. A configured ``controlFrameBitrate`` must satisfy that rule. The response selector uses the actual 32-byte response length when a legal alternate rate is available. These rules retain separate Basic, ACK, and CTS contracts. + +Active Compressed agreements check the complete DATA exchange before source commitment. If an aggregate cannot qualify, HCF evaluates its first ordinary MSDU with the same selected DATA mode. If neither form qualifies, HCF ends the sequence without queue removal, sequence assignment, or deadline replacement. RTS/CTS retains the selected mode. Expiry or capability changes before DATA cancel invalid preparation. + +An initial unaggregated MSDU can use the applicable TXOP overrun exception. A same-size single-MPDU retransmission can also use its exception. That retransmission can carry an A-MSDU. Each exception permits at most one Data or Management frame in that TXOP. A new A-MSDU must fit a positive limit. A zero limit permits one DATA PPDU with one MSDU or A-MSDU, plus its required protection and response. + +Single protection reserves only the current Compressed exchange. A later BAR can require fresh contention. This policy can change airtime and delivery times. Before DATA commitment, failed RTS updates QSRC and the contention window without a provisional sequence counter. QSRC is the short retry counter for an access category. Original MSDU lifetimes bound repeated attempts; QSRC rollover does not discard them. .. code-block:: ini @@ -1030,9 +1041,9 @@ The model does not contain: - PCF and HCCA, the polled channel access methods. The module :ned:`Hcca` exists as a placeholder. -- A-MPDU aggregation, the MSDU lifetime limit, and self-CTS protection. +- A-MPDU aggregation and self-CTS protection. -- Compressed and multi-TID block acknowledgement. +- Multi-TID block acknowledgement and delayed Compressed Block Ack. - Operational HT widths above 20 MHz, and a primary/secondary channel relationship for wider VHT modes. diff --git a/showcases/wireless/blockack/doc/index.rst b/showcases/wireless/blockack/doc/index.rst index 1418ec4a985..2d6aa48f04e 100644 --- a/showcases/wireless/blockack/doc/index.rst +++ b/showcases/wireless/blockack/doc/index.rst @@ -50,7 +50,7 @@ Block Acknowledgment in INET In INET, the block ack mechanism can be enabled by setting the :par:`isBlockAckSupported` parameter of the MAC's :ned:`Hcf` submodule to ``true`` (it is disabled by default). -Select ``blockAckVariant = "basic"`` on both endpoints to retain the historical profile. Basic remains the default during preparation for Compressed support. This stage rejects ``"compressed"`` because its runtime exchange path does not yet exist. HCF rejects unknown selector values during initialization, also when Block Ack support is disabled. +This showcase selects ``blockAckVariant = "basic"`` on both endpoints to retain the historical profile. Basic remains the default. Other configurations can select Compressed explicitly. Compressed agreements require usable local and peer HT state. Without that state, DATA uses Normal Ack. HCF rejects unknown selector values during initialization, also when Block Ack support is disabled. Several submodules of :ned:`Hcf` are involved in the block ack mechanism. These modules have parameters controlling the block ack behavior. The following paragraphs diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc index e136518a229..c526b7fe88c 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.cc @@ -174,6 +174,13 @@ void OriginatorBlockAckAgreementHandler::processReceivedBlockAck(const Ptr(blockAck)) { + auto agreement = getAgreement(compressed->getTransmitterAddress(), compressed->getTidInfo()); + if (agreement) { + agreement->calculateExpirationTime(); + scheduleInactivityTimer(callback); + } + } else throw cRuntimeError("Unsupported BlockAck"); } diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc index 835216df923..1a03dd26ef2 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc @@ -41,6 +41,8 @@ simtime_t OriginatorBlockAckAgreementPolicy::computeAddbaFailureTimeout() const bool OriginatorBlockAckAgreementPolicy::isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const { + if (variant == BlockAckVariant::COMPRESSED && (!localHt || !peerHt)) + EV_DEBUG << "Compressed Block Ack setup refused: " << (!localHt ? "local HT state is absent" : "peer HT state is absent") << "; DATA uses Normal Ack.\n"; return variant == BlockAckVariant::BASIC || (localHt && peerHt); } diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc index f2bd97fa697..33360fcfc32 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc @@ -39,6 +39,8 @@ bool RecipientBlockAckAgreementPolicy::isAddbaReqAccepted(const PtrtransmitControlResponseFrame(blockAckPacket, blockAck, blockAckPacketReq, basicBlockAckReq); } } + else if (auto compressed = dynamicPtrCast(blockAckReq)) { + auto agreement = blockAckAgreementHandler->getAgreement(compressed->getTidInfo(), compressed->getTransmitterAddress()); + if (ackPolicy->isBlockAckNeeded(compressed, agreement)) { + auto blockAck = buildBlockAck(compressed, agreement); + blockAck->setDurationField(ackPolicy->computeCompressedBlockAckDurationField(blockAckPacketReq, compressed)); + callback->transmitControlResponseFrame(new Packet("CompressedBlockAck", blockAck), blockAck, blockAckPacketReq, compressed); + } + } else throw cRuntimeError("Unsupported BlockAckReq"); } diff --git a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc index 02a811e4732..78f06a2d725 100644 --- a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc +++ b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc @@ -50,11 +50,12 @@ void BlockAckReordering::clearPeer(MacAddress peer) } } -BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader) +BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader, bool interframe) { ReceiveBuffer *receiveBuffer = createReceiveBufferIfNecessary(agreement); auto sequenceNumber = dataHeader->getSequenceNumber(); auto windowStart = receiveBuffer->getNextExpectedSequenceNumber(); + bool insideWindow = windowStart <= sequenceNumber && sequenceNumber < windowStart + receiveBuffer->getBufferSize(); ReleasedFrames releasedFrames; // IEEE Std 802.11-2024, 10.25.6.6.2.1(b,c): advance for newer DATA beyond the window; discard older DATA. // The shared reorder service also retains Basic fragment reassembly as an INET compatibility choice. @@ -69,8 +70,15 @@ BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedQoSFrame(R // This allows the recipient to delete the Block Ack if the originator does not switch // back to using Block Ack. if (receiveBuffer->insertFrame(dataPacket, dataHeader)) { - if (dataHeader->getAckPolicy() == BLOCK_ACK) + if (dataHeader->getAckPolicy() == BLOCK_ACK && agreement->getVariant() == BlockAckVariant::BASIC) agreement->blockAckPolicyFrameReceived(dataHeader); + auto record = agreement->getBlockAckRecord(); + // IEEE Std 802.11-2024, 10.25.6.6.2.1(a)(2)(v) and 10.25.6.6.1: release the complete prefix in order. + if (agreement->getVariant() == BlockAckVariant::COMPRESSED && insideWindow && windowStart < sequenceNumber && + interframe && record->hasCompleteReceipt(record->getWindowStart() - 1)) { + auto preceding = advanceReceiveBuffer(agreement, receiveBuffer, sequenceNumber); + releasedFrames.insert(releasedFrames.end(), preceding.begin(), preceding.end()); + } // IEEE Std 802.11-2024, 10.25.6.6.2.1(a)(2): release every consecutive complete unit at the window start. auto consecutiveFrames = collectConsecutiveCompleteFollowingMpdus(receiveBuffer, receiveBuffer->getNextExpectedSequenceNumber()); releaseReceiveBuffer(agreement, receiveBuffer, consecutiveFrames); @@ -92,6 +100,14 @@ BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedBlockAckRe return ReleasedFrames(); startingSequenceNumber = basicReq->getStartingSequenceNumber(); } + else if (auto compressedReq = dynamicPtrCast(blockAckReq)) { + if (compressedReq->getFragmentNumber() != 0 || compressedReq->getMultiTid() || !compressedReq->getCompressedBitmap() || + compressedReq->getTidInfo() < 0 || compressedReq->getTidInfo() > 15 || !compressedReq->getStartingSequenceNumber().isSpecified() || + compressedReq->getChunkLength() != LENGTH_BLOCKACKREQ - B(4)) + return ReleasedFrames(); + startingSequenceNumber = compressedReq->getStartingSequenceNumber(); + agreement->getBlockAckRecord()->advanceCompressedWindow(startingSequenceNumber); + } else { throw cRuntimeError("Multi-Tid BlockAckReq is currently an unimplemented feature"); } @@ -209,7 +225,8 @@ void BlockAckReordering::passedUp(RecipientBlockAckAgreement *agreement, Receive receiveBuffer->setNextExpectedSequenceNumber(sequenceNumber + 1); receiveBuffer->dropFramesUntil(sequenceNumber); receiveBuffer->removeFrame(sequenceNumber); - agreement->getBlockAckRecord()->removeAckStates(sequenceNumber); + if (agreement->getVariant() == BlockAckVariant::BASIC) + agreement->getBlockAckRecord()->removeAckStates(sequenceNumber); } std::vector BlockAckReordering::getEarliestCompleteMsduOrAMsduIfExists(ReceiveBuffer *receiveBuffer) diff --git a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h index 05a203ed44b..fdfbd29e226 100644 --- a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h +++ b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h @@ -54,7 +54,7 @@ class INET_API BlockAckReordering void clearPeer(MacAddress peer); void processReceivedDelba(const Ptr& delba); - ReleasedFrames processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader); + ReleasedFrames processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader, bool interframe = false); ReleasedFrames processReceivedBlockAckReq(RecipientBlockAckAgreement *agreement, const Ptr& blockAckReq); }; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h index ccf47cc5610..42aaecc9db8 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h @@ -26,6 +26,8 @@ class INET_API IRecipientQosAckPolicy virtual simtime_t computeAckDurationField(Packet *packet, const Ptr& header) const = 0; virtual simtime_t computeBasicBlockAckDurationField(Packet *packet, const Ptr& basicBlockAckReq) const = 0; + // The request selects the response variant and its actual airtime. + virtual simtime_t computeCompressedBlockAckDurationField(Packet *packet, const Ptr& blockAckReq) const = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h index 7e97329e94d..7aded713794 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h @@ -26,7 +26,8 @@ class INET_API IRecipientQosMacDataService virtual std::vector retireAgreement(RecipientBlockAckAgreement *agreement, bool associationReset) = 0; virtual void clearPeer(MacAddress peer) = 0; - virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) = 0; + // HCF supplies the observed SIFS or permitted RIFS relation for this frame. + virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe = false) = 0; virtual std::vector controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) = 0; virtual std::vector managementFrameReceived(Packet *mgmtPacket, const Ptr& mgmtHeader) = 0; }; diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index e968aabbee7..601eb39739e 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -18,12 +18,17 @@ #include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" #include "inet/linklayer/ieee80211/mac/framesequence/HcfFs.h" #include "inet/linklayer/ieee80211/mac/rateselection/RateSelection.h" +#include "inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h" #include "inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h" #include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h" #include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h" #include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" #include "inet/queueing/contract/ISelectivePacketCollection.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IReception.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h" namespace inet { namespace ieee80211 { @@ -47,8 +52,6 @@ void Hcf::initialize(int stage) blockAckVariant = BlockAckVariant::COMPRESSED; else throw cRuntimeError("Unknown blockAckVariant \"%s\": expected \"basic\" or \"compressed\"", configuredVariant); - if (blockAckVariant == BlockAckVariant::COMPRESSED) - throw cRuntimeError("Compressed Block Ack exchanges are not implemented"); mac = check_and_cast(getContainingNicModule(this)->getSubmodule("mac")); mib = check_and_cast(mac->getModuleByPath(mac->par("mibModule"))); startRxTimer = new cMessage("startRxTimeout"); @@ -65,6 +68,7 @@ void Hcf::initialize(int stage) rateSelection = check_and_cast(getSubmodule("rateSelection")); frameSequenceHandler = new FrameSequenceHandler(); WATCH_EXPR("frameSequenceInfo", getFrameSequenceInfo()); + WATCH_EXPR("numPendingInterframeReceptions", pendingReceptions.size()); originatorDataService = check_and_cast(getSubmodule(("originatorMacDataService"))); recipientDataService = check_and_cast(getSubmodule("recipientMacDataService")); originatorAckPolicy = check_and_cast(getSubmodule("originatorAckPolicy")); @@ -83,6 +87,23 @@ void Hcf::initialize(int stage) } } else if (stage == INITSTAGE_LAST) { + if (blockAckVariant == BlockAckVariant::COMPRESSED && par("isBlockAckSupported").boolValue()) { + interframeRadio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto radioModule = check_and_cast(interframeRadio.get()); + for (auto signal : {receptionStartedSignal, receptionEndedSignal, transmissionStartedSignal, transmissionEndedSignal, IRadio::receptionStateChangedSignal}) + radioModule->subscribe(signal, this); + } + if (par("isBlockAckSupported").boolValue()) { + EV_INFO << "Block Ack profile: " << (blockAckVariant == BlockAckVariant::BASIC ? "basic" : "compressed") << endl; + if (blockAckVariant == BlockAckVariant::COMPRESSED) { + if (originatorBlockAckAgreementPolicy && originatorBlockAckAgreementPolicy->isDelayedAckPolicySupported()) + throw cRuntimeError("Compressed Block Ack does not support delayedAckPolicySupported in %s.originatorBlockAckAgreementPolicy", getFullPath().c_str()); + if (recipientBlockAckAgreementPolicy && recipientBlockAckAgreementPolicy->delayedBlockAckPolicySupported()) + throw cRuntimeError("Compressed Block Ack does not support delayedAckPolicySupported in %s.recipientBlockAckAgreementPolicy", getFullPath().c_str()); + if (!mib->isHtOperationSupported()) + EV_WARN << "Compressed Block Ack has no usable local HT support; DATA uses Normal Ack. Set blockAckVariant = basic for Basic compatibility.\n"; + } + } // Edca resolves its Edcaf array at the link-layer stage. Install the // queue signal listeners after all child initialization has completed. auto lifetimeHandler = edca->getLifetimeHandler(); @@ -92,6 +113,13 @@ void Hcf::initialize(int stage) check_and_cast(originatorDataService)->setEligibility( [this](Packet *packet) { return isFrameEligible(packet, false); }, [this](Packet *packet) { return isAMsduPermitted(packet); }); + check_and_cast(originatorDataService)->setFragmentationPermission([this](Packet *packet) { + auto data = dynamicPtrCast(packet->peekAtFront()); + if (blockAckVariant != BlockAckVariant::COMPRESSED || !data || data->getType() != ST_DATA_WITH_QOS || !originatorBlockAckAgreementHandler) + return true; + auto agreement = originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()); + return !agreement || !agreement->getIsAddbaResponseReceived(); + }); mib->subscribe(Ieee80211Mib::rateStateChangedSignal, this); for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { edca->getEdcaf(static_cast(ac))->setFrameEligibility( @@ -310,7 +338,59 @@ void Hcf::processUpperFrame(Packet *packet, const Ptr(interframeRadio.get()) && signalID == receptionStartedSignal) { + auto reception = check_and_cast(obj); + auto transmission = reception->getTransmission(); + std::set active; + for (auto ongoing : interframeRadio->getReceptionsInProgress()) + active.insert(ongoing->getId()); + for (auto it = pendingReceptions.begin(); it != pendingReceptions.end();) { + if (!it->second.completed && !active.count(it->first)) + it = pendingReceptions.erase(it); + else + ++it; + } + PendingReception pending; + auto medium = interframeRadio->getMedium(); + pending.timing = medium->getTransmissionTimingSnapshot(transmission->getId()); + auto wifi = dynamic_cast(transmission); + pending.ht = wifi && wifi->getMode()->getModulationClass() == IIeee80211Mode::ModulationClass::HT; + if (wifi) + pending.extension = wifi->getSignalExtensionDuration(); + auto gap = medium->computePrecedingSignalGap(transmission->getId(), interframeHistory.timing); + if (gap && (interframeHistory.mpdu || interframeHistory.ack)) { + // IEEE Std 802.11-2024, 10.3.2.3.3: this model uses coverage class zero. + pending.sifs = std::abs((*gap - modeSet->getSifsTime()).raw()) <= modeSet->getSlotTime().raw() / 10; + if (interframeHistory.mpdu && interframeHistory.ht && pending.ht && interframeHistory.noSifsResponse && + interframeHistory.timing.transmitterRadioId == pending.timing.transmitterRadioId && interframeHistory.extension) { + auto rifs = wifi->getMode()->getRifsTime(); + // IEEE Std 802.11-2024, 10.3.2.3.2 and 10.3.8: RIFS excludes the actual preceding extension. + pending.rifs = std::abs((*gap + *interframeHistory.extension - rifs).raw()) <= rifs.raw() / 10; + pending.precedingReceiver = interframeHistory.receiver; + } + } + interframeHistory = {}; + pendingReceptions.insert_or_assign(transmission->getId(), std::move(pending)); + } + else if (interframeRadio && source == dynamic_cast(interframeRadio.get()) && signalID == receptionEndedSignal) { + auto reception = check_and_cast(obj); + auto pending = pendingReceptions.find(reception->getTransmission()->getId()); + if (pending != pendingReceptions.end()) + pending->second.completed = true; + } + else if (interframeRadio && source == dynamic_cast(interframeRadio.get()) && signalID == transmissionStartedSignal) + clearInterframeHistory(); + else if (interframeRadio && source == dynamic_cast(interframeRadio.get()) && signalID == transmissionEndedSignal) { + clearInterframeHistory(); + auto transmission = check_and_cast(obj); + if (completedTransmissionWasAck) { + interframeHistory.timing = interframeRadio->getMedium()->getTransmissionTimingSnapshot(transmission->getId()); + interframeHistory.ack = true; + } + completedTransmissionWasAck = false; + } + else if (signalID == InProgressFrames::packetDequeuedSignal) { Enter_Method("packetDequeued"); edca->getLifetimeHandler()->forgetFrame(check_and_cast(obj)->getId()); } @@ -329,6 +409,56 @@ void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, ModeSetListener::receiveSignal(source, signalID, obj, details); } +void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, intval_t value, cObject *details) +{ + Enter_Method_Silent(); + if (interframeRadio && source == dynamic_cast(interframeRadio.get()) && signalID == IRadio::receptionStateChangedSignal && + value != IRadio::RECEPTION_STATE_RECEIVING) { + bool incomplete = false; + for (auto it = pendingReceptions.begin(); it != pendingReceptions.end();) { + if (!it->second.completed) { + incomplete = true; + it = pendingReceptions.erase(it); + } + else + ++it; + } + if (incomplete || value == IRadio::RECEPTION_STATE_BUSY || value == IRadio::RECEPTION_STATE_UNDEFINED) + interframeHistory = {}; + } +} + +void Hcf::clearInterframeHistory() +{ + interframeHistory = {}; + pendingReceptions.clear(); +} + +bool Hcf::receiveInterframe(Packet *packet, const Ptr& header) +{ + auto time = packet->findTag(); + if (!time) + return false; + auto entry = pendingReceptions.find(time->getTransmissionId()); + if (entry == pendingReceptions.end() || !entry->second.completed) + return false; + auto pending = std::move(entry->second); + pendingReceptions.erase(entry); + // IEEE Std 802.11-2024, 10.27.3.1, 10.27.3.3, and 11.38.1: the BSS controls RIFS permission. + bool rifsPermitted = pending.rifs && modeSet->getPhyType() != Ieee80211ModeSet::PhyType::VHT && + (mib->mode == Ieee80211Mib::INDEPENDENT || mib->mode == Ieee80211Mib::MESH || mib->getHtOperation().rifsMode); + bool related = pending.sifs || (pending.rifs && rifsPermitted && pending.precedingReceiver == header->getReceiverAddress()); + interframeHistory.timing = std::move(pending.timing); + interframeHistory.mpdu = true; + interframeHistory.ht = pending.ht; + interframeHistory.receiver = header->getReceiverAddress(); + interframeHistory.extension = pending.extension; + auto dataOrMgmt = dynamicPtrCast(header); + interframeHistory.noSifsResponse = dataOrMgmt ? !recipientAckPolicy->isAckNeeded(dataOrMgmt) : + !dynamicPtrCast(header) && !dynamicPtrCast(header); + return related; +} + void Hcf::scheduleStartRxTimer(simtime_t timeout) { Enter_Method("scheduleStartRxTimer"); @@ -571,6 +701,14 @@ void Hcf::completeTransfers() void Hcf::discardAgreementData(MacAddress peer, Tid tid, bool all, int64_t highestTransmittedDataIndex) { + if (frameSequenceHandler->isSequenceRunning()) { + auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); + if (prepared) { + auto header = prepared->frame->peekAtFront(); + if (header->getReceiverAddress() == peer && header->getTid() == tid) + prepared->cancelled = true; + } + } for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { auto edcaf = edca->getEdcaf(static_cast(ac)); auto frames = edcaf->getInProgressFrames(); @@ -693,6 +831,8 @@ void Hcf::invalidateActions(MacAddress peer, Tid tid, bool originator) void Hcf::retireAgreement(MacAddress peer, Tid tid, bool originator, bool associationReset) { + if (!originator) + clearInterframeHistory(); if (originator) { auto agreement = originatorBlockAckAgreementHandler->detachAgreement(peer, tid); invalidateActions(peer, tid, originator); @@ -787,6 +927,7 @@ void Hcf::actionTerminated(Packet *packet, bool acknowledged) void Hcf::resetPeer(MacAddress peer) { + clearInterframeHistory(); Enter_Method("resetPeer"); if (!originatorBlockAckAgreementHandler) return; @@ -842,6 +983,16 @@ void Hcf::processLowerFrame(Packet *packet, const Ptr& { Enter_Method("processLowerFrame(%s)", packet->getName()); take(packet); + if (auto bar = dynamicPtrCast(header)) { + if (!validateBlockAckRequest(packet, bar)) { + interframeHistory = {}; + if (auto time = packet->findTag()) + pendingReceptions.erase(time->getTransmissionId()); + delete packet; + return; + } + } + bool interframe = interframeRadio && receiveInterframe(packet, header); EV_INFO << "Processing lower frame: " << packet->getName() << endl; auto edcaf = edca->getChannelOwner(); auto action = dynamicPtrCast(header); @@ -887,7 +1038,7 @@ void Hcf::processLowerFrame(Packet *packet, const Ptr& else if (hcca->isOwning()) throw cRuntimeError("Hcca is unimplemented!"); else if (isForUs(header)) - recipientProcessReceivedFrame(packet, header); + recipientProcessReceivedFrame(packet, header, interframe); else { EV_INFO << "This frame is not for us" << std::endl; PacketDropDetails details; @@ -897,6 +1048,33 @@ void Hcf::processLowerFrame(Packet *packet, const Ptr& } } +bool Hcf::validateBlockAckRequest(Packet *packet, const Ptr& bar) const +{ + // IEEE Std 802.11-2024, 9.3.1.7.2: the supported Compressed BAR has a zero Fragment Number. + auto basic = dynamicPtrCast(bar); + auto compressed = dynamicPtrCast(bar); + auto tid = basic ? basic->getTidInfo() : compressed ? compressed->getTidInfo() : -1; + bool valid = basic || compressed; + if (basic) + valid &= basic->getFragmentNumber() == 0 && !basic->getMultiTid() && !basic->getCompressedBitmap() && + basic->getStartingSequenceNumber().isSpecified() && (basic->getReserved() & 3) == 0; + if (compressed) + valid &= compressed->getFragmentNumber() == 0 && !compressed->getMultiTid() && compressed->getCompressedBitmap() && + compressed->getStartingSequenceNumber().isSpecified(); + if (!valid || tid < 0 || tid > 15 || bar->getChunkLength() != LENGTH_BLOCKACKREQ - B(4) || + packet->getDataLength() != LENGTH_BLOCKACKREQ || bar->getTransmitterAddress().isUnspecified() || + bar->getTransmitterAddress().isMulticast() || bar->getReceiverAddress().isUnspecified() || bar->getReceiverAddress().isMulticast()) + return false; + auto agreement = recipientBlockAckAgreementHandler ? + recipientBlockAckAgreementHandler->getAgreement(tid, bar->getTransmitterAddress()) : nullptr; + // ADDBA has no variant field. INET stops before any protocol update for an active conflicting profile. + if (bar->getReceiverAddress() == mac->getAddress() && agreement && bool(compressed) != (blockAckVariant == BlockAckVariant::COMPRESSED)) + throw cRuntimeError("Block Ack profile conflict at %s: peer=%s TID=%d local=%s received=%s; ADDBA does not negotiate the profile. Configure matching blockAckVariant values and start a new run", + getFullPath().c_str(), bar->getTransmitterAddress().str().c_str(), tid, + blockAckVariant == BlockAckVariant::COMPRESSED ? "compressed" : "basic", compressed ? "compressed" : "basic"); + return true; +} + void Hcf::channelGranted(IChannelAccess *channelAccess) { Enter_Method("channelGranted"); @@ -929,7 +1107,8 @@ void Hcf::channelGranted(IChannelAccess *channelAccess) FrameSequenceContext *Hcf::buildContext(AccessCategory ac) { auto edcaf = edca->getEdcaf(ac); - auto qosContext = new QoSContext(originatorAckPolicy, originatorBlockAckProcedure, originatorBlockAckAgreementHandler, edcaf->getTxopProcedure()); + auto qosContext = new QoSContext(originatorAckPolicy, originatorBlockAckProcedure, originatorBlockAckAgreementHandler, edcaf->getTxopProcedure(), blockAckVariant); + qosContext->prepareData = [this](FrameSequenceContext *context) { return prepareDataTransmission(context); }; return new FrameSequenceContext(mac->getAddress(), modeSet, edcaf->getInProgressFrames(), rtsProcedure, rtsPolicy, nullptr, qosContext); } @@ -954,7 +1133,30 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) edcaf->requestChannel(this); continue; } - Packet *internallyCollidedFrame = edcaf->getInProgressFrames()->getFrameToTransmit(); + auto frames = edcaf->getInProgressFrames(); + Packet *internallyCollidedFrame = nullptr; + bool scopedQueuedData = false; + if (blockAckVariant == BlockAckVariant::COMPRESSED && originatorBlockAckAgreementHandler) { + auto candidate = frames->peekFrameToTransmit(); + auto data = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; + auto agreement = data ? originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()) : nullptr; + if (data && data->getType() == ST_DATA_WITH_QOS && !data->getReceiverAddress().isMulticast() && + agreement && agreement->getIsAddbaResponseReceived() && !frames->containsFrame(candidate)) { + scopedQueuedData = true; + // Collision recovery needs a numbered frame, but it must not form an unadmitted aggregate. + auto service = check_and_cast(originatorDataService); + auto prepared = service->prepareFrame(edcaf->getPendingQueue(), false); + if (prepared) { + auto selected = prepared->packet->peekAtFront(); + if (selected->getReceiverAddress() == data->getReceiverAddress() && selected->getTid() == data->getTid()) + internallyCollidedFrame = service->commitPreparedFrame(*prepared); + } + if (internallyCollidedFrame) + frames->adoptPreparedFrame(internallyCollidedFrame); + } + } + if (!internallyCollidedFrame && !scopedQueuedData) + internallyCollidedFrame = frames->getFrameToTransmit(); if (internallyCollidedFrame == nullptr) continue; auto internallyCollidedHeader = internallyCollidedFrame->peekAtFront(); @@ -1037,7 +1239,7 @@ void Hcf::frameSequenceFinished() finishingSequence = false; } -void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr& header) +void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr& header, bool interframe) { EV_INFO << "Processing received frame " << packet->getName() << " as recipient.\n"; emit(packetReceivedFromPeerSignal, packet); @@ -1045,6 +1247,17 @@ void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr(header)) { + auto agreement = data->getType() == ST_DATA_WITH_QOS ? + recipientBlockAckAgreementHandler->getAgreement(data->getTid(), data->getTransmitterAddress()) : nullptr; + if (agreement && (data->getTid() < 0 || data->getTid() > 15 || !data->getSequenceNumber().isSpecified())) { + delete packet; + return; + } + if (agreement && blockAckVariant == BlockAckVariant::COMPRESSED && + (data->getFragmentNumber() != 0 || data->getMoreFragments())) { + delete packet; + return; + } if (data->getType() == ST_DATA_WITH_QOS && data->getAckPolicy() == BLOCK_ACK && (data->getTid() < 0 || data->getTid() > 15 || !data->getSequenceNumber().isSpecified() || data->getTransmitterAddress().isUnspecified() || data->getTransmitterAddress().isMulticast())) { @@ -1061,16 +1274,17 @@ void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr(header)) { - if (bar->getFragmentNumber() != 0 || bar->getMultiTid() || bar->getCompressedBitmap() || - bar->getTidInfo() < 0 || bar->getTidInfo() > 15 || !bar->getStartingSequenceNumber().isSpecified() || - bar->getTransmitterAddress().isUnspecified() || bar->getTransmitterAddress().isMulticast()) { + else if (auto bar = dynamicPtrCast(header)) { + if (!validateBlockAckRequest(packet, bar)) { delete packet; return; } - auto agreement = recipientBlockAckAgreementHandler->getAgreement(bar->getTidInfo(), bar->getTransmitterAddress()); + auto basic = dynamicPtrCast(bar); + auto compressed = dynamicPtrCast(bar); + auto tid = basic ? basic->getTidInfo() : compressed->getTidInfo(); + auto agreement = recipientBlockAckAgreementHandler->getAgreement(tid, bar->getTransmitterAddress()); if (!agreement) { - beginTeardown(bar->getTransmitterAddress(), bar->getTidInfo(), false, 38); + beginTeardown(bar->getTransmitterAddress(), tid, false, 38); delete packet; return; } @@ -1083,7 +1297,7 @@ void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr(header)) { if (dataHeader->getType() == ST_DATA_WITH_QOS && recipientBlockAckAgreementHandler) recipientBlockAckAgreementHandler->qosFrameReceived(dataHeader, this); - sendUp(recipientDataService->dataFrameReceived(packet, dataHeader, recipientBlockAckAgreementHandler)); + sendUp(recipientDataService->dataFrameReceived(packet, dataHeader, recipientBlockAckAgreementHandler, interframe)); } else if (auto mgmtHeader = dynamicPtrCast(header)) { auto accepted = recipientDataService->managementFrameReceived(packet, mgmtHeader); @@ -1111,7 +1325,7 @@ void Hcf::recipientProcessReceivedControlFrame(Packet *packet, const Ptr(header)) ctsProcedure->processReceivedRts(packet, rtsFrame, ctsPolicy, this); - else if (auto blockAckRequest = dynamicPtrCast(header)) { + else if (auto blockAckRequest = dynamicPtrCast(header)) { if (recipientBlockAckProcedure) recipientBlockAckProcedure->processReceivedBlockAckReq(packet, blockAckRequest, recipientAckPolicy, recipientBlockAckAgreementHandler, this); } @@ -1144,6 +1358,10 @@ bool Hcf::dispatchAgreementAction(const Ptr& header) } recipientBlockAckAgreementHandler->processReceivedAddbaRequest(addbaRequest, recipientBlockAckAgreementPolicy, this); auto agreement = recipientBlockAckAgreementHandler->getAgreement(addbaRequest->getTid(), addbaRequest->getTransmitterAddress()); + if (!previous && agreement) + agreement->setVariant(blockAckVariant); + if (!previous && agreement) + clearInterframeHistory(); if (!previous && agreement) emit(blockAckAgreementAddedSignal, agreement); scheduleInactivityTimer(); @@ -1197,6 +1415,7 @@ bool Hcf::dispatchAgreementAction(const Ptr& header) void Hcf::transmissionComplete(Packet *packet, const Ptr& header) { Enter_Method("transmissionComplete"); + completedTransmissionWasAck = header->getType() == ST_ACK; auto edcaf = edca->getChannelOwner(); if (edcaf) { auto step = check_and_cast(frameSequenceHandler->getContext()->getLastStep()); @@ -1217,6 +1436,15 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) Enter_Method("originatorProcessRtsProtectionFailed"); auto protectedHeader = packet->peekAtFront(); auto edcaf = edca->getChannelOwner(); + auto context = frameSequenceHandler->getContext(); + auto prepared = context->getQoSContext()->preparedData.get(); + if (prepared && prepared->frame == packet && prepared->preparation) { + // IEEE Std 802.11-2024, 10.23.2.2 and 10.23.2.12.1: BA RTS failure updates QSRC/CW. + // The uncommitted sources retain their lifetimes. No provisional sequence owns an SRC entry. + if (validatePreparedData(*prepared, simTime())) + edcaf->getRecoveryProcedure()->controlFrameTransmissionFailed(); + return; + } if (obsoleteActions.count(packet->getId()) || !edcaf->getInProgressFrames()->containsFrame(packet)) return; if (edcaf) { @@ -1345,9 +1573,12 @@ void Hcf::originatorProcessTransmittedManagementFrame(const Ptr& controlHeader, AccessCategory ac) { auto edcaf = edca->getEdcaf(ac); - if (auto blockAckReq = dynamicPtrCast(controlHeader)) { + if (auto blockAckReq = dynamicPtrCast(controlHeader)) { + auto basic = dynamicPtrCast(blockAckReq); + auto compressed = dynamicPtrCast(blockAckReq); + auto tid = basic ? basic->getTidInfo() : compressed->getTidInfo(); auto agreement = originatorBlockAckAgreementHandler ? - originatorBlockAckAgreementHandler->getAgreement(blockAckReq->getReceiverAddress(), blockAckReq->getTidInfo()) : nullptr; + originatorBlockAckAgreementHandler->getAgreement(blockAckReq->getReceiverAddress(), tid) : nullptr; if (agreement) edcaf->getAckHandler()->processTransmittedBlockAckReq(blockAckReq, agreement); } @@ -1495,13 +1726,18 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const Ptr(header)) { - if (!originatorBlockAckAgreementHandler || - !originatorBlockAckAgreementHandler->getAgreement(blockAck->getTransmitterAddress(), blockAck->getTidInfo())) + else if (auto blockAck = dynamicPtrCast(header)) { + auto basic = dynamicPtrCast(blockAck); + auto compressed = dynamicPtrCast(blockAck); + auto tid = basic ? basic->getTidInfo() : compressed->getTidInfo(); + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(blockAck->getTransmitterAddress(), tid) : nullptr; + if (!agreement) return; - EV_INFO << "BasicBlockAck has arrived" << std::endl; + EV_INFO << "BlockAck has arrived" << std::endl; edcaf->getRecoveryProcedure()->blockAckFrameReceived(); - auto ackedSeqAndFragNums = edcaf->getAckHandler()->processReceivedBlockAck(blockAck); + auto ackedSeqAndFragNums = compressed ? edcaf->getAckHandler()->processReceivedCompressedBlockAck(compressed, agreement) : + edcaf->getAckHandler()->processReceivedBlockAck(blockAck); if (originatorBlockAckAgreementHandler) originatorBlockAckAgreementHandler->processReceivedBlockAck(blockAck, this); EV_TRACE << "It has acknowledged the following frames:" << std::endl; @@ -1528,7 +1764,7 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const PtrgetType() == ST_DATA_WITH_QOS) ; // void - else if (dynamicPtrCast(header)) + else if (dynamicPtrCast(header)) ; // void else throw cRuntimeError("Unknown control frame"); @@ -1629,8 +1865,9 @@ simtime_t Hcf::estimateZeroLimitExchange(Packet *packet, const Ptr(header)) - return ppduDuration + sifs + rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT)->getDuration(LENGTH_BASIC_BLOCKACK); + if (auto bar = dynamicPtrCast(header)) + return ppduDuration + sifs + rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT)->getDuration( + dynamicPtrCast(bar) ? LENGTH_COMPRESSED_BLOCKACK : LENGTH_BASIC_BLOCKACK); if (auto dataOrMgmt = dynamicPtrCast(header)) { if (recipientAckPolicy->isAckNeeded(dataOrMgmt)) return ppduDuration + sifs + rateSelection->computeResponseAckFrameMode(packet, dataOrMgmt, ResponseQueryRole::PREDICT)->getDuration(LENGTH_ACK); @@ -1645,6 +1882,180 @@ simtime_t Hcf::computeImmediateResponseDuration(Packet *packet, const PtrcomputeResponseAckFrameMode(packet, header, ResponseQueryRole::PREDICT)->getDuration(LENGTH_ACK) : SIMTIME_ZERO; } +bool Hcf::isInitialDataException(const FrameSequenceContext *context, const PreparedDataTransmission& prepared) const +{ + auto header = prepared.frame->peekAtFront(); + // IEEE Std 802.11-2024, 10.23.2.9: the same-size single-MPDU retry exception also permits an A-MSDU. + // Committed Compressed MPDUs retain their payload and length throughout retry; this path forms no A-MPDU. + bool committedRetry = !prepared.preparation && header->getRetry(); + if (!committedRetry && (header->getAMsduPresent() || header->getRetry())) + return false; + for (int i = 0; i < context->getNumSteps(); i++) { + auto step = dynamic_cast(context->getStep(i)); + if (step && step->getPpduEnd() >= SIMTIME_ZERO && + dynamicPtrCast(step->getFrameToTransmit()->peekAtFront())) + return false; + } + return true; +} + +simtime_t Hcf::computePreparedDataCost(const PreparedDataTransmission& prepared, bool protect) const +{ + auto sifs = modeSet->getSifsTime(); + auto cost = prepared.dataMode->getDuration(prepared.frame->getDataLength()); + if (prepared.ackMode) + cost += sifs + prepared.ackMode->getDuration(LENGTH_ACK); + if (protect) + cost += prepared.rtsMode->getDuration(prepared.rtsPrediction->getDataLength()) + + sifs + prepared.ctsMode->getDuration(LENGTH_CTS) + sifs; + return cost; +} + +bool Hcf::canAdmitPreparedData(const FrameSequenceContext *context, const PreparedDataTransmission& prepared, + simtime_t ifs, bool protect) const +{ + auto txop = context->getQoSContext()->txopProcedure; + auto cost = computePreparedDataCost(prepared, protect); + int previousData = 0; + for (int i = 0; i < context->getNumSteps(); i++) { + auto step = dynamic_cast(context->getStep(i)); + if (step && step->getPpduEnd() >= SIMTIME_ZERO && + dynamicPtrCast(step->getFrameToTransmit()->peekAtFront())) + previousData++; + } + // IEEE Std 802.11-2024, 10.23.2.9: zero permits one SU DATA PPDU, including an A-MSDU. + if (txop->getLimit() == 0) { + if (previousData != 0) + return false; + } + else if (ifs + cost > txop->getRemaining() && !isInitialDataException(context, prepared)) + return false; + bool later = context->getNumSteps() > 0; + // The current TransmitStep is already present at the final submission check. + if (later) { + auto last = dynamic_cast(context->getLastStep()); + later = !last || last->getPpduEnd() >= SIMTIME_ZERO || context->getNumSteps() > 1; + } + // 10.23.2.8 samples TXNAV at exchange completion, before the leading IFS. + if (later && txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && cost >= rx->getTxnavRemaining()) + return false; + if (later && protect && txop->getLimit() > 0 && txop->getProtectionMechanism() == TxopProcedure::MULTIPLE_PROTECTION && + (simTime() + ifs - txop->getStart() - txop->getLimit()).raw() % SimTime(1, SIMTIME_US).raw() != 0) + return false; + return true; +} + +bool Hcf::validatePreparedData(const PreparedDataTransmission& prepared, simtime_t start) const +{ + if (prepared.cancelled || prepared.modeSet != modeSet) + return false; + auto header = prepared.frame->peekAtFront(); + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(header->getReceiverAddress(), header->getTid()) : nullptr; + if (agreement != prepared.agreement || !agreement || !agreement->getIsAddbaResponseReceived() || + !isProfileAllowed(header->getReceiverAddress(), true)) + return false; + auto service = check_and_cast(originatorDataService); + if (prepared.preparation) { + if (!service->isPreparationValid(*prepared.preparation, start)) + return false; + } + else if (!edca->getChannelOwner()->getInProgressFrames()->containsFrame(prepared.frame) || + !isFrameEligible(prepared.frame, true) || edca->getLifetimeHandler()->isExpired(prepared.frame, start)) + return false; + auto peer = mib->findPeerHtState(header->getReceiverAddress()); + if (!isPeerCompatibleMode(modeSet, peer, prepared.dataMode) || + (prepared.rtsMode && !isPeerCompatibleMode(modeSet, peer, prepared.rtsMode))) + return false; + if (originatorAckPolicy->computeAckPolicy(prepared.frame, header, agreement) != header->getAckPolicy()) + return false; + if (prepared.ackMode && (!modeSet->containsMode(prepared.ackMode) || + rateSelection->computeResponseAckFrameMode(prepared.frame, header, ResponseQueryRole::PREDICT) != prepared.ackMode)) + return false; + if (prepared.ctsMode && (!modeSet->containsMode(prepared.ctsMode) || + rateSelection->computeResponseCtsFrameMode(prepared.rtsPrediction.get(), + prepared.rtsPrediction->peekAtFront(), ResponseQueryRole::PREDICT) != prepared.ctsMode)) + return false; + return true; +} + +DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context) +{ + Enter_Method("prepareDataTransmission"); + if (blockAckVariant != BlockAckVariant::COMPRESSED || !originatorBlockAckAgreementHandler) + return DataPreparationResult::LEGACY; + auto frames = context->getInProgressFrames(); + auto candidate = frames->peekFrameToTransmit(); + auto header = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; + if (!header || header->getType() != ST_DATA_WITH_QOS || header->getReceiverAddress().isMulticast()) + return DataPreparationResult::LEGACY; + auto agreement = originatorBlockAckAgreementHandler->getAgreement(header->getReceiverAddress(), header->getTid()); + if (!agreement || !agreement->getIsAddbaResponseReceived()) + return DataPreparationResult::LEGACY; + auto prepared = std::make_unique(); + prepared->modeSet = modeSet; + prepared->agreement = agreement; + auto service = check_and_cast(originatorDataService); + if (frames->containsFrame(candidate)) + prepared->frame = candidate; + else { + prepared->preparation = service->prepareFrame(edca->getChannelOwner()->getPendingQueue(), true); + if (!prepared->preparation) + return DataPreparationResult::DEFERRED; + prepared->frame = prepared->preparation->packet.get(); + } + auto selected = prepared->frame->peekAtFront(); + if (selected->getReceiverAddress() != header->getReceiverAddress() || selected->getTid() != header->getTid()) + return DataPreparationResult::DEFERRED; + auto txop = context->getQoSContext()->txopProcedure; + prepared->dataMode = rateSelection->computeMode(prepared->frame, + prepared->frame->peekAtFront(), txop); + const IIeee80211Mode *selectedRtsMode = nullptr; + for (;;) { + auto packet = prepared->frame; + auto policy = originatorAckPolicy->computeAckPolicy(packet, packet->peekAtFront(), agreement); + auto updated = packet->removeAtFront(); + bool retry = false; + if (!prepared->preparation) { + auto status = edca->getChannelOwner()->getAckHandler()->getQoSDataAckStatus(updated); + retry = status == QosAckHandler::Status::NORMAL_ACK_NOT_ARRIVED || + status == QosAckHandler::Status::BLOCK_ACK_NOT_ARRIVED || status == QosAckHandler::Status::BLOCK_ACK_ARRIVED_UNACKED; + } + // Forwarded MSDUs can carry the preceding hop's Retry bit. Local ACK state owns this hop's retry decision. + updated->setRetry(retry); + updated->setAckPolicy(policy); + packet->insertAtFront(updated); + setFrameMode(packet, updated, prepared->dataMode); + prepared->ackMode = recipientAckPolicy->isAckNeeded(updated) ? + rateSelection->computeResponseAckFrameMode(packet, updated, ResponseQueryRole::PREDICT) : nullptr; + bool protect = rtsPolicy->isRtsNeeded(packet, updated); + prepared->setRtsPrediction(nullptr); + prepared->rtsMode = nullptr; + prepared->ctsMode = nullptr; + if (protect) { + prepared->setRtsPrediction(new Packet("prepared-RTS", rtsProcedure->buildRtsFrame(updated))); + prepared->rtsPrediction->insertAtBack(makeShared()); + auto rts = prepared->rtsPrediction->peekAtFront(); + if (!selectedRtsMode) + selectedRtsMode = rateSelection->computeMode(prepared->rtsPrediction.get(), rts, txop); + prepared->rtsMode = selectedRtsMode; + setFrameMode(prepared->rtsPrediction.get(), rts, selectedRtsMode); + prepared->ctsMode = rateSelection->computeResponseCtsFrameMode(prepared->rtsPrediction.get(), rts, ResponseQueryRole::PREDICT); + } + if (validatePreparedData(*prepared, simTime() + context->getIfs()) && + canAdmitPreparedData(context, *prepared, context->getIfs(), protect)) { + context->getQoSContext()->preparedData = std::move(prepared); + return DataPreparationResult::READY; + } + if (!prepared->preparation || !prepared->preparation->aggregate) + return DataPreparationResult::DEFERRED; + prepared->preparation = service->prepareFrame(edca->getChannelOwner()->getPendingQueue(), false); + if (!prepared->preparation) + return DataPreparationResult::DEFERRED; + prepared->frame = prepared->preparation->packet.get(); + } +} + simtime_t Hcf::forecastSingleProtectionSuccessor(Packet *packet, const Ptr& header, TxopProcedure *txop, InProgressFrames *frames, simtime_t completionTime) { @@ -1692,7 +2103,16 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) auto channelOwner = edca->getChannelOwner(); if (channelOwner) { auto header = packet->peekAtFront(); + auto context = frameSequenceHandler->getContext(); + auto prepared = context->getQoSContext()->preparedData.get(); + auto rtsStep = dynamic_cast(context->getLastStep()); + bool preparedStep = prepared && (prepared->frame == packet || + (rtsStep && rtsStep->getProtectedFrame() == prepared->frame)); + if (preparedStep && (!validatePreparedData(*prepared, simTime() + ifs) || + !canAdmitPreparedData(context, *prepared, ifs, rtsStep != nullptr))) + return false; if (dynamicPtrCast(header) && + !(preparedStep && prepared->preparation) && !channelOwner->getInProgressFrames()->containsFrame(packet)) return false; if (!isFrameEligible(packet, true)) @@ -1716,7 +2136,6 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) if (lifetimeHandler->isExpired(data, simTime() + ifs)) return false; auto txop = channelOwner->getTxopProcedure(); - auto context = frameSequenceHandler->getContext(); bool scopedSingle = txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && !par("isBlockAckSupported").boolValue(); Packet *retainedPacket = packet; auto retainedModeTag = scopedSingle ? retainedPacket->findTag() : nullptr; @@ -1729,14 +2148,21 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) receiveStep->getCompletion() == IFrameSequenceStep::Completion::ACCEPTED && receiveStep->getReceivedFrame()->peekAtFront()->getType() == ST_CTS; } - auto mode = dataAfterCts ? packet->getTag()->getMode() : rateSelection->computeMode(packet, header, txop); + auto compressedBar = dynamicPtrCast(header); + auto mode = preparedStep ? (rtsStep ? prepared->rtsMode : prepared->dataMode) : + compressedBar ? rateSelection->computeCompressedBlockAckReqMode(packet, compressedBar, context->getNumSteps() == 1) : + dataAfterCts ? packet->getTag()->getMode() : rateSelection->computeMode(packet, header, txop); setFrameMode(packet, header, mode); - if (auto bar = dynamicPtrCast(header)) { + if (auto bar = dynamicPtrCast(header)) { + auto basic = dynamicPtrCast(bar); + auto compressed = dynamicPtrCast(bar); + auto tid = basic ? basic->getTidInfo() : compressed->getTidInfo(); auto agreement = originatorBlockAckAgreementHandler ? - originatorBlockAckAgreementHandler->getAgreement(bar->getReceiverAddress(), bar->getTidInfo()) : nullptr; + originatorBlockAckAgreementHandler->getAgreement(bar->getReceiverAddress(), tid) : nullptr; if (!agreement || !agreement->getIsAddbaResponseReceived()) return false; - auto response = rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT)->getDuration(LENGTH_BASIC_BLOCKACK); + auto response = rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT)->getDuration( + compressed ? LENGTH_COMPRESSED_BLOCKACK : LENGTH_BASIC_BLOCKACK); auto cost = mode->getDuration(packet->getDataLength()) + modeSet->getSifsTime() + response; // IEEE Std 802.11-2024, 10.23.2.8 and 10.23.2.9: a later BAR must fit both bounds. if (context->getNumSteps() > 1 && @@ -1744,7 +2170,33 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) (txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && cost >= rx->getTxnavRemaining()))) return false; } - if (scopedSingle) { + if (preparedStep) { + auto response = rtsStep ? prepared->ctsMode->getDuration(LENGTH_CTS) : + prepared->ackMode ? prepared->ackMode->getDuration(LENGTH_ACK) : SIMTIME_ZERO; + simtime_t duration; + if (txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION) { + // Reserve this exchange only. A later BAR obtains contention through the existing arbitration path. + duration = encodeDuration(singleProtectionMechanism->computeDurationField(header, response, + rtsStep ? computePreparedDataCost(*prepared, false) : SIMTIME_ZERO, true), true); + } + else { + auto ppduDuration = mode->getDuration(packet->getDataLength()); + auto projectedStart = simTime() + ifs; + auto reservation = std::max(SIMTIME_ZERO, txop->getReservationEnd() - projectedStart); + auto remaining = std::max(SIMTIME_ZERO, txop->getStart() + txop->getLimit() - projectedStart); + auto cost = computePreparedDataCost(*prepared, rtsStep != nullptr); + bool singleDataOverrun = txop->getLimit() > 0 && ifs + cost > txop->getRemaining() && + isInitialDataException(context, *prepared); + // An allowed single-DATA overrun protects its actual exchange beyond the nominal limit. + duration = singleDataOverrun ? computeMultipleProtectionDuration(0, 0, 0, ppduDuration, cost, false) : + computeMultipleProtectionDuration(txop->getLimit(), remaining, reservation, ppduDuration, + txop->getLimit() == 0 ? cost : SIMTIME_ZERO, txop->getReservationEnd() != 0); + } + auto updated = packet->removeAtFront(); + updated->setDurationField(duration); + packet->insertAtFront(updated); + } + else if (scopedSingle) { auto sifs = modeSet->getSifsTime(); auto cost = mode->getDuration(packet->getDataLength()); simtime_t responseDuration = SIMTIME_ZERO; @@ -1829,6 +2281,16 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) } else throw cRuntimeError("Undefined protection mechanism"); + if (preparedStep && packet == prepared->frame && prepared->preparation) { + auto service = check_and_cast(originatorDataService); + auto committed = service->commitPreparedFrame(*prepared->preparation); + if (!committed) + return false; + ASSERT(committed == packet); + prepared->preparation.reset(); + channelOwner->getInProgressFrames()->adoptPreparedFrame(committed); + header = committed->peekAtFront(); + } RateSelection::emitDatarateSelected(this, header, mode); EV_DEBUG << "Datarate for " << packet->getName() << " is set to " << mode->getDataMode()->getNetBitrate() << ".\n"; tx->transmitFrame(packet, packet->peekAtFront(), ifs, false, this); @@ -1858,7 +2320,7 @@ void Hcf::transmitControlResponseFrame(Packet *responsePacket, const Ptr(receivedHeader)) responseMode = rateSelection->computeResponseCtsFrameMode(receivedPacket, rtsFrame, ResponseQueryRole::RESPOND); - else if (auto blockAckReq = dynamicPtrCast(receivedHeader)) + else if (auto blockAckReq = dynamicPtrCast(receivedHeader)) responseMode = rateSelection->computeResponseBlockAckFrameMode(receivedPacket, blockAckReq, ResponseQueryRole::RESPOND); else if (auto dataOrMgmtHeader = dynamicPtrCast(receivedHeader)) responseMode = rateSelection->computeResponseAckFrameMode(receivedPacket, dataOrMgmtHeader, ResponseQueryRole::RESPOND); @@ -1957,6 +2419,7 @@ bool Hcf::isSentByUs(const Ptr& header) const void Hcf::corruptedFrameReceived() { Enter_Method("corruptedFrameReceived"); + clearInterframeHistory(); if (frameSequenceHandler->isSequenceRunning() && !startRxTimer->isScheduled()) { frameSequenceHandler->handleStartRxTimeout(); } @@ -1966,6 +2429,11 @@ void Hcf::corruptedFrameReceived() Hcf::~Hcf() { + if (interframeRadio) { + auto radioModule = check_and_cast(interframeRadio.get()); + for (auto signal : {receptionStartedSignal, receptionEndedSignal, transmissionStartedSignal, transmissionEndedSignal, IRadio::receptionStateChangedSignal}) + radioModule->unsubscribe(signal, this); + } cancelAndDelete(addbaResponseTimer); cancelAndDelete(dataLifetimeTimer); cancelAndDelete(startRxTimer); diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h index 03d7bb93a45..a6594025b0f 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h @@ -8,6 +8,8 @@ #ifndef __INET_HCF_H #define __INET_HCF_H +#include + #include "inet/linklayer/ieee80211/mac/channelaccess/Edca.h" #include "inet/linklayer/ieee80211/mac/channelaccess/Hcca.h" #include "inet/linklayer/ieee80211/mac/common/ModeSetListener.h" @@ -37,6 +39,8 @@ #include "inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h" #include "inet/linklayer/ieee80211/mac/queue/InProgressFrames.h" #include "inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h" namespace inet { namespace ieee80211 { @@ -51,6 +55,31 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: { private: BlockAckVariant blockAckVariant = BlockAckVariant::BASIC; + bool validateBlockAckRequest(Packet *packet, const Ptr& bar) const; + struct InterframeHistory { + physicallayer::TransmissionTimingSnapshot timing; + bool mpdu = false; + bool ack = false; + bool ht = false; + bool noSifsResponse = false; + MacAddress receiver; + std::optional extension; + }; + struct PendingReception { + bool completed = false; + bool sifs = false; + bool rifs = false; + MacAddress precedingReceiver; + physicallayer::TransmissionTimingSnapshot timing; + bool ht = false; + std::optional extension; + }; + opp_component_ptr interframeRadio; + InterframeHistory interframeHistory; + std::map pendingReceptions; + bool completedTransmissionWasAck = false; + void clearInterframeHistory(); + bool receiveInterframe(Packet *packet, const Ptr& header); public: static simsignal_t edcaCollisionDetectedSignal; @@ -130,6 +159,7 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: virtual void handleMessage(cMessage *msg) override; virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; virtual void receiveSignal(cComponent *source, simsignal_t signalID, bool value, cObject *details) override; + virtual void receiveSignal(cComponent *source, simsignal_t signalID, intval_t value, cObject *details) override; virtual void refreshDisplay() const override; void startFrameSequence(AccessCategory ac); @@ -140,6 +170,12 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: FrameSequenceContext *buildContext(AccessCategory ac); static simtime_t encodeDuration(simtime_t duration, bool holder); simtime_t computeImmediateResponseDuration(Packet *packet, const Ptr& header); + DataPreparationResult prepareDataTransmission(FrameSequenceContext *context); + bool validatePreparedData(const PreparedDataTransmission& prepared, simtime_t start) const; + simtime_t computePreparedDataCost(const PreparedDataTransmission& prepared, bool protect) const; + bool canAdmitPreparedData(const FrameSequenceContext *context, const PreparedDataTransmission& prepared, + simtime_t ifs, bool protect) const; + bool isInitialDataException(const FrameSequenceContext *context, const PreparedDataTransmission& prepared) const; simtime_t forecastSingleProtectionSuccessor(Packet *packet, const Ptr& header, TxopProcedure *txop, InProgressFrames *frames, simtime_t completionTime); static simtime_t computeMultipleProtectionDuration(simtime_t limit, simtime_t remaining, @@ -173,7 +209,7 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: bool isProfileAllowed(MacAddress peer, bool originator) const; // Recipient - virtual void recipientProcessReceivedFrame(Packet *packet, const Ptr& header); + virtual void recipientProcessReceivedFrame(Packet *packet, const Ptr& header, bool interframe = false); virtual void recipientProcessReceivedControlFrame(Packet *packet, const Ptr& header); virtual void recipientProcessReceivedManagementFrame(const Ptr& header); virtual void recipientProcessTransmittedControlResponseFrame(Packet *packet, const Ptr& header); diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned index 2036bbbe680..e38a6636622 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned @@ -29,7 +29,7 @@ module Hcf extends Module like IHcf { parameters: bool isBlockAckSupported = default(false); - string blockAckVariant = default("basic"); // "basic" selects historical compatibility. "compressed" is reserved until its exchange path exists. + string blockAckVariant = default("basic"); // Compressed requires usable HT state. Select Basic explicitly for historical compatibility. string rxModule; string txModule; diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc index d5a8ac4d2c3..f392d6fc3aa 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc @@ -12,6 +12,21 @@ namespace ieee80211 { using namespace inet::physicallayer; +PreparedDataTransmission::~PreparedDataTransmission() +{ + if (rtsPrediction) + drop(rtsPrediction.get()); +} + +void PreparedDataTransmission::setRtsPrediction(Packet *packet) +{ + if (rtsPrediction) + drop(rtsPrediction.get()); + rtsPrediction.reset(packet); + if (rtsPrediction) + take(rtsPrediction.get()); +} + FrameSequenceContext::FrameSequenceContext(MacAddress address, Ieee80211ModeSet *modeSet, InProgressFrames *inProgressFrames, IRtsProcedure *rtsProcedure, IRtsPolicy *rtsPolicy, NonQoSContext *nonQoSContext, QoSContext *qosContext) : address(address), modeSet(modeSet), @@ -31,6 +46,11 @@ void FrameSequenceContext::removeLastStep() delete step; } +Packet *FrameSequenceContext::getDataFrameToTransmit() const +{ + return qosContext && qosContext->preparedData ? qosContext->preparedData->frame : inProgressFrames->getFrameToTransmit(); +} + simtime_t FrameSequenceContext::getIfs() const { return getNumSteps() == 0 ? 0 : modeSet->getSifsTime(); // TODO pifs diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h index ba9a3695257..85fa551c5f4 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h @@ -8,13 +8,18 @@ #ifndef __INET_FRAMESEQUENCECONTEXT_H #define __INET_FRAMESEQUENCECONTEXT_H +#include +#include + #include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h" +#include "inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h" #include "inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h" #include "inet/linklayer/ieee80211/mac/contract/IFrameSequence.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h" +#include "inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h" #include "inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h" #include "inet/linklayer/ieee80211/mac/originator/RtsProcedure.h" #include "inet/linklayer/ieee80211/mac/originator/TxopProcedure.h" @@ -24,20 +29,46 @@ namespace inet { namespace ieee80211 { +class FrameSequenceContext; + +enum class DataPreparationResult { LEGACY, READY, DEFERRED }; + +/** Retains one actual mode decision until DATA submission or cancellation. */ +struct INET_API PreparedDataTransmission : public cObject +{ + std::unique_ptr preparation; + Packet *frame = nullptr; // Borrowed from preparation, or from InProgressFrames after commitment. + const physicallayer::Ieee80211ModeSet *modeSet = nullptr; + const physicallayer::IIeee80211Mode *dataMode = nullptr; + const physicallayer::IIeee80211Mode *rtsMode = nullptr; + const physicallayer::IIeee80211Mode *ackMode = nullptr; + const physicallayer::IIeee80211Mode *ctsMode = nullptr; + std::unique_ptr rtsPrediction; + OriginatorBlockAckAgreement *agreement = nullptr; // Identity only; validation obtains current state from its owner. + bool cancelled = false; + + ~PreparedDataTransmission() override; + void setRtsPrediction(Packet *packet); +}; + class INET_API QoSContext { public: - QoSContext(IOriginatorQoSAckPolicy *ackPolicy, IOriginatorBlockAckProcedure *blockAckProcedure, IOriginatorBlockAckAgreementHandler *blockAckAgreementHandler, TxopProcedure *txopProcedure) : + QoSContext(IOriginatorQoSAckPolicy *ackPolicy, IOriginatorBlockAckProcedure *blockAckProcedure, IOriginatorBlockAckAgreementHandler *blockAckAgreementHandler, TxopProcedure *txopProcedure, BlockAckVariant variant = BlockAckVariant::BASIC) : ackPolicy(ackPolicy), blockAckProcedure(blockAckProcedure), blockAckAgreementHandler(blockAckAgreementHandler), - txopProcedure(txopProcedure) + txopProcedure(txopProcedure), + blockAckVariant(variant) {} IOriginatorQoSAckPolicy *ackPolicy = nullptr; IOriginatorBlockAckProcedure *blockAckProcedure = nullptr; IOriginatorBlockAckAgreementHandler *blockAckAgreementHandler = nullptr; TxopProcedure *txopProcedure = nullptr; + const BlockAckVariant blockAckVariant; + std::function prepareData; + std::unique_ptr preparedData; }; class INET_API NonQoSContext @@ -79,6 +110,8 @@ class INET_API FrameSequenceContext : public cObject virtual IFrameSequenceStep *getStepBeforeLast() const { return steps.size() > 1 ? steps[steps.size() - 2] : nullptr; } virtual InProgressFrames *getInProgressFrames() const { return inProgressFrames; } + // A reversible preview replaces destructive extraction only for the scoped QoS path. + Packet *getDataFrameToTransmit() const; virtual IRtsProcedure *getRtsProcedure() const { return rtsProcedure; } virtual IRtsPolicy *getRtsPolicy() const { return rtsPolicy; } diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc b/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc index 7a49e0ece7c..7bcd7d3be5c 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc @@ -64,6 +64,14 @@ bool HcfFs::hasMoreTxOps(RepeatingFs *frameSequence, FrameSequenceContext *conte auto frames = context->getInProgressFrames(); auto qos = context->getQoSContext(); bool bar = qos->ackPolicy->isBlockAckReqNeeded(frames, qos->txopProcedure, qos->blockAckAgreementHandler); + qos->preparedData.reset(); + if (!bar && qos->prepareData) { + auto preparation = qos->prepareData(context); + if (preparation == DataPreparationResult::READY) + return true; + if (preparation == DataPreparationResult::DEFERRED) + return false; + } bool hasFrameToTransmit = qos->blockAckAgreementHandler ? bar || frames->peekFrameToTransmit() != nullptr : frames->hasInProgressFrames(); if (hasFrameToTransmit) { @@ -101,7 +109,7 @@ bool HcfFs::hasMoreTxOps(RepeatingFs *frameSequence, FrameSequenceContext *conte bool HcfFs::hasMoreTxOpsAndMulticast(RepeatingFs *frameSequence, FrameSequenceContext *context) { - return hasMoreTxOps(frameSequence, context) && context->getInProgressFrames()->getFrameToTransmit()->peekAtFront()->getReceiverAddress().isMulticast(); + return hasMoreTxOps(frameSequence, context) && context->getDataFrameToTransmit()->peekAtFront()->getReceiverAddress().isMulticast(); } } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc index f9a3de4a6e5..66da226a753 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc @@ -40,7 +40,7 @@ IFrameSequenceStep *RtsFs::prepareStep(FrameSequenceContext *context) { switch (step) { case 0: { - auto dataOrMgmtPacket = context->getInProgressFrames()->getFrameToTransmit(); + auto dataOrMgmtPacket = context->getDataFrameToTransmit(); auto rtsFrame = context->getRtsProcedure()->buildRtsFrame(dataOrMgmtPacket->peekAtFront()); auto rtsPacket = new Packet("RTS"); rtsPacket->insertAtBack(rtsFrame); @@ -119,7 +119,7 @@ IFrameSequenceStep *DataFs::prepareStep(FrameSequenceContext *context) // RTS/CTS retains its selected DATA even if its lifetime expires during protection. // HCF rejects the next submission before Tx accepts that expired DATA. if (packet == nullptr) - packet = context->getInProgressFrames()->getFrameToTransmit(); + packet = context->getDataFrameToTransmit(); return new TransmitStep(packet, context->getIfs()); } case 1: @@ -275,7 +275,7 @@ IFrameSequenceStep *RtsCtsFs::prepareStep(FrameSequenceContext *context) { switch (step) { case 0: { - auto packet = context->getInProgressFrames()->getFrameToTransmit(); + auto packet = context->getDataFrameToTransmit(); auto dataOrMgmtHeader = packet->peekAtFront(); auto rtsFrame = context->getRtsProcedure()->buildRtsFrame(dataOrMgmtHeader); auto rtsPacket = new Packet("RTS"); @@ -417,8 +417,10 @@ IFrameSequenceStep *BlockAckReqBlockAckFs::prepareStep(FrameSequenceContext *con auto receiverAddr = std::get<0>(blockAckReqParams); auto startingSequenceNumber = std::get<1>(blockAckReqParams); auto tid = std::get<2>(blockAckReqParams); - auto blockAckReq = context->getQoSContext()->blockAckProcedure->buildBasicBlockAckReqFrame(receiverAddr, tid, startingSequenceNumber); - auto blockAckPacket = new Packet("BasicBlockAckReq", blockAckReq); + bool compressed = qos->blockAckVariant == BlockAckVariant::COMPRESSED; + auto blockAckReq = compressed ? qos->blockAckProcedure->buildCompressedBlockAckReqFrame(receiverAddr, tid, startingSequenceNumber) : + qos->blockAckProcedure->buildBasicBlockAckReqFrame(receiverAddr, tid, startingSequenceNumber); + auto blockAckPacket = new Packet(compressed ? "CompressedBlockAckReq" : "BasicBlockAckReq", blockAckReq); blockAckPacket->insertAtBack(makeShared()); return new TransmitStep(blockAckPacket, context->getIfs(), true); } @@ -446,12 +448,33 @@ bool BlockAckReqBlockAckFs::completeStep(FrameSequenceContext *context) step++; auto receivedPacket = receiveStep->getReceivedFrame(); const auto& receivedHeader = receivedPacket->peekAtFront(); - auto response = dynamicPtrCast(receivedHeader); auto requestStep = check_and_cast(context->getStep(firstStep)); - auto request = requestStep->getFrameToTransmit()->peekAtFront(); - return context->isForUs(receivedHeader) && response && - response->getTransmitterAddress() == request->getReceiverAddress() && - response->getTidInfo() == request->getTidInfo(); + auto request = requestStep->getFrameToTransmit()->peekAtFront(); + if (auto basic = dynamicPtrCast(request)) { + auto response = dynamicPtrCast(receivedHeader); + bool valid = response && !response->getMultiTid() && !response->getCompressedBitmap() && + response->getFragmentNumber() == 0 && response->getStartingSequenceNumber().isSpecified() && + (response->getReserved() & 3) == 0 && response->getChunkLength() == LENGTH_BASIC_BLOCKACK - B(4) && + receivedPacket->getDataLength() == LENGTH_BASIC_BLOCKACK && response->getBlockAckBitmapArraySize() == 64; + if (valid) + for (int i = 0; i < 64; i++) + valid &= response->getBlockAckBitmap(i).getSize() == 16; + return valid && context->isForUs(receivedHeader) && + response->getReceiverAddress() == basic->getTransmitterAddress() && + response->getTransmitterAddress() == basic->getReceiverAddress() && + response->getTidInfo() == basic->getTidInfo(); + } + auto compressed = dynamicPtrCast(request); + auto response = dynamicPtrCast(receivedHeader); + // IEEE Std 802.11-2024, 9.3.1.8.2: this profile supports the 64-bit bitmap without dynamic fragmentation. + return context->isForUs(receivedHeader) && compressed && response && + response->getReceiverAddress() == compressed->getTransmitterAddress() && + response->getTransmitterAddress() == compressed->getReceiverAddress() && + response->getTidInfo() == compressed->getTidInfo() && + !response->getMultiTid() && response->getCompressedBitmap() && response->getFragmentNumber() == 0 && + response->getStartingSequenceNumber().isSpecified() && response->getBlockAckBitmap().getSize() == 64 && + response->getChunkLength() == LENGTH_COMPRESSED_BLOCKACK - B(4) && + receivedPacket->getDataLength() == LENGTH_COMPRESSED_BLOCKACK; } default: throw cRuntimeError("Unknown step"); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc index e0daefabaa7..d2986e6dffe 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc @@ -47,7 +47,7 @@ int TxOpFs::selectTxOpSequence(AlternativesFs *frameSequence, FrameSequenceConte auto qos = context->getQoSContext(); if (qos->ackPolicy->isBlockAckReqNeeded(context->getInProgressFrames(), qos->txopProcedure, qos->blockAckAgreementHandler)) return 2; - auto frameToTransmit = context->getInProgressFrames()->getFrameToTransmit(); + auto frameToTransmit = context->getDataFrameToTransmit(); const auto& macHeader = frameToTransmit->peekAtFront(); if (dynamicPtrCast(macHeader)) return 3; @@ -71,7 +71,7 @@ int TxOpFs::selectTxOpSequence(AlternativesFs *frameSequence, FrameSequenceConte bool TxOpFs::isRtsCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *context) { - auto protectedFrame = context->getInProgressFrames()->getFrameToTransmit(); + auto protectedFrame = context->getDataFrameToTransmit(); return context->getRtsPolicy()->isRtsNeeded(protectedFrame, protectedFrame->peekAtFront()); } diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc index 7986ca4f13c..c3612e1c969 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc @@ -309,7 +309,7 @@ std::vector *OriginatorQosMacDataService::extractFramesToTransmit(queu // if (msduIntegrityAndProtection) // frame = protectMsduIfNeeded(frame); std::vector *fragments = nullptr; - if (fragmentationPolicy) + if (fragmentationPolicy && (!fragmentationPermitted || fragmentationPermitted(packet))) fragments = fragmentIfNeeded(packet); if (!fragments) fragments = new std::vector({ packet }); diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h index 73bda528989..cddf0af45be 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h @@ -43,6 +43,7 @@ class INET_API OriginatorQosMacDataService : public IOriginatorQosMacDataService std::function expireFrames; std::function extractionEligible; std::function aMsduPermitted; + std::function fragmentationPermitted; int64_t nextDataAllocationIndex = 0; protected: @@ -54,6 +55,7 @@ class INET_API OriginatorQosMacDataService : public IOriginatorQosMacDataService virtual Packet *aMpduAggregateIfNeeded(std::vector *fragments); public: + void setFragmentationPermission(std::function permission) { fragmentationPermitted = permission; } void setEligibility(std::function eligible, std::function permission) { extractionEligible = eligible; aMsduPermitted = permission; diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc index c79877d4a72..e213b5665bb 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc @@ -109,6 +109,33 @@ void QosAckHandler::dropFrames(std::set>> QosAckHandler::processReceivedCompressedBlockAck( + const Ptr& blockAck, const OriginatorBlockAckAgreement *agreement) +{ + std::set acked; + if (!agreement) + return acked; + auto start = blockAck->getStartingSequenceNumber(); + const auto& bitmap = blockAck->getBlockAckBitmap(); + // IEEE Std 802.11-2024, 10.25.6.8: positive bits cover transmitted frames throughout the active window. + for (auto& entry : ackStatuses) { + if (entry.first.first != blockAck->getTransmitterAddress() || entry.first.second.first != blockAck->getTidInfo()) + continue; + auto sequence = SequenceNumberCyclic(entry.first.second.second.getSequenceNumber()); + auto& status = entry.second; + bool transmitted = status != Status::FRAME_NOT_YET_TRANSMITTED && status != Status::NO_ACK_REQUIRED; + int offset = OriginatorBlockAckAgreement::computeSequenceDistance(start, sequence); + if (transmitted && agreement->containsSequence(sequence) && entry.first.second.second.getFragmentNumber() == 0 && + offset < 64 && bitmap.getBit(offset)) { + status = Status::BLOCK_ACK_ARRIVED_ACKED; + acked.insert(entry.first); + } + else if (status == Status::WAITING_FOR_BLOCK_ACK) + status = Status::BLOCK_ACK_ARRIVED_UNACKED; + } + return acked; +} + std::set>> QosAckHandler::processReceivedBlockAck(const Ptr& blockAck) { MacAddress receiverAddr = blockAck->getTransmitterAddress(); diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h index 96f1026d85f..69371236796 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h @@ -57,6 +57,8 @@ class INET_API QosAckHandler : public SimpleModule, public IAckHandler virtual void processReceivedAck(const Ptr& ack, const Ptr& ackedHeader); virtual std::set>> processReceivedBlockAck(const Ptr& blockAck); + std::set>> processReceivedCompressedBlockAck( + const Ptr& blockAck, const OriginatorBlockAckAgreement *agreement); virtual void processFailedBlockAckReq(const Ptr& blockAckReq); virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) override; diff --git a/src/inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.cc b/src/inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.cc index fbd4606601a..e2f2b63c464 100644 --- a/src/inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.cc +++ b/src/inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.cc @@ -67,8 +67,9 @@ simtime_t SingleProtectionMechanism::computeCtsDurationField(const Ptr& blockAckReq) { // TODO ACK or BlockAck frame, as applicable - if (dynamicPtrCast(blockAckReq)) { - simtime_t blockAckFrameDuration = rateSelection->computeResponseBlockAckFrameMode(packet, blockAckReq, ResponseQueryRole::PREDICT)->getDuration(LENGTH_BASIC_BLOCKACK); + if (dynamicPtrCast(blockAckReq) || dynamicPtrCast(blockAckReq)) { + simtime_t blockAckFrameDuration = rateSelection->computeResponseBlockAckFrameMode(packet, blockAckReq, ResponseQueryRole::PREDICT)->getDuration( + dynamicPtrCast(blockAckReq) ? LENGTH_COMPRESSED_BLOCKACK : LENGTH_BASIC_BLOCKACK); simtime_t blockAckReqDurationPerId = blockAckFrameDuration + modeSet->getSifsTime(); return blockAckReqDurationPerId; } diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc index 416e9709ad3..190afe1d5c6 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc @@ -87,6 +87,16 @@ void InProgressFrames::ensureHasFrameToTransmit() } } +void InProgressFrames::adoptPreparedFrame(Packet *packet) +{ + Enter_Method("adoptPreparedFrame"); + take(packet); + ackHandler->frameGotInProgress(packet->peekAtFront()); + inProgressFrames.push_back(packet); + packet->setArrivalTime(simTime()); + emit(packetEnqueuedSignal, packet); +} + Packet *InProgressFrames::getFrameToTransmit() { ensureHasFrameToTransmit(); diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h index 65b13b67aa7..4804e562628 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h @@ -52,6 +52,8 @@ class INET_API InProgressFrames : public SimpleModule virtual int getLength() const { return inProgressFrames.size(); } virtual Packet *getFrames(int i) const { return inProgressFrames[i]; } bool containsFrame(const Packet *packet) const; + // Takes ownership after the data service commits a reversible preparation. + void adoptPreparedFrame(Packet *packet); virtual Packet *getFrameToTransmit(); virtual Packet *peekFrameToTransmit(); SequenceNumberCyclic getCandidateSequenceNumber(Packet *packet) const; diff --git a/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.cc b/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.cc index 6076a48172d..bd93bd3c52d 100644 --- a/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.cc +++ b/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.cc @@ -131,6 +131,17 @@ static const IIeee80211Mode *selectCompatibleMode(const Ieee80211ModeSet *modeSe } // namespace +bool isPeerCompatibleMode(const Ieee80211ModeSet *modeSet, + const Ieee80211Mib::PeerHtState *peerHtState, const IIeee80211Mode *mode) +{ + if (!modeSet || !mode || !modeSet->containsMode(mode)) + return false; + if (mode->getHtMcsIndex() < 0) + return true; + return peerHtState && peerHtState->valid && + isCompatibleHtMode(mode, peerHtState->negotiatedCapabilities.localTxPeerRx, peerHtState->negotiatedCapabilities.operation); +} + const IIeee80211Mode *selectPeerCompatibleMode(const Ieee80211ModeSet *modeSet, const Ieee80211Mib::PeerHtState *peerHtState, const IIeee80211Mode *mode, const MacAddress& peerAddress) { diff --git a/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h b/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h index 5197aa38891..e512fbbdb28 100644 --- a/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h +++ b/src/inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h @@ -15,6 +15,10 @@ namespace inet { namespace ieee80211 { +/** Checks the retained transmit mode without a new rate-control decision. */ +INET_API bool isPeerCompatibleMode(const physicallayer::Ieee80211ModeSet *modeSet, + const Ieee80211Mib::PeerHtState *peerHtState, const physicallayer::IIeee80211Mode *mode); + /** * Selects a mode compatible with local transmission to the peer. * Non-HT modes remain unchanged. Absent peer state selects a legacy mode diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.cc b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.cc index cb9b112bd42..4712d009d0c 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.cc @@ -61,7 +61,7 @@ bool RecipientQosAckPolicy::isAckNeeded(const Ptr& blockAckReq, RecipientBlockAckAgreement *agreement) const { - if (dynamicPtrCast(blockAckReq)) { + if (dynamicPtrCast(blockAckReq) || dynamicPtrCast(blockAckReq)) { return agreement != nullptr; // TODO The Basic BlockAckReq frame shall be discarded if all MSDUs referenced by this // frame have been discarded from the transmit buffer due to expiry of their lifetime limit. @@ -94,6 +94,13 @@ simtime_t RecipientQosAckPolicy::computeBasicBlockAckDurationField(Packet *packe return basicBlockAckReq->getDurationField() - modeSet->getSifsTime() - computeBasicBlockAckDuration(packet, basicBlockAckReq); } +simtime_t RecipientQosAckPolicy::computeCompressedBlockAckDurationField(Packet *packet, const Ptr& blockAckReq) const +{ + // IEEE Std 802.11-2024, 9.2.5.6: subtract the actual response airtime and SIFS. + auto airtime = rateSelection->computeResponseBlockAckFrameMode(packet, blockAckReq, ResponseQueryRole::RESPOND)->getDuration(LENGTH_COMPRESSED_BLOCKACK); + return std::max(SIMTIME_ZERO, blockAckReq->getDurationField() - modeSet->getSifsTime() - airtime); +} + } /* namespace ieee80211 */ } /* namespace inet */ diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h index 9f4ce456784..0012ef77b55 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h @@ -34,6 +34,7 @@ class INET_API RecipientQosAckPolicy : public ModeSetListener, public IRecipient virtual simtime_t computeAckDurationField(Packet *packet, const Ptr& header) const override; virtual simtime_t computeBasicBlockAckDurationField(Packet *packet, const Ptr& basicBlockAckReq) const override; + virtual simtime_t computeCompressedBlockAckDurationField(Packet *packet, const Ptr& blockAckReq) const override; }; } /* namespace ieee80211 */ diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc index e73a15720c1..e3f9ea2151d 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc @@ -53,14 +53,17 @@ Packet *RecipientQosMacDataService::defragment(Packet *mgmtFragment) return nullptr; } -std::vector RecipientQosMacDataService::dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) +std::vector RecipientQosMacDataService::dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe) { Enter_Method("dataFrameReceived"); take(dataPacket); if (blockAckAgreementHandler) { auto agreement = blockAckAgreementHandler->getAgreement(dataHeader->getTid(), dataHeader->getTransmitterAddress()); - if (agreement) + if (agreement) { agreement->recordReceived(dataHeader); + if (agreement->getVariant() == BlockAckVariant::COMPRESSED) + agreement->getBlockAckRecord()->compressedFrameReceived(dataHeader); + } } // TODO A-MPDU Deaggregation, MPDU Header+FCS Validation, Address1 Filtering, Duplicate Removal, MPDU Decryption if (duplicateRemoval && duplicateRemoval->isDuplicate(dataHeader)) { @@ -77,7 +80,7 @@ std::vector RecipientQosMacDataService::dataFrameReceived(Packet *data MacAddress originatorAddr = dataHeader->getTransmitterAddress(); RecipientBlockAckAgreement *agreement = blockAckAgreementHandler->getAgreement(tid, originatorAddr); if (agreement) - frames = blockAckReordering->processReceivedQoSFrame(agreement, dataPacket, dataHeader); + frames = blockAckReordering->processReceivedQoSFrame(agreement, dataPacket, dataHeader, interframe); } std::vector defragmentedFrames; if (basicReassembly) { // FIXME defragmentation @@ -137,14 +140,19 @@ std::vector RecipientQosMacDataService::managementFrameReceived(Packet std::vector RecipientQosMacDataService::controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) { Enter_Method("controlFrameReceived"); - if (auto blockAckReq = dynamicPtrCast(controlHeader)) { + if (auto blockAckReq = dynamicPtrCast(controlHeader)) { BlockAckReordering::ReleasedFrames frames; if (blockAckReordering) { - Tid tid = blockAckReq->getTidInfo(); + auto basic = dynamicPtrCast(blockAckReq); + auto compressed = dynamicPtrCast(blockAckReq); + if (!basic && !compressed) + return {}; + Tid tid = basic ? basic->getTidInfo() : compressed->getTidInfo(); MacAddress originatorAddr = blockAckReq->getTransmitterAddress(); RecipientBlockAckAgreement *agreement = blockAckAgreementHandler->getAgreement(tid, originatorAddr); - if (agreement) + if (agreement) { frames = blockAckReordering->processReceivedBlockAckReq(agreement, blockAckReq); + } else return std::vector(); } diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h index 10b26ca843f..066359162b1 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h @@ -48,7 +48,7 @@ class INET_API RecipientQosMacDataService : public IRecipientQosMacDataService, public: virtual std::vector retireAgreement(RecipientBlockAckAgreement *agreement, bool associationReset) override; virtual void clearPeer(MacAddress peer) override; - virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) override; + virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe = false) override; virtual std::vector controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) override; virtual std::vector managementFrameReceived(Packet *mgmtPacket, const Ptr& mgmtHeader) override; }; diff --git a/tests/module/Ieee80211BlockAckReordering_1.test b/tests/module/Ieee80211BlockAckReordering_1.test index 449a6041fde..3731b956b54 100644 --- a/tests/module/Ieee80211BlockAckReordering_1.test +++ b/tests/module/Ieee80211BlockAckReordering_1.test @@ -3,9 +3,10 @@ Check S1 recipient delivery through RecipientQosMacDataService. Supply accepted Basic agreements with known buffer sizes. Check fragment capacity, complete gap release, cyclic delivery, and BAR before DATA. Check window movement, incomplete-unit disposal, peer/TID isolation, and A-MSDU order. -The fixture supplies agreements; it does not test ADDBA negotiation or Compressed exchanges. +The fixture supplies agreements; it does not test ADDBA negotiation. +Compressed cases check gap release, cyclic delivery, peer/TID isolation, and receipt retention through the production recipient service. -%extraargs: -r 0..7 +%extraargs: -r 0..10 %file: RecipientReordering.cc #include "inet/common/packet/chunk/ByteCountChunk.h" @@ -40,8 +41,9 @@ Define_Module(ReorderingRecipient); class ReorderingAgreements : public RecipientBlockAckAgreementHandler { public: - void accept(MacAddress peer, Tid tid, int start, int size) { + void accept(MacAddress peer, Tid tid, int start, int size, BlockAckVariant variant = BlockAckVariant::BASIC) { auto agreement = new RecipientBlockAckAgreement(peer, tid, SequenceNumberCyclic(start), size, SIMTIME_ZERO); + agreement->setVariant(variant); agreement->addbaResposneSent(); blockAckAgreements[{peer, tid}] = agreement; } @@ -224,6 +226,33 @@ class RecipientReorderingTest : public cSimpleModule { checkDelivery(receive(makeData(101, "fragmented-frag1", 1)), {"fragmented", "third"}); checkWindow(103, 0, peer); break; + case 8: + case 9: { + int start = scenario == 8 ? 100 : 4095; + agreements.accept(peer, 5, start, 4, BlockAckVariant::COMPRESSED); + checkDelivery(receive(makeData(start, "first")), {"first"}); + checkDelivery(receive(makeData((start + 2) % 4096, "third")), {}); + checkDelivery(receive(makeData((start + 1) % 4096, "second")), {"second", "third"}); + checkWindow((start + 3) % 4096, 0, peer); + auto record = agreements.getAgreement(5, peer)->getBlockAckRecord(); + for (int offset = 0; offset < 4; offset++) + ASSERT(record->getCompressedAckState(SequenceNumberCyclic(start) + offset) == (offset < 3)); + break; + } + case 10: + agreements.accept(peer, 5, 100, 4, BlockAckVariant::COMPRESSED); + agreements.accept(otherPeer, 5, 100, 4, BlockAckVariant::COMPRESSED); + agreements.accept(peer, 6, 100, 4, BlockAckVariant::COMPRESSED); + checkDelivery(receive(makeData(101, "peer-one")), {}); + checkDelivery(receive(makeData(101, "peer-two", 0, false, otherPeer)), {}); + checkDelivery(receive(makeData(101, "tid-six", 0, false, peer, 6)), {}); + checkDelivery(receive(makeData(100, "first")), {"first", "peer-one"}); + checkWindow(102, 0, peer); + checkWindow(100, 1, otherPeer); + checkWindow(100, 1, peer, 6); + ASSERT(!agreements.getAgreement(5, otherPeer)->getBlockAckRecord()->getCompressedAckState(SequenceNumberCyclic(100))); + ASSERT(!agreements.getAgreement(6, peer)->getBlockAckRecord()->getCompressedAckState(SequenceNumberCyclic(100))); + break; default: throw cRuntimeError("Unknown recipient scenario"); } @@ -267,7 +296,7 @@ seed-set = 0 cmdenv-express-mode = true record-vector-results = false record-scalar-results = false -*.test.scenario = ${scenario=0..7} +*.test.scenario = ${scenario=0..10} %contains: stdout Recipient reordering checks passed. diff --git a/tests/module/Ieee80211BlockAckScheduling_1.test b/tests/module/Ieee80211BlockAckScheduling_1.test index 3fe472f6f68..ec072ea0dd2 100644 --- a/tests/module/Ieee80211BlockAckScheduling_1.test +++ b/tests/module/Ieee80211BlockAckScheduling_1.test @@ -1,11 +1,12 @@ %description: -Exercise Basic BAR selection and final DELBA through HCF, frame sequences, EDCA, and Tx. +Exercise Basic and Compressed BAR selection and final DELBA through HCF, frame sequences, EDCA, and Tx. The fixture supplies accepted agreements and injects responses at the HCF receive boundary. +Compressed cases supply peer HT capabilities; the fixture does not test capability negotiation. Response events include SIFS and the selected response airtime. Cases cover short bursts, windows smaller than the threshold, two peers, BAR timeout, negative bitmap bits, Normal Ack window progress, and late BAR admission. -%extraargs: -r 0..29 +%extraargs: -r 0..75 %file: Scheduling.cc #include @@ -17,13 +18,16 @@ negative bitmap bits, Normal Ack window progress, and late BAR admission. #include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" namespace inet::ieee80211 { class SchedulingRecipientAgreements : public RecipientBlockAckAgreementHandler { public: - void accept(MacAddress peer) { - auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(0), 64, SIMTIME_ZERO); + void accept(MacAddress peer, BlockAckVariant variant, int start = 0) { + auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(start), 64, SIMTIME_ZERO); + agreement->setVariant(variant); agreement->addbaResposneSent(); agreement->calculateExpirationTime(); blockAckAgreements[{peer, 5}] = agreement; @@ -33,19 +37,69 @@ class SchedulingRecipient : public Hcf { public: std::vector delivered; bool checkedBitmap = false; + bool orderedReceipt = false; + void publishPrimaryChannel() { + auto radio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + } + void checkOrderedReceipt() { + Enter_Method("checkOrderedReceipt"); + delete recipientBlockAckAgreementHandler; + auto agreements = new SchedulingRecipientAgreements(); + recipientBlockAckAgreementHandler = agreements; + orderedReceipt = true; + publishPrimaryChannel(); + mib->setPeerHtCapabilities(MacAddress("02:00:00:00:00:01"), mib->localHtCapabilities, mib->getHtOperation()); + agreements->accept(MacAddress("02:00:00:00:00:01"), BlockAckVariant::COMPRESSED, 100); + for (int sequence : {100, 102, 101}) { + auto data = makeShared(); + data->setType(ST_DATA_WITH_QOS); + data->addChunkLength(QOSCONTROL_PART_LENGTH); + data->setTransmitterAddress(MacAddress("02:00:00:00:00:01")); + data->setReceiverAddress(mac->getAddress()); + data->setAddress3(data->getTransmitterAddress()); + data->setTid(5); + data->setAckPolicy(BLOCK_ACK); + data->setSequenceNumber(SequenceNumberCyclic(sequence)); + auto packet = new Packet("ordered", data); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getSlowestMode()); + processLowerFrame(packet, data); + ASSERT((delivered == (sequence == 101 ? std::vector{100, 101, 102} : std::vector{100}))); + } + auto bar = makeShared(); + bar->setTransmitterAddress(MacAddress("02:00:00:00:00:01")); + bar->setReceiverAddress(mac->getAddress()); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(100)); + auto packet = new Packet("ordered-bar", bar); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(modeSet->getSlowestMode()); + processLowerFrame(packet, bar); + ASSERT(checkedBitmap); + } void prepare() { Enter_Method("prepare"); delete recipientBlockAckAgreementHandler; auto agreements = new SchedulingRecipientAgreements(); recipientBlockAckAgreementHandler = agreements; - agreements->accept(MacAddress("02:00:00:00:00:01")); + if (std::string(par("blockAckVariant").stringValue()) == "compressed") { + publishPrimaryChannel(); + mib->setPeerHtCapabilities(MacAddress("02:00:00:00:00:01"), mib->localHtCapabilities, mib->getHtOperation()); + } + agreements->accept(MacAddress("02:00:00:00:00:01"), std::string(par("blockAckVariant").stringValue()) == "compressed" ? BlockAckVariant::COMPRESSED : BlockAckVariant::BASIC); subscribe(blockAckAgreementDeletedSignal, this); } void receive(Packet *packet) { Enter_Method("receive"); + take(packet); auto header = packet->peekAtFront(); if (auto data = dynamicPtrCast(header)) { - if (data->getSequenceNumber() == SequenceNumberCyclic(0) && data->getFragmentNumber() != 0) { + if (data->getSequenceNumber() == SequenceNumberCyclic(0) && + (std::string(par("blockAckVariant").stringValue()) == "compressed" || data->getFragmentNumber() != 0)) { delete packet; return; } @@ -80,25 +134,42 @@ class SchedulingRecipient : public Hcf { ASSERT(delivered.empty()); } } + if (auto response = dynamicPtrCast(header)) { + if (orderedReceipt) { + ASSERT(response->getStartingSequenceNumber() == SequenceNumberCyclic(100)); + for (int bit = 0; bit < 64; bit++) + ASSERT(response->getBlockAckBitmap().getBit(bit) == (bit < 3)); + ASSERT((delivered == std::vector{100, 101, 102})); + checkedBitmap = true; + delete packet; + return; + } + ASSERT(response->getStartingSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(!response->getBlockAckBitmap().getBit(0)); + if (response->getBlockAckBitmap().getBit(1) && response->getBlockAckBitmap().getBit(2)) { + checkedBitmap = true; + ASSERT(delivered.empty()); + } + } delete packet; } }; Define_Module(SchedulingRecipient); class SchedulingAgreements : public OriginatorBlockAckAgreementHandler { public: - void accept(MacAddress peer, int size) { + void accept(MacAddress peer, int size, Tid tid = 5) { auto request = makeShared(); request->setReceiverAddress(peer); - request->setTid(5); + request->setTid(tid); request->setStartingSequenceNumber(SequenceNumberCyclic(0)); request->setBufferSize(size); request->setBlockAckPolicy(true); createAgreement(request); - auto agreement = getAgreement(peer, 5); + auto agreement = getAgreement(peer, tid); agreement->setIsAddbaResponseReceived(true); agreement->setBlockAckTimeoutValue(SIMTIME_ZERO); agreement->calculateExpirationTime(); - finishProcedure(peer, 5); + finishProcedure(peer, tid); } }; class SchedulingHcf : public Hcf { @@ -111,15 +182,26 @@ class SchedulingHcf : public Hcf { int retries = 0; int dataInTxop = 0; bool responsePending = false; - Ptr pendingBar; + Ptr pendingBar; const physicallayer::IIeee80211Mode *pendingResponseMode = nullptr; bool firstBarWasStandalone = false; int expired = 0; + bool expiredDuringExchange = false; int collisions = 0; SchedulingRecipient *recipient = nullptr; simtime_t responseEnd; simtime_t txopDeadline; int scenario() const { return par("scenario"); } + bool compressed() const { return std::string(par("blockAckVariant").stringValue()) == "compressed"; } + b responseLength() const { return compressed() ? LENGTH_COMPRESSED_BLOCKACK : LENGTH_BASIC_BLOCKACK; } + Tid barTid(const Ptr& bar) const { + return compressed() ? check_and_cast(bar.get())->getTidInfo() : + check_and_cast(bar.get())->getTidInfo(); + } + SequenceNumberCyclic barStart(const Ptr& bar) const { + return compressed() ? check_and_cast(bar.get())->getStartingSequenceNumber() : + check_and_cast(bar.get())->getStartingSequenceNumber(); + } int burst() const { switch (scenario()) { case 0: return 1; @@ -146,7 +228,17 @@ class SchedulingHcf : public Hcf { delete originatorBlockAckAgreementHandler; auto agreements = new SchedulingAgreements(); originatorBlockAckAgreementHandler = agreements; + if (compressed()) { + auto radio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + mib->setPeerHtCapabilities(peer, mib->localHtCapabilities, mib->getHtOperation()); + mib->setPeerHtCapabilities(other, mib->localHtCapabilities, mib->getHtOperation()); + } agreements->accept(peer, window()); + if (compressed() && scenario() == 0) + check_and_cast(getModuleByPath("^.^.^.^.recipient.wlan[0].mac.hcf"))->checkOrderedReceipt(); if (scenario() == 9) { recipient = check_and_cast(getModuleByPath("^.^.^.^.recipient.wlan[0].mac.hcf")); recipient->prepare(); @@ -154,6 +246,8 @@ class SchedulingHcf : public Hcf { } if (scenario() == 4) agreements->accept(other, 64); + if (scenario() == 18) + agreements->accept(peer, 64, 4); rx->setContentionBlocked(true); for (int i = 0; i < burst(); i++) queueData(peer, scenario() == 9 ? (i == 0 ? 200 : 10) : scenario() == 7 && i == 0 ? 1100 : 100); @@ -173,6 +267,10 @@ class SchedulingHcf : public Hcf { for (int i = 0; i < 8; i++) queueData(other, 100); } + if (scenario() == 18) { + for (int i = 0; i < 8; i++) + queueData(peer, 100, 4); + } rx->setContentionBlocked(false); scheduleAfter(SimTime(40, SIMTIME_MS), new cMessage("verify")); } @@ -180,8 +278,11 @@ class SchedulingHcf : public Hcf { void receiveSignal(cComponent *source, simsignal_t signal, cObject *value, cObject *details) override { if (signal == packetDroppedSignal) { auto drop = dynamic_cast(details); - if (drop && drop->getReason() == LIFETIME_EXPIRED) + if (drop && drop->getReason() == LIFETIME_EXPIRED) { expired++; + expiredDuringExchange |= frameSequenceHandler->isSequenceRunning() && + originatorBlockAckAgreementHandler->getAgreement(peer, 5) != nullptr; + } if (source == this) return; } @@ -226,7 +327,7 @@ class SchedulingHcf : public Hcf { } bool transmitFrame(Packet *packet, simtime_t ifs) override { auto header = packet->peekAtFront(); - auto bar = dynamicPtrCast(header); + auto bar = dynamicPtrCast(header); if (bar) { auto frames = edca->getChannelOwner()->getInProgressFrames(); auto candidate = frames->peekFrameToTransmit(); @@ -256,6 +357,8 @@ class SchedulingHcf : public Hcf { } if (scenario() == 4 && data->getReceiverAddress() == other) ASSERT(bars >= 1); + if (scenario() == 18 && data->getTid() == 4) + ASSERT(bars >= 1); auto agreement = originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()); if ((scenario() == 12 || scenario() == 14) && data->getTid() == 6) ASSERT(!data->getRetry()); @@ -273,13 +376,13 @@ class SchedulingHcf : public Hcf { if (bars == 1) { firstBarWasStandalone = dataInTxop == 0; ASSERT(bar->getReceiverAddress() == peer); - ASSERT(bar->getTidInfo() == 5); + ASSERT(barTid(bar) == 5); if (scenario() != 9) ASSERT(dataCount == (scenario() == 2 ? 1 : scenario() == 3 ? 4 : scenario() == 7 || scenario() == 12 || scenario() == 14 ? 2 : scenario() == 11 ? 5 : burst())); } auto mode = packet->getTag()->getMode(); auto responseMode = rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT); - auto cost = mode->getDuration(packet->getDataLength()) + modeSet->getSifsTime() + responseMode->getDuration(LENGTH_BASIC_BLOCKACK); + auto cost = mode->getDuration(packet->getDataLength()) + modeSet->getSifsTime() + responseMode->getDuration(responseLength()); auto txop = edca->getChannelOwner()->getTxopProcedure(); auto end = simTime() + ifs + cost; if (dataInTxop > 1 && txop->getLimit() > 0) @@ -287,7 +390,7 @@ class SchedulingHcf : public Hcf { std::cout << "BAR timing: scenario=" << scenario() << " multiple=" << par("multiple").boolValue() << " start=" << simTime() << " ifs=" << ifs << " bytes=" << packet->getByteLength() << " rate=" << mode->getDataMode()->getNetBitrate() << " responseRate=" << responseMode->getDataMode()->getNetBitrate() - << " response=" << responseMode->getDuration(LENGTH_BASIC_BLOCKACK) << " end=" << end + << " response=" << responseMode->getDuration(responseLength()) << " end=" << end << " deadline=" << txop->getStart() + txop->getLimit() << " data=" << dataInTxop << "\n"; } if (auto delba = dynamicPtrCast(header)) { @@ -300,7 +403,7 @@ class SchedulingHcf : public Hcf { } void transmissionComplete(Packet *packet, const Ptr& header) override { Enter_Method("transmissionComplete"); - auto bar = dynamicPtrCast(header); + auto bar = dynamicPtrCast(header); auto data = dynamicPtrCast(header); if (recipient && (data || bar || dynamicPtrCast(header))) recipient->receive(packet->dup()); @@ -312,7 +415,7 @@ class SchedulingHcf : public Hcf { pendingResponseMode = bar ? rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT) : rateSelection->computeResponseAckFrameMode(packet, dynamicPtrCast(header), ResponseQueryRole::PREDICT); - auto duration = pendingResponseMode->getDuration(bar ? LENGTH_BASIC_BLOCKACK : LENGTH_ACK); + auto duration = pendingResponseMode->getDuration(bar ? responseLength() : LENGTH_ACK); responseEnd = simTime() + modeSet->getSifsTime() + duration; txopDeadline = edca->getChannelOwner()->getTxopProcedure()->getStart() + edca->getChannelOwner()->getTxopProcedure()->getLimit(); scheduleAt(responseEnd, new cMessage("response")); @@ -327,10 +430,25 @@ class SchedulingHcf : public Hcf { responsePending = false; Ptr header; if (pendingBar) { + if (compressed()) { + auto response = makeShared(); + response->setTransmitterAddress(pendingBar->getReceiverAddress()); + response->setTidInfo(barTid(pendingBar)); + auto responseStart = barStart(pendingBar); + if (bars == 1 && scenario() >= 15 && scenario() <= 17) + responseStart = responseStart + (scenario() == 15 ? -2 : scenario() == 16 ? 1 : 100); + response->setStartingSequenceNumber(responseStart); + BitVector bits; + for (int i = 0; i < 64; i++) + bits.appendBit(scenario() == 9 ? i != 0 : !(bars == 1 && (scenario() == 6 || scenario() == 17))); + response->setBlockAckBitmap(bits); + header = response; + } + else { auto response = makeShared(); response->setTransmitterAddress(pendingBar->getReceiverAddress()); - response->setTidInfo(pendingBar->getTidInfo()); - response->setStartingSequenceNumber(pendingBar->getStartingSequenceNumber()); + response->setTidInfo(barTid(pendingBar)); + response->setStartingSequenceNumber(barStart(pendingBar)); for (int i = 0; i < 64; i++) { BitVector bits; for (int j = 0; j < 16; j++) @@ -338,6 +456,7 @@ class SchedulingHcf : public Hcf { response->setBlockAckBitmap(i, bits); } header = response; + } } else header = makeShared(); @@ -352,14 +471,16 @@ class SchedulingHcf : public Hcf { delete message; std::cout << "Scheduling totals: data=" << dataCount << " bars=" << bars << " delbas=" << delbas << " refused=" << refusedBars << "\n"; ASSERT(bars > 0); - ASSERT(delbas == (scenario() == 4 ? 2 : 1)); + ASSERT(delbas == (scenario() == 4 || scenario() == 18 ? 2 : 1)); if (scenario() != 9) - ASSERT(dataCount == burst() + (scenario() == 4 ? 8 : scenario() == 5 || scenario() == 6 || scenario() == 12 || scenario() == 14 ? 1 : 0)); + ASSERT(dataCount == burst() + (scenario() == 4 || scenario() == 18 ? 8 : scenario() == 5 || scenario() == 6 || scenario() == 12 || scenario() == 14 || (compressed() && scenario() == 16) ? 1 : compressed() && scenario() == 17 ? 4 : 0)); else { ASSERT(recipient->checkedBitmap && recipient->retired()); ASSERT((recipient->delivered == std::vector{1, 2})); ASSERT(dataCount > 3); ASSERT(expired > 0); + if (compressed()) + ASSERT(expiredDuringExchange); } ASSERT(originatorBlockAckAgreementHandler->getAgreements().empty()); ASSERT(originatorBlockAckAgreementHandler->getProcedures().empty()); @@ -367,6 +488,8 @@ class SchedulingHcf : public Hcf { ASSERT(!frameSequenceHandler->isSequenceRunning()); if (scenario() == 5 || scenario() == 6) ASSERT(retries == 1 && bars == 2); + if (compressed() && scenario() >= 15 && scenario() <= 17) + ASSERT(retries == (scenario() == 15 ? 0 : scenario() == 16 ? 1 : 4) && bars == (scenario() == 15 ? 1 : 2)); if (scenario() == 8 || scenario() == 10 || scenario() == 13) ASSERT(firstBarWasStandalone); if (scenario() == 12 || scenario() == 14) @@ -416,22 +539,23 @@ record-vector-results = false record-scalar-results = false **.wlan[*].agent.typename = "" **.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" -**.wlan[*].opMode = "a" +**.wlan[*].opMode = ${variant} == "basic" ? "a" : "n(mixed-2.4Ghz)" **.wlan[*].bitrate = 6Mbps +**.wlan[*].radio.channelNumber = 0 *.host.wlan[*].address = "02:00:00:00:00:01" *.recipient.wlan[*].address = "02:00:00:00:00:02" **.wlan[*].mac.qosStation = true *.recipient.wlan[*].mac.hcf.typename = "SchedulingRecipient" *.host.wlan[*].mac.hcf.typename = "SchedulingHcf" -**.wlan[*].mac.hcf.scenario = ${scenario=0..14} +**.wlan[*].mac.hcf.scenario = ${scenario=0..18} **.wlan[*].mac.hcf.multiple = ${multiple=false,true} **.wlan[*].mac.hcf.isBlockAckSupported = true -**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.blockAckVariant = ${variant="basic","compressed"} **.wlan[*].mac.hcf.originatorAckPolicy.ackTimeout = 1ms **.wlan[*].mac.hcf.originatorAckPolicy.blockAckTimeout = 1ms **.wlan[*].mac.hcf.rtsPolicy.rtsThreshold = 2346B **.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" -**.wlan[*].mac.hcf.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = ${scenario} == 9 ? 128B : 2346B +**.wlan[*].mac.hcf.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = ${scenario} == 9 && ${variant} == "basic" ? 128B : 2346B **.wlan[*].mac.hcf.edca.edcaf[*].msduLifetime = ${scenario} == 9 ? 10ms : 512ms **.wlan[*].mac.hcf.edca.edcaf[*].cwMin = ${scenario} == 12 || ${scenario} == 14 ? 0 : -1 **.wlan[*].mac.hcf.edca.edcaf[2].cwMax = ${scenario} == 14 ? 3 : ${scenario} == 12 ? 0 : -1 diff --git a/tests/module/Ieee80211BlockAckVariant_1.test b/tests/module/Ieee80211BlockAckVariant_1.test index 61da5b30adc..195c298c73a 100644 --- a/tests/module/Ieee80211BlockAckVariant_1.test +++ b/tests/module/Ieee80211BlockAckVariant_1.test @@ -1,8 +1,8 @@ %description: Check profile validation through production HCF initialization. -Retain the default and explicit Basic profile. +Accept the default, explicit Basic, and explicit Compressed profiles. Reject unknown values with support enabled or disabled. -Reject Compressed until its runtime exchange path exists. +Reject delayed policy for Compressed before any ADDBA transmission. %testprog: python3 check-profile.py @@ -18,20 +18,26 @@ import subprocess root = Path.cwd().parents[3] cases = [ - (None, True, None), - ("basic", True, None), - ("invalid", True, 'Unknown blockAckVariant "invalid": expected "basic" or "compressed"'), - ("invalid", False, 'Unknown blockAckVariant "invalid": expected "basic" or "compressed"'), - ("compressed", True, 'Compressed Block Ack exchanges are not implemented'), - ("compressed", False, 'Compressed Block Ack exchanges are not implemented'), + (None, True, (), None), + ("basic", True, (), None), + ("invalid", True, (), 'Unknown blockAckVariant "invalid": expected "basic" or "compressed"'), + ("invalid", False, (), 'Unknown blockAckVariant "invalid": expected "basic" or "compressed"'), + ("compressed", True, (), None), + ("compressed", False, (), None), ] -for variant, supported, diagnostic in cases: +for policies in [("originator",), ("recipient",), ("originator", "recipient")]: + cases.append(("compressed", True, policies, + "Compressed Block Ack does not support delayedAckPolicySupported")) + cases.append(("basic", True, policies, None)) +for variant, supported, policies, diagnostic in cases: command = [str(root / "bin/inet"), "--debug", "-u", "Cmdenv", "-f", str(Path.cwd() / "profile.ini"), "-c", "General", "-r", "0", "--sim-time-limit=0s", "--record-vector-results=false", "--record-scalar-results=false", f"--result-dir={Path.cwd() / 'results'}", f"--**.wlan[*].mac.hcf.isBlockAckSupported={'true' if supported else 'false'}"] if variant is not None: command.append(f'--**.wlan[*].mac.hcf.blockAckVariant="{variant}"') + for policy in policies: + command.append(f'--**.wlan[*].mac.hcf.{policy}BlockAckAgreementPolicy.delayedAckPolicySupported=true') result = subprocess.run(command, cwd=root / "showcases/wireless/blockack", text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) print(result.stdout) diff --git a/tests/module/Ieee80211CompressedBlockAckAdmission_1.test b/tests/module/Ieee80211CompressedBlockAckAdmission_1.test new file mode 100644 index 00000000000..d3c46e46cb0 --- /dev/null +++ b/tests/module/Ieee80211CompressedBlockAckAdmission_1.test @@ -0,0 +1,665 @@ +%description: +Check reversible DATA preparation and Compressed TXOP admission through HCF, EDCA, frame sequences, and Tx. +The fixture supplies accepted agreements and peer capabilities. It injects timed CTS, ACK, and Block Ack responses at HCF. +Service cases check queue ownership, deadlines, sequence assignment, and allocation before refusal and after commitment. +Runtime cases check ordinary fallback, one mode decision, RTS recovery, expiry, capability loss, and mode-set changes. +Ordinary commitment preserves elapsed queueing time and one queue pull; retransmission retains that measurement without another pull. +This fixture does not establish association behavior. The infrastructure exchange fixture supplies that evidence. + +%extraargs: -r 0..23 + +%file: Admission.cc +#include +#include "inet/common/Simsignals.h" +#include "inet/common/TimeTag_m.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h" +#include "inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class AdmissionService : public OriginatorQosMacDataService { + public: + int preparations = 0; + int commits = 0; + int64_t allocations() const { return nextDataAllocationIndex; } + std::unique_ptr prepareFrame(queueing::IPacketQueue *queue, bool aggregate) override { + preparations++; + return OriginatorQosMacDataService::prepareFrame(queue, aggregate); + } + Packet *commitPreparedFrame(PreparedQosData& preparation) override { + auto preview = preparation.packet.get(); + auto result = OriginatorQosMacDataService::commitPreparedFrame(preparation); + if (result) { + ASSERT(result == preview); + commits++; + } + return result; + } +}; +Define_Module(AdmissionService); + +class AdmissionRecovery : public QosRecoveryProcedure { + public: + int controls = 0; + int dataFailures = 0; + int numberedRtsFailures = 0; + std::vector qsrcHistory; + int qsrc() const { return stationShortRetryCounter; } + size_t numberedCounters() const { return shortRetryCounter.size() + longRetryCounter.size(); } + void controlFrameTransmissionFailed() override { + controls++; + QosRecoveryProcedure::controlFrameTransmissionFailed(); + qsrcHistory.push_back(stationShortRetryCounter); + } + void dataFrameTransmissionFailed(Packet *packet, const Ptr& header) override { + dataFailures++; + QosRecoveryProcedure::dataFrameTransmissionFailed(packet, header); + } + void rtsFrameTransmissionFailed(const Ptr& header) override { + numberedRtsFailures++; + QosRecoveryProcedure::rtsFrameTransmissionFailed(header); + } +}; +Define_Module(AdmissionRecovery); + +class AdmissionRateControl : public ModeSetListener, public IRateControl { + public: + int queries = 0; + int failedDataFeedback = 0; + const physicallayer::IIeee80211Mode *getRate(const MacAddress&) override { + queries++; + int scenario = getParentModule()->par("scenario"); + int rate = scenario == 22 ? 6 : scenario == 6 || scenario == 19 || scenario == 20 ? (queries % 2 ? 6 : 24) : + scenario == 17 ? (queries <= 2 ? 24 : 6) : queries % 2 ? 24 : 6; + return modeSet->getMode(Mbps(rate)); + } + void frameTransmitted(Packet *packet, int, bool successful, bool) override { + if (!successful && dynamicPtrCast(packet->peekAtFront())) + failedDataFeedback++; + } + void frameReceived(Packet *) override {} +}; +Define_Module(AdmissionRateControl); + +class AdmissionAgreements : public OriginatorBlockAckAgreementHandler { + public: + void accept(MacAddress peer) { + auto request = makeShared(); + request->setReceiverAddress(peer); + request->setTid(5); + request->setStartingSequenceNumber(SequenceNumberCyclic(0)); + request->setBufferSize(64); + request->setBlockAckPolicy(true); + request->setAMsduSupported(true); + createAgreement(request); + auto agreement = getAgreement(peer, 5); + agreement->setIsAddbaResponseReceived(true); + agreement->setResponseAMsduSupported(true); + agreement->setBlockAckTimeoutValue(SIMTIME_ZERO); + agreement->calculateExpirationTime(); + finishProcedure(peer, 5); + } +}; + +class AdmissionHcf : public Hcf { + const MacAddress peer{"02:00:00:00:00:02"}; + Ptr pendingRts; + Ptr pendingAck; + bool pendingBasic = false; + Tid pendingTid = -1; + SequenceNumberCyclic pendingStart; + const physicallayer::IIeee80211Mode *responseMode = nullptr; + simtime_t firstDeadline; + bool responsePending = false; + b firstDataLength; + int failuresWanted() const { return scenario() == 7 ? 1 : scenario() == 8 ? 2 : scenario() == 9 ? 1000 : 0; } + public: + std::vector sourceIds; + std::vector sourcePackets; + std::vector sourceOwners; + std::vector deadlines; + int data = 0; + int scopedData = 0; + int rts = 0; + int aggregates = 0; + int refusedSequences = 0; + int mutation = 0; + int queueRemovals = 0; + int aggregationEvents = 0; + int queuePulls = 0; + int ordinaryMeasurements = 0; + simtime_t ordinaryQueueTime; + int internalCollisions = 0; + std::vector queriesAtData; + int scenario() const { return par("scenario"); } + AdmissionService *service() const { return check_and_cast(getSubmodule("originatorMacDataService")); } + AdmissionRecovery *recovery() const { return check_and_cast(edca->getEdcaf(AC_VI)->getRecoveryProcedure()); } + AdmissionRateControl *control() const { return check_and_cast(getSubmodule("rateControl")); } + queueing::IPacketQueue *queue() const { return edca->getEdcaf(AC_VI)->getPendingQueue(); } + EdcaTransmitLifetimeHandler *lifetime() const { return edca->getLifetimeHandler(); } + InProgressFrames *frames() const { return edca->getEdcaf(AC_VI)->getInProgressFrames(); } + void setup() { + Enter_Method("setup"); + rx->setContentionBlocked(true); + Ieee80211RateSetState rates; + rates.supported.known = rates.basic.known = rates.operational.known = true; + rates.supported.legacyRates = rates.basic.legacyRates = rates.operational.legacyRates = {Mbps(6), Mbps(12), Mbps(24)}; + mib->setLocalRateSet(rates); + mib->installBssAndPeerRateSets(rates, peer, rates); + if (scenario() != 16) { + auto radio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + mib->setPeerHtCapabilities(peer, mib->localHtCapabilities, mib->getHtOperation()); + delete originatorBlockAckAgreementHandler; + auto agreements = new AdmissionAgreements(); + originatorBlockAckAgreementHandler = agreements; + agreements->accept(peer); + } + int firstLength = scenario() == 13 ? 1400 : scenario() == 17 ? 2000 : 700; + if (scenario() == 21) + enqueue(100, 5, false, true); + enqueue(firstLength); + enqueue(scenario() == 17 ? 100 : 700); + if (scenario() == 17) + enqueue(700); + if (scenario() == 18) + enqueue(100, 6, false); + firstDeadline = deadlines.front(); + check_and_cast(queue())->subscribe(packetRemovedSignal, this); + check_and_cast(queue())->subscribe(packetPulledSignal, this); + service()->subscribe(IOriginatorMacDataService::packetAggregatedSignal, this); + } + void enqueue(int bytes, Tid tid = 5, bool record = true, bool group = false) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setTid(tid); + header->setSequenceNumber(SequenceNumberCyclic(77)); + auto receiver = group ? MacAddress("01:00:5e:00:00:01") : peer; + header->setReceiverAddress(receiver); + header->setTransmitterAddress(mac->getAddress()); + header->setAddress3(receiver); + auto packet = new Packet("admission-data", header); + packet->insertAtBack(makeShared(B(bytes))); + packet->insertAtBack(makeShared()); + auto time = packet->addRegionTag(header->getChunkLength(), B(bytes)); + time->setPacketTotalTimesArraySize(1); + time->setPacketTotalTimes(0, SIMTIME_ZERO); + packet->setArrivalTime(simTime()); + processUpperFrame(packet, header); + if (record) { + sourcePackets.push_back(packet); + sourceIds.push_back(packet->getId()); + deadlines.push_back(lifetime()->getDeadline(packet)); + sourceOwners.push_back(packet->getOwner()); + } + } + void unchanged(int expectedAllocations = 0) const { + ASSERT(queue()->getNumPackets() == int(sourceIds.size())); + ASSERT(frames()->getLength() == 0 && service()->allocations() == expectedAllocations); + ASSERT(service()->getNextSequenceNumber(peer, 5) == SequenceNumberCyclic(0)); + for (int i = 0; i < int(sourceIds.size()); i++) { + auto packet = queue()->getPacket(i); + ASSERT(packet == sourcePackets[i] && packet->getId() == sourceIds[i]); + ASSERT(packet->getOwner() == sourceOwners[i]); + ASSERT(packet->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(lifetime()->findFrame(sourceIds[i]) == packet && lifetime()->getDeadline(packet) == deadlines[i]); + } + } + void run() { Enter_Method("run"); rx->setContentionBlocked(false); } + void stop() { Enter_Method("stop"); rx->setContentionBlocked(true); } + void serviceCheck() { + Enter_Method("serviceCheck"); + auto preparation = service()->prepareFrame(queue(), scenario() != 1); + ASSERT(preparation && preparation->packet && preparation->sourceIds.size() == (scenario() == 1 ? 1 : 2)); + ASSERT(preparation->aggregate == (scenario() != 1)); + unchanged(); + ASSERT(queueRemovals == 0 && aggregationEvents == 0); + auto preview = preparation->packet.get(); + ASSERT(lifetime()->findFrame(preview->getId()) == nullptr); + ASSERT(service()->isPreparationValid(*preparation, simTime())); + if (scenario() == 0) { + preparation.reset(); + unchanged(); + ASSERT(queueRemovals == 0 && aggregationEvents == 0); + } + else if (scenario() == 1 || scenario() == 2) { + auto committed = service()->commitPreparedFrame(*preparation); + ASSERT(committed == preview && !preparation->packet); + ASSERT(service()->allocations() == 1 && service()->getNextSequenceNumber(peer, 5) == SequenceNumberCyclic(1)); + ASSERT(committed->getTag()->getAllocationIndex() == 0); + ASSERT(lifetime()->findFrame(sourceIds.front()) == nullptr); + ASSERT(lifetime()->getDeadline(committed) == (scenario() == 1 ? firstDeadline : simTime() + SimTime(100, SIMTIME_MS))); + ASSERT(queue()->getNumPackets() == (scenario() == 1 ? 1 : 0)); + ASSERT(queueRemovals == (scenario() == 1 ? 1 : 2)); + ASSERT(aggregationEvents == (scenario() == 1 ? 0 : 1)); + if (scenario() == 1) { + ASSERT(queue()->getPacket(0) == sourcePackets[1]); + ASSERT(lifetime()->getDeadline(sourcePackets[1]) == deadlines[1]); + } + lifetime()->forgetFrame(committed->getId()); + take(committed); + delete committed; + } + else if (scenario() == 3) { + auto removed = queue()->dequeuePacket(); + lifetime()->forgetFrame(removed->getId()); + take(removed); + delete removed; + ASSERT(!service()->isPreparationValid(*preparation, simTime())); + ASSERT(service()->commitPreparedFrame(*preparation) == nullptr); + ASSERT(service()->allocations() == 0 && queue()->getNumPackets() == 1); + } + else if (scenario() == 4) { + ASSERT(!service()->isPreparationValid(*preparation, firstDeadline)); + unchanged(); + } + else { + service()->setEligibility([](Packet *) { return true; }, [](Packet *) { return false; }); + ASSERT(!service()->isPreparationValid(*preparation, simTime())); + ASSERT(service()->commitPreparedFrame(*preparation) == nullptr); + unchanged(); + } + } + protected: + void initialize(int stage) override { + if (stage == INITSTAGE_LOCAL) { + // Replace fixed submodules before their parent caches pointers. + getSubmodule("originatorMacDataService")->deleteModule(); + auto service = cModuleType::get("AdmissionService")->create("originatorMacDataService", this); + service->finalizeParameters(); + service->buildInside(); + auto access = getSubmodule("edca"); + for (int i = 0; i < 4; i++) { + auto edcaf = access->getSubmodule("edcaf", i); + edcaf->getSubmodule("recoveryProcedure")->deleteModule(); + auto recovery = cModuleType::get("AdmissionRecovery")->create("recoveryProcedure", edcaf); + recovery->finalizeParameters(); + recovery->buildInside(); + } + } + Hcf::initialize(stage); + } + void channelGranted(IChannelAccess *access) override { + auto collided = edca->getInternallyCollidedEdcafs(); + Hcf::channelGranted(access); + if (scenario() == 18 && !collided.empty()) { + internalCollisions += collided.size(); + ASSERT(frames()->getLength() == 1 && queue()->getNumPackets() == 1); + auto committed = frames()->getFrames(0); + auto header = committed->peekAtFront(); + ASSERT(!header->getAMsduPresent() && !header->getRetry()); + ASSERT(queue()->getPacket(0) == sourcePackets[1]); + ASSERT(lifetime()->getDeadline(sourcePackets[1]) == deadlines[1]); + ASSERT(recovery()->dataFailures == 1 && recovery()->getRetryCount(committed, header) == 1); + } + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *value, cObject *details) override { + if (signal == packetRemovedSignal || signal == packetPulledSignal) { + queueRemovals++; + if (signal == packetPulledSignal) + queuePulls++; + } + else if (signal == IOriginatorMacDataService::packetAggregatedSignal) + aggregationEvents++; + else + Hcf::receiveSignal(source, signal, value, details); + } + bool isReceptionInProgress() override { return responsePending || Hcf::isReceptionInProgress(); } + void frameSequenceFinished() override { + if (data == 0 && rts > 0 && scenario() != 9 && mutation == 0) { + if (scenario() != 18) + unchanged(); + ASSERT(recovery()->numberedCounters() == 0); + } + if (scenario() == 13 && data == 1) + refusedSequences++; + Hcf::frameSequenceFinished(); + if ((scenario() >= 22 ? data >= 2 : scenario() == 18 ? scopedData > 0 : data > 0) || mutation > 0) + rx->setContentionBlocked(true); + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + auto header = packet->peekAtFront(); + auto context = frameSequenceHandler->getContext(); + if (auto protectedRts = dynamicPtrCast(header)) { + auto state = context->getQoSContext()->preparedData.get(); + if (state) { + if (state->preparation) { + ASSERT(state->frame == state->preparation->packet.get()); + ASSERT(!frames()->containsFrame(state->frame)); + if (scenario() != 18) + unchanged(); + } + else + ASSERT(frames()->containsFrame(state->frame)); + } + else + ASSERT(scenario() == 15 || scenario() == 16 || scenario() == 18); + pendingRts = protectedRts; + } + bool accepted = Hcf::transmitFrame(packet, ifs); + if (!accepted) + return false; + header = packet->peekAtFront(); + auto mode = packet->getTag()->getMode(); + auto end = simTime() + ifs + mode->getDuration(packet->getDataLength()); + if (dynamicPtrCast(header)) { + pendingRts = staticPtrCast(header); + rts++; + if (scenario() == 19 || scenario() == 20) { + auto state = context->getQoSContext()->preparedData.get(); + ASSERT(state && !state->frame->peekAtFront()->getAMsduPresent()); + auto required = modeSet->getSifsTime() + state->ctsMode->getDuration(LENGTH_CTS) + + modeSet->getSifsTime() + state->dataMode->getDuration(state->frame->getDataLength()); + if (state->ackMode) + required += modeSet->getSifsTime() + state->ackMode->getDuration(LENGTH_ACK); + ASSERT(pendingRts->getDurationField() >= required); + } + if (rts == 1 && (scenario() == 10 || scenario() == 11 || scenario() == 12)) + scheduleAt(end + SimTime(1, SIMTIME_PS), new cMessage("mutation")); + if (rts > failuresWanted()) { + responsePending = true; + responseMode = rateSelection->computeResponseCtsFrameMode(packet, pendingRts, ResponseQueryRole::PREDICT); + scheduleAt(end + modeSet->getSifsTime() + responseMode->getDuration(LENGTH_CTS), new cMessage("cts")); + } + } + else if (auto ordinary = dynamicPtrCast(header)) { + data++; + scopedData += ordinary->getTid() == 5 && !ordinary->getReceiverAddress().isMulticast(); + aggregates += ordinary->getAMsduPresent(); + queriesAtData.push_back(control()->queries); + if (scenario() != 15 && scenario() != 16 && ordinary->getTid() == 5 && !ordinary->getReceiverAddress().isMulticast()) { + auto state = context->getQoSContext()->preparedData.get(); + ASSERT(state && frames()->containsFrame(packet) && state->dataMode == mode); + if (!ordinary->getAMsduPresent() && (scenario() == 6 || scenario() == 19 || scenario() == 20 || scenario() == 22)) { + auto offset = ordinary->getChunkLength(); + auto time = packet->findRegionTag(offset, packet->getDataLength() - offset - B(4)); + if (!ordinary->getRetry()) { + ASSERT(time && time->getPacketTotalTimes(0) == simTime() - SimTime(1, SIMTIME_MS)); + ASSERT(queuePulls >= 1); + ordinaryQueueTime = time->getPacketTotalTimes(0); + ordinaryMeasurements++; + } + else if (scenario() == 22) + ASSERT(time && time->getPacketTotalTimes(0) == ordinaryQueueTime && queuePulls == 1); + } + } + if (scenario() == 20) + ASSERT(ordinary->getAckPolicy() == NORMAL_ACK && ordinary->getDurationField() >= modeSet->getSifsTime() + + rateSelection->computeResponseAckFrameMode(packet, ordinary, ResponseQueryRole::PREDICT)->getDuration(LENGTH_ACK)); + if (scenario() >= 22 && data == 2) { + ASSERT(ordinary->getRetry()); + ASSERT(packet->getDataLength() == firstDataLength); + ASSERT(mode->getDuration(packet->getDataLength()) > SimTime(1, SIMTIME_MS)); + ASSERT(ordinary->getAMsduPresent() == (scenario() == 23)); + } + if (scenario() >= 22 && data == 1) { + firstDataLength = packet->getDataLength(); + ASSERT(!ordinary->getRetry()); + return true; // No ACK forces a retry of the same committed MPDU. + } + if (ordinary->getAckPolicy() == NORMAL_ACK) { + responsePending = true; + pendingAck = ordinary; + responseMode = rateSelection->computeResponseAckFrameMode(packet, ordinary, ResponseQueryRole::PREDICT); + scheduleAt(end + modeSet->getSifsTime() + responseMode->getDuration(LENGTH_ACK), new cMessage("ack")); + } + } + else if (auto management = dynamicPtrCast(header)) { + responsePending = true; + pendingAck = management; + responseMode = rateSelection->computeResponseAckFrameMode(packet, management, ResponseQueryRole::PREDICT); + scheduleAt(end + modeSet->getSifsTime() + responseMode->getDuration(LENGTH_ACK), new cMessage("ack")); + } + else if (auto bar = dynamicPtrCast(header)) { + responsePending = true; + pendingBasic = dynamicPtrCast(bar) != nullptr; + pendingTid = pendingBasic ? staticPtrCast(bar)->getTidInfo() : + staticPtrCast(bar)->getTidInfo(); + pendingStart = pendingBasic ? staticPtrCast(bar)->getStartingSequenceNumber() : + staticPtrCast(bar)->getStartingSequenceNumber(); + responseMode = rateSelection->computeResponseBlockAckFrameMode(packet, bar, ResponseQueryRole::PREDICT); + scheduleAt(end + modeSet->getSifsTime() + responseMode->getDuration(pendingBasic ? LENGTH_BASIC_BLOCKACK : LENGTH_COMPRESSED_BLOCKACK), new cMessage("ba")); + } + return true; + } + void receive(Packet *packet, const Ptr& header) { + packet->addTag()->setMode(responseMode); + if (!frameSequenceHandler->isSequenceRunning()) { + delete packet; + return; + } + processLowerFrame(packet, header); + } + void handleMessage(cMessage *message) override { + if (message->isName("mutation")) { + delete message; + mutation++; + int queries = control()->queries; + if (scenario() == 10) + mib->removePeerHtCapabilities(peer); + else if (scenario() == 11) { + auto rates = mib->getBssRateSet(); + rates.basic.legacyRates.erase(Mbps(12)); + mib->setBssRateSet(rates); + } + else { + auto radio = check_and_cast(getModuleByPath("^.^.radio")); + radio->setMode(modeSet->getMode(Mbps(24))); + auto replacement = physicallayer::Ieee80211ModeSet::getModeSet("g(mixed)"); + radio->setModeSet(replacement); + getContainingNicModule(this)->emit(modesetChangedSignal, replacement); + } + ASSERT(control()->queries == queries); + if (scenario() != 11) + rx->setContentionBlocked(true); + return; + } + if (message->isName("cts")) { + delete message; + responsePending = false; + auto header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + header->setDurationField(std::max(SIMTIME_ZERO, pendingRts->getDurationField() - modeSet->getSifsTime() - responseMode->getDuration(LENGTH_CTS))); + receive(new Packet("synthetic-cts", header), header); + return; + } + if (message->isName("ack")) { + delete message; + responsePending = false; + auto header = makeShared(); + header->setReceiverAddress(mac->getAddress()); + receive(new Packet("synthetic-ack", header), header); + return; + } + if (message->isName("ba")) { + delete message; + responsePending = false; + Ptr header; + if (pendingBasic) { + auto basic = makeShared(); + basic->setTidInfo(pendingTid); + basic->setStartingSequenceNumber(pendingStart); + for (int i = 0; i < 64; i++) basic->setBlockAckBitmap(i, BitVector("1000000000000000")); + header = basic; + } + else { + auto compressed = makeShared(); + compressed->setTidInfo(pendingTid); + compressed->setStartingSequenceNumber(pendingStart); + compressed->setBlockAckBitmap(BitVector(std::string(64, '1').c_str())); + header = compressed; + } + header->setReceiverAddress(mac->getAddress()); + header->setTransmitterAddress(peer); + receive(new Packet("synthetic-ba", header), header); + return; + } + Hcf::handleMessage(message); + } +}; +Define_Module(AdmissionHcf); + +class AdmissionTest : public cSimpleModule { + public: + AdmissionTest() : cSimpleModule(131072) {} + protected: + void activity() override { + wait(SimTime(1, SIMTIME_MS)); + auto hcf = check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf")); + hcf->setup(); + int scenario = par("scenario"); + if (scenario < 6) + hcf->serviceCheck(); + else { + hcf->run(); + wait(SimTime(20, SIMTIME_MS)); + hcf->stop(); + if (scenario == 6 || scenario == 19 || scenario == 20 || scenario == 22) + ASSERT(hcf->ordinaryMeasurements == 1 && hcf->queuePulls == 1); + auto recovery = hcf->recovery(); + ASSERT(recovery->dataFailures == (scenario == 18 || scenario >= 22 ? 1 : 0)); + ASSERT(hcf->control()->failedDataFeedback == (scenario >= 22 ? 1 : 0)); + if (scenario == 9) { + ASSERT(hcf->rts > 0 && hcf->data == 0 && hcf->queue()->isEmpty()); + ASSERT(hcf->service()->allocations() == 0); + int queries = hcf->control()->queries; + wait(SimTime(1, SIMTIME_MS)); + ASSERT(hcf->control()->queries == queries); + } + else if (scenario == 10 || scenario == 12) { + ASSERT(hcf->data == 0 && hcf->mutation == 1); + hcf->unchanged(); + ASSERT(hcf->control()->queries == 1 && recovery->numberedCounters() == 0); + } + else { + ASSERT(hcf->data > 0); + if (scenario == 6 || scenario == 19 || scenario == 20) { + ASSERT(hcf->data == 1 && hcf->aggregates == 0 && hcf->queriesAtData.front() == 1); + ASSERT(hcf->queue()->getNumPackets() == 1 && hcf->service()->allocations() == 1); + ASSERT(hcf->lifetime()->getDeadline(hcf->queue()->getPacket(0)) == hcf->deadlines[1]); + } + if (scenario == 7 || scenario == 8) { + ASSERT(recovery->controls == (scenario == 7 ? 1 : 2)); + ASSERT(recovery->numberedRtsFailures == 0); + ASSERT(hcf->queriesAtData.front() == (scenario == 7 ? 2 : 3)); + ASSERT(recovery->qsrcHistory[0] == 1); + if (scenario == 8) ASSERT(recovery->qsrcHistory[1] == 0); + } + else + ASSERT(recovery->controls == 0); + if (scenario == 11) + ASSERT(hcf->queriesAtData.front() == 1 && hcf->mutation == 1); + if (scenario == 13) { + ASSERT(hcf->data == 1 && hcf->refusedSequences == 1); + ASSERT(hcf->queue()->getNumPackets() == 1 && hcf->service()->allocations() == 1); + ASSERT(hcf->queue()->getPacket(0) == hcf->sourcePackets[1]); + ASSERT(hcf->lifetime()->getDeadline(hcf->queue()->getPacket(0)) == hcf->deadlines[1]); + } + if (scenario == 14) + ASSERT(hcf->data == 1 && hcf->aggregates == 1 && hcf->queriesAtData.front() == 1); + if (scenario == 15 || scenario == 16) + ASSERT(hcf->service()->preparations == 0); + if (scenario == 17) { + ASSERT(hcf->data == 2 && hcf->aggregates == 0); + ASSERT(hcf->queriesAtData[0] == 1 && hcf->queriesAtData[1] == 2); + ASSERT(hcf->queue()->getNumPackets() == 1 && hcf->service()->allocations() == 2); + } + if (scenario == 18) { + ASSERT(hcf->internalCollisions == 1 && hcf->scopedData == 1 && hcf->aggregates == 0); + ASSERT(hcf->queue()->getNumPackets() == 1); + ASSERT(hcf->lifetime()->getDeadline(hcf->queue()->getPacket(0)) == hcf->deadlines[1]); + } + if (scenario == 21) { + ASSERT(hcf->data == 1 && hcf->scopedData == 0 && hcf->service()->commits == 0); + ASSERT(hcf->service()->preparations > 0); + hcf->unchanged(1); + } + if (scenario >= 22) { + ASSERT(hcf->data == 2 && hcf->aggregates == (scenario == 23 ? 2 : 0)); + ASSERT(hcf->service()->commits == 1 && hcf->service()->allocations() == 1); + ASSERT(hcf->queue()->getNumPackets() == (scenario == 22 ? 1 : 0)); + } + } + } + std::cout << "Compressed admission scenario " << scenario << " passed.\n"; + endSimulation(); + } +}; +Define_Module(AdmissionTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.originator.OriginatorQosMacDataService; +import inet.linklayer.ieee80211.mac.originator.QosRecoveryProcedure; +import inet.linklayer.ieee80211.mac.contract.IRateControl; +import inet.node.inet.AdhocHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module AdmissionService extends OriginatorQosMacDataService { parameters: @class(::inet::ieee80211::AdmissionService); } +simple AdmissionRecovery extends QosRecoveryProcedure { parameters: @class(::inet::ieee80211::AdmissionRecovery); } +simple AdmissionRateControl like IRateControl { parameters: @class(::inet::ieee80211::AdmissionRateControl); } +module AdmissionHcf extends Hcf { parameters: int scenario; @class(::inet::ieee80211::AdmissionHcf); } +simple AdmissionTest { parameters: int scenario; @class(::inet::ieee80211::AdmissionTest); @display("i=block/cogwheel"); } +network AdmissionNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: AdhocHost; + test: AdmissionTest; +} + +%inifile: omnetpp.ini +[General] +network = AdmissionNetwork +ned-path = .;../../../../src +sim-time-limit = 100ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.test.scenario = ${scenario=0..23} +*.host.wlan[*].opMode = "n(mixed-2.4Ghz)" +*.host.wlan[*].mac.qosStation = true +*.host.wlan[*].mac.hcf.typename = "AdmissionHcf" +*.host.wlan[*].mac.hcf.scenario = ${scenario} +*.host.wlan[*].mac.hcf.isBlockAckSupported = true +*.host.wlan[*].mac.hcf.blockAckVariant = ${scenario} == 15 ? "basic" : "compressed" +*.host.wlan[*].mac.hcf.rateControl.typename = "AdmissionRateControl" +*.host.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = -1bps +*.host.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps +*.host.wlan[*].mac.hcf.originatorAckPolicy.maxBlockAckPolicyFrameLength = ${scenario} == 20 || ${scenario} >= 22 ? 0B : 10000B +*.host.wlan[*].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 5 +*.host.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.maxAMsduSize = 1600 +*.host.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 +*.host.wlan[*].mac.hcf.edca.edcaf[*].recoveryProcedure.shortRetryLimit = 1 +*.host.wlan[*].mac.hcf.edca.edcaf[*].cwMin = ${scenario} == 18 ? 0 : -1 +*.host.wlan[*].mac.hcf.edca.edcaf[*].cwMax = ${scenario} == 18 ? 0 : -1 +*.host.wlan[*].mac.hcf.edca.edcaf[*].aifsn = ${scenario} == 18 ? 2 : -1 +*.host.wlan[*].mac.hcf.edca.edcaf[*].msduLifetime = ${scenario} == 9 ? 250us : 100ms +*.host.wlan[*].mac.hcf.edca.edcaf[*].txopProcedure.txopLimit = ${scenario} == 14 ? 0s : 1ms +*.host.wlan[*].mac.hcf.edca.edcaf[*].txopProcedure.protectionMechanism = ${scenario} == 13 || ${scenario} == 17 || ${scenario} == 19 || ${scenario} == 20 || ${scenario} == 21 ? "multiple" : "single" +*.host.wlan[*].mac.hcf.rtsPolicy.rtsThreshold = 500B +**.mobility.initFromDisplayString = false +**.mobility.initialX = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m + +%contains: stdout +Compressed admission scenario 23 passed. diff --git a/tests/module/Ieee80211CompressedBlockAckExchange_1.test b/tests/module/Ieee80211CompressedBlockAckExchange_1.test new file mode 100644 index 00000000000..4ccb39e660a --- /dev/null +++ b/tests/module/Ieee80211CompressedBlockAckExchange_1.test @@ -0,0 +1,428 @@ +%description: +Use real association and management rate publication for two Compressed Block Ack hops. +The STA sends thirty UDP payloads through the AP to the other STA. +Observe accepted ADDBA dialogs, matched Compressed BAR/BA, positive receipt bits, and final agreement retirement. +After setup, remove one BSS basic rate through the MIB API. Require the agreement and HT generation to remain unchanged. +Record actual frame modes, lengths, airtime, IFS, and TXOP bounds for both protection modes at 6 and 24 Mbps. +The medium uses zero propagation time. Compare local receipt completion with the exact TXOP endpoint without a timing allowance. +The fixture enforces DATA and ACK bounds under active Compressed agreements, with the permitted initial MSDU and same-size retry exceptions. +The fixture records overruns outside active agreements separately. StrictAllTiming retains the original aggregate assertion for inherited failures. +Repeat each case with a non-HT link. Require payload delivery without ADDBA or BAR. +Repeat each case with A-MSDU aggregation enabled. Require actual A-MSDUs under accepted agreements at 24 Mbps. +The LowestResponse configuration supplies two extra runs with a 6 Mbps BAR and BA, one per protection mode. + +%extraargs: -r 0..15 + +%file: Exchange.cc +#include +#include "inet/common/Simsignals.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class ExchangeHcf : public Hcf { + struct DataScope { + bool activeCompressed; + AckPolicy policy; + }; + std::map dataScopes; + struct PendingBar { + SequenceNumberCyclic start; + simtime_t bound; + int dataManagementCount; + bool aggregate; + }; + std::map, int> dialogs; + std::map, PendingBar> pendingBars; + simtime_t observedTxopStart = -1; + int dataManagementCount = 0; + bool aggregate = false; + simtime_t controlReceivedAt = -1; + public: + int requests = 0; + int acceptedResponses = 0; + int bars = 0; + int positiveResponses = 0; + int activeData = 0; + int activeAggregates = 0; + int retired = 0; + int initialOverruns = 0; + int generalDataOverruns = 0; + int generalAckOverruns = 0; + int initialAckOverruns = 0; + int initialBlockAckOverruns = 0; + int outsideAgreementDataOverruns = 0; + int outsideAgreementAckOverruns = 0; + int permittedRetryOverruns = 0; + bool refreshedRates = false; + bool clean() const { + std::cout << "Exchange cleanup: node=" << getParentModule()->getParentModule()->getParentModule()->getFullName() + << " originator=" << originatorBlockAckAgreementHandler->getAgreements().size() + << " recipient=" << recipientBlockAckAgreementHandler->getAgreements().size() + << " pendingBars=" << pendingBars.size() + << " inactivityTimer=" << inactivityTimer->isScheduled() << " addbaTimer=" << addbaResponseTimer->isScheduled() << "\n"; + for (const auto& entry : originatorBlockAckAgreementHandler->getProcedures()) { + std::cout << "Exchange procedure: peer=" << entry.first.first << " tid=" << int(entry.first.second) + << " state=" << int(entry.second.state) << " deadline=" << entry.second.responseDeadline << "\n"; + ASSERT(entry.second.state == IOriginatorBlockAckAgreementHandler::ProcedureState::WAITING_FOR_SUCCESSOR); + ASSERT(!entry.second.requestAttempted && entry.second.responseDeadline == SIMTIME_MAX); + } + for (auto category : {AC_BK, AC_BE, AC_VI, AC_VO}) { + std::cout << "Exchange remaining: ac=" << category + << " queued=" << edca->getEdcaf(category)->getPendingQueue()->getNumPackets() + << " committed=" << edca->getEdcaf(category)->getInProgressFrames()->getLength() << "\n"; + ASSERT(edca->getEdcaf(category)->getPendingQueue()->isEmpty()); + ASSERT(edca->getEdcaf(category)->getInProgressFrames()->getLength() == 0); + } + ASSERT(!inactivityTimer->isScheduled() && !addbaResponseTimer->isScheduled()); + return originatorBlockAckAgreementHandler->getAgreements().empty() && + recipientBlockAckAgreementHandler->getAgreements().empty() && pendingBars.empty(); + } + void checkPublishedState(MacAddress peer) { + ASSERT(mib->getLocalRateSet().operational.known); + ASSERT(mib->getBssRateSet().basic.known); + ASSERT(!mib->getBssRateSet().basic.legacyRates.empty()); + auto rates = mib->findPeerRateSet(peer); + ASSERT(rates && rates->operational.known && !rates->operational.legacyRates.empty()); + auto ht = mib->findPeerHtState(peer); + ASSERT(mib->isHtOperationSupported() && ht && ht->valid); + } + protected: + void transmitControlResponseFrame(Packet *responsePacket, const Ptr& responseHeader, + Packet *receivedPacket, const Ptr& receivedHeader) override { + controlReceivedAt = simTime(); + Hcf::transmitControlResponseFrame(responsePacket, responseHeader, receivedPacket, receivedHeader); + } + void recipientProcessTransmittedControlResponseFrame(Packet *packet, const Ptr& header) override { + auto mode = packet->getTag()->getMode(); + auto airtime = mode->getDuration(packet->getDataLength()); + ASSERT(simTime() - airtime - controlReceivedAt == modeSet->getSifsTime()); + if (dynamicPtrCast(header)) + ASSERT(packet->getDataLength() == LENGTH_COMPRESSED_BLOCKACK); + std::cout << "Exchange response: node=" << getParentModule()->getParentModule()->getParentModule()->getFullName() + << " start=" << simTime() - airtime << " end=" << simTime() << " type=" << header->getType() + << " bytes=" << packet->getByteLength() << " bitrate=" << mode->getDataMode()->getNetBitrate() + << " airtime=" << airtime << " ifs=" << modeSet->getSifsTime() << "\n"; + Hcf::recipientProcessTransmittedControlResponseFrame(packet, header); + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (auto data = dynamicPtrCast(header)) { + auto index = packet->getTag()->getAllocationIndex(); + ASSERT(dataScopes.count(index)); + const auto& scope = dataScopes.at(index); + std::cout << "Exchange scope: node=" << getParentModule()->getParentModule()->getParentModule()->getFullName() + << " at=" << simTime() << " allocation=" << index << " activeCompressed=" << scope.activeCompressed + << " ackPolicy=" << scope.policy << " aggregate=" << data->getAMsduPresent() << " retry=" << data->getRetry() << "\n"; + auto owner = edca->getChannelOwner(); + ASSERT(owner); + auto txop = owner->getTxopProcedure(); + auto bound = txop->getStart() + txop->getLimit(); + if (simTime() > bound) { + if (par("strictAllTiming").boolValue()) + ASSERT(!data->getAMsduPresent()); + if (scope.activeCompressed) { + ASSERT(dataManagementCount == 1); + ASSERT(!data->getAMsduPresent() || data->getRetry()); + permittedRetryOverruns += data->getRetry(); + } + else + outsideAgreementDataOverruns++; + if (dataManagementCount == 1) + initialOverruns++; + else + generalDataOverruns++; + } + } + Hcf::transmissionComplete(packet, header); + } + void originatorProcessReceivedFrame(Packet *packet, Packet *transmitted) override { + auto data = dynamicPtrCast(transmitted->peekAtFront()); + if (data) { + auto owner = edca->getChannelOwner(); + ASSERT(owner); + auto txop = owner->getTxopProcedure(); + if (simTime() > txop->getStart() + txop->getLimit()) { + auto index = transmitted->getTag()->getAllocationIndex(); + const auto& scope = dataScopes.at(index); + if (par("strictAllTiming").boolValue()) + ASSERT(!data->getAMsduPresent()); + if (scope.activeCompressed) { + ASSERT(dataManagementCount == 1); + ASSERT(!data->getAMsduPresent() || data->getRetry()); + } + else + outsideAgreementAckOverruns++; + if (dataManagementCount > 1) + generalAckOverruns++; + else + initialAckOverruns++; + } + } + Hcf::originatorProcessReceivedFrame(packet, transmitted); + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + auto header = packet->peekAtFront(); + bool activeCompressed = false; + if (auto data = dynamicPtrCast(header)) { + auto agreement = originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()); + activeCompressed = std::string(par("blockAckVariant").stringValue()) == "compressed" && + agreement && agreement->getIsAddbaResponseReceived(); + } + bool sent = Hcf::transmitFrame(packet, ifs); + if (!sent) + return false; + header = packet->peekAtFront(); + if (auto data = dynamicPtrCast(header)) + dataScopes.insert_or_assign(packet->getTag()->getAllocationIndex(), + DataScope{activeCompressed, data->getAckPolicy()}); + auto owner = edca->getChannelOwner(); + if (owner) { + auto txop = owner->getTxopProcedure(); + if (txop->getStart() != observedTxopStart) { + observedTxopStart = txop->getStart(); + dataManagementCount = 0; + aggregate = false; + } + if (dynamicPtrCast(header)) + dataManagementCount++; + } + if (auto request = dynamicPtrCast(header)) { + checkPublishedState(request->getReceiverAddress()); + dialogs[{request->getReceiverAddress(), request->getTid()}] = request->getDialogToken(); + requests++; + } + if (auto bar = dynamicPtrCast(header)) { + ASSERT(bar->getCompressedBitmap() && !bar->getMultiTid()); + ASSERT(packet->getDataLength() == LENGTH_BLOCKACKREQ); + ASSERT(owner); + auto txop = owner->getTxopProcedure(); + pendingBars.insert_or_assign({bar->getReceiverAddress(), bar->getTidInfo()}, + PendingBar{bar->getStartingSequenceNumber(), txop->getStart() + txop->getLimit(), dataManagementCount, aggregate}); + bars++; + } + ASSERT(!dynamicPtrCast(header)); + if (dynamicPtrCast(header)) + ASSERT(packet->getDataLength() == LENGTH_COMPRESSED_BLOCKACK); + if (auto data = dynamicPtrCast(header)) { + aggregate |= data->getAMsduPresent(); + auto agreement = originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()); + if (agreement && agreement->getIsAddbaResponseReceived()) { + ASSERT(data->getFragmentNumber() == 0 && !data->getMoreFragments()); + activeData++; + activeAggregates += data->getAMsduPresent(); + } + } + if (dynamicPtrCast(header)) + retired++; + if (header->getType() == ST_DATA_WITH_QOS || header->getType() == ST_RTS || + header->getType() == ST_CTS || header->getType() == ST_BLOCKACK_REQ || header->getType() == ST_BLOCKACK) { + auto mode = packet->getTag()->getMode(); + std::cout << "Exchange frame: node=" << getParentModule()->getParentModule()->getParentModule()->getFullName() + << " at=" << simTime() << " type=" << header->getType() << " bytes=" << packet->getByteLength() + << " bitrate=" << mode->getDataMode()->getNetBitrate() << " ifs=" << ifs + << " airtime=" << mode->getDuration(packet->getDataLength()); + if (owner) { + auto txop = owner->getTxopProcedure(); + std::cout << " txopStart=" << txop->getStart() << " txopLimit=" << txop->getLimit() + << " protection=" << txop->getProtectionMechanism() << " dataManagementCount=" << dataManagementCount; + } + std::cout << "\n"; + } + return true; + } + void processLowerFrame(Packet *packet, const Ptr& header) override { + if (auto response = dynamicPtrCast(header); response && response->getReceiverAddress() == mib->address) { + auto key = std::make_pair(response->getTransmitterAddress(), int(response->getTid())); + ASSERT(dialogs.count(key) && dialogs.at(key) == response->getDialogToken()); + ASSERT(response->getStatusCode() == 0 && response->getBlockAckPolicy()); + acceptedResponses++; + } + if (auto response = dynamicPtrCast(header); response && response->getReceiverAddress() == mib->address) { + auto key = std::make_pair(response->getTransmitterAddress(), int(response->getTidInfo())); + ASSERT(pendingBars.count(key)); + auto pending = pendingBars.at(key); + ASSERT(response->getStartingSequenceNumber() == pending.start); + ASSERT(response->getCompressedBitmap() && !response->getMultiTid()); + ASSERT(response->getBlockAckBitmap().getSize() == 64); + bool positive = false; + for (unsigned int i = 0; i < response->getBlockAckBitmap().getSize(); i++) + positive |= response->getBlockAckBitmap().getBit(i); + ASSERT(positive); + std::cout << "Exchange completion: at=" << simTime() << " bound=" << pending.bound + << " dataManagementCount=" << pending.dataManagementCount << "\n"; + // One initial unaggregated MSDU can overrun. A later exchange must finish within the TXOP. + if (pending.dataManagementCount != 1 || pending.aggregate) + ASSERT(simTime() <= pending.bound); + else if (simTime() > pending.bound) + initialBlockAckOverruns++; + positiveResponses++; + pendingBars.erase(key); + } + ASSERT(!dynamicPtrCast(header)); + Hcf::processLowerFrame(packet, header); + if (auto response = dynamicPtrCast(header); + response && response->getReceiverAddress() == mib->address && !refreshedRates) { + auto peer = response->getTransmitterAddress(); + auto tid = response->getTid(); + auto agreement = originatorBlockAckAgreementHandler->getAgreement(peer, tid); + ASSERT(agreement && agreement->getIsAddbaResponseReceived()); + auto generation = mib->findPeerHtState(peer)->generation; + auto rates = mib->getBssRateSet(); + ASSERT(rates.basic.legacyRates.size() > 1); + rates.basic.legacyRates.erase(std::prev(rates.basic.legacyRates.end())); + // Association supplies the initial rates. This rate-only update exercises the production subscriber. + mib->setBssRateSet(rates); + ASSERT(originatorBlockAckAgreementHandler->getAgreement(peer, tid) == agreement); + ASSERT(mib->findPeerHtState(peer)->generation == generation); + refreshedRates = true; + } + } +}; +Define_Module(ExchangeHcf); + +class ExchangeTest : public cSimpleModule, public cListener { + int received = 0; + int64_t bytes = 0; + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("subscribe")); } + void receiveSignal(cComponent *, simsignal_t, cObject *value, cObject *) override { + auto packet = check_and_cast(value); + received++; + bytes += packet->getByteLength(); + } + void handleMessage(cMessage *message) override { + if (message->isName("subscribe")) { + delete message; + getModuleByPath("^.sta2.app[0]")->subscribe(packetReceivedSignal, this); + scheduleAt(SimTime(1200, SIMTIME_MS), new cMessage("verify")); + return; + } + delete message; + ASSERT(received == 30 && bytes == 21000); + for (const char *path : {"^.sta1.wlan[0].mac.hcf", "^.ap.wlan[0].mac.hcf"}) { + auto hcf = check_and_cast(getModuleByPath(path)); + std::cout << "Exchange summary: node=" << path << " accepted=" << hcf->acceptedResponses + << " bars=" << hcf->bars << " positiveResponses=" << hcf->positiveResponses + << " activeData=" << hcf->activeData << " retired=" << hcf->retired + << " activeAggregates=" << hcf->activeAggregates << " initialOverruns=" << hcf->initialOverruns + << " generalDataOverruns=" << hcf->generalDataOverruns << " generalAckOverruns=" << hcf->generalAckOverruns + << " outsideAgreementDataOverruns=" << hcf->outsideAgreementDataOverruns + << " outsideAgreementAckOverruns=" << hcf->outsideAgreementAckOverruns + << " permittedRetryOverruns=" << hcf->permittedRetryOverruns + << " initialAckOverruns=" << hcf->initialAckOverruns << " initialBlockAckOverruns=" << hcf->initialBlockAckOverruns << "\n"; + if (par("ht").boolValue()) { + ASSERT(hcf->requests > 0 && hcf->acceptedResponses > 0 && hcf->bars > 0); + ASSERT(hcf->positiveResponses > 0 && hcf->positiveResponses <= hcf->bars && hcf->activeData > 0 && hcf->retired > 0); + ASSERT(hcf->refreshedRates); + if (par("aggregate").boolValue() && par("rate").intValue() == 24) + ASSERT(hcf->activeAggregates > 0); + } + else + ASSERT(hcf->requests == 0 && hcf->acceptedResponses == 0 && hcf->bars == 0 && hcf->activeData == 0); + ASSERT(hcf->clean()); + } + ASSERT(check_and_cast(getModuleByPath("^.sta2.wlan[0].mac.hcf"))->clean()); + std::cout << "Compressed infrastructure exchange assertions passed.\n"; + endSimulation(); + } +}; +Define_Module(ExchangeTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module ExchangeHcf extends Hcf { parameters: bool strictAllTiming = default(false); @class(::inet::ieee80211::ExchangeHcf); } +simple ExchangeTest { parameters: bool ht; bool aggregate; int rate; @class(::inet::ieee80211::ExchangeTest); } +network ExchangeNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: Ieee80211ScalarRadioMedium; + ap: AccessPoint; + sta1: WirelessHost; + sta2: WirelessHost; + test: ExchangeTest; +} + +%inifile: omnetpp.ini +[General] +**.hcf.blockAckVariant = "compressed" +network = ExchangeNetwork +ned-path = .;../../../../src +sim-time-limit = 1.3s +seed-set = 0 +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.sta1.numApps = 1 +*.sta1.app[0].typename = "UdpBasicApp" +*.sta1.app[0].destAddresses = "sta2" +*.sta1.app[0].destPort = 1000 +*.sta1.app[0].messageLength = 700B +*.sta1.app[0].startTime = 1s +*.sta1.app[0].stopTime = 1.00295s +*.sta1.app[0].sendInterval = 100us +*.sta2.numApps = 1 +*.sta2.app[0].typename = "UdpSink" +*.sta2.app[0].localPort = 1000 +*.sta*.ipv4.arp.typename = "GlobalArp" +*.test.ht = ${ht=true,false} +*.test.aggregate = ${aggregationPolicy="","BasicMsduAggregationPolicy"} != "" +*.test.rate = ${rate=6,24} +**.wlan[*].opMode = ${ht} ? "n(mixed-2.4Ghz)" : "g(mixed)" +**.wlan[*].bitrate = ${rate}Mbps +**.bandName = "2.4 GHz" +**.wlan[*].radio.antenna.numAntennas = 2 +**.wlan[*].classifier.typename = "QosClassifier" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "ExchangeHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.originatorAckPolicy.blockAckReqThreshold = 5 +**.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +**.originatorMacDataService.msduAggregationPolicy.typename = ${aggregationPolicy} +**.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 +**.originatorMacDataService.msduAggregationPolicy.maxAMsduSize = 1600 +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 2346B +**.rtsPolicy.rtsThreshold = 500B +**.txopProcedure.protectionMechanism = ${protection="single","multiple"} +**.txopProcedure.txopLimit = 1ms +**.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.sta1.mobility.initialX = 0m +*.ap.mobility.initialX = 5m +*.sta2.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +[Config StrictAllTiming] +**.wlan[*].mac.hcf.strictAllTiming = true + +[Config LowestResponse] +constraint = $ht == true && $aggregationPolicy == "" && $rate == 6 +*.test.ht = true +*.test.aggregate = false +*.test.rate = 6 +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].bitrate = 6Mbps +**.originatorMacDataService.msduAggregationPolicy.typename = "" +**.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps + +%contains: stdout +Compressed infrastructure exchange assertions passed. diff --git a/tests/module/Ieee80211CompressedBlockAckInput_1.test b/tests/module/Ieee80211CompressedBlockAckInput_1.test new file mode 100644 index 00000000000..0775fc9b4a7 --- /dev/null +++ b/tests/module/Ieee80211CompressedBlockAckInput_1.test @@ -0,0 +1,325 @@ +%description: +Check malformed input and profile conflicts through initialized HCF. +Both local profiles receive valid addressed BAR from the opposite profile. +HCF must stop before receipt, reorder, inactivity, recovery, or response updates. +Malformed BAR and unaddressed BAR must not cause a profile conflict. +An active Compressed agreement rejects fragmented DATA before ACK and data-service callbacks. +A valid Compressed BAR without an agreement requests DELBA. A malformed BAR does not. +The fixture supplies an accepted agreement. It does not test ADDBA negotiation or wireless reception. +The separate Compressed exchange fixture tests negotiation and frame exchange. + +%extraargs: -r 0..1 + +%file: CompressedInput.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class InputAgreement : public RecipientBlockAckAgreement { + public: + int refreshes = 0; + using RecipientBlockAckAgreement::RecipientBlockAckAgreement; + void calculateExpirationTime() override { + refreshes++; + RecipientBlockAckAgreement::calculateExpirationTime(); + } +}; +class InputAgreements : public RecipientBlockAckAgreementHandler { + public: + int dataUpdates = 0; + InputAgreement *accept(MacAddress peer, BlockAckVariant variant) { + auto agreement = new InputAgreement(peer, 5, SequenceNumberCyclic(100), 64, SimTime(5, SIMTIME_MS)); + agreement->setVariant(variant); + agreement->addbaResposneSent(); + blockAckAgreements[{peer, 5}] = agreement; + return agreement; + } + void qosFrameReceived(const Ptr& header, IBlockAckAgreementHandlerCallback *callback) override { + dataUpdates++; + RecipientBlockAckAgreementHandler::qosFrameReceived(header, callback); + } +}; +class InputAckSpy : public IRecipientAckProcedure { + public: + IRecipientAckProcedure *delegate; + int calls = 0; + explicit InputAckSpy(IRecipientAckProcedure *delegate) : delegate(delegate) {} + ~InputAckSpy() override { delete delegate; } + void processReceivedFrame(Packet *packet, const Ptr& header, + IRecipientAckPolicy *policy, IProcedureCallback *callback) override { + calls++; + delegate->processReceivedFrame(packet, header, policy, callback); + } + void processTransmittedAck(const Ptr& header) override { + delegate->processTransmittedAck(header); + } +}; +class InputDataSpy : public IRecipientQosMacDataService { + public: + IRecipientQosMacDataService *delegate = nullptr; + int dataCalls = 0; + int controlCalls = 0; + int retireCalls = 0; + std::vector retireAgreement(RecipientBlockAckAgreement *agreement, bool reset) override { + retireCalls++; + return delegate->retireAgreement(agreement, reset); + } + void clearPeer(MacAddress peer) override { delegate->clearPeer(peer); } + std::vector dataFrameReceived(Packet *packet, const Ptr& header, + IRecipientBlockAckAgreementHandler *agreements, bool interframe = false) override { + dataCalls++; + return delegate->dataFrameReceived(packet, header, agreements, interframe); + } + std::vector controlFrameReceived(Packet *packet, const Ptr& header, + IRecipientBlockAckAgreementHandler *agreements) override { + controlCalls++; + return delegate->controlFrameReceived(packet, header, agreements); + } + std::vector managementFrameReceived(Packet *packet, const Ptr& header) override { + return delegate->managementFrameReceived(packet, header); + } +}; +class CompressedInputHcf : public Hcf { + protected: + InputDataSpy dataSpy; + InputAckSpy *ackSpy = nullptr; + InputAgreements *agreements = nullptr; + InputAgreement *accepted = nullptr; + BlockAckVariant localVariant = BlockAckVariant::BASIC; + int responses = 0; + int deliveries = 0; + int delbas = 0; + const MacAddress peer = MacAddress("02:00:00:00:00:02"); + const MacAddress absent = MacAddress("02:00:00:00:00:04"); + std::vector receiptSnapshot; + simtime_t expirationSnapshot; + + std::vector receipts() { + std::vector result; + auto record = accepted->getBlockAckRecord(); + for (int sequence = 100; sequence < 164; sequence++) { + if (localVariant == BlockAckVariant::COMPRESSED) + result.push_back(record->hasCompleteReceipt(SequenceNumberCyclic(sequence))); + else + for (int fragment = 0; fragment < 16; fragment++) + result.push_back(record->getAckState(SequenceNumberCyclic(sequence), fragment)); + } + return result; + } + void unchanged() { + ASSERT(agreements->getAgreement(5, peer) == accepted); + ASSERT(!agreements->isTeardownPending(peer, 5)); + ASSERT(accepted->refreshes == 0); + ASSERT(accepted->getExpirationTime() == expirationSnapshot); + ASSERT(accepted->getHighestReceivedSequence() == SequenceNumberCyclic(100)); + ASSERT(receipts() == receiptSnapshot); + if (localVariant == BlockAckVariant::COMPRESSED) + ASSERT(accepted->getBlockAckRecord()->getWindowStart() == SequenceNumberCyclic(100)); + ASSERT(inactivityTimer->isScheduled()); + ASSERT(inactivityTimer->getArrivalTime() == expirationSnapshot); + ASSERT(agreements->dataUpdates == 0); + ASSERT(dataSpy.dataCalls == 0 && dataSpy.controlCalls == 0 && dataSpy.retireCalls == 0); + ASSERT(ackSpy->calls == 0); + ASSERT(responses == 0 && deliveries == 0 && delbas == 0); + } + Ptr makeBar(bool compressed, MacAddress transmitter, bool addressed, + int fragment = 0, bool unsupported = false) { + Ptr bar; + if (unsupported) + bar = makeShared(); + else if (compressed) { + auto concrete = makeShared(); + concrete->setTidInfo(5); + concrete->setFragmentNumber(fragment); + concrete->setStartingSequenceNumber(SequenceNumberCyclic(101)); + bar = concrete; + } + else { + auto concrete = makeShared(); + concrete->setTidInfo(5); + concrete->setFragmentNumber(fragment); + concrete->setStartingSequenceNumber(SequenceNumberCyclic(101)); + bar = concrete; + } + bar->setTransmitterAddress(transmitter); + bar->setReceiverAddress(addressed ? mac->getAddress() : MacAddress("02:00:00:00:00:09")); + return bar; + } + void injectBar(bool compressed, MacAddress transmitter, bool addressed, bool conflict, + int fragment = 0, int extraBytes = 0, bool unsupported = false) { + auto bar = makeBar(compressed, transmitter, addressed, fragment, unsupported); + auto packet = new Packet("bar", bar); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + if (extraBytes) + packet->insertAtBack(makeShared(B(extraBytes))); + packet->insertAtBack(makeShared()); + bool caught = false; + try { + processLowerFrame(packet, bar); + } + catch (const cRuntimeError& error) { + // processLowerFrame takes the Packet before the exception. This wrapper owns its disposal. + take(packet); + delete packet; + std::string message = error.what(); + ASSERT(message.find("Block Ack profile conflict at ") == 0); + ASSERT(message.find("peer=" + peer.str() + " TID=5") != std::string::npos); + ASSERT(message.find(compressed ? "local=basic received=compressed" : "local=compressed received=basic") != std::string::npos); + caught = true; + } + ASSERT(caught == conflict); + } + void injectFragment(int fragment, bool more, AckPolicy policy) { + auto data = makeShared(); + data->setType(ST_DATA_WITH_QOS); + data->addChunkLength(QOSCONTROL_PART_LENGTH); + data->setTransmitterAddress(peer); + data->setReceiverAddress(mac->getAddress()); + data->setAddress3(peer); + data->setTid(5); + data->setAckPolicy(policy); + data->setSequenceNumber(SequenceNumberCyclic(101)); + data->setFragmentNumber(fragment); + data->setMoreFragments(more); + auto packet = new Packet("fragment", data); + packet->addTag()->setMode(modeSet->getMode(bps(6000000))); + packet->insertAtBack(makeShared(B(10))); + packet->insertAtBack(makeShared()); + processLowerFrame(packet, data); + } + void sendUp(const std::vector& frames) override { + deliveries += frames.size(); + for (auto frame : frames) { + take(frame); + delete frame; + } + } + void transmitControlResponseFrame(Packet *packet, const Ptr&, + Packet *, const Ptr&) override { + responses++; + delete packet; + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + auto delba = dynamicPtrCast(header); + ASSERT(delba && delba->getReceiverAddress() == absent && delba->getTid() == 5); + ASSERT(!delba->getInitiator() && delba->getReasonCode() == 38); + delbas++; + delete packet; + } + public: + void runChecks() { + Enter_Method("runChecks"); + localVariant = std::string(par("blockAckVariant").stringValue()) == "compressed" ? BlockAckVariant::COMPRESSED : BlockAckVariant::BASIC; + delete recipientBlockAckAgreementHandler; + agreements = new InputAgreements(); + recipientBlockAckAgreementHandler = agreements; + accepted = agreements->accept(peer, localVariant); + ackSpy = new InputAckSpy(recipientAckProcedure); + recipientAckProcedure = ackSpy; + dataSpy.delegate = recipientDataService; + recipientDataService = &dataSpy; + auto seed = makeShared(); + seed->setAckPolicy(BLOCK_ACK); + seed->setSequenceNumber(SequenceNumberCyclic(100)); + accepted->recordReceived(seed); + if (localVariant == BlockAckVariant::COMPRESSED) + accepted->getBlockAckRecord()->compressedFrameReceived(seed); + else + accepted->blockAckPolicyFrameReceived(seed); + receiptSnapshot = receipts(); + expirationSnapshot = accepted->getExpirationTime(); + scheduleInactivityTimer(); + unchanged(); + + bool oppositeCompressed = localVariant == BlockAckVariant::BASIC; + injectBar(oppositeCompressed, peer, true, true); + unchanged(); + injectBar(oppositeCompressed, peer, false, false); + unchanged(); + for (bool compressed : {false, true}) { + injectBar(compressed, peer, true, false, 1); + unchanged(); + injectBar(compressed, peer, true, false, 0, 1); + unchanged(); + injectBar(compressed, peer, true, false, 0, 0, true); + unchanged(); + injectBar(compressed, absent, true, false, 1); + unchanged(); + injectBar(compressed, absent, true, false, 0, 1); + unchanged(); + } + if (localVariant == BlockAckVariant::COMPRESSED) { + for (AckPolicy policy : {NORMAL_ACK, BLOCK_ACK}) { + injectFragment(0, true, policy); + unchanged(); + injectFragment(1, false, policy); + unchanged(); + } + } + injectBar(true, absent, true, false); + ASSERT(delbas == 1 && responses == 0 && deliveries == 0); + ASSERT(agreements->getAgreement(5, absent) == nullptr); + ASSERT(agreements->isTeardownPending(absent, 5)); + ASSERT(agreements->getAgreement(5, peer) == accepted); + ASSERT(receipts() == receiptSnapshot && accepted->refreshes == 0); + std::cout << "Compressed Block Ack input assertions passed.\n"; + } +}; +Define_Module(CompressedInputHcf); +class CompressedInputTest : public cSimpleModule { + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("test")); } + void handleMessage(cMessage *message) override { + delete message; + check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf"))->runChecks(); + endSimulation(); + } +}; +Define_Module(CompressedInputTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module CompressedInputHcf extends Hcf { parameters: @class(::inet::ieee80211::CompressedInputHcf); } +simple CompressedInputTest { parameters: @class(::inet::ieee80211::CompressedInputTest); } +network CompressedInputNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: CompressedInputTest; +} + +%inifile: omnetpp.ini +[General] +network = CompressedInputNetwork +ned-path = .;../../../../src +sim-time-limit = 2ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "CompressedInputHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = ${"basic", "compressed"} +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m + +%contains: stdout +Compressed Block Ack input assertions passed. diff --git a/tests/module/Ieee80211CompressedBlockAckInterframe_1.test b/tests/module/Ieee80211CompressedBlockAckInterframe_1.test new file mode 100644 index 00000000000..6d9a76be69d --- /dev/null +++ b/tests/module/Ieee80211CompressedBlockAckInterframe_1.test @@ -0,0 +1,542 @@ +%description: +Check Compressed interframe behavior through physical reception and HCF ACK completion. +The fixture supplies an accepted recipient agreement with four positions. It does not test negotiation. +A raw radio driver transmits HT DATA and receives real HCF responses. +The driver supplies no interframe relation flag to HCF or the data service. +Check SIFS, the exact tolerance boundary, a missing prior receipt, wrap, and unrelated traffic. +Check RIFS with an external HT waveform that omits the six-microsecond signal extension. +The external transmitter changes physical and analog duration together. It retains the actual HT mode and PHY length. +Check a default-extension RIFS control and a gap outside the RIFS tolerance. +Repeat each case with zero and five-microsecond propagation time. +After cache expiry, require the saved physical snapshot to retain the exact interval for a later transmission. + +%extraargs: -r 0..27 + +%file: Interframe.cc +#include +#include "inet/common/ProtocolTag_m.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h" +#include "inet/mobility/contract/IMobility.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/ITransmitterAnalogModel.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" + +namespace inet::ieee80211 { +using namespace physicallayer; + +class InterframeTransmitter : public Ieee80211Transmitter { + public: + const ITransmission *createTransmission(const IRadio *radio, const Packet *packet, simtime_t start) const override { + if (!packet->isName("first-no-extension")) + return Ieee80211Transmitter::createTransmission(radio, packet, start); + auto selected = computeTransmissionMode(packet); + auto phy = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(packet); + ASSERT(selected->getHtMcsIndex() == 0); + ASSERT(selected->getSignalExtensionTime() == SimTime(6, SIMTIME_US)); + auto duration = selected->getDuration(B(phy->getLengthField())) - SimTime(6, SIMTIME_US); + auto preamble = selected->getPreambleMode()->getDuration(); + auto header = selected->getHeaderMode()->getDuration(); + auto data = duration - preamble - header; + auto mobility = radio->getAntenna()->getMobility(); + auto position = mobility->getCurrentPosition(); + auto orientation = mobility->getCurrentAngularPosition(); + auto analog = getAnalogModel()->createAnalogModel(preamble, header, data, centerFrequency, + selected->getDataMode()->getBandwidth(), computeTransmissionPower(packet)); + return new Ieee80211Transmission(radio, packet, start, start + duration, preamble, header, data, + position, position, orientation, orientation, nullptr, nullptr, nullptr, nullptr, + analog, selected, computeTransmissionChannel(packet)); + } +}; +Define_Module(InterframeTransmitter); + +class InterframeReordering : public BlockAckReordering { + public: + ReceiveBuffer *find(MacAddress peer) const { + auto it = receiveBuffers.find({5, peer}); + return it == receiveBuffers.end() ? nullptr : it->second; + } +}; +class InterframeRecipient : public RecipientQosMacDataService { + protected: + void initialize() override { + RecipientQosMacDataService::initialize(); + delete blockAckReordering; + blockAckReordering = new InterframeReordering(); + } + public: + ReceiveBuffer *buffer(MacAddress peer) const { + return static_cast(blockAckReordering)->find(peer); + } +}; +Define_Module(InterframeRecipient); + +class InterframeJammer : public cSimpleModule { + public: + void start() { + Enter_Method("start"); + scheduleAfter(SimTime(1, SIMTIME_PS), new cMessage("busy")); + } + protected: + void handleMessage(cMessage *message) override { + delete message; + auto radio = check_and_cast(getParentModule()->getSubmodule("radio")); + radio->setRadioMode(IRadio::RADIO_MODE_TRANSMITTER); + auto header = makeShared(); + header->setReceiverAddress(MacAddress("02:00:00:00:00:09")); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:08")); + header->setDurationField(SIMTIME_ZERO); + auto packet = new Packet("busy-only", header); + auto fcs = makeShared(); + fcs->setFcsMode(FCS_DECLARED_CORRECT); + packet->insertAtBack(fcs); + auto catalog = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + const IIeee80211Mode *mode = nullptr; + for (int i = 0; i < catalog->getNumModes(); i++) { + auto candidate = catalog->getMode(i); + if (candidate->getHtMcsIndex() == 8 && !candidate->isHtShortGuardInterval() && + candidate->getDataMode()->getBandwidth() == MHz(20)) + mode = candidate; + } + ASSERT(mode && mode->getDataMode()->getNumberOfSpatialStreams() == 2); + packet->addTag()->setMode(mode); + packet->addTag()->setProtocol(&Protocol::ieee80211Mac); + send(packet, "out"); + } +}; +Define_Module(InterframeJammer); + +class InterframeAgreements : public RecipientBlockAckAgreementHandler { + public: + RecipientBlockAckAgreement *accept(MacAddress peer, int start) { + auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(start), 4, SIMTIME_ZERO); + agreement->setVariant(BlockAckVariant::COMPRESSED); + agreement->addbaResposneSent(); + blockAckAgreements[{peer, 5}] = agreement; + return agreement; + } +}; +class InterframeHcf : public Hcf { + public: + const MacAddress peer = MacAddress("02:00:00:00:00:02"); + InterframeRecipient *recipient = nullptr; + InterframeAgreements *agreements = nullptr; + RecipientBlockAckAgreement *accepted = nullptr; + std::vector delivered; + int ackCompletions = 0; + int ctsCompletions = 0; + int baCompletions = 0; + int physicalStarts = 0; + int busyStates = 0; + MacAddress address() const { return mac->getAddress(); } + void prepare(int start) { + Enter_Method("prepare"); + delete recipientBlockAckAgreementHandler; + agreements = new InterframeAgreements(); + recipientBlockAckAgreementHandler = agreements; + accepted = agreements->accept(peer, start); + recipient = check_and_cast(getSimulation()->getSystemModule()->getSubmodule("recipientProbe")); + recipientDataService = recipient; + } + void retireAndAcceptAgain(int start) { + Enter_Method("retireAndAcceptAgain"); + retireAgreement(peer, 5, false, true); + accepted = agreements->accept(peer, start); + // Supply prior receipt state independently of the previous agreement's physical ACK context. + auto seed = makeShared(); + seed->setSequenceNumber(SequenceNumberCyclic(start)); + accepted->recordReceived(seed); + accepted->getBlockAckRecord()->compressedFrameReceived(seed); + } + void check(int start, int scenario, bool report = true) { + Enter_Method("check"); + int first = (start + (scenario == 2 || scenario == 12 ? 1 : 0)) % 4096; + int last = (start + 4) % 4096; + int recordStart = (start + 1) % 4096; + bool related = scenario == 0 || scenario == 3 || scenario == 4 || scenario == 6 || scenario == 7; + auto record = accepted->getBlockAckRecord(); + ASSERT(record->getWindowStart() == SequenceNumberCyclic(recordStart)); + unsigned bitmap = 0; + for (int i = 0; i < 64; i++) + if (record->getCompressedAckState(SequenceNumberCyclic((recordStart + i) % 4096))) + bitmap |= 1u << i; + ASSERT(bitmap == (scenario == 2 || scenario == 12 ? 9u : 8u)); + auto buffer = recipient->buffer(peer); + ASSERT(buffer); + int expectedB = related ? (last + 1) % 4096 : scenario == 2 || scenario == 12 ? (start + 2) % 4096 : recordStart; + ASSERT(buffer->getNextExpectedSequenceNumber() == SequenceNumberCyclic(expectedB)); + ASSERT(buffer->getLength() == (related ? 0 : 1)); + std::vector expected = related ? std::vector{first, last} : std::vector{first}; + ASSERT(delivered == expected); + ASSERT(ackCompletions == (scenario >= 7 && scenario <= 9 ? 1 : 2)); + ASSERT(ctsCompletions == (scenario == 5 ? 1 : 0)); + ASSERT(baCompletions == (scenario == 12 ? 1 : 0)); + if (scenario == 13 && report) { + ASSERT(physicalStarts == 2); + ASSERT(busyStates > 0); + } + if (report) + std::cout << "Interframe scenario=" << scenario << " R=" << recordStart << " bitmap=" << bitmap + << " B=" << expectedB << " ACK=" << ackCompletions << " CTS=" << ctsCompletions << "\n"; + } + void checkNoPending() { + Enter_Method("checkNoPending"); + auto watch = dynamic_cast(findObject("numPendingInterframeReceptions", false)); + ASSERT(watch && watch->str() == "0"); + } + protected: + void sendUp(const std::vector& frames) override { + for (auto frame : frames) { + delivered.push_back(frame->peekAtFront()->getSequenceNumber().get()); + take(frame); + delete frame; + } + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (header->getType() == ST_ACK) + ackCompletions++; + if (header->getType() == ST_CTS) + ctsCompletions++; + if (header->getType() == ST_BLOCKACK) + baCompletions++; + Hcf::transmissionComplete(packet, header); + if (header->getType() == ST_ACK && ackCompletions == 1 && par("busyProbe").boolValue()) + check_and_cast(getSimulation()->getSystemModule()->getModuleByPath("jammerNode.jammer"))->start(); + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *details) override { + if (source == getParentModule()->getParentModule()->getSubmodule("radio") && signal == receptionStartedSignal) + physicalStarts++; + Hcf::receiveSignal(source, signal, object, details); + } + void receiveSignal(cComponent *source, simsignal_t signal, intval_t value, cObject *details) override { + if (source == getParentModule()->getParentModule()->getSubmodule("radio") && + signal == IRadio::receptionStateChangedSignal && value == IRadio::RECEPTION_STATE_BUSY) + busyStates++; + Hcf::receiveSignal(source, signal, value, details); + } +}; +Define_Module(InterframeHcf); + +class InterframeDriver : public cSimpleModule, public cListener { + protected: + InterframeHcf *receiver = nullptr; + Ieee80211Radio *radio = nullptr; + const IRadioMedium *medium = nullptr; + const IIeee80211Mode *ht = nullptr; + const Ieee80211ModeSet *catalog = nullptr; + int scenario = -1; + int start = 100; + int receivedAcks = 0; + bool finalSent = false; + TransmissionTimingSnapshot saved; + simtime_t initialAckArrival = -1; + bool snapshotVerified = false; + bool completed = false; + int malformedIndex = 0; + + void initialize() override { + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("start")); + } + void finish() override { ASSERT(completed); } + void scheduleFinal(simtime_t gap) { + scheduleAfter(gap, new cMessage("final")); + } + void sendFrame(const Ptr& header, const char *name, bool payload = false) { + header->setDurationField(SIMTIME_ZERO); + auto packet = new Packet(name, header); + if (payload) + packet->insertAtBack(makeShared(B(10))); + auto fcs = makeShared(); + fcs->setFcsMode(FCS_DECLARED_CORRECT); + packet->insertAtBack(fcs); + packet->addTag()->setProtocol(&Protocol::ieee80211Mac); + packet->addTag()->setMode(header->getType() == ST_RTS ? catalog->getMode(bps(6000000)) : ht); + send(packet, "out"); + } + void data(int sequence, const char *name, bool addressed = true, AckPolicy policy = NORMAL_ACK) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(addressed ? receiver->address() : MacAddress("02:00:00:00:00:09")); + header->setTransmitterAddress(receiver->peer); + header->setAddress3(receiver->peer); + header->setTid(5); + header->setSequenceNumber(SequenceNumberCyclic(sequence)); + header->setAckPolicy(policy); + sendFrame(header, name, true); + } + void sendMalformed() { + Ptr bar; + int kind = malformedIndex % 3; + if (kind == 2) + bar = makeShared(); + else { + auto compressed = makeShared(); + compressed->setStartingSequenceNumber(SequenceNumberCyclic((start + 2) % 4096)); + compressed->setTidInfo(5); + compressed->setFragmentNumber(kind == 0 ? 1 : 0); + bar = compressed; + } + bar->setTransmitterAddress(receiver->peer); + bar->setReceiverAddress(receiver->address()); + sendFrame(bar, "malformed-bar", kind == 1); + } + void receiveSignal(cComponent *, simsignal_t signal, cObject *object, cObject *) override { + Enter_Method_Silent(); + auto transmission = check_and_cast(object); + auto name = std::string(transmission->getPacket()->getName()); + if (signal == transmissionStartedSignal && name == "snapshot-probe") { + ASSERT(saved.transmissionId >= 0); + ASSERT(medium->getTransmission(saved.transmissionId) == nullptr); + ASSERT(medium->getTransmissionTimingSnapshot(saved.transmissionId).transmissionId == -1); + auto gap = medium->computePrecedingSignalGap(transmission->getId(), saved); + ASSERT(gap.has_value()); + ASSERT(*gap == transmission->getStartTime() - saved.arrivalEndTimes.at(radio->getId())); + snapshotVerified = true; + } + if (signal == transmissionEndedSignal && name == "unrelated") + scheduleFinal(catalog->getSifsTime() + (scenario == 11 ? SimTime::fromRaw(catalog->getSlotTime().raw() / 10 + 1) : SIMTIME_ZERO)); + if (signal == transmissionEndedSignal && (name == "first-no-extension" || name == "first-rifs-default")) { + auto extension = transmission->getSignalExtensionDuration(); + ASSERT(extension.has_value()); + ASSERT(*extension == (scenario == 8 ? SimTime(6, SIMTIME_US) : SIMTIME_ZERO)); + scheduleFinal(SimTime(2, SIMTIME_US) + (scenario == 9 ? SimTime(200001, SIMTIME_PS) : SIMTIME_ZERO)); + } + if (signal == transmissionEndedSignal && name == "snapshot-probe") + scheduleAfter(SimTime(20, SIMTIME_US), new cMessage("finish")); + if (signal == transmissionEndedSignal && name == "malformed-bar") { + auto propagation = getSimulation()->getSystemModule()->getSubmodule("radioMedium")->getSubmodule("propagation"); + scheduleAfter(SimTime(propagation->par("propagationTime").doubleValue()) + SimTime(1, SIMTIME_PS), + new cMessage("malformed-check")); + } + } + void handleMessage(cMessage *message) override { + if (!message->isSelfMessage()) { + auto packet = check_and_cast(message); + ASSERT(!packet->hasBitError()); + if (packet->isName("busy-only")) { + delete packet; + return; + } + auto header = packet->peekAtFront(); + if (header->getType() == ST_BLOCKACK) { + ASSERT(scenario == 12 && receivedAcks == 0); + scheduleAfter(catalog->getSifsTime(), new cMessage("first")); + } + else if (header->getType() == ST_CTS) { + ASSERT(scenario == 5 && receivedAcks == 1); + scheduleFinal(catalog->getSifsTime()); + } + else { + ASSERT(header->getType() == ST_ACK); + receivedAcks++; + if (receivedAcks == 1 && (scenario < 7 || scenario >= 10)) { + auto timing = packet->getTag(); + saved = medium->getTransmissionTimingSnapshot(timing->getTransmissionId()); + initialAckArrival = timing->getEndTime(); + ASSERT(initialAckArrival == simTime()); + if (scenario == 10) + receiver->retireAndAcceptAgain(start); + if (scenario == 4 || scenario == 11) + scheduleAfter(catalog->getSifsTime(), new cMessage("unrelated")); + else if (scenario == 5) + scheduleAfter(catalog->getSifsTime(), new cMessage("rts")); + else { + auto offset = scenario == 1 ? SimTime::fromRaw(catalog->getSlotTime().raw() / 10 + 1) : + scenario == 6 ? SimTime::fromRaw(catalog->getSlotTime().raw() / 10) : SIMTIME_ZERO; + scheduleFinal(catalog->getSifsTime() + offset); + } + } + else { + ASSERT(finalSent); + if (saved.transmissionId < 0) + saved = medium->getTransmissionTimingSnapshot(packet->getTag()->getTransmissionId()); + scheduleAfter(SimTime(2, SIMTIME_MS), new cMessage("snapshot")); + } + } + delete packet; + return; + } + std::string name = message->getName(); + delete message; + if (name == "start") { + receiver = check_and_cast(getSimulation()->getSystemModule()->getModuleByPath("receiver.wlan[0].mac.hcf")); + radio = check_and_cast(getParentModule()->getSubmodule("radio")); + medium = radio->getMedium(); + ASSERT(medium->getTransmission(0) == nullptr); + ASSERT(medium->getTransmissionTimingSnapshot(0).transmissionId == -1); + ASSERT(!medium->computePrecedingSignalGap(0, TransmissionTimingSnapshot()).has_value()); + radio->setRadioMode(IRadio::RADIO_MODE_TRANSCEIVER); + radio->subscribe(transmissionStartedSignal, this); + radio->subscribe(transmissionEndedSignal, this); + scenario = par("scenario"); + start = scenario == 3 ? 4094 : 100; + catalog = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + for (int i = 0; i < catalog->getNumModes(); i++) { + auto candidate = catalog->getMode(i); + if (candidate->getHtMcsIndex() == 0 && !candidate->isHtShortGuardInterval() && + candidate->getDataMode()->getBandwidth() == MHz(20)) + ht = candidate; + } + ASSERT(ht); + receiver->prepare(start); + bool rifs = scenario >= 7 && scenario <= 9; + if (scenario == 12) { + auto bar = makeShared(); + bar->setTransmitterAddress(receiver->peer); + bar->setReceiverAddress(receiver->address()); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(101)); + sendFrame(bar, "initial-bar"); + } + else + data((start + (scenario == 2 ? 1 : 0)) % 4096, + rifs ? scenario == 8 ? "first-rifs-default" : "first-no-extension" : "first", + true, rifs ? BLOCK_ACK : NORMAL_ACK); + } + else if (name == "first") + data(101, "first"); + else if (name == "final") { + finalSent = true; + data((start + 4) % 4096, "final"); + } + else if (name == "unrelated") + data(200, "unrelated", false); + else if (name == "rts") { + auto header = makeShared(); + header->setTransmitterAddress(receiver->peer); + header->setReceiverAddress(receiver->address()); + sendFrame(header, "rts"); + } + else if (name == "snapshot") { + receiver->check(start, scenario); + data(300, "snapshot-probe", false); + } + else if (name == "finish") { + ASSERT(snapshotVerified); + ASSERT(receivedAcks == (scenario >= 7 && scenario <= 9 ? 1 : 2)); + sendMalformed(); + } + else if (name == "malformed-check") { + receiver->checkNoPending(); + receiver->check(start, scenario, false); + malformedIndex++; + if (malformedIndex < 6) { + sendMalformed(); + return; + } + std::cout << "Compressed Block Ack interframe assertions passed.\n"; + completed = true; + endSimulation(); + } + } +}; +Define_Module(InterframeDriver); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.recipient.RecipientQosMacDataService; +import inet.mobility.static.StationaryMobility; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadio; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Transmitter; +module InterframeTransmitter extends Ieee80211Transmitter { parameters: @class(::inet::ieee80211::InterframeTransmitter); } +module InterframeRecipient extends RecipientQosMacDataService { parameters: @class(::inet::ieee80211::InterframeRecipient); } +module InterframeHcf extends Hcf { parameters: bool busyProbe; @class(::inet::ieee80211::InterframeHcf); } +simple InterframeJammer { + parameters: @class(::inet::ieee80211::InterframeJammer); + gates: output out; +} +simple InterframeDriver { + parameters: int scenario; @class(::inet::ieee80211::InterframeDriver); + gates: input in; output out; +} +module DriverNode { + parameters: @networkNode; + submodules: + mobility: StationaryMobility; + radio: Ieee80211ScalarRadio; + driver: InterframeDriver; + connections allowunconnected: + driver.out --> radio.upperLayerIn; + radio.upperLayerOut --> driver.in; +} +module JammerNode { + parameters: @networkNode; + submodules: + mobility: StationaryMobility; + radio: Ieee80211ScalarRadio; + jammer: InterframeJammer; + connections allowunconnected: + jammer.out --> radio.upperLayerIn; +} +network InterframeNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + receiver: WirelessHost; + driverNode: DriverNode; + jammerNode: JammerNode; + recipientProbe: InterframeRecipient; +} + +%inifile: omnetpp.ini +[General] +network = InterframeNetwork +ned-path = .;../../../../src +sim-time-limit = 10ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.driverNode.driver.scenario = ${scenario=0..13} +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = (${scenario} == 13 ? 100us : 0s) + ${propagation=0s,5us} +*.radioMedium.mediumLimitCache.maxTransmissionDuration = 1ms +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "InterframeHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "compressed" +*.receiver.wlan[0].mac.hcf.busyProbe = ${scenario} == 13 +*.receiver.wlan[0].radio.bandwidth = 20MHz +*.receiver.wlan[0].radio.antenna.numAntennas = 1 +*.receiver.wlan[0].radio.receiver.sensitivity = -70dBm +*.receiver.wlan[0].radio.receiver.energyDetection = -90dBm +*.jammerNode.radio.opMode = "n(mixed-2.4Ghz)" +*.jammerNode.radio.bandwidth = 20MHz +*.jammerNode.radio.transmitter.bitrate = 6.5Mbps +*.jammerNode.radio.transmitter.power = -40dBm +*.jammerNode.radio.antenna.numAntennas = 2 +*.jammerNode.radio.antenna.mobilityModule = "^.^.mobility" +*.driverNode.radio.opMode = "n(mixed-2.4Ghz)" +*.driverNode.radio.bandwidth = 20MHz +*.driverNode.radio.transmitter.typename = "InterframeTransmitter" +*.driverNode.radio.transmitter.bitrate = 6.5Mbps +*.driverNode.radio.antenna.mobilityModule = "^.^.mobility" +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 10m +**.mobility.constraintAreaMaxY = 10m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m +*.receiver.mobility.initialX = 0m +*.driverNode.mobility.initialX = 1m +*.jammerNode.mobility.initialX = 1m + +%contains: stdout +Compressed Block Ack interframe assertions passed. diff --git a/tests/module/Ieee80211CompressedBlockAckOriginator_1.test b/tests/module/Ieee80211CompressedBlockAckOriginator_1.test new file mode 100644 index 00000000000..10bac06324e --- /dev/null +++ b/tests/module/Ieee80211CompressedBlockAckOriginator_1.test @@ -0,0 +1,175 @@ +%description: +Check Compressed responses through the HCF control callback and real EDCAF state. +The fixture supplies accepted agreements and numbered frames with known ACK states. +The fixture supplies peer HT capabilities; it does not test capability negotiation. +An earlier response acknowledges a sent frame outside the current BAR wait. +Later and disjoint responses release every current BAR wait for retry. +Unsent frames, frames outside the active window, other peers, and other TIDs retain their state. +Cases use ordinary sequence numbers and wrap across 4095. +Scheduling_1 separately checks shifted responses through an active frame sequence. + +%extraargs: -r 0..5 + +%file: Originator.cc +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" + +namespace inet::ieee80211 { +class OriginatorAgreements : public OriginatorBlockAckAgreementHandler { + public: + OriginatorBlockAckAgreement *accept(MacAddress peer, int start) { + auto agreement = new OriginatorBlockAckAgreement(peer, 5, SequenceNumberCyclic(start), 64, false, false); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(SIMTIME_ZERO); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + return agreement; + } +}; +class OriginatorHcf : public Hcf { + public: + void check() { + Enter_Method("check"); + rx->setContentionBlocked(true); + const MacAddress peer("02:00:00:00:00:02"); + const MacAddress other("02:00:00:00:00:03"); + auto radio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + mib->setPeerHtCapabilities(peer, mib->localHtCapabilities, mib->getHtOperation()); + int start = par("start"); + int offset = par("offset"); + delete originatorBlockAckAgreementHandler; + auto agreements = new OriginatorAgreements(); + originatorBlockAckAgreementHandler = agreements; + auto agreement = agreements->accept(peer, start); + auto edcaf = edca->getEdcaf(AC_VI); + auto frames = edcaf->getInProgressFrames(); + auto ack = edcaf->getAckHandler(); + auto add = [&](MacAddress receiver, Tid tid, int position, bool sent) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(receiver); + header->setTransmitterAddress(mac->getAddress()); + header->setTid(tid); + header->setAckPolicy(BLOCK_ACK); + header->setSequenceNumber(SequenceNumberCyclic(start) + position); + auto packet = new Packet("supplied-data", header); + packet->insertAtBack(makeShared()); + frames->adoptPreparedFrame(packet); + if (sent) + ack->processTransmittedDataOrMgmtFrame(header); + return packet; + }; + auto earlier = add(peer, 5, 2, true); + auto earlierHeader = earlier->peekAtFront(); + auto requested = add(peer, 5, 4, true); + auto requestedHeader = requested->peekAtFront(); + auto unsent = add(peer, 5, 5, false); + auto outside = add(peer, 5, 64, true); + auto otherTid = add(peer, 6, 2, true); + auto otherPeer = add(other, 5, 2, true); + auto request = makeShared(); + request->setReceiverAddress(peer); + request->setTidInfo(5); + request->setStartingSequenceNumber(SequenceNumberCyclic(start) + 4); + ack->processTransmittedBlockAckReq(request, agreement); + ASSERT(ack->getQoSDataAckStatus(earlierHeader) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); + ASSERT(ack->getQoSDataAckStatus(requestedHeader) == QosAckHandler::Status::WAITING_FOR_BLOCK_ACK); + auto response = makeShared(); + response->setTransmitterAddress(peer); + response->setReceiverAddress(mac->getAddress()); + response->setTidInfo(5); + response->setStartingSequenceNumber(SequenceNumberCyclic(start) + offset); + BitVector bits; + for (int bit = 0; bit < 64; bit++) + bits.appendBit((offset == 0 && (bit == 2 || bit == 5)) || (offset == 6 && bit == 58) || offset == 100); + response->setBlockAckBitmap(bits); + auto packet = new Packet("supplied-response", response); + packet->insertAtBack(makeShared()); + originatorProcessReceivedControlFrame(packet, response, nullptr, request, AC_VI); + delete packet; + ASSERT(frames->containsFrame(earlier) == (offset != 0)); + if (offset != 0) + ASSERT(ack->getQoSDataAckStatus(earlierHeader) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); + ASSERT(frames->containsFrame(requested)); + ASSERT(ack->isEligibleToTransmit(requestedHeader)); + ASSERT(frames->containsFrame(unsent)); + ASSERT(ack->getQoSDataAckStatus(unsent->peekAtFront()) == QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED); + for (auto untouched : {outside, otherTid, otherPeer}) { + ASSERT(frames->containsFrame(untouched)); + ASSERT(ack->getQoSDataAckStatus(untouched->peekAtFront()) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); + } + ASSERT(frames->getLength() == (offset == 0 ? 5 : 6)); + std::cout << "Compressed HCF originator assertions passed.\n"; + endSimulation(); + } +}; +Define_Module(OriginatorHcf); +class OriginatorTest : public cSimpleModule { + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("check")); } + void handleMessage(cMessage *message) override { + delete message; + check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf"))->check(); + } +}; +Define_Module(OriginatorTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module OriginatorHcf extends Hcf { + parameters: + int start; + int offset; + @class(::inet::ieee80211::OriginatorHcf); +} +simple OriginatorTest { parameters: @class(::inet::ieee80211::OriginatorTest); } +network OriginatorNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; + test: OriginatorTest; +} + +%inifile: omnetpp.ini +[General] +network = OriginatorNetwork +ned-path = .;../../../../src +sim-time-limit = 10ms +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +**.wlan[*].agent.typename = "" +**.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].bitrate = 6Mbps +**.wlan[*].radio.channelNumber = 0 +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "OriginatorHcf" +**.wlan[*].mac.hcf.blockAckVariant = "compressed" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.start = ${start=100,4094} +**.wlan[*].mac.hcf.offset = ${offset=0,6,100} +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +**.mobility.initialX = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Compressed HCF originator assertions passed. diff --git a/tests/module/Ieee80211HcfMultipleProtection_2.test b/tests/module/Ieee80211HcfMultipleProtection_2.test index 1d278478756..bd2ef75b3d2 100644 --- a/tests/module/Ieee80211HcfMultipleProtection_2.test +++ b/tests/module/Ieee80211HcfMultipleProtection_2.test @@ -2,8 +2,11 @@ Exercise the existing immediate Basic Block Ack exchange through HCF. Check zero-limit RTS estimates with an absent agreement, a Block Ack agreement, AARF query effects, and a deterministic rate decrease. Check response conversion at Tx. +Retain all seven existing scenarios. Add Compressed exchanges with positive and zero TXOP limits. +Repeat negative and fractional Duration/ID conversion with the 32-byte Compressed response. +The Compressed cases supply valid HT peer state and accepted agreements where the exchange requires them. -%extraargs: -r 0..6 +%extraargs: -r 0..9 %file: ProtectionRates.cc #include "inet/common/packet/chunk/ByteCountChunk.h" @@ -16,6 +19,8 @@ AARF query effects, and a deterministic rate decrease. Check response conversion #include "inet/linklayer/ieee80211/mac/ratecontrol/RateControlBase.h" #include "inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" namespace inet::ieee80211 { class RateProtectionRx : public Rx { @@ -41,14 +46,17 @@ class SeededOriginator : public OriginatorBlockAckAgreementHandler { }; class SeededRecipient : public RecipientBlockAckAgreementHandler { public: - void seed(const MacAddress& peer) { + void seed(const MacAddress& peer, bool compressed = false) { auto request = makeShared(); request->setTransmitterAddress(peer); request->setTid(5); request->setStartingSequenceNumber(SequenceNumberCyclic(0)); request->setBufferSize(64); request->setBlockAckTimeoutValue(0); - addAgreement(request)->addbaResposneSent(); + auto agreement = addAgreement(request); + if (compressed) + agreement->setVariant(BlockAckVariant::COMPRESSED); + agreement->addbaResposneSent(); } }; @@ -88,6 +96,8 @@ class RateProtectionMac : public Ieee80211Mac { std::vector ends; std::vector durations; std::vector rates; + std::vector lengths; + std::vector compressedFrames; bool suppressed = false; void sendDownFrame(Packet *packet) override { auto header = packet->peekAtFront(); @@ -97,6 +107,9 @@ class RateProtectionMac : public Ieee80211Mac { ends.push_back(simTime() + mode->getDuration(packet->getDataLength())); durations.push_back(header->getDurationField()); rates.push_back(mode->getDataMode()->getNetBitrate()); + lengths.push_back(packet->getDataLength()); + compressedFrames.push_back(bool(dynamicPtrCast(header)) || + bool(dynamicPtrCast(header))); Ieee80211Mac::sendDownFrame(packet); } protected: @@ -126,11 +139,21 @@ class RateProtectionHcf : public Hcf { handler->seed(MacAddress("02:00:00:00:00:02")); originatorBlockAckAgreementHandler = handler; } - void seedRecipient() { + void seedHtPeer(MacAddress peer) { + Enter_Method("seedHtPeer"); + ASSERT(mib->isHtOperationSupported() && mib->localHtCapabilitiesValid); + auto radio = check_and_cast(getParentModule()->getParentModule()->getSubmodule("radio")); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + mib->setPeerHtCapabilities(peer, mib->localHtCapabilities, mib->getHtOperation()); + ASSERT(mib->findPeerHtState(peer) && mib->findPeerHtState(peer)->valid); + } + void seedRecipient(bool compressed = false) { Enter_Method("seedRecipient"); delete recipientBlockAckAgreementHandler; auto handler = new SeededRecipient(); - handler->seed(MacAddress("02:00:00:00:00:01")); + handler->seed(MacAddress("02:00:00:00:00:01"), compressed); recipientBlockAckAgreementHandler = handler; } void inject(int payload = 66, bool fragment = false) { @@ -148,21 +171,40 @@ class RateProtectionHcf : public Hcf { packet->insertAtBack(makeShared()); processUpperFrame(packet, header); } - void sendSyntheticBlockAck(simtime_t calculatedField) { + void sendSyntheticBlockAck(simtime_t calculatedField, bool compressed = false) { Enter_Method("sendSyntheticBlockAck"); - auto request = makeShared(); + Ptr request = compressed ? Ptr(makeShared()) : + Ptr(makeShared()); + if (compressed) { + auto bar = dynamicPtrCast(request); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(0)); + } request->setTransmitterAddress(MacAddress("02:00:00:00:00:07")); request->setReceiverAddress(mac->getAddress()); auto received = new Packet("synthetic-bar", request); auto mode = modeSet->getMode(bps(6000000)); setFrameMode(received, request, mode); - auto updatedRequest = received->removeAtFront(); - updatedRequest->setDurationField(calculatedField + modeSet->getSifsTime() + mode->getDuration(LENGTH_BASIC_BLOCKACK)); + auto updatedRequest = received->removeAtFront(); + updatedRequest->setDurationField(calculatedField + modeSet->getSifsTime() + + mode->getDuration(compressed ? LENGTH_COMPRESSED_BLOCKACK : LENGTH_BASIC_BLOCKACK)); received->insertAtFront(updatedRequest); request = updatedRequest; - auto response = makeShared(); + Ptr response; + if (compressed) { + auto ba = makeShared(); + ba->setTidInfo(5); + ba->setStartingSequenceNumber(SequenceNumberCyclic(0)); + ba->setBlockAckBitmap(BitVector(0u, 64)); + response = ba; + } + else + response = makeShared(); response->setReceiverAddress(request->getTransmitterAddress()); - response->setDurationField(recipientAckPolicy->computeBasicBlockAckDurationField(received, request)); + response->setDurationField(compressed ? recipientAckPolicy->computeCompressedBlockAckDurationField(received, + dynamicPtrCast(request)) : + recipientAckPolicy->computeBasicBlockAckDurationField(received, + dynamicPtrCast(request))); auto packet = new Packet("synthetic-block-ack", response); Hcf::transmitControlResponseFrame(packet, response, received, request); delete received; @@ -199,17 +241,25 @@ class RateProtectionTest : public cSimpleModule { auto receiver = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.hcf")); auto senderMac = check_and_cast(getModuleByPath("^.sender.wlan[0].mac")); auto receiverMac = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac")); - int scenario = senderMac->par("scenario"); + int configuredScenario = senderMac->par("scenario"); + bool compressed = configuredScenario >= 7; + int scenario = configuredScenario == 7 ? 0 : configuredScenario == 8 ? 1 : configuredScenario == 9 ? 5 : configuredScenario; + if (compressed) { + sender->seedHtPeer(MacAddress("02:00:00:00:00:02")); + receiver->seedHtPeer(MacAddress("02:00:00:00:00:01")); + } if (scenario == 0 || scenario == 1) { sender->seedOriginator(); - receiver->seedRecipient(); + receiver->seedRecipient(compressed); } if (scenario == 2 || scenario == 3) check_and_cast(getModuleByPath("^.sender.wlan[0].mac.hcf.rateControl"))->seedPeer(); if (scenario == 5) { - receiver->sendSyntheticBlockAck(SimTime(-10, SIMTIME_US)); + if (compressed) + receiver->seedHtPeer(MacAddress("02:00:00:00:00:07")); + receiver->sendSyntheticBlockAck(SimTime(-10, SIMTIME_US), compressed); wait(SimTime(300, SIMTIME_US)); - receiver->sendSyntheticBlockAck(SimTime(31.2e-6)); + receiver->sendSyntheticBlockAck(SimTime(31.2e-6), compressed); } else { sender->inject(66, scenario == 6); @@ -223,6 +273,19 @@ class RateProtectionTest : public cSimpleModule { ASSERT(sender->managementAcknowledgments == 1); ASSERT(std::find(senderMac->types.begin(), senderMac->types.end(), ST_BLOCKACK_REQ) != senderMac->types.end()); ASSERT(receiverMac->types[0] == ST_CTS); + if (compressed) { + for (size_t i = 0; i < senderMac->types.size(); i++) + if (senderMac->types[i] == ST_BLOCKACK_REQ) { + ASSERT(senderMac->compressedFrames[i]); + ASSERT(senderMac->lengths[i] == B(24)); + } + for (size_t i = 0; i < receiverMac->types.size(); i++) + if (receiverMac->types[i] == ST_BLOCKACK) { + ASSERT(receiverMac->compressedFrames[i]); + ASSERT(receiverMac->lengths[i] == B(32)); + ASSERT(receiverMac->rates[i] == bps(6000000)); + } + } auto firstRtsEndpoint = senderMac->ends[0] + senderMac->durations[0]; if (scenario == 1) { ASSERT(firstRtsEndpoint - senderMac->starts[0] == SimTime(280, SIMTIME_US)); @@ -272,6 +335,12 @@ class RateProtectionTest : public cSimpleModule { ASSERT(receiverMac->types.size() == 2); ASSERT(receiverMac->durations[0] == 0); ASSERT(receiverMac->durations[1] == SimTime(32, SIMTIME_US)); + if (compressed) + for (size_t i = 0; i < 2; i++) { + ASSERT(receiverMac->compressedFrames[i]); + ASSERT(receiverMac->lengths[i] == B(32)); + ASSERT(receiverMac->rates[i] == bps(6000000)); + } } if (scenario == 6) { ASSERT(senderMac->types.size() == 2); @@ -279,7 +348,10 @@ class RateProtectionTest : public cSimpleModule { ASSERT(senderMac->ends[0] + senderMac->durations[0] - senderMac->starts[0] == SimTime(340, SIMTIME_US)); ASSERT(sender->acknowledgments == 1); } - std::cout << "Basic Block Ack, response conversion, and rate estimates passed.\n"; + if (compressed) + std::cout << "Compressed Block Ack protection and response duration checks passed.\n"; + else + std::cout << "Basic Block Ack, response conversion, and rate estimates passed.\n"; } }; Define_Module(RateProtectionTest); @@ -341,20 +413,22 @@ record-scalar-results = false *.radioMedium.propagation.propagationTime = 0s **.wlan[*].agent.typename = "" **.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" -**.wlan[*].opMode = "a" +**.wlan[*].opMode = ${scenario} >= 7 ? "ac" : "a" +**.bandName = ${scenario} >= 7 ? "5 GHz (mapped 20 MHz)" : "2.4 GHz" +**.centerFrequency = ${scenario} >= 7 ? 5.18GHz : 2.412GHz **.wlan[*].bitrate = 6Mbps **.wlan[*].mac.typename = "RateProtectionMac" -**.wlan[*].mac.scenario = ${scenario=0..6} +**.wlan[*].mac.scenario = ${scenario=0..9} **.wlan[*].mac.qosStation = true **.wlan[*].mac.rx.typename = "RateProtectionRx" **.wlan[*].mac.hcf.typename = "RateProtectionHcf" -**.wlan[*].mac.hcf.isBlockAckSupported = ${scenario} == 0 || ${scenario} == 1 || ${scenario} == 5 -**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.isBlockAckSupported = ${scenario} == 0 || ${scenario} == 1 || ${scenario} == 5 || ${scenario} >= 7 +**.wlan[*].mac.hcf.blockAckVariant = ${scenario} >= 7 ? "compressed" : "basic" **.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" **.wlan[*].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "" **.wlan[*].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 1 **.wlan[*].mac.hcf.originatorAckPolicy.maxBlockAckPolicyFrameLength = 4096B -*.sender.wlan[0].mac.hcf.rateControl.typename = ${rateControl="","","TraceAarf","TraceAarf","DecreaseRateControl","","" ! scenario} +*.sender.wlan[0].mac.hcf.rateControl.typename = ${rateControl="","","TraceAarf","TraceAarf","DecreaseRateControl","","","","","" ! scenario} *.sender.wlan[0].mac.hcf.rateControl.initialRate = 6Mbps *.sender.wlan[0].mac.hcf.rateControl.interval = 100us **.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = ${scenario} >= 2 && ${scenario} <= 4 ? -1bps : 6Mbps @@ -365,7 +439,7 @@ record-scalar-results = false **.wlan[*].mac.hcf.rtsPolicy.rtsThreshold = 0B **.wlan[*].mac.hcf.edca.edcaf[*].cwMin = 0 **.wlan[*].mac.hcf.edca.edcaf[*].cwMax = 0 -**.wlan[*].mac.hcf.edca.edcaf[*].txopProcedure.txopLimit = ${scenario} == 0 ? 1024us : 0s +**.wlan[*].mac.hcf.edca.edcaf[*].txopProcedure.txopLimit = ${scenario} == 0 || ${scenario} == 7 ? 1024us : 0s *.sender.wlan[0].mac.hcf.edca.edcaf[*].txopProcedure.protectionMechanism = "multiple" *.sender.wlan[0].address = "02:00:00:00:00:01" *.receiver.wlan[0].address = "02:00:00:00:00:02" @@ -386,3 +460,6 @@ record-scalar-results = false %contains: stdout Basic Block Ack, response conversion, and rate estimates passed. + +%contains: stdout +Compressed Block Ack protection and response duration checks passed. diff --git a/tests/module/Ieee80211RecipientNav_1.test b/tests/module/Ieee80211RecipientNav_1.test index c4812c86883..bb8a4008e40 100644 --- a/tests/module/Ieee80211RecipientNav_1.test +++ b/tests/module/Ieee80211RecipientNav_1.test @@ -5,8 +5,10 @@ Retain received NAV refusal and DCF local NAV updates for holder frames. Require zero HCF local NAV updates for holder frames. Check a Basic Block Ack response after an ADDBA exchange through production HCF. Require its positive Duration/ID field without a local NAV update. +Repeat the response checks with Compressed and valid supplied HT peer state. +The Compressed case uses a 32-byte response MPDU and retains the same NAV invariant. -%extraargs: -r 0..2 +%extraargs: -r 0..3 %file: RecipientNav.cc #include "inet/common/packet/chunk/ByteCountChunk.h" @@ -14,6 +16,8 @@ Require its positive Duration/ID field without a local NAV update. #include "inet/linklayer/ieee80211/mac/Rx.h" #include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" namespace inet::ieee80211 { class RecipientNavRx : public Rx { @@ -32,6 +36,9 @@ class RecipientNavMac : public Ieee80211Mac { std::vector durations; simtime_t addbaResponseEnd = -1; Ptr basicBlockAck; + Ptr compressedBlockAck; + units::values::b blockAckLength; + const physicallayer::IIeee80211Mode *blockAckMode = nullptr; void sendDownFrame(Packet *packet) override { auto header = packet->peekAtFront(); types.push_back(header->getType()); @@ -43,6 +50,11 @@ class RecipientNavMac : public Ieee80211Mac { } if (auto response = dynamicPtrCast(header)) basicBlockAck = response; + if (auto response = dynamicPtrCast(header)) { + compressedBlockAck = response; + blockAckLength = packet->getDataLength(); + blockAckMode = packet->getTag()->getMode(); + } Ieee80211Mac::sendDownFrame(packet); } void injectBlockAckSetup() { @@ -58,12 +70,33 @@ class RecipientNavMac : public Ieee80211Mac { request->setStartingSequenceNumber(SequenceNumberCyclic(0)); injectBlockAckFrame(request); } - void injectBlockAckRequest() { + void prepareCompressedPeer() { + Enter_Method("prepareCompressedPeer"); + const MacAddress peer("02:00:00:00:00:02"); + ASSERT(mib->isHtOperationSupported() && mib->localHtCapabilitiesValid); + auto radio = check_and_cast(getParentModule()->getSubmodule("radio")); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + mib->setPeerHtCapabilities(peer, mib->localHtCapabilities, mib->getHtOperation()); + ASSERT(mib->findPeerHtState(peer) && mib->findPeerHtState(peer)->valid); + } + void injectBlockAckRequest(bool compressed = false) { Enter_Method("injectBlockAckRequest"); - auto request = makeShared(); + Ptr request; + if (compressed) { + auto bar = makeShared(); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(0)); + request = bar; + } + else { + auto bar = makeShared(); + bar->setTidInfo(5); + bar->setStartingSequenceNumber(SequenceNumberCyclic(0)); + request = bar; + } request->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); - request->setTidInfo(5); - request->setStartingSequenceNumber(SequenceNumberCyclic(0)); request->setDurationField(SimTime(500, SIMTIME_US)); injectBlockAckFrame(request); } @@ -77,7 +110,7 @@ class RecipientNavMac : public Ieee80211Mac { header->setReceiverAddress(getAddress()); auto packet = new Packet("received-block-ack-exchange", header); packet->addTag()->setMode( - physicallayer::Ieee80211ModeSet::getModeSet("a")->getMode(bps(6000000))); + physicallayer::Ieee80211ModeSet::getModeSet(mib->isHtOperationSupported() ? "n(mixed-2.4Ghz)" : "a")->getMode(bps(6000000))); auto trailer = makeShared(); trailer->setFcsMode(FCS_DECLARED_CORRECT); packet->insertAtBack(trailer); @@ -140,8 +173,10 @@ class RecipientNavTest : public cSimpleModule { public: RecipientNavTest() : cSimpleModule(65536) {} protected: - void checkBasicBlockAck(RecipientNavMac *mac, RecipientNavRx *rx) { - auto mode = physicallayer::Ieee80211ModeSet::getModeSet("a")->getMode(bps(6000000)); + void checkBlockAck(RecipientNavMac *mac, RecipientNavRx *rx, bool compressed) { + auto mode = physicallayer::Ieee80211ModeSet::getModeSet(compressed ? "n(mixed-2.4Ghz)" : "a")->getMode(bps(6000000)); + if (compressed) + mac->prepareCompressedPeer(); mac->injectBlockAckSetup(); for (int i = 0; i < 100 && mac->addbaResponseEnd < SIMTIME_ZERO; i++) wait(SimTime(10, SIMTIME_US)); @@ -154,27 +189,40 @@ class RecipientNavTest : public cSimpleModule { ASSERT(rx->isMediumFree()); auto updatesBeforeResponse = rx->localUpdates; auto framesBeforeResponse = mac->types.size(); - mac->injectBlockAckRequest(); + mac->injectBlockAckRequest(compressed); wait(SimTime(350, SIMTIME_US)); ASSERT(mac->types.size() == framesBeforeResponse + 1); - ASSERT(mac->basicBlockAck != nullptr); - ASSERT(mac->basicBlockAck->getReceiverAddress() == MacAddress("02:00:00:00:00:02")); - ASSERT(mac->basicBlockAck->getTidInfo() == 5); - ASSERT(mac->basicBlockAck->getStartingSequenceNumber() == SequenceNumberCyclic(0)); + Ptr response; + if (compressed) { + ASSERT(mac->compressedBlockAck != nullptr && mac->basicBlockAck == nullptr); + ASSERT(mac->compressedBlockAck->getTidInfo() == 5); + ASSERT(mac->compressedBlockAck->getStartingSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(mac->compressedBlockAck->getBlockAckBitmap().getSize() == 64); + ASSERT(mac->blockAckLength == B(32)); + ASSERT(mac->blockAckMode == mode && mac->blockAckMode->getHtMcsIndex() < 0); + response = mac->compressedBlockAck; + } + else { + ASSERT(mac->basicBlockAck != nullptr); + ASSERT(mac->basicBlockAck->getTidInfo() == 5); + ASSERT(mac->basicBlockAck->getStartingSequenceNumber() == SequenceNumberCyclic(0)); + response = mac->basicBlockAck; + } + ASSERT(response->getReceiverAddress() == MacAddress("02:00:00:00:00:02")); // IEEE Std 802.11-2024, 9.2.5.6: subtract SIFS and response airtime from the request duration. - auto expectedDuration = SimTime(500, SIMTIME_US) - mode->getSifsTime() - mode->getDuration(LENGTH_BASIC_BLOCKACK); + auto expectedDuration = SimTime(500, SIMTIME_US) - mode->getSifsTime() - mode->getDuration(compressed ? LENGTH_COMPRESSED_BLOCKACK : LENGTH_BASIC_BLOCKACK); ASSERT(expectedDuration > SIMTIME_ZERO); - ASSERT(mac->basicBlockAck->getDurationField() == expectedDuration); + ASSERT(response->getDurationField() == expectedDuration); ASSERT(rx->localUpdates == updatesBeforeResponse); ASSERT(rx->isMediumFree()); - std::cout << "Basic Block Ack recipient NAV checks passed.\n"; + std::cout << (compressed ? "Compressed" : "Basic") << " Block Ack recipient NAV checks passed.\n"; } void activity() override { wait(SimTime(1, SIMTIME_MS)); auto mac = check_and_cast(getModuleByPath("^.host.wlan[0].mac")); auto rx = check_and_cast(mac->getSubmodule("rx")); - if (par("basicBlockAckOnly").boolValue()) { - checkBasicBlockAck(mac, rx); + if (par("basicBlockAckOnly").boolValue() || par("compressedBlockAckOnly").boolValue()) { + checkBlockAck(mac, rx, par("compressedBlockAckOnly").boolValue()); std::cout << "Recipient NAV production checks passed.\n"; return; } @@ -231,6 +279,7 @@ simple RecipientNavRx extends Rx { simple RecipientNavTest extends SimpleModule { parameters: bool basicBlockAckOnly = default(false); + bool compressedBlockAckOnly = default(false); @class(::inet::ieee80211::RecipientNavTest); } network RecipientNavNetwork { @@ -251,14 +300,15 @@ record-vector-results = false record-scalar-results = false **.wlan[*].agent.typename = "" **.wlan[*].mgmt.typename = "Ieee80211MgmtAdhoc" -**.wlan[*].opMode = "a" +**.wlan[*].opMode = ${scenario} == "compressedBlockAck" ? "n(mixed-2.4Ghz)" : "a" **.wlan[*].bitrate = 6Mbps **.wlan[*].mac.typename = "RecipientNavMac" -**.wlan[*].mac.qosStation = ${scenario="hcf","dcf","blockAck"} != "dcf" +**.wlan[*].mac.qosStation = ${scenario="hcf","dcf","blockAck","compressedBlockAck"} != "dcf" **.wlan[*].mac.rx.typename = "RecipientNavRx" -**.wlan[*].mac.hcf.isBlockAckSupported = ${scenario} == "blockAck" -**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.isBlockAckSupported = ${scenario} == "blockAck" || ${scenario} == "compressedBlockAck" +**.wlan[*].mac.hcf.blockAckVariant = ${scenario} == "compressedBlockAck" ? "compressed" : "basic" *.test.basicBlockAckOnly = ${scenario} == "blockAck" +*.test.compressedBlockAckOnly = ${scenario} == "compressedBlockAck" **.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" **.wlan[*].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "" **.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 6Mbps @@ -287,3 +337,6 @@ Recipient NAV production checks passed. %contains: stdout Basic Block Ack recipient NAV checks passed. + +%contains: stdout +Compressed Block Ack recipient NAV checks passed. diff --git a/tests/protocol/wifi/11ac/Ac_BlockAck.test b/tests/protocol/wifi/11ac/Ac_BlockAck.test index eeaa886371b..cd274cf2543 100644 --- a/tests/protocol/wifi/11ac/Ac_BlockAck.test +++ b/tests/protocol/wifi/11ac/Ac_BlockAck.test @@ -1,13 +1,19 @@ %description: 802.11ac Block Ack session: ADDBA action (type 13), BlockAckReq (type 24), BlockAck (type 25). [Required] +Check explicit Basic and Compressed with concrete BAR/BA types and positive receipt bits. + +%extraargs: -r 0..1 %file: Ac_BlockAck.cc #include "ProtocolTest.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" namespace inet { namespace protocoltest { +using namespace inet::ieee80211; + // Block Ack session on 11ac: STA sends ADDBA Request (type 13), // then BlockAckReq (type 24), AP replies with BlockAck (type 25). Define_ProtocolTest(wifi_11ac_block_ack) @@ -18,21 +24,63 @@ Define_ProtocolTest(wifi_11ac_block_ack) .describe("ADDBA action frame from sta1").within(2.5)) .once(on("sta1.wlan[0].mac").signal("packetSentToLower") .filterPacket("ieee80211mac.type == 24") + .filterEvent([](const MatchContext& c) { + return c.event.packet && c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + }) .describe("BlockAckReq from sta1").within(1.0)) .once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") .filterPacket("ieee80211mac.type == 25") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto ba = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + if (!ba) return false; + for (int i = 0; i < 64; i++) + for (unsigned int j = 0; j < ba->getBlockAckBitmap(i).getSize(); j++) + if (ba->getBlockAckBitmap(i).getBit(j)) return true; + return false; + }) .describe("BlockAck received at sta1").within(0.02)); } +Define_ProtocolTest(wifi_11ac_compressed_exchange) +{ + return ProtocolTest("wifi_11ac_compressed_exchange") + .once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") + .filterPacket("ieee80211mac.type == 13") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto response = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + return response && response->getStatusCode() == 0 && response->getBlockAckPolicy(); + }) + .describe("successful immediate ADDBA response").within(2.5)) + .once(on("sta1.wlan[0].mac").signal("packetSentToLower") + .filterPacket("ieee80211mac.type == 24") + .filterEvent([](const MatchContext& c) { + return c.event.packet && c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + }) + .describe("Compressed BAR from sta1").within(1.0)) + .once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") + .filterPacket("ieee80211mac.type == 25") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto ba = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + if (!ba) return false; + for (unsigned int i = 0; i < ba->getBlockAckBitmap().getSize(); i++) + if (ba->getBlockAckBitmap().getBit(i)) return true; + return false; + }) + .describe("Compressed Block Ack with positive receipt evidence").within(0.02)); +} + } // namespace protocoltest } // namespace inet %inifile: test.ini [General] -*.tester.testName = "wifi_11ac_block_ack" +*.tester.testName = ${test="wifi_11ac_block_ack","wifi_11ac_compressed_exchange"} *.sta*.wlan[*].mac.hcf.isBlockAckSupported = true -**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.blockAckVariant = ${profile="basic","compressed" ! test} *.ap.wlan[*].mac.hcf.isBlockAckSupported = true *.sta*.wlan[*].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 5 *.sta1.app[0].sendInterval = 0.1ms @@ -50,3 +98,6 @@ include ../../ini/_base.ini %contains: stdout PROTOCOLTEST wifi_11ac_block_ack: PASS + +%contains: stdout +PROTOCOLTEST wifi_11ac_compressed_exchange: PASS diff --git a/tests/protocol/wifi/11ac/Ac_BlockAckFallback.test b/tests/protocol/wifi/11ac/Ac_BlockAckFallback.test new file mode 100644 index 00000000000..dd86abc74e5 --- /dev/null +++ b/tests/protocol/wifi/11ac/Ac_BlockAckFallback.test @@ -0,0 +1,186 @@ +%description: +Check runtime Compressed fallback under a controlled peer HT capability gap. +Simplified management supplies static association and valid HT state after initialization. +Before DATA, the fixture removes peer HT records at both ends of both wireless hops. +The fixture retains association, local HT support, ac operation, and Compressed Block Ack support. +During traffic, require delivered Normal Ack QoS DATA without ADDBA, BAR, or Block Ack. +Check absent peer HT records during traffic and at the final audit. +This fixture does not establish an on-air association exchange or a limitation of all ac stations. + +%file: Ac_BlockAckFallback.cc +#include "ProtocolTest.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" + +namespace inet::protocoltest { +using namespace inet::ieee80211; + +class FallbackHcf : public Hcf { + public: + bool hasNoAgreements() const { + return originatorBlockAckAgreementHandler->getAgreements().empty() && + recipientBlockAckAgreementHandler->getAgreements().empty(); + } +}; +Define_Module(FallbackHcf); + +class BlockAckFallbackAudit : public cSimpleModule, public cListener { + protected: + Ieee80211Mib *ap = nullptr; + Ieee80211Mib *sta1 = nullptr; + Ieee80211Mib *sta2 = nullptr; + std::vector hcfs; + std::map macs; + bool removed = false; + bool completed = false; + int delivered = 0; + int sentFirstHop = 0; + int receivedFirstHop = 0; + int sentSecondHop = 0; + int receivedSecondHop = 0; + simsignal_t sentSignal; + simsignal_t receivedSignal; + simsignal_t appSignal; + + void checkAssociation() const { + for (auto sta : {sta1, sta2}) { + ASSERT(sta->bssStationData.isAssociated); + ASSERT(sta->bssData.bssid == ap->address); + auto it = ap->bssAccessPointData.stations.find(sta->address); + ASSERT(it != ap->bssAccessPointData.stations.end() && it->second == Ieee80211Mib::ASSOCIATED); + } + for (auto mib : {ap, sta1, sta2}) + ASSERT(mib->isHtOperationSupported() && mib->localHtCapabilitiesValid); + for (auto hcf : hcfs) { + ASSERT(hcf->par("isBlockAckSupported").boolValue()); + ASSERT(std::string(hcf->par("blockAckVariant").stringValue()) == "compressed"); + ASSERT(hcf->hasNoAgreements()); + } + } + void checkGap() const { + checkAssociation(); + ASSERT(ap->findPeerHtState(sta1->address) == nullptr); + ASSERT(ap->findPeerHtState(sta2->address) == nullptr); + ASSERT(sta1->findPeerHtState(ap->address) == nullptr); + ASSERT(sta2->findPeerHtState(ap->address) == nullptr); + } + void initialize() override { + sentSignal = registerSignal("packetSentToLower"); + receivedSignal = registerSignal("packetReceivedFromLower"); + appSignal = registerSignal("packetReceived"); + scheduleAt(SIMTIME_ZERO, new cMessage("remove")); + scheduleAt(SimTime(1100, SIMTIME_MS), new cMessage("audit")); + } + void handleMessage(cMessage *message) override { + bool remove = message->isName("remove"); + delete message; + if (remove) { + ap = check_and_cast(getModuleByPath("^.ap.wlan[0].mib")); + sta1 = check_and_cast(getModuleByPath("^.sta1.wlan[0].mib")); + sta2 = check_and_cast(getModuleByPath("^.sta2.wlan[0].mib")); + for (const char *name : {"ap", "sta1", "sta2"}) { + auto wlan = getParentModule()->getSubmodule(name)->getSubmodule("wlan", 0); + ASSERT(std::string(wlan->par("opMode").stringValue()) == "ac"); + auto mac = check_and_cast(wlan->getSubmodule("mac")); + macs[name] = mac; + hcfs.push_back(check_and_cast(mac->getSubmodule("hcf"))); + mac->subscribe(sentSignal, this); + mac->subscribe(receivedSignal, this); + } + checkAssociation(); + for (auto sta : {sta1, sta2}) { + auto atAp = ap->findPeerHtState(sta->address); + auto atSta = sta->findPeerHtState(ap->address); + ASSERT(atAp && atAp->valid && atSta && atSta->valid); + } + for (auto sta : {sta1, sta2}) { + ap->removePeerHtCapabilities(sta->address); + sta->removePeerHtCapabilities(ap->address); + } + getModuleByPath("^.sta2.app[0]")->subscribe(appSignal, this); + removed = true; + checkGap(); + } + else { + ASSERT(removed); + checkGap(); + ASSERT(delivered >= 5); + ASSERT(sentFirstHop >= 5 && receivedFirstHop >= 5); + ASSERT(sentSecondHop >= 5 && receivedSecondHop >= 5); + completed = true; + std::cout << "Absent peer HT fallback: Normal Ack delivered=" << delivered + << " firstHop=" << receivedFirstHop << " secondHop=" << receivedSecondHop << "\n"; + emit(registerSignal("fallbackAuditPassed"), intval_t(1)); + } + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *) override { + ASSERT(removed); + checkGap(); + auto packet = check_and_cast(object); + if (signal == appSignal) { + delivered++; + return; + } + auto header = packet->peekAtFront(); + ASSERT(!dynamicPtrCast(header)); + ASSERT(!dynamicPtrCast(header)); + ASSERT(header->getType() != ST_BLOCKACK_REQ && header->getType() != ST_BLOCKACK); + auto data = dynamicPtrCast(header); + if (!data) + return; + ASSERT(data->getType() == ST_DATA_WITH_QOS && data->getAckPolicy() == NORMAL_ACK); + bool firstHop = data->getTransmitterAddress() == sta1->address && data->getReceiverAddress() == ap->address; + bool secondHop = data->getTransmitterAddress() == ap->address && data->getReceiverAddress() == sta2->address; + if (signal == sentSignal) { + sentFirstHop += firstHop && source == macs.at("sta1"); + sentSecondHop += secondHop && source == macs.at("ap"); + } + else if (signal == receivedSignal) { + receivedFirstHop += firstHop && source == macs.at("ap"); + receivedSecondHop += secondHop && source == macs.at("sta2"); + } + } + void finish() override { ASSERT(completed); } +}; +Define_Module(BlockAckFallbackAudit); + +Define_ProtocolTest(wifi_11ac_blockack_fallback) +{ + return ProtocolTest("wifi_11ac_blockack_fallback") + .once(on("audit").signal("fallbackAuditPassed") + .describe("Normal Ack delivery with absent peer HT state on both hops").within(1.2)); +} +} + +%file: FallbackNetwork.ned +import inet.protocoltest.wifi.WifiInfraNetwork; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +module FallbackHcf extends Hcf { parameters: @class(::inet::protocoltest::FallbackHcf); } +simple BlockAckFallbackAudit { parameters: @class(::inet::protocoltest::BlockAckFallbackAudit); } +network FallbackNetwork extends WifiInfraNetwork { + submodules: + audit: BlockAckFallbackAudit; +} + +%inifile: test.ini +[General] +network = FallbackNetwork +*.tester.testName = "wifi_11ac_blockack_fallback" +*.ap.wlan[*].mgmt.typename = "Ieee80211MgmtApSimplified" +*.sta*.wlan[*].mgmt.typename = "Ieee80211MgmtStaSimplified" +*.sta*.wlan[*].agent.typename = "" +*.sta*.wlan[*].mgmt.accessPointAddress = "ap" +**.wlan[*].mac.hcf.typename = "FallbackHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "compressed" +*.sta1.app[0].sendInterval = 0.1ms +*.sta1.app[0].stopTime = 1.01s +include ../../ini/_ac.ini +include ../../ini/_base.ini +**.hcf.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 10000B +**.hcf.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 100 +**.hcf.originatorMacDataService.msduAggregationPolicy.aggregationLengthThreshold = 10000 + +%contains: stdout +PROTOCOLTEST wifi_11ac_blockack_fallback: PASS diff --git a/tests/protocol/wifi/11n/N_BlockAck.test b/tests/protocol/wifi/11n/N_BlockAck.test index d5ab66019fe..98f60e3b1d7 100644 --- a/tests/protocol/wifi/11n/N_BlockAck.test +++ b/tests/protocol/wifi/11n/N_BlockAck.test @@ -1,13 +1,19 @@ %description: 802.11n Block Ack session: ADDBA action (type 13), BlockAckReq (type 24), BlockAck (type 25). [Required] +Check explicit Basic and Compressed with concrete BAR/BA types and positive receipt bits. + +%extraargs: -r 0..1 %file: N_BlockAck.cc #include "ProtocolTest.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" namespace inet { namespace protocoltest { +using namespace inet::ieee80211; + // Block Ack session flow: STA sends ADDBA Request (action frame, type 13), // AP responds with ADDBA Response (type 13), then after enough frames are // queued, STA sends BlockAckReq (type 24) and AP sends BlockAck (type 25). @@ -19,21 +25,63 @@ Define_ProtocolTest(wifi_11n_block_ack) .describe("ADDBA action frame from sta1").within(2.5)) .once(on("sta1.wlan[0].mac").signal("packetSentToLower") .filterPacket("ieee80211mac.type == 24") + .filterEvent([](const MatchContext& c) { + return c.event.packet && c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + }) .describe("BlockAckReq from sta1").within(1.0)) .once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") .filterPacket("ieee80211mac.type == 25") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto ba = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + if (!ba) return false; + for (int i = 0; i < 64; i++) + for (unsigned int j = 0; j < ba->getBlockAckBitmap(i).getSize(); j++) + if (ba->getBlockAckBitmap(i).getBit(j)) return true; + return false; + }) .describe("BlockAck received at sta1").within(0.02)); } +Define_ProtocolTest(wifi_11n_compressed_exchange) +{ + return ProtocolTest("wifi_11n_compressed_exchange") + .once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") + .filterPacket("ieee80211mac.type == 13") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto response = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + return response && response->getStatusCode() == 0 && response->getBlockAckPolicy(); + }) + .describe("successful immediate ADDBA response").within(2.5)) + .once(on("sta1.wlan[0].mac").signal("packetSentToLower") + .filterPacket("ieee80211mac.type == 24") + .filterEvent([](const MatchContext& c) { + return c.event.packet && c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + }) + .describe("Compressed BAR from sta1").within(1.0)) + .once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") + .filterPacket("ieee80211mac.type == 25") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto ba = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + if (!ba) return false; + for (unsigned int i = 0; i < ba->getBlockAckBitmap().getSize(); i++) + if (ba->getBlockAckBitmap().getBit(i)) return true; + return false; + }) + .describe("Compressed Block Ack with positive receipt evidence").within(0.02)); +} + } // namespace protocoltest } // namespace inet %inifile: test.ini [General] -*.tester.testName = "wifi_11n_block_ack" +*.tester.testName = ${test="wifi_11n_block_ack","wifi_11n_compressed_exchange"} *.sta*.wlan[*].mac.hcf.isBlockAckSupported = true -**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.blockAckVariant = ${profile="basic","compressed" ! test} *.ap.wlan[*].mac.hcf.isBlockAckSupported = true *.sta*.wlan[*].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 5 *.sta1.app[0].sendInterval = 0.1ms @@ -51,3 +99,6 @@ include ../../ini/_base.ini %contains: stdout PROTOCOLTEST wifi_11n_block_ack: PASS + +%contains: stdout +PROTOCOLTEST wifi_11n_compressed_exchange: PASS diff --git a/tests/protocol/wifi/11n/N_CompressedBa.test b/tests/protocol/wifi/11n/N_CompressedBa.test index 8d7910bb180..ffc72bf4215 100644 --- a/tests/protocol/wifi/11n/N_CompressedBa.test +++ b/tests/protocol/wifi/11n/N_CompressedBa.test @@ -1,5 +1,5 @@ %description: -802.11n Block Ack received at sta1 with non-empty bitmap (acknowledges at least one frame). [Required] +802.11n Compressed Block Ack received at sta1 with a positive receipt bit. [Required] %file: N_CompressedBa.cc @@ -11,10 +11,6 @@ namespace protocoltest { using namespace inet::ieee80211; -// INET sends Ieee80211BasicBlockAck (not CompressedBlockAck) for all block ack sessions. -// The Basic Block Ack carries a 64x16-bit bitmap acknowledging MPDUs. -// We assert that a BasicBlockAck is received and its bitmap has at least one bit set, -// confirming the AP has positively acknowledged at least one received data MPDU. Define_ProtocolTest(wifi_11n_compressed_ba) { return ProtocolTest("wifi_11n_compressed_ba") @@ -22,18 +18,14 @@ Define_ProtocolTest(wifi_11n_compressed_ba) .filterPacket("ieee80211mac.type == 25") .filterEvent([](const MatchContext& c) { if (!c.event.packet) return false; - auto ba = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); + auto ba = c.event.packet->peekAtFront(b(-1), Chunk::PF_ALLOW_NULLPTR); if (!ba) return false; - // At least one bit set means at least one MPDU was acknowledged. - for (int i = 0; i < 64; i++) { - const auto& bv = ba->getBlockAckBitmap(i); - for (unsigned int j = 0; j < bv.getSize(); j++) { - if (bv.getBit(j)) return true; - } - } + const auto& bitmap = ba->getBlockAckBitmap(); + for (unsigned int i = 0; i < bitmap.getSize(); i++) + if (bitmap.getBit(i)) return true; return false; }) - .describe("a BasicBlockAck with at least one acknowledged MPDU").within(2.5)); + .describe("a Compressed Block Ack with a positive receipt bit").within(2.5)); } } // namespace protocoltest @@ -44,7 +36,7 @@ Define_ProtocolTest(wifi_11n_compressed_ba) [General] *.tester.testName = "wifi_11n_compressed_ba" *.sta*.wlan[*].mac.hcf.isBlockAckSupported = true -**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.wlan[*].mac.hcf.blockAckVariant = "compressed" *.ap.wlan[*].mac.hcf.isBlockAckSupported = true *.sta*.wlan[*].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 5 *.sta1.app[0].sendInterval = 0.1ms diff --git a/tests/unit/Ieee80211BlockAckScheduling_1.test b/tests/unit/Ieee80211BlockAckScheduling_1.test index aeb1b29a0f3..ce6049d666d 100644 --- a/tests/unit/Ieee80211BlockAckScheduling_1.test +++ b/tests/unit/Ieee80211BlockAckScheduling_1.test @@ -149,6 +149,48 @@ choice = policy.computeBlockAckReqParameters(&frames, nullptr, &agreements); ASSERT(std::get<0>(choice) == peer && std::get<2>(choice) == 2); ASSERT(std::get<1>(choice) == SequenceNumberCyclic(100)); ASSERT(otherAgreement->getStartingSequenceNumber() == SequenceNumberCyclic(4094)); +for (int start : {100, 4094}) { + for (int responseOffset : {0, 6, 100}) { + QosAckHandler compressedAck; + SchedulingFrames compressedFrames; + compressedFrames.configure(&compressedAck); + OriginatorBlockAckAgreement active(peer, 5, SequenceNumberCyclic(start), 64, false, false); + auto earlier = compressedFrames.add(peer, 5, (start + 2) % 4096); + auto requested = compressedFrames.add(peer, 5, (start + 4) % 4096); + auto unsent = compressedFrames.add(peer, 5, (start + 5) % 4096, false); + auto outsideWindow = compressedFrames.add(peer, 5, (start + 64) % 4096); + auto otherTid = compressedFrames.add(peer, 2, (start + 2) % 4096); + auto request = makeShared(); + request->setReceiverAddress(peer); + request->setTidInfo(5); + request->setStartingSequenceNumber(SequenceNumberCyclic(start) + 4); + compressedAck.processTransmittedBlockAckReq(request, &active); + ASSERT(compressedAck.getQoSDataAckStatus(earlier) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); + ASSERT(compressedAck.getQoSDataAckStatus(requested) == QosAckHandler::Status::WAITING_FOR_BLOCK_ACK); + auto response = makeShared(); + response->setTransmitterAddress(peer); + response->setTidInfo(5); + response->setStartingSequenceNumber(SequenceNumberCyclic(start) + responseOffset); + BitVector bitmap; + for (int bit = 0; bit < 64; bit++) + bitmap.appendBit(responseOffset == 0 && (bit == 2 || bit == 5)); + response->setBlockAckBitmap(bitmap); + compressedAck.processReceivedCompressedBlockAck(response, &active); + ASSERT(compressedAck.getQoSDataAckStatus(earlier) == (responseOffset == 0 ? + QosAckHandler::Status::BLOCK_ACK_ARRIVED_ACKED : QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED)); + ASSERT(compressedAck.isEligibleToTransmit(requested)); + ASSERT(compressedAck.getQoSDataAckStatus(unsent) == QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED); + ASSERT(compressedAck.getQoSDataAckStatus(otherTid) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); + ASSERT(compressedAck.getQoSDataAckStatus(outsideWindow) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); + response->setStartingSequenceNumber(SequenceNumberCyclic(start) + 4); + BitVector outsideBitmap; + for (int bit = 0; bit < 64; bit++) + outsideBitmap.appendBit(bit == 60); + response->setBlockAckBitmap(outsideBitmap); + compressedAck.processReceivedCompressedBlockAck(response, &active); + ASSERT(compressedAck.getQoSDataAckStatus(outsideWindow) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); + } +} auto duration = SimTime(1, SIMTIME_US); EdcaTransmitLifetimeHandler lifetime(duration, duration, duration, duration); frames.setLifetimeHandler(&lifetime); From 4960ebc3f3fed65ee1b7ff5d25858cb929d65649 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:52:08 +0200 Subject: [PATCH 17/41] ieee80211: change: default HCF to immediate Compressed Block Ack Before this commit, a configuration without a profile selector uses Basic. The complete Compressed runtime requires an explicit selector. After this commit, HCF selects Compressed by default. Eligible HT links use immediate Compressed exchanges. Links without usable local or peer HT state retain Normal Ack. Explicit Basic retains its historical compatibility path and fragment bitmap. For example, an eligible n link without blockAckVariant now uses Compressed. The n and ac consumers cover explicit Basic, explicit Compressed, and the default. Migration cases cover capability fallback, profile conflict, and unsupported delayed policy. Existing Basic demonstrations retain explicit selectors. Execution records retain supported scope and evidence limits. A-MPDU, Multi-TID Block Ack, delayed Compressed policy, complete historical Basic conformance, and complete VHT transfer remain outside this result. Admission limits outside active Compressed agreements also remain outside the correction. Plan: plan/pending/ieee80211-compressed-blockack-replacement.md Change: src.ieee80211 | behavior.change | test whatsnew migration | ieee80211-compressed-blockack-replacement --- WHATSNEW | 2 +- doc/src/migration-guide/index.rst | 2 +- doc/src/users-guide/ch-80211.rst | 2 +- ...e80211-compressed-blockack-s5-execution.md | 227 ++++++++++++++++++ ...0211-compressed-blockack-txop-admission.md | 121 ++++++++++ showcases/wireless/blockack/doc/index.rst | 2 +- .../mac/coordinationfunction/Hcf.ned | 2 +- tests/module/Ieee80211BlockAckDeferral_1.test | 1 + ...Ieee80211CompressedBlockAckExchange_1.test | 1 - ...eee80211CompressedBlockAckMigration_1.test | 179 ++++++++++++++ tests/protocol/wifi/11ac/Ac_BlockAck.test | 25 +- tests/protocol/wifi/11n/N_BlockAck.test | 25 +- 12 files changed, 575 insertions(+), 14 deletions(-) create mode 100644 plan/pending/ieee80211-compressed-blockack-s5-execution.md create mode 100644 plan/pending/ieee80211-compressed-blockack-txop-admission.md create mode 100644 tests/module/Ieee80211CompressedBlockAckMigration_1.test diff --git a/WHATSNEW b/WHATSNEW index a0646fd959e..8cebaec1905 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -456,7 +456,7 @@ Notable backward incompatible changes are the following: 52. IEEE 802.11 immediate Compressed Block Ack - HCF supports explicit immediate Compressed Block Ack. Basic remains the default. Eligible HT infrastructure links and the supported ac path use accepted agreements and 32-byte Compressed responses with FCS. Links without usable local or peer HT state retain Normal Ack. Select blockAckVariant = "basic" at both endpoints for historical Basic compatibility. An HT PHY mode alone does not supply peer capability state. + HCF defaults to immediate Compressed Block Ack. Eligible HT infrastructure links and the supported ac path use accepted agreements and 32-byte Compressed responses with FCS. Links without usable local or peer HT state retain Normal Ack. Select blockAckVariant = "basic" at both endpoints for historical Basic compatibility. An HT PHY mode alone does not supply peer capability state. Both endpoints must select the same blockAckVariant because ADDBA does not negotiate it. A valid addressed BAR with the other profile stops the simulation before agreement updates. The diagnostic identifies the peer, TID, and profiles. Compressed rejects delayedAckPolicySupported = true in either agreement policy at initialization. diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 49984769ef5..8a171ab7075 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -46,7 +46,7 @@ Custom QoS data services must implement the reversible preparation operations in IEEE 802.11 Compressed Block Ack extension points ------------------------------------------------ -Select ``mac.hcf.blockAckVariant = "compressed"`` for immediate Compressed Block Ack. Basic remains the default. Both endpoints must select the same profile. ADDBA does not negotiate this selector. A valid addressed BAR with the other profile stops the simulation before agreement updates. The diagnostic identifies the peer, TID, local profile, and received profile. Configure the same selectors before a new run. +HCF defaults to ``mac.hcf.blockAckVariant = "compressed"``. Both endpoints must select the same profile. ADDBA does not negotiate this selector. A valid addressed BAR with the other profile stops the simulation before agreement updates. The diagnostic identifies the peer, TID, local profile, and received profile. Configure the same selectors before a new run. Compressed agreements require usable local HT support and directional peer HT state. An HT PHY mode alone does not supply that state. Without it, HCF retains Normal Ack DATA. Explicit ``blockAckVariant = "basic"`` retains historical Basic compatibility without that HT requirement. Compressed agreements suppress fragmentation for their peer and TID. Fragmentation outside those agreements retains its existing threshold. diff --git a/doc/src/users-guide/ch-80211.rst b/doc/src/users-guide/ch-80211.rst index e6f09b57bd6..fa35d64e63b 100644 --- a/doc/src/users-guide/ch-80211.rst +++ b/doc/src/users-guide/ch-80211.rst @@ -706,7 +706,7 @@ After the final exchange, the originator sends DELBA when its agreement has no q The agreement policies, ``mac.hcf.originatorBlockAckAgreementPolicy`` and ``mac.hcf.recipientBlockAckAgreementPolicy``, set the buffer size. ``maximumAllowedBufferSize`` defaults to 64. Both negotiated ``aMsduSupported`` flags control A-MSDU use; each defaults to ``true``. ``blockAckTimeoutValue`` defaults to ``0s``, which disables the inactivity timeout. Transfer completion and DATA lifetime expiry retain their separate teardown rules. -Select ``mac.hcf.blockAckVariant = "compressed"`` for immediate Compressed Block Ack. Basic remains the default. Block Ack support itself remains disabled by default. The response contains a 64-bit bitmap and occupies 32 bytes with FCS. Each positive bit acknowledges one unfragmented MPDU. The recipient retains receipt bits after delivery, so a later BAR can still obtain those positive bits. Missing receipt evidence produces zero. +HCF defaults to ``mac.hcf.blockAckVariant = "compressed"`` for immediate Compressed Block Ack. Block Ack support itself remains disabled by default. The response contains a 64-bit bitmap and occupies 32 bytes with FCS. Each positive bit acknowledges one unfragmented MPDU. The recipient retains receipt bits after delivery, so a later BAR can still obtain those positive bits. Missing receipt evidence produces zero. Compressed agreements require usable local HT support and directional peer HT state. Infrastructure association supplies that peer state for eligible HT links and the supported ``ac`` path. An HT radio mode alone does not supply peer capabilities. Without usable state, DATA uses Normal Ack. Local non-HT operation produces a warning when Block Ack support is enabled. HT ad hoc links without peer state retain Normal Ack. diff --git a/plan/pending/ieee80211-compressed-blockack-s5-execution.md b/plan/pending/ieee80211-compressed-blockack-s5-execution.md new file mode 100644 index 00000000000..e89c9e74f7d --- /dev/null +++ b/plan/pending/ieee80211-compressed-blockack-s5-execution.md @@ -0,0 +1,227 @@ +# S5 execution: Compressed Block Ack beside Basic compatibility + +S5 is complete through C1, C2, C3, and C4. The authorized TXOP correction removes the active Compressed timing blocker. HCF now defaults to Compressed. Explicit Basic compatibility remains available. + +The comparison parent is `75559a49661e33f727fa93a8c81c021596cfb4c9`. The active checkout is `/home/user/omnetpp_ws/inet-compressed-blockack-s5`. The maintainer requested S5 execution on 16 October 2026. That request authorizes C1 through C4 in the [replacement plan](ieee80211-compressed-blockack-replacement.md#compressed-replacement-steps). + +The checkout contained changes to `AGENTS.md` and four prerequisite plans before execution. It also contained an untracked planning history. This work preserves those changes. The pinned parent contains the S4 implementation. The [S4 execution record](ieee80211-compressed-blockack-s4-execution.md) supplies its earlier evidence and limits. + +## Implementation contract + +HCF owns the immutable profile and validates received frame formats before agreement updates. An active agreement identifies one peer and TID. A valid conflicting BAR stops the simulation because ADDBA does not negotiate the profile. Malformed input cannot cause that diagnostic, receipt updates, or agreement recovery. + +The recipient record owns explicit Compressed receipt bits and its scoreboard window. The reorder service owns delivery order and its separate window. Delivery must preserve receipt bits. An absent receipt produces zero, including positions before the first received DATA. Basic retains its fragment bitmap and existing compatibility behavior. + +The rate selector consumes the MIB rate sets. It selects a non-HT Compressed response and distinguishes initial BAR from later BAR. Frame sequences supply the actual request profile. Protection, timeouts, and duration calculations use the corresponding response length. Compressed responses contain 32 bytes with FCS; Basic responses contain 152 bytes. + +For an active Compressed agreement, the originator suppresses fragmentation for that peer and TID. The recipient rejects fragmented DATA before receipt or reorder updates. Normal Ack outside that agreement retains its existing fragmentation behavior. + +## Recipient interframe design + +The recipient must distinguish receipt evidence from the interframe relation. An agreement with start 100 and size four first receives Normal Ack DATA 100. Delivery advances the reorder start to 101. DATA 104 advances the scoreboard start to 101 and preserves receipt evidence for 100. A qualifying interframe relation permits delivery of 104 despite the gap. A false receipt bit or absent relation retains 104. + +Local receive endpoints alone cannot establish the ACK-to-DATA relation with propagation delay. The medium therefore supplies one copied snapshot of physical endpoints. The snapshot contains transmission identity, transmitter identity, transmission endpoints, and cached arrival endpoints. It retains no frame, transmission, arrival, or radio pointer. + +The PHY derives the interval at the current transmitter. For the same transmitter, it subtracts the preceding transmission end from the current transmission start. Otherwise, it subtracts the preceding signal's cached arrival end at the current transmitter. This calculation uses the propagation result that the medium already produced. It does not assume equal outward and return delay. + +HCF owns local event history. A pending candidate preserves the interval across PHY reception completion and later MAC delivery. A receiver-created transmission identifier connects those events. Unrelated receptions replace prior history. Failed, abandoned, and overlapping receptions must not preserve stale eligibility. Every local transmission clears prior history; completed ACK transmission can establish new history. + +SIFS recognition uses the reconstructed interval after signal extension. The current PHY model uses baseline timing without coverage-class adjustment. The permitted bound is one tenth of the slot time. Integer tick division rounds that bound inward. Physical propagation remains separate from this MAC timing parameter. + +RIFS recognition requires permitted HT operation, the same transmitter and RA, and no preceding SIFS response obligation. It uses the preceding PPDU endpoint without signal extension. Management must preserve the advertised RIFS Mode. VHT operation does not permit RIFS. This recipient rule adds no RIFS transmitter scheduler. + +The review found that ordinary HT transmission at 2.4 GHz omitted the six-microsecond signal extension. The correction belongs in the authoritative PHY duration. HCF must not add it again. Existing short-GI duration differences remain inherited PHY fidelity limits; they do not independently establish an interval error. + +## Standards evidence + +The standards source is IEEE Std 802.11-2024. The fresh local corpus is `/home/user/omnetpp_ws/inet/standards/processed`. The corpus lint output is `/tmp/inet-s5-standards-lint.json`. + +| Canonical node | Physical PDF pages | Requirement | +| --- | --- | --- | +| `ieee80211-2024:table:9-36` | 719–720 | BAR variant Type encoding. | +| `ieee80211-2024:table:9-37` | 722–723 | Block Ack variant Type encoding. | +| `ieee80211-2024:clause:10.25.6.3` | 2060–2061 | Full-state recipient receipt state. | +| `ieee80211-2024:clause:10.25.6.6.2.1` | 2065–2066 | Recipient delivery and interframe conditions. | +| `ieee80211-2024:clause:10.3.2.3.3` | 1889–1890 | SIFS definition and tolerance. | +| `ieee80211-2024:clause:10.3.2.3.2` | 1888–1889 | RIFS definition and conditions. | +| `ieee80211-2024:clause:10.22.5` | 1997–1998 | Coverage-class timing behavior. | +| `ieee80211-2024:table:19-25` | 3493–3494 | Band-specific HT signal extension. | + +These provisions are normative. The selected corpus clauses resolve uniquely. The review inspected the original PDF for Clause 11.38.1 on physical page 2886. That clause requires a VHT AP to clear RIFS Mode. The corpus result without children does not include all later prose in that clause. + +## Verification boundary + +The initial full debug build and subsequent focused rebuilds pass. A build supplies no exchange or timing proof. The focused wire fixture passes independent octet checks. The constructed serializer fixture passes 278 cases. The HCF input fixture passes both configured profiles with supplied recipient agreements. Those results do not establish negotiation or PHY interval recognition. + +Five initial protocol simulations pass across the selected n/ac fixtures. They retain Basic coverage and add actual Compressed exchanges. This initial boundary precedes complete infrastructure timing classification and final interframe execution. Later sections record those results and the authorized correction. + +An isolated observer reproduces a DATA continuation overrun in the pinned parent. With a one-millisecond TXOP, the third DATA ends 178 microseconds after the bound. The candidate reaches the same endpoints. The parent also reproduces the first observed A-MSDU overrun. These observations identify inherited DATA admission limits. They do not establish general TXOP conformance or excuse a new Compressed violation. + +No recorded fingerprint baseline changed. This record does not authorize a baseline change or publication. + +## Confirmed timing blocker + +The candidate before the TXOP correction introduced a failing supported case that the exact parent did not reproduce. General run 6 uses HT operation, 24 Mbit/s DATA, single protection, aggregation, a one-millisecond TXOP, and seed zero. That candidate transmits two later A-MSDUs beyond their TXOP bounds. Each overrun is 310 microseconds. The affected TXOP contains two DATA frames, so the initial-MSDU exception does not apply. + +The second DATA ends at 1.014426 seconds. Its TXOP bound is 1.014116 seconds. The violation exists before any Block Ack response. The aggregate contains 1532 bytes in both versions. The exact parent has no aggregate overrun in run 6. Parent run 14 demonstrates a similar admission defect under different conditions. That other case does not make candidate run 6 acceptable. + +A direct run 6 reproduction also fails with the final reviewed debug library. Its output is `/tmp/inet-s5-reviewed-run6.out`; its error is `/tmp/inet-s5-reviewed-run6.err`. That run stops at the first later A-MSDU violation, at 1.014426 seconds. The earlier non-fatal observer campaign records both violations. + +The inherited admission mechanism causes the new result. `HcfFs` tests positive remaining time before a later exchange. It does not establish that the complete exchange fits. HCF excludes Block Ack support from its existing complete-cost DATA guard. The corrected HT control airtime and Compressed responses change the trajectory. The comparison does not isolate their separate contributions. + +All sixteen initial parent and candidate runs deliver thirty payloads, with 21000 payload bytes per run. All observed BAR/Block Ack exchanges remain within their applicable bounds. Those successes do not establish DATA containment. An independent review rejected that candidate under the [plan's timing condition](ieee80211-compressed-blockack-replacement.md#airtime-acceptance-and-admission-dependencies). The later correction and C3 acceptance below supersede that rejection. + +The [separate correction proposal](ieee80211-compressed-blockack-txop-admission.md) addresses preparation and admission. A final transmit guard alone cannot solve the problem. Aggregation already deletes constituent frames before HCF selects the actual mode. An oversized aggregate can therefore remain prepared and fail every later attempt. The proposal must preserve progress through ordinary MSDUs and the permitted initial-MSDU exception. + +## Focused verification after source review + +The reviewed debug library has SHA-256 `1635793563ff1c0912a4a0e55a70507879af2a20ef83a0b88502562748a347db`. Its build log is `/tmp/inet-s5-reviewed-debug-build.log`. The interframe fixture and direct run 6 reproduction use this library. The earlier mixed-interface regression batch is discarded. + +The unit and legacy results below use their recorded fresh libraries before the final bounded PHY review corrections. Those corrections repair empty-cache lookup, remove an unused virtual, and expose a watch. The protocol campaign uses library `1c57b8f562dbeb5cddbba49b77a3a676042fea7aef9b9e5578e1980c63109f56`. These earlier results retain their recorded source boundaries; they are not new executions against the final relink. + +| Check | Result | Evidence | +| --- | --- | --- | +| Focused units | Nine fixtures pass. | `/tmp/inet-s5-final-unit.log` | +| HT Operation conversion | One fixture passes both RIFS permission values and operation equality checks. | `/tmp/inet-s5-ht-operation-unit.log` | +| Legacy and HCF input modules | Thirty fixtures pass across the main batch and two repaired-fixture reruns. | `/tmp/inet-s5-final-module.log`, `/tmp/inet-s5-repaired-module.log` | +| EDCA DATA lifetime modules | Nine fixtures pass. | `/tmp/inet-s5-lifetime-module.log` | +| Production interframe fixture | All 28 runs pass with seed zero. | `/tmp/inet-s5-interframe-final/` | +| Constructed serializers | All 278 cases pass. | `/tmp/inet-s5-serializer-roundtrip.log` | +| n/ac protocol fixtures | Five simulations pass with Basic and Compressed coverage. | `/tmp/inet-s5-exchange-protocol-final.log` | +| Lowest response mode | Two real infrastructure runs pass at 6 Mbit/s. | `/tmp/inet-s5-exchange-lowest-config.out` | + +The two legacy fixtures required valid synthetic frames. The Action-dispatch fixture now supplies the BAR trailer. The fragment-retirement fixture now supplies all 64 fragment bitmap entries. Their behavioral assertions remain intact. + +The interframe fixture supplies accepted agreements. It uses real PHY reception and HCF ACK completion. It verifies SIFS and RIFS bounds, sequence wrap, prior receipt truth, unrelated traffic, retirement, and cache expiry. Its BUSY control uses a signal below reception sensitivity but above energy detection. Its 168 malformed BAR receptions each leave zero pending candidates. Separate infrastructure tests establish real association and ADDBA; the interframe fixture does not claim negotiation coverage. + +The source reviewers report no remaining confirmed correctness defect in their bounded core and interframe scopes. Architecture gates pass for the changed MAC and PHY subtrees. Review supplies no runtime proof beyond the executed fixtures. + +## Extension contracts in this candidate + +These obligations describe the current candidate. They require migration guidance before publication. They do not change the C3 blocker or activate the default. + +| Contract | Obligation for a custom implementation | +| --- | --- | +| `IQosRateSelection::computeCompressedBlockAckReqMode()` | Select a legal non-HT BAR mode from the supplied initial-or-later TXOP position and current rate sets. | +| `IRecipientQosAckPolicy::computeCompressedBlockAckDurationField()` | Subtract SIFS and the actual 32-byte response airtime from the request reservation. Preserve the Basic method. | +| `IRecipientQosMacDataService::dataFrameReceived()` | Accept the new interframe argument. Preserve its meaning through recipient processing. A false value supplies no interval evidence. | +| `QoSContext` | Supply HCF's resolved profile to the exchange. Existing callers retain the Basic default unless they explicitly supply Compressed. | +| `RecipientBlockAckAgreement::setVariant()` | Set the profile during agreement creation. Do not change it during that agreement's lifetime. Compressed creation initializes explicit receipt state. | +| `IRadioMedium` | Implement the new snapshot and gap queries with copied physical facts. Unavailable transmissions or arrival endpoints produce an absent result. | +| `ICommunicationCache::findCachedArrival()` | Return a cached arrival without insertion, resizing, geometry recalculation, or other state changes. | +| `IIeee80211Mode::getSignalExtensionTime()` | Supply the nominal extension for the mode. `Ieee80211ModeBase` supplies zero; ERP and HT override it where necessary. | + +## Common regression result + +All nineteen selected rows match their recorded non-graphical fingerprints. The runner uses debug mode and the original configuration, run, time limit, and requested non-graphical ingredients. It completes in 182.173 seconds with exit status zero. The selected input is `/tmp/inet-s5-fingerprint-selection.csv`; the log is `/tmp/inet-s5-fingerprint.log`. + +The command runs from `tests/fingerprint`: + +```sh +./fingerprinttest -d \ + -m '(showcases/wireless/(blockack|aggregation|fragmentation|qos|txop)|examples/(wireless/qos|adhoc/qos))' \ + -f tplx -f '~tNl' -f '~tND' -t 6 \ + /tmp/inet-s5-fingerprint-selection.csv +``` + +The graphical `tyf` ingredient remains unverified. No fingerprint baseline changed. These matches preserve the selected legacy regression evidence. They do not override the direct Compressed timing failure. + +These initial regression matches precede the separate TXOP correction and C4. No commit or publication occurred during this execution. + +## Build state before the authorized TXOP correction + +Both debug and release builds pass. The final release freshness check uses `make MODE=release -j6` from the repository root. Its log is `/tmp/inet-s5-reviewed-release-build.log`. The final debug build uses `make MODE=debug -j6`; its log is `/tmp/inet-s5-reviewed-debug-build.log`. The later NED edit corrects a comment and retains the Basic default. + +The separate TXOP proposal passed a consistency review as a scope request. On 2026-10-16, the maintainer authorized that correction and subsequent S5 completion. Source validation and independent review resolved the RTS boundary, lifetime ownership, and mode validation before implementation. The retained strict fixture preserves the inherited outside-agreement failure separately from active Compressed acceptance. + +## Authorized TXOP correction and C3 acceptance + +The [TXOP contract](ieee80211-compressed-blockack-txop-admission.md#resolved-implementation-contract) defines source ownership and each event boundary. The service creates duplicate previews without source removal. HCF selects one DATA mode, evaluates the aggregate, and evaluates an ordinary fallback with that same mode. Commitment transfers the same preview pointer only before DATA submission. Refusal preserves queue frames, deadlines, sequence state, and allocation state. + +RTS failure before DATA updates QSRC and the contention window without a provisional sequence counter. Original MSDU lifetimes bound repeated attempts. Expiry, capability loss, or changed response inputs cancel invalid preparation. Single protection reserves only the current exchange. A later BAR can require fresh contention. Basic and traffic outside active Compressed agreements retain their existing preparation and admission. + +Runtime verification found two effective selection callers that bypassed the first implementation. `RtsCtsFs` still extracted originals after admission. The multicast repeat predicate could also extract a prepared unicast successor before it ended the group sequence. Both callers now use the context-selected frame. Their focused regression cases preserve original queue state when no DATA submission occurs. + +The first retry policy required containment for all committed frames. A real BAR collision exposed a progress failure at 6 Mbit/s. One ordinary protected exchange needs 1.166 milliseconds under a nominal one-millisecond limit. Its first attempt qualifies for an exception, but conservative retry containment refused every later attempt. The implementation now uses the standard same-size single-MPDU exception with no earlier Data or Management frame. The supported path preserves committed MPDU size across retries. + +New previews clear Retry from the previous wireless hop. Committed retries derive Retry from local acknowledgment state. An oversized first-attempt A-MSDU still cannot use the retry exception. Internal collision commits only ordinary queued DATA before its retained recovery action. Multiple protection reserves the actual complete exchange for a permitted overrun. + +The corrected debug library has SHA-256 `0298dbd4c9625cd6f306865f5c1cfd0a3412230c6339b3a84289eb68eba713df`. The release library has SHA-256 `4b32335cdb2f558d60ada0761e46fde84c9879889e1c46b3c3f69bd11d9ae780`. Debug build 4 and the release build pass. Their logs are `/tmp/inet-s5-txop-debug-build-4.log` and `/tmp/inet-s5-txop-release-build.log`. + +The focused admission fixture passes all 24 cases with seed zero. It checks refusal, ordinary fallback, ownership, deadlines, sequence state, one mode query, and RTS cancellation. It also checks QSRC rollover, lifetime expiry, capability changes, internal collision, and multicast-to-unicast refusal. Cases 22 and 23 require actual ordinary and A-MSDU retries with unchanged size and DATA airtime above one millisecond. Evidence is `/tmp/inet-s5-admission24.out` and `/tmp/inet-s5-admission24.err`. + +All sixteen explicit-profile infrastructure cases pass the scoped timing assertions. The observer records agreement scope at DATA submission, before later teardown can change lookup results. Active Compressed checks include DATA with Normal Ack. No active later DATA or ACK overrun remains. All 98 matched BAR/Block Ack exchanges finish within their bounds. All 32 hop summaries report zero Block Ack overruns. + +The former run 6 failure now passes with zero DATA, ACK, or Block Ack overruns on both hops. Those hops transmit 23 and 11 active aggregates. The separate two-run lowest-response campaign records 29 actual 32-byte responses at 6 Mbit/s. Their airtime is 74 microseconds, with exactly 10 microseconds of SIFS. No Block Ack response exceeds its bound. + +The infrastructure observer separately records inherited violations outside active agreements. `StrictAllTiming` retains the original aggregate assertions and reproduces the pre-agreement aggregate failure in run 4. This acceptance establishes no timing compliance for those retained paths. The default change does not repair Basic or outside-agreement admission. + +The cleanup assertion permits only the idle `WAITING_FOR_SUCCESSOR` procedure with `SIMTIME_MAX` response deadline. Queues, in-progress frames, agreements, pending BAR state, and agreement timers must remain empty or inactive. That phase records a possible future setup after a completed Normal Ack transfer. It holds no unresolved exchange. + +Independent review accepts C3 for this scope and permits C4. The verdict is `/tmp/inet-s5-c3-acceptance-review.md`. Explicit-profile evidence is `/tmp/inet-s5-exchange-scoped-general16.out` and `/tmp/inet-s5-exchange-scoped-lowest2.out`. The scope table is `/tmp/inet-s5-exchange-scoped-general16.csv`. The unchanged strict failure remains in `/tmp/inet-s5-exchange-strict-all-inherited.out` and its `.err` file. + +## C4 default and migration verification + +`Hcf.ned` now defaults to Compressed. The infrastructure fixture omits the selector after C3 and requires actual Compressed frames. All sixteen default cases pass. Both lowest-response cases also pass after default activation. Evidence is `/tmp/inet-s5-default-exchange16.out` and `/tmp/inet-s5-default-lowest2.out`. + +All six external-style migration cases pass without an explicit selector. Legacy g and a links, and HT ad hoc links without peer records, deliver twelve UDP payloads through Normal Ack. Support-disabled controls produce no irrelevant warning. The fixture checks the resolved default, fallback diagnostics, absent ADDBA/BAR/Block Ack, and empty active state. Evidence is `/tmp/inet-s5-default-migration6.out`. + +All twelve initialization cases pass after default activation. They cover the omitted selector, explicit Basic, explicit Compressed, unknown values, and both delayed-policy guards. Evidence is `/tmp/inet-s5-default-variant12.out`. Retained Basic fragment, bitmap, and public API checks remain separate regression obligations. + +Both `N_BlockAck` and `Ac_BlockAck` also pass three consumer runs: explicit Basic, explicit Compressed, and the NED default. The third run uses bare INI `default`, which invokes OMNeT++ `acceptDefault()`. It verifies the resolved profile at all three HCF instances. Actual Compressed BAR/Block Ack and positive receipt bits complete that run. All six simulations and both diagnostic scripts pass. Evidence is `/tmp/inet-s5-default-consumer-protocol6.log` and `/tmp/inet-s5-default-consumer-{n3,ac3}.out`. + +Both final build freshness checks pass after the NED change. Their logs are `/tmp/inet-s5-c4-debug-build.log` and `/tmp/inet-s5-c4-release-build.log`. The C4 change affects the runtime NED default; the recorded debug and release library hashes remain unchanged. + +## Final regression evidence + +All final checks use the active checkout and seed zero where a simulation requires a seed. Debug mode retains runtime assertions. The release build supplies a separate compilation check. No fingerprint expectation changed. + +| Check | Final result | Evidence | +| --- | --- | --- | +| Unit fixtures | All ten pass. | `/tmp/inet-s5-c4-unit.log` | +| Module regression batch | Forty-one pass initially. The retained Basic deferral fixture passes after its explicit profile correction. All 42 selected fixtures therefore pass across the batch and focused rerun. | `/tmp/inet-s5-c4-module-regression.log`, `/tmp/inet-s5-c4-deferral-module.log` | +| Default infrastructure and migration | Both additional module fixtures pass: sixteen infrastructure cases and six migration cases. Both lowest-response cases pass. | `/tmp/inet-s5-default-module.log`, `/tmp/inet-s5-default-lowest2.out` | +| Serializer | All 278 constructed cases pass, with zero unexpected or stale coverage entries. The separate golden-octet unit also passes. | `/tmp/inet-s5-c4-serializer.log`, `/tmp/inet-s5-c4-unit.log` | +| Wi-Fi protocol files | Five supported files pass. Four deferred files retain expected failures. No unexpected result occurs. | `/tmp/inet-s5-default-plan-protocol9.log`, `/tmp/inet-s5-default-protocol-deferred.txt` | +| Fingerprint rows | All nineteen selected rows match in 153.811 seconds. | `/tmp/inet-s5-c4-fingerprint.log` | +| Architecture | All three scoped checks pass. | `/tmp/inet-s5-c4-architecture-mac.log`, `/tmp/inet-s5-c4-architecture-common.log`, `/tmp/inet-s5-c4-architecture-wifi.log` | + +The module union contains 44 distinct fixtures. It preserves Basic teardown, fragmentation, NAV, setup, association reset, response modes, and lifetime checks. It repeats the 28 physical interframe cases, 24 admission cases, and 76 scheduling cases after default activation. The scheduling fixture retains all original Basic cases. It adds actual Compressed shifted responses through active frame sequences and small-window arbitration. + +The recipient integration checks DATA 100, 102, and 101 through HCF. Delivery order is 100, 101, and 102. A subsequent BAR produces three positive receipt bits and zero holes after delivery. The six focused originator cases call the HCF control boundary directly. The scheduling fixture separately supplies actual response matching. These fixtures supply accepted agreements; the infrastructure and protocol fixtures prove negotiation separately. + +The legacy deferral fixture omitted a selector while it used non-HT mode `a`. The Compressed default correctly prevented its expected Basic setup. The fixture now selects Basic explicitly. All twelve original scenarios pass without assertion changes. This correction preserves the fixture's intended historical profile. + +The deferred protocol results remain explicit. `N_Ampdu` and `Ac_Ampdu` first miss an A-MPDU subframe. `Ac_MultiTidBa` passes both TID observations before it misses Multi-TID Block Ack. `WifiQosDelayedBa` observes a delayed request before recipient delayed acceptance fails. No expectation changed, and these results establish no support for those features. + +The interface gates report two MAC findings and three PHY findings. Their output is byte-identical to the pinned parent's output. The implicated source files remain unchanged. Logs are `/tmp/inet-s5-c4-interfaces-mac.log` and `/tmp/inet-s5-c4-interfaces-phy.log`, with corresponding `/tmp/inet-s5-parent-interfaces-*.log` files. This work adds no interface-gate finding. + +The final unit command runs from the checkout root: + +```sh +inet_run_unit_tests -m debug -f '(Ieee80211BlockAck(Wire|Scheduling|ActionWire)_1|Ieee80211CompressedBlockAck(Rate|Record)_1|Ieee80211(ResponseModeSelection|ResponseTimeout|HtModeSet|HtCapabilities|VhtHtCapabilities)_1)\.test$' +``` + +The module regression command runs from the checkout root: + +```sh +inet_run_module_tests -m debug -f 'Ieee80211(BlockAck.*|EdcaDataLifetime.*|PreparedCancellation_1|RecipientNav_1|Txnav_1|Hcf(SingleProtection_1|MultipleProtection_[12]|Header_1)|SingleProtectionGroup_1|VhtHtSupport_1|HtAssociation_1|Mgmt(StateCommit|RatePublication)_1|CompressedBlockAck(Input|Interframe|Admission|Originator)_1)\.test$' +inet_run_module_tests -m debug -f 'Ieee80211BlockAckDeferral_1\.test$' +inet_run_module_tests -m debug -f '(Ieee80211CompressedBlockAckExchange_1|Ieee80211CompressedBlockAckMigration_1|Ieee80211BlockAckVariant_1)\.test$' +``` + +The serializer and protocol commands run from the checkout root: + +```sh +inet_run_serializer_tests -m debug -f 'serializer_chunk_roundtrip\.test$' +inet_run_protocol_tests -m debug -w '^tests/protocol/wifi$' -f '(N_BlockAck|N_CompressedBa|N_Amsdu|N_Ampdu|Ac_BlockAck|Ac_BlockAckFallback|Ac_Ampdu|Ac_MultiTidBa|WifiQosDelayedBa)\.test$' +inet_run_protocol_tests -m debug -w '^tests/protocol/wifi$' -f '(N_BlockAck|Ac_BlockAck)\.test$' +``` + +The final fingerprint command repeats the nineteen-row command above from `tests/fingerprint`. It uses the original configurations, runs, time limits, and selected non-graphical ingredients. Graphical `tyf` remains unverified. No CSV or other recorded baseline changed. + +Current user and migration guides describe the default, fallback, profile conflict, fragmentation boundary, and added interface obligations. Release notes preserve the supported `ac` path and all four deferred protocol requirements. The Basic showcase retains its explicit profile, topology, and result rows. + +The evidence remains limited to the recorded deterministic cases and seed. Production HT catalogs provide no distinct legal alternate response for the tested 32-byte frame. The selector unit verifies that alternate-rate contract separately. The recipient prefix release remains an interpretation of ordered delivery together with the individual-MPDU release condition. This work establishes no complete historical Basic conformance or complete VHT transfer conformance. + +The implementation checks above precede the separate commit, push, and pull request phase. The user authorized that phase after implementation. The original local plan changes and untracked history remain outside the publication scope. diff --git a/plan/pending/ieee80211-compressed-blockack-txop-admission.md b/plan/pending/ieee80211-compressed-blockack-txop-admission.md new file mode 100644 index 00000000000..6664e786d49 --- /dev/null +++ b/plan/pending/ieee80211-compressed-blockack-txop-admission.md @@ -0,0 +1,121 @@ +# TXOP prerequisite: admit Compressed DATA before destructive preparation + +This correction is complete and removes the active Compressed timing blocker. The [replacement plan](ieee80211-compressed-blockack-replacement.md#excluded-features-and-fragmentation) excludes complete-cost TXOP admission from its original scope. On 2026-10-16, the maintainer authorized this separate correction and subsequent S5 completion. The resolved contract below passed source validation and independent review before production edits. The [S5 execution record](ieee80211-compressed-blockack-s5-execution.md#authorized-txop-correction-and-c3-acceptance) supplies the final runtime evidence and scope limits. + +## Problem and required result + +The final S5 candidate sends two later A-MSDUs beyond their TXOP bounds in a supported case. The exact parent has no such violation in that case. The [S5 execution record](ieee80211-compressed-blockack-s5-execution.md#confirmed-timing-blocker) supplies the comparison and its limits. IEEE Std 802.11-2024, Clause 10.23.2.9 does not permit the observed continuation. + +The correction must establish the complete exchange cost before DATA commitment. An aggregate must fit its applicable bound. A later ordinary MSDU must also fit. The correction must retain the permitted initial unaggregated MSDU exception. It must not strand an oversized aggregate until lifetime expiry. + +A zero TXOP limit permits one SU PPDU with one MSDU or A-MSDU, plus its required protection and response. It does not mean zero permitted airtime. With a positive limit, the initial unaggregated MSDU exception permits at most one Data or Management frame. RTS and CTS airtime counts toward the exchange cost, but those Control frames do not increase that count. A same-size retransmission has a separate permitted exception under Clause 10.23.2.9; the implementation contract must state its retry policy. + +Hypothetical example: a TXOP has 200 microseconds left. The proposed aggregate needs 400 microseconds, while its first ordinary MSDU needs 150 microseconds. The service must commit that ordinary MSDU and leave the other MSDUs queued. If neither form qualifies, the sequence must end without queue removal or sequence assignment. + +The initial implementation scope covers active Compressed agreements. Explicit Basic and Normal Ack fallback outside an agreement retain their current preparation paths. This boundary avoids an unrelated compatibility repair. It does not claim that those retained paths satisfy every TXOP constraint. + +## Confirmed cause + +The [data service](../../src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc) removes aggregation candidates before HCF selects the actual DATA mode. The aggregation builder deletes the constituent frames. The service replaces their lifetime records and assigns a sequence number. At that point, a final HCF refusal cannot recover the original queue form. + +The [frame sequence](../../src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc) tests whether positive TXOP time remains. That test does not prove that a complete later exchange fits. HCF excludes Block Ack support from its existing complete-cost DATA guard. A guard at final submission therefore needs a preparation correction as well. + +AARF and Onoe can change state when the rate selector queries them. Separate mode queries for a preview, RTS protection, and DATA submission can produce different decisions. The cost calculation must use the actual selected mode without extra rate-control queries. + +## Proposed ownership and sequence + +| Step | Responsible component and proposed action | Expected result and verification | +| --- | --- | --- | +| 1. Prepare without commitment. | The data service obtains borrowed candidates from the aggregation policy. It constructs a preview from duplicates. | Queue ownership, deadlines, and sequence counters remain unchanged. A focused fixture records them before and after refusal. | +| 2. Select one DATA mode. | HCF selects the mode once for this preparation. The frame-sequence context owns that decision and the preparation state. | Aggregate evaluation, ordinary-MSDU evaluation, protection, and submission use one mode decision. A test rate control counts queries. | +| 3. Calculate complete cost. | HCF derives the applicable IFS, DATA duration, protection, and immediate response from their existing owners. | Admission checks the TXOP bound and the applicable TXNAV bound. PHY mode objects supply durations. | +| 4. Select a permitted form. | HCF first evaluates the aggregate. If it fails, HCF evaluates the selected ordinary MSDU with the same mode. | An oversized aggregate does not cause permanent refusal. The ordinary MSDU can fit or qualify for the initial-MSDU exception. | +| 5. Defer when necessary. | The frame sequence ends normally when neither form qualifies. | The queue remains intact. Refusal causes no DATA retry outcome, sequence assignment, or aggregate lifetime replacement. | +| 6. Commit at a safe boundary. | The data service commits only the accepted form. HCF uses its retained mode for the actual exchange. | Extraction, lifetime replacement, and sequence assignment occur once. No committed aggregate waits indefinitely because its form cannot fit. | + +BAR arbitration must precede DATA preparation, as S4 requires. The correction adds no BAR forecast. A final BAR can obtain a later TXOP through the existing arbitration path. + +The existing final false-transmit result remains a safety check. The frame-sequence handler removes a refused step and ends the sequence without a transmission-failure result. Normal admission refusal must occur before destructive source commitment. + +## Boundary requirements + +RTS creates an event boundary between preparation and DATA submission. A capability update, lifetime expiry, or RTS failure can occur before DATA starts. The implementation contract must identify the owner of each preview and original frame throughout that interval. + +The resolved contract retains reversible preparation until the first DATA submission. A failed RTS or invalidated capability discards the preview and its selected mode. Original queue frames retain their existing deadlines and sequence state. A later attempt obtains a new preparation and mode decision. The source trace established that this boundary fits the existing ownership and lifetime contracts. + +The frame-sequence API must distinguish preparation refusal from an empty queue and a failed transmission. `InProgressFrames` must not convert those outcomes into a DATA retry. The integration must preserve S4's preview and BAR-first contracts. + +Admission refusal causes no DATA retry outcome. An actual RTS failure retains its required recovery behavior while the service discards reversible preparation. The implementation contract must keep those paths separate. + +For DATA under an active Block Ack agreement, an actual RTS failure updates QSRC and the contention window. QSRC is the short retry counter for an access category. Clause 10.23.2.12.1 applies its associated-RTS increment rule to MSDUs and A-MSDUs outside a Block Ack agreement. A preview must not create a sequence-keyed counter before sequence assignment. QSRC rollover therefore does not discard queued DATA; its lifetime still bounds repeated attempts. This changes INET's former per-frame RTS discard behavior on this scoped path. Basic and Normal Ack outside an agreement retain their existing recovery. + +At the preceding exchange completion, TXNAV admission compares complete exchange cost strictly below the remaining TXNAV. That cost excludes the leading IFS. Positive-limit TXOP containment includes the leading IFS and permits equality with the bound. Clauses 10.23.2.8 and 9.2.5.2 support these separate comparisons. The correction must not move the strict TXNAV comparison to a later reference that rejects an exact single-protection reservation. + +The correction must not retain an illegal mode after peer capabilities change. It must also avoid a second adaptive-rate query merely to validate an unchanged prepared decision. The implementation contract must specify that validation separately from mode selection. + +These are engineering checks for the approved scope. They do not require the maintainer to choose a cache format or callback signature. If source analysis needs a different behavior or a wider compatibility change, the owner must update this proposal first. + +## Resolved implementation contract + +The data service owns duplicate previews through `PreparedQosData`. Each preparation records original frame IDs and its source queue. It retains no original frame pointer across events. `prepareFrame(queue, allowAggregation)` creates one form without extraction. HCF first requests the aggregate form. If that form fails admission, HCF requests the ordinary form with the same DATA mode. + +`QoSContext` owns the selected preparation and its retained modes. HCF supplies a preparation callback with three outcomes: `LEGACY`, `READY`, and `DEFERRED`. `HcfFs` calls it after BAR arbitration and before extraction. Refusal ends the repeat normally. Legacy contexts retain their existing extraction route. + +`isPreparationValid()` checks source membership, eligibility, deadlines, next sequence, and A-MSDU permission. HCF separately validates every retained mode and response input through pure queries. These checks include mode-set changes. A changed input cancels preparation without another adaptive DATA query. HCF repeats validation before RTS and before DATA submission. + +`commitPreparedFrame()` removes the accepted sources only before first DATA submission. It transfers the same preview pointer to `InProgressFrames`. Ordinary commitment transfers the original absolute deadline. Aggregate commitment starts the existing A-MSDU lifetime. Commitment assigns one sequence number and allocation index. Frame-sequence steps retain valid borrowed pointers until their disposal. + +```mermaid +flowchart TD + Queue[Original MSDUs remain queued.] --> Preview[The service creates duplicate previews.] + Preview --> Admission{Does a permitted form qualify?} + Admission -->|No| Refuse[HCF ends the sequence without commitment.] + Admission -->|Yes| Protection{Does DATA require RTS?} + Protection -->|No| Validate{Are sources and retained modes valid?} + Protection -->|Yes| RTS[HCF submits RTS with the retained decision.] + RTS -->|CTS succeeds| Validate + RTS -->|CTS fails for valid sources| Recovery[Recovery updates QSRC and CW.] + RTS -->|Sources become invalid| Discard + Recovery --> Discard[Context disposal deletes the preview.] + Validate -->|No| Discard + Validate -->|Yes| Commit[The service commits the same preview pointer.] + Commit --> Data[HCF submits DATA with its retained mode.] +``` + +Expiry during CTS wait can remove originals safely because preparation stores their IDs. An invalid preparation ends without stale DATA or a synthetic RTS failure. A valid preparation with failed CTS causes one actual RTS recovery outcome. Context disposal deletes unused previews after step disposal. + +The scoped single-protection path reserves only its current exchange. It makes no forecast for unprepared successor DATA. A later BAR can contend through the existing S4 route. Multiple protection retains its reservation formula. This choice can increase contention and change simulation trajectories for active Compressed agreements. + +Committed retransmissions use the same-size single-MPDU exception from Clause 10.23.2.9 when no earlier Data or Management frame occurred in the TXOP. This exception can include a retransmitted A-MSDU. It does not permit an oversized first-attempt A-MSDU. The supported Compressed path has no fragmentation or A-MPDU operation. Its committed MPDU retains its size across retries; Retry and Duration field changes do not change that size. Basic and outside-agreement fallback retain their existing paths. + +A bounded LLDB observation established why conservative retry containment cannot satisfy the supported exchange. AP DATA at 6 Mbit/s needs a 1.166-millisecond protected exchange within a nominal one-millisecond TXOP. Its first ordinary transmission qualifies for the initial exception. A real BAR collision makes that DATA retry eligible. Conservative containment then refuses every attempt despite the permitted same-size exception. The root validated the required policy correction before source edits. Evidence is `/tmp/inet-s5-txop-diagnostic-lldb-cost.out`. + +Internal collision has a separate preparation entry. The existing HCF branch extracts DATA before it updates collision recovery. On the scoped queued path, HCF instead commits one ordinary preview before that existing recovery action. It must not create an aggregate before admission. Other queued MSDUs retain their ownership and deadlines. An unsent ordinary MSDU still qualifies for the first-transmission exception when its conditions hold. + +Multiple protection must reserve the actual exchange when a permitted initial ordinary MSDU or same-size retransmission exceeds a positive limit. The scoped path uses the existing helper's current-exchange form for that case. It must not reduce protection to zero merely because DATA exceeds the limit. The helper's reservation formula remains unchanged. + +The root validated this contract against the current source. An independent review found no unresolved blocking gap. This contract review supplies no runtime proof. Production implementation and focused verification follow this gate. + +## Proposed verification + +The direct reproduction uses `Ieee80211CompressedBlockAckExchange_1.test`, General run 6, seed zero. It selects HT operation, 24 Mbit/s DATA, single protection, aggregation, and a one-millisecond TXOP. The candidate must eliminate both 310-microsecond continuation overruns. The raw comparison remains in `/tmp/inet-s5-exchange-parent-candidate-comparison.json`. + +Add a focused preparation fixture at the proposed path `tests/module/Ieee80211CompressedBlockAckAdmission_1.test`. That fixture does not yet exist. Its cases must establish these results: + +- An initial aggregate that cannot fit becomes an ordinary MSDU before commitment. +- A permitted initial unaggregated MSDU can exceed the TXOP limit under the applicable exception. +- A smaller ordinary MSDU can replace an aggregate when it fits the remaining interval. +- Refusal preserves queue ownership, deadlines, and sequence counters when neither form qualifies. +- RTS failure, lifetime expiry, and capability changes discard invalid preparation without stale DATA transmission. +- RTS protection, DATA duration, and admission consume one selected mode. +- Basic controls preserve their existing behavior. + +Repeat S5's complete infrastructure campaign after the correction. Retain the lowest-response cases and exact BAR/Block Ack bounds. Repeat the affected lifetime, setup, frame-sequence, and fragmentation fixtures. Repeat the nineteen selected fingerprint rows without a baseline update. + +C3 can pass only after the supported corrected exchanges meet their applicable bounds. C4 and default activation must follow that result. This proposal grants no publication or fingerprint-baseline authority. + +## Execution result + +All 24 focused admission cases pass. All sixteen infrastructure cases pass the active Compressed timing assertions. Both lowest-response cases pass. Independent review accepts C3. C4 activates the default only after that decision and repeats its required checks. + +The former run 6 violation no longer occurs on either hop. Outside-agreement admission retains its inherited limits. `StrictAllTiming` preserves their separate reproduction. Basic settings and recorded fingerprint expectations remain unchanged. The final nineteen-row fingerprint campaign passes without a baseline update. diff --git a/showcases/wireless/blockack/doc/index.rst b/showcases/wireless/blockack/doc/index.rst index 2d6aa48f04e..b4808ed7c33 100644 --- a/showcases/wireless/blockack/doc/index.rst +++ b/showcases/wireless/blockack/doc/index.rst @@ -50,7 +50,7 @@ Block Acknowledgment in INET In INET, the block ack mechanism can be enabled by setting the :par:`isBlockAckSupported` parameter of the MAC's :ned:`Hcf` submodule to ``true`` (it is disabled by default). -This showcase selects ``blockAckVariant = "basic"`` on both endpoints to retain the historical profile. Basic remains the default. Other configurations can select Compressed explicitly. Compressed agreements require usable local and peer HT state. Without that state, DATA uses Normal Ack. HCF rejects unknown selector values during initialization, also when Block Ack support is disabled. +This showcase selects ``blockAckVariant = "basic"`` on both endpoints to retain the historical profile. HCF defaults to Compressed for other configurations. Compressed agreements require usable local and peer HT state. Without that state, DATA uses Normal Ack. HCF rejects unknown selector values during initialization, also when Block Ack support is disabled. Several submodules of :ned:`Hcf` are involved in the block ack mechanism. These modules have parameters controlling the block ack behavior. The following paragraphs diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned index e38a6636622..19462280f07 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.ned @@ -29,7 +29,7 @@ module Hcf extends Module like IHcf { parameters: bool isBlockAckSupported = default(false); - string blockAckVariant = default("basic"); // Compressed requires usable HT state. Select Basic explicitly for historical compatibility. + string blockAckVariant = default("compressed"); // Compressed requires usable HT state. Select Basic explicitly for historical compatibility. string rxModule; string txModule; diff --git a/tests/module/Ieee80211BlockAckDeferral_1.test b/tests/module/Ieee80211BlockAckDeferral_1.test index 58f6614bc96..b1d38cbbfa9 100644 --- a/tests/module/Ieee80211BlockAckDeferral_1.test +++ b/tests/module/Ieee80211BlockAckDeferral_1.test @@ -384,6 +384,7 @@ record-vector-results = false **.wlan[*].mac.qosStation = true **.wlan[*].mac.hcf.typename = "DeferralHcf" **.wlan[*].mac.hcf.isBlockAckSupported = ${scenario} != 4 +**.wlan[*].mac.hcf.blockAckVariant = "basic" **.wlan[*].mac.hcf.originatorBlockAckAgreementPolicy.typename = ${policy="OriginatorBlockAckAgreementPolicy","LongTimeoutPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy","OriginatorBlockAckAgreementPolicy" ! scenario} **.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = ${aggregation="","","","","","","","","","","","BasicMsduAggregationPolicy" ! scenario} **.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 diff --git a/tests/module/Ieee80211CompressedBlockAckExchange_1.test b/tests/module/Ieee80211CompressedBlockAckExchange_1.test index 4ccb39e660a..2988432ef82 100644 --- a/tests/module/Ieee80211CompressedBlockAckExchange_1.test +++ b/tests/module/Ieee80211CompressedBlockAckExchange_1.test @@ -352,7 +352,6 @@ network ExchangeNetwork { %inifile: omnetpp.ini [General] -**.hcf.blockAckVariant = "compressed" network = ExchangeNetwork ned-path = .;../../../../src sim-time-limit = 1.3s diff --git a/tests/module/Ieee80211CompressedBlockAckMigration_1.test b/tests/module/Ieee80211CompressedBlockAckMigration_1.test new file mode 100644 index 00000000000..72db8ff5672 --- /dev/null +++ b/tests/module/Ieee80211CompressedBlockAckMigration_1.test @@ -0,0 +1,179 @@ +%description: +An external configuration enables Block Ack without an explicit profile. +Legacy g and a links, and an HT ad hoc link without peer HT records, must deliver twelve UDP payloads with Normal Ack. +Require a queued successor without ADDBA, BAR, or BA. Check profile and capability diagnostics with support enabled and disabled. + +%extraargs: -r 0..5 + +%postrun-command: python3 check-diagnostics.py + +%file: Migration.cc +#include +#include "inet/common/Simsignals.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/queueing/contract/IPacketQueue.h" + +namespace inet::ieee80211 { +class MigrationHcf : public Hcf { + public: + int normalData = 0; + int requests = 0; + int bars = 0; + int responses = 0; + bool queuedSuccessor = false; + bool compressed() const { return std::string(par("blockAckVariant").stringValue()) == "compressed"; } + bool clean() const { + return (!originatorBlockAckAgreementHandler || (originatorBlockAckAgreementHandler->getAgreements().empty() && + originatorBlockAckAgreementHandler->getProcedures().empty())) && + (!recipientBlockAckAgreementHandler || recipientBlockAckAgreementHandler->getAgreements().empty()); + } + protected: + bool transmitFrame(Packet *packet, simtime_t ifs) override { + auto header = packet->peekAtFront(); + bool accepted = Hcf::transmitFrame(packet, ifs); + if (!accepted) + return false; + requests += dynamicPtrCast(header) != nullptr; + bars += dynamicPtrCast(header) != nullptr; + responses += dynamicPtrCast(header) != nullptr; + if (auto data = dynamicPtrCast(header)) { + ASSERT(data->getAckPolicy() == NORMAL_ACK); + ASSERT(!mib->findPeerHtState(data->getReceiverAddress())); + normalData++; + } + return true; + } + void originatorProcessTransmittedDataFrame(Packet *packet, const Ptr& header, AccessCategory ac) override { + queuedSuccessor |= edca->getEdcaf(ac)->getPendingQueue()->getNumPackets() > 0; + Hcf::originatorProcessTransmittedDataFrame(packet, header, ac); + } +}; +Define_Module(MigrationHcf); + +class MigrationTest : public cSimpleModule, public cListener { + int received = 0; + int bytes = 0; + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("subscribe")); } + void receiveSignal(cComponent *, simsignal_t, cObject *value, cObject *) override { + auto packet = check_and_cast(value); + received++; + bytes += packet->getByteLength(); + } + void handleMessage(cMessage *message) override { + if (message->isName("subscribe")) { + delete message; + getModuleByPath("^.host2.app[0]")->subscribe(packetReceivedSignal, this); + scheduleAt(SimTime(99, SIMTIME_MS), new cMessage("verify")); + return; + } + delete message; + ASSERT(received == 12 && bytes == 8400); + for (const char *path : {"^.host1.wlan[0].mac.hcf", "^.host2.wlan[0].mac.hcf"}) { + auto hcf = check_and_cast(getModuleByPath(path)); + ASSERT(hcf->compressed() && hcf->clean()); + ASSERT(hcf->requests == 0 && hcf->bars == 0 && hcf->responses == 0); + if (hcf->normalData > 0) + ASSERT(hcf->normalData >= 12 && hcf->queuedSuccessor); + } + ASSERT(check_and_cast(getModuleByPath("^.host1.wlan[0].mac.hcf"))->normalData >= 12); + std::cout << "Compressed default migration assertions passed.\n"; + endSimulation(); + } +}; +Define_Module(MigrationTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.AdhocHost; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module MigrationHcf extends Hcf { parameters: @class(::inet::ieee80211::MigrationHcf); } +simple MigrationTest { parameters: string opMode; bool supported; @class(::inet::ieee80211::MigrationTest); } +network MigrationNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: Ieee80211ScalarRadioMedium; + host1: AdhocHost; + host2: AdhocHost; + test: MigrationTest; +} + +%inifile: omnetpp.ini +[General] +network = MigrationNetwork +ned-path = .;../../../../src +sim-time-limit = 100ms +seed-set = 0 +cmdenv-express-mode = false +cmdenv-event-banners = false +**.mac.hcf.originatorBlockAckAgreementPolicy.cmdenv-log-level = debug +**.mac.hcf.cmdenv-log-level = info +**.cmdenv-log-level = off +record-vector-results = false +record-scalar-results = false +*.test.opMode = ${opMode="g(mixed)","a","n(mixed-2.4Ghz)"} +*.test.supported = ${supported=true,false} +*.host1.numApps = 1 +*.host1.app[0].typename = "UdpBasicApp" +*.host1.app[0].destAddresses = "host2" +*.host1.app[0].destPort = 1000 +*.host1.app[0].messageLength = 700B +*.host1.app[0].startTime = 10ms +*.host1.app[0].stopTime = 11.15ms +*.host1.app[0].sendInterval = 100us +*.host2.numApps = 1 +*.host2.app[0].typename = "UdpSink" +*.host2.app[0].localPort = 1000 +*.host*.ipv4.arp.typename = "GlobalArp" +*.host*.wlan[*].opMode = ${opMode} +*.host*.wlan[*].radio.bandName = ${opMode} == "a" ? "5 GHz (mapped 20 MHz)" : "2.4 GHz" +*.host*.wlan[*].radio.channelNumber = 0 +*.host*.wlan[*].bitrate = 6Mbps +*.host*.wlan[*].classifier.typename = "QosClassifier" +*.host*.wlan[*].mac.qosStation = true +*.host*.wlan[*].mac.hcf.typename = "MigrationHcf" +*.host*.wlan[*].mac.hcf.isBlockAckSupported = ${supported} +**.originatorMacDataService.msduAggregationPolicy.typename = "" +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 2346B +*.host*.wlan[*].radio.receiver.energyDetection = -105dBm +*.host*.wlan[*].radio.receiver.sensitivity = -105dBm +*.host*.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.host1.mobility.initialX = 0m +*.host2.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%file: check-diagnostics.py +from pathlib import Path +import re + +text = Path("test.out").read_text() +runs = re.split(r"Preparing for running configuration General, run #\d+\.\.\.", text)[1:] +assert len(runs) == 6, len(runs) +warning = "Compressed Block Ack has no usable local HT support" +profile = "Block Ack profile: compressed" +for run in runs: + ht = '$opMode="n(mixed-2.4Ghz)"' in run + supported = "$supported=true" in run + assert "Compressed default migration assertions passed." in run + assert run.count(profile) == (2 if supported else 0), run + assert run.count(warning) == (2 if supported and not ht else 0), run + if supported: + reason = "peer HT state is absent" if ht else "local HT state is absent" + assert f"Compressed Block Ack setup refused: {reason}; DATA uses Normal Ack." in run, run + else: + assert "Compressed Block Ack setup refused:" not in run, run +print("Compressed default migration diagnostics passed.") + +%contains: stdout +Compressed default migration assertions passed. diff --git a/tests/protocol/wifi/11ac/Ac_BlockAck.test b/tests/protocol/wifi/11ac/Ac_BlockAck.test index cd274cf2543..e6407799617 100644 --- a/tests/protocol/wifi/11ac/Ac_BlockAck.test +++ b/tests/protocol/wifi/11ac/Ac_BlockAck.test @@ -1,8 +1,11 @@ %description: 802.11ac Block Ack session: ADDBA action (type 13), BlockAckReq (type 24), BlockAck (type 25). [Required] -Check explicit Basic and Compressed with concrete BAR/BA types and positive receipt bits. +Check explicit Basic, explicit Compressed, and the NED default with concrete BAR/BA types and positive receipt bits. +The third run uses the unquoted INI keyword default. OMNeT++ accepts the parameter's NED default for this keyword. -%extraargs: -r 0..1 +%extraargs: -r 0..2 + +%postrun-command: python3 check-default.py %file: Ac_BlockAck.cc @@ -78,9 +81,9 @@ Define_ProtocolTest(wifi_11ac_compressed_exchange) %inifile: test.ini [General] -*.tester.testName = ${test="wifi_11ac_block_ack","wifi_11ac_compressed_exchange"} +*.tester.testName = ${test="wifi_11ac_block_ack","wifi_11ac_compressed_exchange","wifi_11ac_compressed_exchange"} *.sta*.wlan[*].mac.hcf.isBlockAckSupported = true -**.wlan[*].mac.hcf.blockAckVariant = ${profile="basic","compressed" ! test} +**.wlan[*].mac.hcf.blockAckVariant = ${profile="basic","compressed",default ! test} *.ap.wlan[*].mac.hcf.isBlockAckSupported = true *.sta*.wlan[*].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 5 *.sta1.app[0].sendInterval = 0.1ms @@ -96,6 +99,20 @@ include ../../ini/_base.ini **.hcf.originatorMacDataService.msduAggregationPolicy.aggregationLengthThreshold = 10000 *.sta*.wlan[*].mac.hcf.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +%file: check-default.py +from pathlib import Path +import re + +runs = re.split(r"Preparing for running configuration General, run #\d+\.\.\.", Path("test.out").read_text())[1:] +assert len(runs) == 3, len(runs) +for run, profile in zip(runs, ["basic", "compressed", "default"]): + assert f'$profile={profile if profile == "default" else chr(34) + profile + chr(34)}' in run + resolved = "basic" if profile == "basic" else "compressed" + assert run.count(f"Block Ack profile: {resolved}") == 3 + test = "wifi_11ac_block_ack" if profile == "basic" else "wifi_11ac_compressed_exchange" + assert f"PROTOCOLTEST {test}: PASS" in run +print("Basic, explicit Compressed, and NED default exchanges passed.") + %contains: stdout PROTOCOLTEST wifi_11ac_block_ack: PASS diff --git a/tests/protocol/wifi/11n/N_BlockAck.test b/tests/protocol/wifi/11n/N_BlockAck.test index 98f60e3b1d7..0ae29c49cad 100644 --- a/tests/protocol/wifi/11n/N_BlockAck.test +++ b/tests/protocol/wifi/11n/N_BlockAck.test @@ -1,8 +1,11 @@ %description: 802.11n Block Ack session: ADDBA action (type 13), BlockAckReq (type 24), BlockAck (type 25). [Required] -Check explicit Basic and Compressed with concrete BAR/BA types and positive receipt bits. +Check explicit Basic, explicit Compressed, and the NED default with concrete BAR/BA types and positive receipt bits. +The third run uses the unquoted INI keyword default. OMNeT++ accepts the parameter's NED default for this keyword. -%extraargs: -r 0..1 +%extraargs: -r 0..2 + +%postrun-command: python3 check-default.py %file: N_BlockAck.cc @@ -79,9 +82,9 @@ Define_ProtocolTest(wifi_11n_compressed_exchange) %inifile: test.ini [General] -*.tester.testName = ${test="wifi_11n_block_ack","wifi_11n_compressed_exchange"} +*.tester.testName = ${test="wifi_11n_block_ack","wifi_11n_compressed_exchange","wifi_11n_compressed_exchange"} *.sta*.wlan[*].mac.hcf.isBlockAckSupported = true -**.wlan[*].mac.hcf.blockAckVariant = ${profile="basic","compressed" ! test} +**.wlan[*].mac.hcf.blockAckVariant = ${profile="basic","compressed",default ! test} *.ap.wlan[*].mac.hcf.isBlockAckSupported = true *.sta*.wlan[*].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 5 *.sta1.app[0].sendInterval = 0.1ms @@ -97,6 +100,20 @@ include ../../ini/_base.ini **.hcf.originatorMacDataService.msduAggregationPolicy.aggregationLengthThreshold = 10000 *.sta*.wlan[*].mac.hcf.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +%file: check-default.py +from pathlib import Path +import re + +runs = re.split(r"Preparing for running configuration General, run #\d+\.\.\.", Path("test.out").read_text())[1:] +assert len(runs) == 3, len(runs) +for run, profile in zip(runs, ["basic", "compressed", "default"]): + assert f'$profile={profile if profile == "default" else chr(34) + profile + chr(34)}' in run + resolved = "basic" if profile == "basic" else "compressed" + assert run.count(f"Block Ack profile: {resolved}") == 3 + test = "wifi_11n_block_ack" if profile == "basic" else "wifi_11n_compressed_exchange" + assert f"PROTOCOLTEST {test}: PASS" in run +print("Basic, explicit Compressed, and NED default exchanges passed.") + %contains: stdout PROTOCOLTEST wifi_11n_block_ack: PASS From 917471ab57b7b246c90984e567d3daa0e90dc73e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:52:52 +0200 Subject: [PATCH 18/41] plan: add: define HT A-MPDU reception stages Before this commit, the branch has no plan for HT aggregate reception or implicit Block Ack integration. After this commit, the plans define separate PHY and MAC duties, staged changes, required evidence, and acceptance limits. The PHY plan records the approved exception to the merge prerequisite. Its first stages define wire representation, bounded member ranges, and cached PHY outcomes. Later MAC acceptance remains separate. This commit changes no runtime behavior. Plan: plan/pending/ieee80211-ampdu-phy-reception.md Change: plan | behavior.add | - | ieee80211-ampdu-phy-reception --- ...ee80211-ampdu-implicit-blockack-summary.md | 368 ++++++++++ .../ieee80211-ampdu-implicit-blockack.md | 639 ++++++++++++++++++ plan/pending/ieee80211-ampdu-phy-reception.md | 363 ++++++++++ 3 files changed, 1370 insertions(+) create mode 100644 plan/pending/ieee80211-ampdu-implicit-blockack-summary.md create mode 100644 plan/pending/ieee80211-ampdu-implicit-blockack.md create mode 100644 plan/pending/ieee80211-ampdu-phy-reception.md diff --git a/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md b/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md new file mode 100644 index 00000000000..55bd58dea82 --- /dev/null +++ b/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md @@ -0,0 +1,368 @@ +# A-MPDU with implicit Compressed Block Ack: plan summary + +> **Kind:** reference · **Status:** draft · **Seal:** none · **Owns:** — · **Stands on:** [feature plan](ieee80211-ampdu-implicit-blockack.md), [PHY plan](ieee80211-ampdu-phy-reception.md) + +This plan proposes several independently acknowledged MPDUs in one HT transmission. The recipient sends one Compressed Block Ack after the transmission ends. The aggregate requests that response without a separate BAR. The originator retries only the MPDUs that remain unacknowledged. + +This summary describes revision 12 of the [feature plan](ieee80211-ampdu-implicit-blockack.md) and revision 11 of the [PHY plan](ieee80211-ampdu-phy-reception.md), dated 2026-10-17. Their source reference is branch `work/compressed-blockack-s5` at `4fa5cc0de15ee57388bcb3f20e866cab5972a670`. The feature remains proposed. The diagrams describe the design, not executed simulation traces. + +The PHY plan supplies aggregate reception before the MAC feature uses it. Its first gate proves deterministic member outcomes and includes the shared NIST/Yans implementation. It also preserves default HT operation and reception without an error model. Its second gate extends the NIST/Yans and compatibility evidence. The MAC feature can reach deterministic integration between those gates. + +Implementation waits for merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). Read-only source checks can occur now. Both plans require a refreshed merged base before source implementation. This is the agreed delivery policy for one shared S5 baseline. + +## What changes after S5 + +S5 is the stage that supplies explicit Compressed BAR exchanges for individual MPDUs. The originator sends those MPDUs in separate PPDUs. It later sends BAR to request their receipt status. The proposed path puts several MPDUs into one A-MPDU and requests receipt status through that aggregate. [Problem and intended behavior](ieee80211-ampdu-implicit-blockack.md#1-problem-and-intended-behavior). + +This illustration assumes an accepted agreement and three MPDUs. Both paths end with a Compressed Block Ack. The proposed path needs fewer separate PHY transmissions for those MPDUs. Protection, contention, response rates, and loss still affect goodput; the plan promises no fixed performance gain. + +```mermaid +flowchart TB + subgraph Current["Current S5: explicit request"] + direction LR + C1["DATA 100
One PPDU"] --> C2["DATA 101
One PPDU"] + C2 --> C3["DATA 102
One PPDU"] + C3 --> CB["BAR
One PPDU"] + CB --> CR["Compressed Block Ack"] + end + subgraph Proposed["Proposed: implicit request"] + direction LR + A["One A-MPDU in one PPDU
MPDUs 100, 101, 102"] --> R["Compressed Block Ack
after SIFS"] + end +``` + +An A-MSDU and an A-MPDU combine different units. An A-MSDU combines MSDUs inside one MPDU. An A-MPDU combines complete MPDUs, each with its own FCS. Separate receipt bits therefore permit selective retry within the aggregate. + +## What the aggregate contains + +One common PHY preamble and header serve the complete aggregate. Each MPDU retains its MAC header, payload, sequence number, and FCS. A delimiter identifies each MPDU boundary and length. The aggregate has no additional outer MAC header or outer FCS. [Representation and limits](ieee80211-ampdu-implicit-blockack.md#42-eligibility-and-limits). + +PHY P1 extends the modeled HT-SIG fields and their serializer together. HT-SIG is the HT signal field that carries PSDU length and the Aggregation property. Golden bytes and independent decode must preserve both values in the 48-bit header. A singleton must retain Aggregation equal to one after byte conversion. This work covers the modeled HT-SIG header without a new waveform model. [HT-SIG representation and verification](ieee80211-ampdu-phy-reception.md#41-representation-and-bounded-ranges). + +The radio already assigns that 48-bit header length. P0 records its current value and the mode/PSDU duration path. P1 completes byte conversion within the same length; ordinary HT controls must preserve airtime under identical inputs. Changed byte content alone establishes no airtime change or reason to update a fingerprint expectation. + +Correct bytes alone do not establish rejection of an invalid received header. P1 also defines one stateless HT-SIG validator. P2 applies it before member outcomes and before radio decapsulation trusts HT Length. Invalid CRC or unsupported fields cause HEADER failure without delimiter or member draws. The current header-failure paths prevent receipt updates, delivery, and responses. [HT-SIG receive validation](ieee80211-ampdu-phy-reception.md#ht-sig-receive-validation). + +A separate bounds check refuses modeled PSDU content shorter than a valid header's HT Length. HEADER retains success and the decoded Aggregation property. DATA reports failure without range outcomes or draws, and MAC refuses the content before header or trailer peeks. Decapsulation skips length-based trailer removal. This case proves bounds safety for malformed input. It establishes no physical carrier-loss behavior or acceptance of a received prefix. + +The diagram shows two members. Nonfinal HT subframes need alignment padding of zero to three octets. The final HT subframe has no alignment padding. Extra zero-length delimiters can provide the minimum MPDU start spacing that the receiver requires. + +```mermaid +flowchart TB + PHY["One common HT PHY preamble and header"] --> BODY + subgraph BODY["One PSDU: the A-MPDU"] + direction LR + D1["Delimiter
4 octets"] --> M1["MPDU 100
Header, MSDU, FCS"] + M1 --> P["Alignment padding
0 to 3 octets"] + P --> S["Zero-length delimiters
if spacing requires them"] + S --> D2["Delimiter
4 octets"] + D2 --> M2["Final MPDU 101
Header, MSDU, FCS"] + end +``` + +Each complete HT member must fit the 4095-octet delimiter limit. The whole aggregate must fit both the peer's advertised limit and the HT maximum of 65535 octets. Its airtime must also satisfy the PHY and TXOP limits. A byte count alone cannot establish that an aggregate qualifies. + +## Which traffic can use the first version + +The first transmit profile uses packet-level `Ieee80211Radio`, scalar or dimensional reception, HT mixed format, 20 MHz, and long GI. Aggregate transmission requires fixed DATA rates and no HCF rate-control submodule. Each aggregate serves one recipient and TID under an accepted immediate Compressed agreement. Compressed responses retain the 64-bit bitmap. Multiple peers and agreements can coexist; each retains separate state. [Supported profile](ieee80211-ampdu-implicit-blockack.md#first-supported-profile). + +Receive support also covers advertised HT20 short-GI modes at the permitted MCS and NSS values. Before the MIB update, the MAC supplies its exact mode set, effective channel widths, and NSS limit for receiver validation. The check covers advertised modes; unsupported catalog modes outside those limits do not cause rejection. A peer can select an advertised short-GI receive mode even when the local aggregate transmitter uses long GI. The new transmit policy remains limited to long GI. [Required receive coverage](ieee80211-ampdu-phy-reception.md#42-optional-role-and-shared-implementation). + +HCF coordinates eligibility and the exchange. Management and the MIB supply local and peer capabilities. The proposed HT policy selects members within those capabilities and the agreement's transmit window. The policy cannot grant an agreement or bypass a PHY limit. + +```mermaid +flowchart TD + P{"Does the transmitter select
the new HT aggregation policy?"} + P -->|No| OLD["Use the current individual-frame path"] + P -->|Yes| H{"Do the actual HT mode
and peer state qualify?"} + H -->|No| FALL["Apply current fallback rules
No A-MPDU transmission"] + H -->|Yes| A{"Is an immediate Compressed
agreement active for this peer and TID?"} + A -->|No| SETUP["Use current setup or fallback
No aggregate before acceptance"] + A -->|Yes| L{"Do members, spacing, window,
length, and airtime qualify?"} + L -->|No| SMALL["Reduce the batch or use
an eligible individual frame"] + L -->|Yes| TX["Prepare one aggregate exchange"] +``` + +The transmit feature requires an explicit policy choice. The default policy continues to select no A-MPDU. A receiver must recognize supported received aggregates even when its own transmitter uses the default policy. Absent peer HT state retains S5's Normal Ack fallback. + +The WLAN receiver checks role presence at PHY initialization. The MAC requests exact coverage validation later, before its MIB update at link-layer initialization. Absent roles and incomplete advertised coverage cause failure before management sends capability information. These checks apply even when local transmit aggregation remains disabled. Non-HT custom models retain ordinary MPDU reception without that role. [Early compatibility checks](ieee80211-ampdu-phy-reception.md#44-model-detail-and-diagnostics). + +HT length exponent zero still advertises 8191 octets; it cannot disable aggregate reception. A model that exposes the role but lacks advertised short-GI support therefore fails initialization. A one-antenna configuration must pass when the model supports every advertised mode. The catalog can contain unsupported modes for more spatial streams. The validation adds no second capability store or independent filter. + +BerTable remains outside the HT aggregate profile. Its current initializer rejects HT operation strings before the new role check. This delivery adds no aggregate role to BerTable. The migration guide directs supported HT configurations to NIST or Yans. The PHY fixture compares a non-HT parent control and verifies the current HT refusal separately from the custom-model role diagnostic. [Compatibility decision and checks](ieee80211-ampdu-phy-reception.md#5-affected-components-and-compatibility). + +An absent error model retains the current error-free abstraction after PHY acquisition, possibility, attempt, and SNIR checks. Successful common checks permit physical success for bounded delimiter and member ranges without new error draws. Delimiter, FCS, address, and agreement checks still control MAC acceptance. This case adds no replacement module or interface requirement. + +The proposed settings are: + +```ini +**.mac.hcf.isBlockAckSupported = true +**.mac.hcf.blockAckVariant = "compressed" +**.mac.hcf.rateControl.typename = "" +**.mac.hcf.rateSelection.dataFrameBitrate = 6.5Mbps +**.mac.hcf.rateSelection.dataFrameBandwidth = 20MHz +**.mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1 +**.mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +``` + +`HtMpduAggregationPolicy` does not exist yet. The fixed rate above selects HT MCS 0 with one spatial stream under the required HT20 long-GI configuration. These settings also need compatible modes, usable peer HT state, and accepted agreements. An `ac` interface qualifies only through an actual supported HT transmission. It does not establish VHT A-MPDU support. [Configuration and compatibility](ieee80211-ampdu-implicit-blockack.md#5-affected-components-and-compatibility). + +## How partial loss leads to selective retry + +Consider this hypothetical exchange with MPDUs 100 through 103. The recipient receives 100, 102, and 103 correctly. MPDU 101 fails. The recipient reports those separate results in one bitmap after the complete PPDU and SIFS. + +```mermaid +sequenceDiagram + participant O as Originator HCF + participant R as Recipient PHY and HCF + participant U as Recipient upper protocol + Note over O,R: Accepted immediate Compressed agreement for one peer and TID + O->>R: One A-MPDU: 100, 101, 102, 103 + Note over R: 101 fails. Retain receipt evidence for 100, 102, 103. + R->>O: After SIFS: bitmap 100=1, 101=0, 102=1, 103=1 + Note over O: Release acknowledged MPDUs. Retain 101 with its original deadline. + O->>R: Singleton A-MPDU: retry 101 + R->>O: After SIFS: Compressed Block Ack + Note over R,U: Apply reorder rules. Deliver each MSDU exactly once. +``` + +The originator releases 100, 102, and 103 from its transmit store. It retains 101 until acknowledgment or terminal disposal. The retry preserves 101's sequence number and absolute deadline. A singleton A-MPDU still requests Block Ack. One member does not turn it into a standalone MPDU with an individual ACK. + +The wire ACK policy bits remain `00`. In a standalone MPDU, those bits ordinarily mean Normal Ack. In the supported aggregate context, they mean Implicit BAR. The PHY aggregation property and MAC exchange context preserve that distinction. [Implicit exchange and recovery](ieee80211-ampdu-implicit-blockack.md#47-originator-exchange-timing-and-recovery). + +## Why preparation must preserve the source frames + +The MAC must know whether the complete exchange fits before it removes source MSDUs from their queues. The QoS data service therefore creates previews first. HCF selects one DATA mode and checks the batch with that mode. A refusal leaves the source MSDUs, deadlines, and sequence counter intact. [Preparation and ownership](ieee80211-ampdu-implicit-blockack.md#43-preparation-commitment-and-ownership). + +The current fixed-rate rules select the DATA mode by recipient before the service calculates mode-dependent spacing and aggregate length. If padding makes the batch too large, HCF reduces it and checks the smaller batch at that same mode. The design adds no size-aware DATA rate-control API. + +HCF rejects aggregate transmit opt-in with a rate-control submodule, also when fixed-rate settings would bypass that controller's rate choice. AARF can change its rate and probe state after a member callback. Separate callbacks for one PPDU can therefore describe a probe at a rate that no transmission used. The first profile avoids that false result through fixed rates. Adaptive aggregate feedback needs a separate design; existing individual-frame configurations retain their current rate-control behavior. + +The proposed policy selects transmitted retries first, numbered unsent MPDUs second, and queued new members last. Both committed groups use cyclic sequence order; queued new members use queue order. This order is an INET choice. Previews of queued members use candidate numbers without counter advancement. Commitment validates that reference before actual assignment. Already numbered members retain their numbers and deadlines. + +An internal collision can cause the current HCF handler to extract and number one frame without a DATA transmission. The EDCAF that loses the collision retains its current single-frame recovery, including terminal disposal. Aggregate preparation accepts a retained numbered frame without another sequence allocation. Current acknowledgment state keeps Retry clear for its first DATA transmission. The feature plan's [source-state table](ieee80211-ampdu-implicit-blockack.md#43-preparation-commitment-and-ownership) defines that distinction. + +A1 supplies capability propagation and aggregate construction calculations for spacing, serialization, and member layout. A3 uses those calculations for dynamic member selection, spacing at the retained mode, and batch reduction. A3 also retains canonical member ownership. [Implementation responsibilities](ieee80211-ampdu-implicit-blockack.md#6-implementation-steps-and-dependencies). + +```mermaid +flowchart TD + Q["Source MSDUs remain in their queues"] --> P["Create previews
Select one DATA mode"] + P --> F{"Does a permitted batch fit?"} + F -->|No| KEEP["Preserve queue contents,
deadlines, and sequence state"] + F -->|Yes| PROTECT["Perform RTS/CTS if required"] + PROTECT --> START["At the existing Tx IFS boundary
Call HCF before actual submission"] + START --> V{"Are sources, agreement,
deadlines, and modes still valid?"} + PROTECT -->|RTS fails| RTSFAIL["Release unused previews
Apply one contention failure"] + V -->|No| CANCEL["Cancel the unsent aggregate
Create no DATA failure feedback"] + V -->|Yes| COMMIT["Commit new members
Assign their sequence numbers"] + COMMIT --> STORE["Transmit store retains
independent MPDUs"] + STORE --> FINAL["Finalize each member header
Calculate its own FCS"] + FINAL --> ENV["Aggregate envelope references
immutable member content"] + ENV --> TX["Transmit one PPDU"] + TX --> FREE["Release the envelope
Retain unresolved MPDUs"] +``` + +The transmit store, `InProgressFrames`, owns each committed MPDU until acknowledgment, expiration, or another terminal outcome. The envelope holds references to member content. Envelope disposal must not destroy the MPDUs that still need retry. Each MPDU retains its own lifetime; aggregate construction does not restart it. + +DATA submission means the actual call from Tx to the radio. Tx acceptance before SIFS leaves source MSDUs uncommitted. At its existing IFS timer boundary, Tx calls HCF before it copies or sends the PSDU. HCF validates the batch before the service commits new members. Tx then finalizes each member and submits the envelope within that synchronous call chain. Zero IFS uses the same callback immediately. + +HCF sets each member's Retry bit, ACK policy, and common Duration/ID. Tx applies the local TA and calculates each member's FCS after those header edits. The builder then constructs the delimiter envelope without an outer MAC header or outer FCS. Selective retry requires a fresh member FCS after any header change. [Member finalization](ieee80211-ampdu-implicit-blockack.md#43-preparation-commitment-and-ownership). + +If the originator inactivity timer retires the agreement during SIFS, the start callback refuses the cancelled preparation. No DATA reaches the radio, and no source receives a new sequence number. The frame sequence context retains the preparation until submission or cancellation. Reset cancels the pending Tx request before it releases that context. + +With an active agreement, aggregate RTS failure applies one contention update for new members, committed members, or both together. It adds no member retry increment, DATA attempt, DATA outcome, or pending probe. Queued sources remain queued; committed members retain their numbers, acknowledgment state, recovery state, and deadlines. The contention retry boundary resets access-category state without member disposal. Independent expiry or agreement retirement can still remove members. Current individual-frame RTS recovery and internal collision recovery retain their existing rules, including suppression of obsolete completion feedback. + +## Why the PHY needs separate member results + +The current receiver obtains a whole-data success decision. That decision cannot represent one failed MPDU beside three successful MPDUs. The plan adds separate delimiter and MPDU outcomes, with common PHY acquisition and header success. [Partial reception design](ieee80211-ampdu-implicit-blockack.md#44-phy-representation-and-partial-reception). + +```mermaid +flowchart TD + H{"Did PHY acquisition
and header reception succeed?"} + H -->|No| NONE["No valid aggregate content"] + H -->|Yes| E["Score every delimiter and MPDU
Leave alignment padding unscored"] + E --> C["Reuse PREAMBLE and HEADER decisions
Retain DATA outcomes and derive WHOLE"] + C --> D["Decode bounded delimiter chains
Preserve any continuity break"] + D --> V["Set each failed member Packet flag
Apply FCS and address checks"] + V --> GOOD["Valid members update
receipt and reorder state"] + V --> BAD["Invalid members cause
no receipt or success update"] + GOOD --> END{"At PPDU end, does a valid
addressed member request a response?"} + BAD --> END + END -->|Yes| BA["Send one Compressed Block Ack
after SIFS"] + END -->|No| SILENT["Send no Block Ack"] +``` + +The cache keeps separate entries for each receiver, transmission, and signal part. PREAMBLE preserves the current per-part checks without early HEADER or DATA calculation. HEADER reuses PREAMBLE before its own header calculation. DATA owns bounded range outcomes or structural refusal after successful header reception. A WHOLE query derives its summary from those entries without another error draw. Aggregate success queries must use those same entries. + +In separate-part mode, PREAMBLE or HEADER failure aborts the attempted reception before a container reaches MAC. Existing radio state notifications let HCF invalidate its physical history. Whole-signal mode can supply a failure container that MAC rejects before header or trailer parsing. Both paths prevent acceptance, responses, and range draws. The design preserves their existing event boundaries. + +The PHY scores every four-octet delimiter, also when its MPDU length is zero. It scores each nonzero MPDU range once. Alignment padding still contributes airtime but has no separate error draw. The model cannot represent errors confined to alignment padding. Header failure prevents all range draws. A failed spacing delimiter preserves a continuity break even if a later delimiter becomes recoverable. + +P0 checks cache insertion, replacement, cleanup, and direct success queries against the merged base. P2 checks PREAMBLE at its actual boundary before any HEADER or DATA calculation. Later HEADER, DATA, WHOLE, and repeated result queries must reuse their retained outcomes. The [PHY design](ieee80211-ampdu-phy-reception.md#43-decision-ownership-and-random-draws) defines that ownership. The aggregate result path preserves valid members despite a failed PPDU summary. + +With a present error model, aggregate results retain `ErrorRateInd` with all three probability fields set to `NaN`. The new range model supplies retained outcomes without an aggregate probability estimate. Result construction must preserve applicable power, SNIR, timing, mode, and channel metadata. Without an error model, the common base's existing probability tag presence and exact values remain valid. Ordinary MPDU metadata keeps its current calculations. [Aggregate metadata contract](ieee80211-ampdu-phy-reception.md#aggregate-error-rate-metadata). + +The tag contract permits `NaN` for unknown probabilities. P0 must audit readers, filters, and recorders that can receive aggregate metadata before P2 implements this contract. A reachable incompatibility blocks that implementation until the PHY plan records its resolution. Tag omission requires evidence that all affected consumers accept absence. The PHY fixture must verify the identified consumer paths before D1 closes. + +The [PHY plan](ieee80211-ampdu-phy-reception.md#42-optional-role-and-shared-implementation) defines an optional WLAN role for per-range probabilities and a pure mode-support query. A shared WLAN base implementation reuses the current length-based calculations for NIST, Yans, and compatible custom subclasses. P2 supplies this implementation and the MAC validation call before it enables the HT compatibility checks. The receiver checks the exact MAC capability inputs without a probability call or random draw. It calls the probability operations only for aggregates. An absent model follows the explicit error-free case. + +Deterministic tests supply probabilities of zero or one through the same role. The real receiver still produces and caches the outcomes. Those tests establish receiver integration and selective recovery. They do not establish the full NIST/Yans profile. + +The shared NIST/Yans implementation uses independent delimiter and MPDU outcomes under the current scalar SNIR reduction. This is a packet-level abstraction. It does not model correlated FEC errors or reconstruct interference within each MPDU. D2 extends the evidence for that implementation before completion of the documented profile. + +The decoder checks lengths, alignment, delimiter CRC, and signature before it trusts a member boundary. It can recover a later valid delimiter after corruption. That recovery does not erase the earlier continuity break. + +The decoder creates a separate Packet for each complete recoverable member. A failed PHY range sets only that member's bit-error flag. Rx rejects the flag before any FCS-mode branch. Other valid members retain their own outcomes and intact shared chunks. A valid FCS cannot override the member's error flag. [Receive validation](ieee80211-ampdu-implicit-blockack.md#45-receive-validation-and-one-response-per-ppdu). + +Rx reports one complete aggregate outcome for contention after all member checks. A correctly received member suppresses EIFS, also when that member addresses another station or lacks an agreement. A delivered container with no correct member invokes the existing corruption procedure once. Separate-part header failure retains the earlier radio abort. An individual member failure must not invoke HCF's ordinary corruption callback or erase valid aggregate history. The PHY's WHOLE summary cannot replace this MAC decision. + +## Why receipt and delivery need separate state + +Receipt state answers whether an MPDU arrived correctly. The reorder buffer answers when the recipient can deliver its contents. A positive Block Ack bit does not prove immediate upper delivery. Conversely, delivery must not erase receipt evidence that a later Block Ack needs. + +```mermaid +flowchart TD + V["Valid received MPDU"] --> S["Receipt record
Preserve its receipt bit"] + V --> R["Reorder buffer
Retain data until a release rule applies"] + S --> BA["Compressed Block Ack bitmap"] + S --> CHECK["Evaluate release conditions"] + R --> CHECK + FACTS["Member position
Delimiter continuity
Previous PPDU or response history"] --> CHECK + CHECK -->|Release required| U["Deliver eligible MSDUs once"] + CHECK -->|No release condition holds| HOLD["Retain buffered data"] + U -.-> KEEP["Delivery preserves receipt evidence
until scoreboard retirement"] +``` + +Aggregate release rules need more information than S5's individual-MPDU interframe check. The reorder service needs member position, delimiter continuity, prior receipt evidence, and the applicable physical interval. HCF supplies those facts through copied timing history. The reorder service releases eligible data when an applicable condition requires that action. [Reorder release and history](ieee80211-ampdu-implicit-blockack.md#46-reorder-release-and-physical-history). + +The hypothetical loss of 101 does not imply that every later MPDU must remain buffered. Clause 10.25.6.6.2.1 requires release when an applicable condition in (a)(2)(i–iv) holds. Conservative gap retention cannot replace that action. Tests must prove each reachable condition and its required release action. Sequence arithmetic must also remain correct across 4095 and 0. + +## How timing constrains an aggregate + +HCF checks the complete exchange: optional RTS/CTS, required interframe spaces, the DATA PPDU, and Block Ack. The actual selected mode and delimiter padding determine DATA airtime. All members carry the same Duration/ID value, referenced to PPDU end. The PHY mode calculation remains the authority for airtime. + +RTS selection uses the complete PSDU length, including members, delimiters, alignment, and spacing. Clause 10.3.5 requires RTS/CTS when that length exceeds the threshold. The current policy also selects protection at equality, which the clause permits. HCF supplies an exact aggregate preview and a separate valid member header to that policy. Every batch reduction reevaluates protection and complete-cost admission at the same retained DATA mode. The preview reaches no radio and establishes no commitment or attempt. + +In a hypothetical case, a retained retry and a new preview each contain a complete 1500-octet MPDU. With zero extra spacing, the PSDU measures 3008 octets and exceeds a 2346-octet RTS threshold. HCF therefore selects RTS/CTS although each member falls below the threshold. If CTS does not arrive, HCF records one contention failure and releases the previews. The queued source stays queued; the retained member keeps its retry state and deadline. [RTS selection and recovery](ieee80211-ampdu-implicit-blockack.md#47-originator-exchange-timing-and-recovery). + +For a hypothetical later exchange, assume 200 microseconds remain in the TXOP. If the complete aggregate exchange needs 240 microseconds, HCF must reduce the batch or defer it. The source MSDUs remain available for a later attempt. A positive amount of time left does not prove that the exchange fits. + +| Condition | Proposed result | +| --- | --- | +| TXOP limit is zero. | Permit one A-MPDU DATA PPDU with its required protection and acknowledgment. Do not add a second DATA PPDU. | +| TXOP limit is positive and the aggregate contains multiple MPDUs. | The complete exchange must fit, even when every member is a retry. | +| A singleton retry can exceed the limit. | Apply the same-size retry exception only when its full conditions and TXOP history permit it. | +| An initial singleton carries an ordinary MSDU under the agreement. | Apply its separate exception only when the TXOP conditions permit it. A first-attempt A-MSDU cannot use that exception. | +| HT mixed-format duration reaches its L-SIG limit. | Require calculated `L_LENGTH` at or below 4095. For this profile, `TXTIME - SignalExtension` must not exceed 5484 microseconds. | +| HT PPDU duration reaches its separate PHY limit. | Also apply the HT limit of 10 ms independently of the L-SIG and TXOP rules. | + +For a hypothetical 5 GHz aggregate that needs 6 ms, the 10 ms check passes but calculated `L_LENGTH` reaches 4482. HCF must reduce the batch or defer it. The signal extension changes the corresponding total-duration boundary in 2.4 GHz. [HT duration conditions](ieee80211-ampdu-implicit-blockack.md#42-eligibility-and-limits). + +The first profile uses legal non-HT RTS/CTS and non-HT OFDM or ERP-OFDM Block Ack responses. The recipient first selects the highest permitted BSS basic rate at or below the actual HT PPDU's non-HT reference rate. If none qualifies, it selects the highest permitted mandatory rate at or below that same reference rate. A legal alternate must preserve response duration and modulation class. HCF must reject a forced incompatible control format before aggregate submission. + +The response deadline starts at PHY transmission completion. It covers SIFS, one slot, and the PHY receive-start delay. Once an eligible reception starts, HCF waits for reception end and validates the response. It does not replace that procedure with an arbitrary whole-response delay. [Timing and response rules](ieee80211-ampdu-implicit-blockack.md#47-originator-exchange-timing-and-recovery). + +## What happens when the exchange fails + +One aggregate produces one contention outcome, but it can produce different delivery outcomes for its members. A valid matched Block Ack completes the response exchange even when its bitmap contains no positive bits. Members without positive acknowledgment still need retry. An absent or invalid response produces one contention failure. + +| Event | Result for the proposed path | +| --- | --- | +| A valid bitmap acknowledges some members. | Release those members. Retain the other members with their original deadlines. | +| A valid bitmap acknowledges no members. | Complete the response exchange. Retain unresolved DATA for retry. | +| The implicit wait ends without a valid matched Block Ack. | Report one response-exchange failure. End the sequence and arm one explicit BAR probe before further DATA for that agreement. | +| DATA lifetime expires. | Dispose of the affected member through its current owner. Do not restart its deadline through another aggregate. | +| Valid addressed Implicit BAR DATA arrives without an agreement. | Discard the DATA. Send no Block Ack or individual ACK. That DATA triggers no DELBA or receive state. | +| A valid addressed implicit aggregate conflicts with an active Basic agreement. | Report the profile conflict before receipt or reorder updates. Do not silently send a Basic response. | + +Silent discard is the first profile's explicit policy choice. Clause 11.5.4 names Block Ack-policy DATA in its absent-agreement DELBA rule. This plan does not extend that rule to Implicit BAR DATA. Current explicit BAR and inactivity recovery retain their separate triggers. [Receive validation and absent-agreement recovery](ieee80211-ampdu-implicit-blockack.md#45-receive-validation-and-one-response-per-ppdu). + +Silence gives the originator no immediate agreement-loss notice. Finite batches already have a recovery trigger. After the last DATA expires, HCF checks transfer completion at a safe exchange boundary. It retires the accepted agreement when that peer/TID has no queued or in-progress DATA. This works with inactivity timeout zero. + +Continuous arrivals can keep DATA queued. The first failed implicit response wait therefore sets one boolean probe requirement in the current originator agreement. The BAR policy selects one real explicit Compressed BAR before further DATA for that agreement. Admission refusal preserves the flag. Actual submission consumes it. Current EDCA classification derives the probe's access category from the agreement's TID; no category is stored with the flag. + +The probe is INET policy beyond the standard's requirements. Clause 10.25.6.7.1 also permits direct DATA retransmission after a lost Block Ack. A submitted probe adds BAR airtime, channel access delay, and a response exchange or timeout. This cost also applies when the agreement remains healthy. Transfer completion can retire an empty agreement before probe submission. + +A valid probe response applies the current bitmap rules. Probe failure returns to DATA retry if the agreement remains active. It does not arm another probe by itself. For each agreement, at most one submitted probe occurs between DATA attempts. A valid zero-bit implicit Block Ack does not arm a probe. The probe adds no DATA attempt or duplicate member feedback. + +In this hypothetical case, fresh DATA continues to arrive, but the recipient lacks the agreement. It silently discards an implicit aggregate. The failed wait causes an explicit probe. The recipient answers that BAR with DELBA under S5's current rule. The originator retires its stale agreement and can establish a later agreement without queue drain. + +```mermaid +flowchart TD + FAIL["Implicit wait ends
No valid matched Block Ack"] --> ARM["Set one probe flag on the agreement
End the sequence and return to contention"] + ARM --> EMPTY{"Does this peer/TID
have queued or in-progress DATA?"} + EMPTY -->|No| DONE["Current transfer completion
Retire agreement and send DELBA"] + EMPTY -->|Yes| BAR["At the next permitted access
Submit one explicit Compressed BAR"] + BAR --> OUT{"What occurs after the probe?"} + OUT -->|Recipient DELBA| RETIRE["Current lifecycle handler
retires the stale agreement"] + OUT -->|Valid Block Ack| BITMAP["Apply transmitted-only bitmap
Permit normal DATA eligibility"] + OUT -->|No valid matched response| RETRY["Current BAR control recovery
Permit DATA retry before another probe"] + RETIRE --> SETUP["Current setup procedures
can establish a later agreement"] +``` + +The diagram describes the proposed recovery policy. The probe waits for Block Ack. DELBA uses the current Action path and can arrive after that wait. It still retires the agreement. + +A6 checks finite batches and continuous arrivals with zero and nonzero inactivity values. The finite case forces probe failure so DATA expiry reaches the current completion trigger. The continuous case verifies an actual BAR, recipient DELBA, and later setup while fresh DATA remains queued. [Recovery transitions and checks](ieee80211-ampdu-implicit-blockack.md#appendix-c-recovery-transitions-and-acceptance-cases). + +A separate A6 case keeps a healthy agreement active while selected implicit Block Ack responses fail. Full, partial, and absent probe responses must permit actual subsequent DATA transmission before another probe. Original deadlines, per-member feedback, and exactly-once upper delivery remain required. This controlled case establishes no general fairness or goodput bound. + +With an active agreement, valid Implicit BAR DATA refreshes recipient inactivity. A duplicate can refresh inactivity without another delivery. Invalid members cannot refresh it. The originator accepts positive bitmap bits only for applicable transmitted MPDUs. + +The originator validates received responses against the active receive interval, peer, TID, profile, and frame fields. Frames outside that interval and callbacks from retired local contexts cannot complete the wait. Compressed Block Ack has no identifier for an individual exchange. A hypothetical delayed frame with identical fields inside a later valid interval follows ordinary response validation. The plan promises no rejection based on a hidden link to an earlier exchange. Supported peers send their immediate responses after the required SIFS. + +Recovery and observations report each attempted member's actual outcome. The first aggregate transmit profile has no rate-control submodule, so member results cause no rate-control callbacks. Contention counters must not increase once for every member of the same failed exchange. Block Ack DATA retries remain bounded by the current lifetime policy; the plan adds no new member retry limit. General stop/start recovery remains outside this work. + +## How the work reaches a complete feature + +Two linked plans separate the receiver prerequisite from the MAC feature. The PHY plan owns representation, bounded delimiter parsing, cached outcomes, and error-model integration. The feature plan owns selection, independent member state, reception, mandatory release, responses, and recovery. + +D1 is the PHY plan's receiver integration gate. It includes deterministic reception evidence, the shared NIST/Yans implementation, and basic compatibility checks. Feature A2 accepts copied PHY indications and refusal behavior; A4 supplies MAC reception and required release. A5 connects complete exchanges, with the short-GI response check, and A6 verifies negotiation and recovery. None of those steps can omit A4. [Feature steps](ieee80211-ampdu-implicit-blockack.md#6-implementation-steps-and-dependencies). + +D2 is the PHY plan's broader NIST/Yans and compatibility evidence gate. Those checks can follow deterministic MAC integration because D1 already includes the implementation and preserves default HT operation. Feature A7 needs both A6 and D2 before the supported profile reaches completion. This split gives each delivery a clear evidence boundary. [PHY steps and gates](ieee80211-ampdu-phy-reception.md#6-implementation-steps-and-dependencies). + +```mermaid +flowchart TD + MERGE["Merged #1343, #1344, #1345
Refresh the implementation base"] --> P1 + P1["PHY P1
Representation and bounded ranges"] --> D1 + P1 --> PREP["Feature A1 and A3
Capabilities and member preparation"] + D1["PHY P2 / D1
Receiver integration, shared models,
and basic compatibility"] --> ACCEPT + PREP --> ACCEPT["Feature A2 and A4
Accept outcomes and apply mandatory release"] + ACCEPT --> A5["Feature A5 and A6
Complete exchanges, negotiation, and recovery"] + D1 --> D2["PHY P3 and P4 / D2
NIST/Yans and compatibility evidence"] + A5 --> A7["Feature A7
Document and verify the supported profile"] + D2 --> A7 +``` + +The two plans retain nine proposed fixtures across unit, module, and protocol tests. The PHY plan owns two; the feature plan owns seven. They must check wire bytes, capability propagation, source ownership, partial PHY reception, reorder release, complete exchanges, recovery, timing, and production negotiation. Current Basic, explicit Compressed, lifetime, reset, and disabled-feature checks provide regression coverage. Compatible configurations with disabled transmit aggregation must preserve current frame sequences and random draws. [Verification methods](ieee80211-ampdu-implicit-blockack.md#7-verification-methods-and-expected-results). + +Direct exchange assertions must prove one DATA PPDU, one response after SIFS, correct receipt bits, selective retry, and exactly-once upper delivery. Physical reception tests must produce the partial results through the real receiver. An injected bitmap cannot prove that PHY integration. Fingerprints can detect a changed trajectory; they cannot replace these assertions. + +The planned campaign also checks member flags under declared-correct and computed FCS modes. It covers 2.4 GHz and 5 GHz, HT MCS 0 and 7, legal response modes, and supported protection combinations. Boundary checks cover sequence wrap, buffer sizes 1, 2, and 64, expiration order, and independent peers and TIDs. Deterministic loss cases prove the causal paths. The small additional seed campaign establishes no statistical goodput claim. + +The corrected checks also cover production member FCS before and after selective retry, partial-reception EIFS suppression, and agreement removal during SIFS. Admission checks distinguish the HT mixed-format L-SIG condition from the separate 10 ms limit. A nonzero-spacing case proves that batch reduction retains one DATA rate decision. + +RTS checks use complete PSDU lengths below, equal to, and above the configured threshold. Spacing and batch reduction must cause renewed protection selection. Recovery checks cover mixed batches, numbered unsent members, internal collision survivors, and terminal collision disposal. Repeated aggregate RTS failure reaches the contention retry boundary without member retry increments, member disposal, DATA outcomes, or a pending probe. Probe checks derive ownership from the agreement's TID after member expiry. These cases remain proposed verification. + +PHY checks also prove HT-SIG golden bytes and independent decode, PREAMBLE query order, and the two failed-header delivery paths. Invalid CRC and unsupported fields cause HEADER failure with successful header probabilities and without an error model. A separate malformed-input case retains HEADER success but refuses insufficient modeled PSDU content at DATA. Metadata checks verify the aggregate probability fields and the applicable receive tags without another probability call or random draw. The same proposed fixtures own these cases; the inventory remains nine. None of these checks establishes physical carrier-loss behavior. + +Configuration checks reject aggregate transmit opt-in with AARF. They also reject absent aggregate roles and incomplete advertised receive-mode coverage before capability advertisement. D1 controls preserve ordinary HT reception with NIST, Yans, and an absent error model. Aggregate checks without an error model retain PHY checks, delimiter validation, and FCS rejection without new error draws. Response checks separate observable mismatches and retired callbacks from indistinguishable valid frames inside an active interval. These are proposed checks; no runtime evidence establishes their results yet. + +A fixture peer supplies a valid HT20 short-GI aggregate through the real radio. D1 and A2 verify copied PHY indications without MAC receipt or response requirements. After A4 supplies member validation, A5 verifies MAC receipt and one Compressed response after SIFS. A6 verifies production capability negotiation with the local aggregate transmit policy at long GI. This receive case does not establish short-GI selection from production transmit queues. [Receive acceptance cases](ieee80211-ampdu-implicit-blockack.md#proposed-direct-checks). + +## What the first version leaves for later + +The first transmit policy selects ordinary MSDU members. It does not add nested A-MSDU selection. Current individual A-MSDU operation remains available, and reception preserves the current negotiated A-MSDU checks and deaggregation. + +The first version excludes these larger features: + +- VHT PPDUs, HT40, HE/EHT, Multi-TID, and multi-user aggregates. +- Short-GI aggregate transmission through the new HT policy. +- Delayed Block Ack, partial-state scoreboards, protected agreements, dynamic fragmentation, and group-addressed aggregates. +- Reverse direction, mixed control/data aggregates, adaptive aggregate transmission, new rate-control algorithms, and general MAC stop/start recovery. +- Bit-level FEC behavior, correlated error accuracy, errors confined to alignment padding, and a guaranteed performance gain. + +Custom data services, MPDU policies, Tx/Rx modules, response policies, and response-rate selectors can need interface updates. The DATA rate-control API remains unchanged; aggregate transmit opt-in requires its HCF submodule to be absent. Present custom HT models need the optional PHY role with coverage of advertised receive modes. This includes configurations that previously used only ordinary MPDUs. Non-HT custom reception and operation without an error model remain available without that role. The implementation must document those obligations. + +The design reuses the public Packet API and proposes no edit to its sealed implementation. Related feature branches remain separate integration work. [Compatibility and scope](ieee80211-ampdu-implicit-blockack.md#5-affected-components-and-compatibility). + +The user's approved revision covers these documents only. It adds no implementation approval or runtime evidence. The two linked plans own the detailed decisions, source references, standard clauses, commands, and verification limits. diff --git a/plan/pending/ieee80211-ampdu-implicit-blockack.md b/plan/pending/ieee80211-ampdu-implicit-blockack.md new file mode 100644 index 00000000000..99e45df8099 --- /dev/null +++ b/plan/pending/ieee80211-ampdu-implicit-blockack.md @@ -0,0 +1,639 @@ +# Implementation plan: A-MPDU with implicit Compressed Block Ack + +> **Kind:** procedure · **Status:** draft · **Seal:** none · **Owns:** — · **Stands on:** [PHY prerequisite plan](ieee80211-ampdu-phy-reception.md), [S5 execution record](ieee80211-compressed-blockack-s5-execution.md), [implementation plan procedure](../../doc/project/guide/write-an-implementation-plan.md), [IEEE 802.11 rules](../../doc/project/domain/ieee80211.md) + +Checkout: `/home/user/omnetpp_ws/inet-compressed-blockack-s5`, branch `work/compressed-blockack-s5`, HEAD `4fa5cc0de15ee57388bcb3f20e866cab5972a670`. + +Plan revision: 12, 2026-10-17. The user's `proceed, including the optional simplification` authorizes the reviewed document corrections. This revision defines PSDU-based RTS selection, recovery before DATA submission, and a boolean probe requirement with a derived access category. This document accompanies PHY revision 11 and the revised summary. The delivery gates and PHY behavior retain their current scope. Implementation, expectation changes, commits, and publication remain outside this authorization. + +The project plan procedure remains a draft; this document uses its structure without an additional approval requirement. + +This feature plan consumes the [PHY prerequisite plan](ieee80211-ampdu-phy-reception.md). That plan owns aggregate representation, bounded delimiter parsing, cached partial reception, and error-model integration. This plan owns member selection, MAC reception, mandatory release, implicit responses, and recovery. + +Implementation waits for merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). The assessment on 2026-10-16 confirmed all three as open. Read-only A0 checks can occur before merge. A0 cannot close until the merged dependency chain and refreshed implementation base exist. + +The [delivery table](#6-implementation-steps-and-dependencies) identifies the stages and their prerequisites. The [fixture table](#7-verification-methods-and-expected-results) identifies acceptance evidence. Detailed standards and execution commands remain in the appendices. + +## 1. Problem and intended behavior + +The proposed feature sends multiple QoS MPDUs in one HT PPDU. The recipient returns one Compressed Block Ack after SIFS. The aggregate itself requests that response, so the successful exchange needs no separate BAR. Each MPDU retains its own sequence number, FCS, lifetime, and retry state. + +S5 supplies explicit Compressed BAR exchanges for individual MPDUs. It does not connect A-MPDU selection, aggregate reception, or the implicit response sequence. The current aggregate builder alone cannot provide those mechanisms. This plan adds the complete path through production queues, PHY reception, and acknowledgment recovery. + +This hypothetical case defines the main acceptance scenario. An immediate Compressed agreement exists for one peer and TID, with a transmit window that starts at 100. Four queued MSDUs become MPDUs 100 through 103 in one A-MPDU. The recipient receives 100, 102, and 103 correctly; MPDU 101 fails its FCS check. The recipient sends one Compressed Block Ack after the PPDU ends. The bitmap reports 100, 102, and 103 as received. + +The originator retains 101 for retry and releases the other transmitted MPDUs. A singleton A-MPDU can carry the retry of 101 and request another Block Ack. Each MSDU reaches the upper protocol exactly once. The reorder service applies every release condition that the supported aggregate path requires; an applicable release condition requires delivery across a gap. + +```mermaid +sequenceDiagram + participant Q as Originator queue and HCF + participant P as Recipient PHY and HCF + participant U as Recipient upper protocol + Note over Q,P: Accepted immediate Compressed agreement for one peer and TID + Q->>P: One HT PPDU: MPDUs 100, 101, 102, 103 + Note over P: 101 fails. Record valid MPDUs and apply reorder rules. + P->>Q: After SIFS: Compressed Block Ack, bits 100=1, 101=0, 102=1, 103=1 + Note over Q: Release 100, 102, 103. Retain 101 with its original deadline. + Q->>P: Singleton A-MPDU: retry 101 + P->>Q: After SIFS: Compressed Block Ack + P->>U: Deliver each eligible MSDU once +``` + +The diagram describes proposed behavior. It is not an executed trace. + +## 2. Current implementation and evidence + +The facts below come from the pinned source. The [S5 record](ieee80211-compressed-blockack-s5-execution.md) supplies historical verification; this plan supplies no new runtime result. + +| Component and source | Confirmed behavior | Required consequence | +| --- | --- | --- | +| [QoS data service](../../src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc) | Lines 309–313 contain the commented A-MPDU invocation. Reversible preparation currently produces one MPDU or A-MSDU. | Extend preparation to a batch without premature queue extraction. | +| [Default MPDU policy](../../src/inet/linklayer/ieee80211/mac/aggregation/BasicMpduAggregationPolicy.cc) | The policy always returns `nullptr`. | Add an explicit HT policy; preserve the current default. | +| [Aggregate builder](../../src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.cc) | The helper concatenates MPDUs with delimiters and alignment padding. It deletes its inputs. | Retain canonical MPDUs separately for selective retry. | +| [Aggregate decoder](../../src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc) | The helper assumes valid lengths and derives names from the aggregate name. | Consume bounded parsing from the PHY plan. Apply MAC validation without name-dependent behavior. | +| [HT capability state](../../src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h) | Directional state retains the receiver's maximum A-MPDU length exponent. It omits minimum MPDU start spacing. | Carry spacing through local advertisement, peer state, and directional negotiation. | +| [Management conversion](../../src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h) | The wire element contains spacing, but conversion does not retain it. | Preserve all supported spacing values through real management paths. | +| [MAC receive entry](../../src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc) and [Rx](../../src/inet/linklayer/ieee80211/mac/Rx.cc) | Rx expects one MAC trailer and one MAC header. | Recognize an aggregate before the ordinary MPDU FCS and header path. | +| [Tx](../../src/inet/linklayer/ieee80211/mac/Tx.cc) and [its contract](../../src/inet/linklayer/ieee80211/mac/contract/ITx.h) | Tx finalizes one MPDU before SIFS, retains a copy, and sends that copy when its timer expires. | Add aggregate submission at the actual start, with per-member finalization and an explicit cancellation result. | +| [RTS policy](../../src/inet/linklayer/ieee80211/mac/originator/QosRtsPolicy.cc) and [its contract](../../src/inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h) | The policy reads the supplied Packet's length and a separate MAC header. Its current threshold comparison includes equality. | Supply the complete aggregate preview and a valid member header. Reevaluate protection after batch reduction. | +| [HCF recovery before DATA](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) | Internal collision recovery can number an unsent frame. RTS failure updates only contention for an uncommitted preview; committed frames also receive member retry accounting. | Include numbered, unsent candidates. Define aggregate RTS recovery independently of one representative member's state. | +| [Rx failure processing](../../src/inet/linklayer/ieee80211/mac/Rx.cc) and [HCF corruption callback](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) | Ordinary rejection notifies contention. The MAC also invokes HCF's corruption callback, which clears interframe history. | Separate member rejection from the complete aggregate outcome for contention and history. | +| [DATA rate selection](../../src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc) and [rate control](../../src/inet/linklayer/ieee80211/mac/contract/IRateControl.h) | Current rate control selects a rate by recipient address. It takes no aggregate size. | Select one mode before mode-dependent spacing. Reuse the current recipient-based decision. | +| [AARF feedback](../../src/inet/linklayer/ieee80211/mac/ratecontrol/AarfRateControl.cc) | Each callback can change the selected rate and probe state. The callback contains no actual transmission mode. | Separate callbacks for one aggregate can describe a probe at a rate that no member used. Restrict the first transmit profile to fixed rates. | +| [PHY receiver](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.cc) and [error model](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc) | The receiver obtains a whole-data success decision. The WLAN error model supports whole-Packet corruption only. | Consume cached delimiter and MPDU outcomes from the PHY plan. | +| [HT PHY header](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader.msg) | The modeled HT header has no aggregation field. | Consume the PHY plan's HT aggregation property for both singleton and multiple-member aggregates. | +| [Frame sequence](../../src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc) and [acknowledgment handler](../../src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc) | `NORMAL_ACK` selects an ACK wait. An explicit BAR creates the current Block Ack wait. | Add an aggregate exchange with a Block Ack wait and no synthetic BAR. | +| [Reorder service](../../src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc) and [HCF history](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h) | S5 supplies individual-MPDU interframe evidence. The reorder call accepts one interframe boolean. | Supply aggregate position, delimiter continuity, and previous PPDU facts for aggregate release rules. | +| [HCF transfer completion](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) | Lifetime expiry and exchange completion invoke `completeTransfers()`. An accepted agreement with transmitted DATA retires when its peer/TID has no queued or numbered DATA. | Name this finite-batch recovery trigger. Preserve transmitted-member records for aggregate submissions. | +| [QosAckHandler](../../src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc) and [BAR policy](../../src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc) | Current BAR selection uses `BLOCK_ACK_NOT_YET_REQUESTED` members. It does not select failed implicit waits automatically. | Define an explicit probe trigger that also works while fresh DATA remains queued. | + +Prior local edits affect `AGENTS.md`, the replacement plan, its summary, the agreement lifecycle plan, and the EDCA lifetime plan. The S5 summary and planning history also exist as untracked files. This plan does not alter those files. The source revision above remains the implementation reference; local prose does not establish additional runtime support. + +## 3. Scope and acceptance criteria + +### First supported profile + +The first aggregate transmit profile targets packet-level `Ieee80211Radio` with scalar or dimensional reception, HT mixed format, 20 MHz, and long GI. Aggregate transmission requires a fixed DATA rate and no HCF rate-control submodule. The transmitter must select an actual HT mode. An `ac` interface can qualify only when its actual transmission uses this HT profile and valid peer HT state. This does not add VHT PPDU support. + +Reception also covers HT20 short GI when local HT capability advertises that receive mode. The PHY contract requires coverage of the advertised MCS and NSS values within the effective radio limits. Interface presence alone cannot establish that coverage. The MAC supplies its exact capability inputs to the receiver for validation before the MIB update. This receive requirement does not extend the new aggregate transmit policy to short GI. [PHY receive contract](ieee80211-ampdu-phy-reception.md#42-optional-role-and-shared-implementation). + +Each aggregate contains unfragmented, individually addressed QoS Data MPDUs for one RA, TA, and TID. An accepted immediate Compressed agreement must exist. Multiple peers and agreements can coexist; each aggregate remains within one agreement. The first transmit policy forms ordinary MSDU members. New selection of nested A-MSDUs remains separate work; current individual A-MSDU operation remains available. + +The recipient must preserve the current negotiated A-MSDU checks and deaggregation when it accepts an otherwise valid received member. The new transmitter must not use nested A-MSDU selection to bypass an absent peer length limit. An A-MSDU retry from S5 can retain the individual path. + +A-MPDU transmission uses a new `HtMpduAggregationPolicy` through the current optional `mpduAggregationPolicy` slot. The default `BasicMpduAggregationPolicy` retains its no-aggregation behavior. The receiver recognizes supported aggregates independently of its own transmit policy. No new on-wire capability bit or Block Ack profile selector represents this local choice. + +When no aggregate qualifies, use the current individual-frame path where its conditions permit transmission. Absent peer HT state retains S5's Normal Ack fallback. An enabled policy does not grant an agreement or override a PHY limit. + +The PHY plan rejects a present HT model without the aggregate role or required receive-mode coverage before management advertises capabilities. This check applies independently of local transmit aggregation. An absent error model retains the current error-free abstraction after the required PHY checks. The PHY plan's [compatibility section](ieee80211-ampdu-phy-reception.md#5-affected-components-and-compatibility) defines custom-model migration and the supported absent-model case. + +This work remains outside this plan: + +- VHT PPDUs, HT40, HE/EHT, Multi-TID, and multi-user aggregates. +- Short-GI aggregate transmission through the new HT policy. +- Delayed Block Ack, partial-state scoreboards, protected agreements, and dynamic fragmentation. +- Group-addressed aggregates, reverse direction, and mixed control/data aggregates. +- New stop/start recovery, general TXOP repair outside this feature, adaptive aggregate transmission, and rate-control algorithms. +- Bit-level FEC simulation, time-resolved error correlation, and a performance improvement guarantee. + +Current explicit Compressed and Basic exchanges remain supported. A valid explicit BAR still receives its current response. The new feature preserves the S5 profile conflict diagnostic and finite QoS DATA lifetime. + +### Observable completion + +1. Production association establishes the HT limits and immediate agreement before aggregate transmission. +2. One HT PPDU carries at least two independently identifiable MPDUs from production queues. +3. A valid member with ACK policy bits `00` causes one Compressed Block Ack after the complete PPDU and SIFS. +4. The successful implicit exchange contains no BAR and no individual ACK for its members. +5. Partial loss produces correct receipt bits and selective retry without duplicate delivery. +6. A singleton aggregate retry still receives Block Ack; MPDU count does not change its response kind. +7. Refusal, RTS failure, expiration, and agreement removal preserve or dispose of each owned frame through its current owner. +8. Aggregate length, member length, spacing, transmit window, PPDU duration, and TXOP conditions hold at actual transmission. +9. Compatible feature-off cases preserve current sequences and random draws. Separate peers and TIDs retain independent state. +10. Absent-agreement Implicit BAR DATA causes discard without a response to that DATA. Finite and continuous traffic cases prove recovery and later setup. +11. Deterministic integration and NIST/Yans support have separate evidence gates. Completion of the documented profile requires the PHY plan's D2 gate. +12. A failed implicit response wait arms one explicit BAR probe before further DATA for that agreement. Valid zero-bit Block Ack does not arm a probe. One boolean retains the requirement; current EDCA classification derives its access category from the agreement's TID. +13. Admission checks the L-SIG length condition for HT mixed format. The separate 10 ms HT duration limit also applies. +14. Production transmission calculates each member's FCS after its final header fields, including changes for selective retry. +15. A correctly received aggregate member prevents EIFS, an access delay after specified reception errors. This also applies to valid overheard members. +16. Agreement removal during SIFS cancels an unsent aggregate before queued-source commitment, new sequence assignment, or DATA attempt accounting. Existing canonical members retain their assigned numbers unless current disposal rules remove them. +17. Aggregate transmit opt-in with a rate-control submodule fails initialization, even when a fixed-rate override would bypass its rate selection. +18. Present HT models without the aggregate role or required receive-mode coverage fail before capability advertisement, also with local transmit aggregation disabled. +19. Response acceptance uses the active receive interval and observable frame fields. Retired local callbacks cannot complete another wait. +20. An absent error model preserves current PHY checks and adds no error draws. PHY D1 preserves default NIST and configured Yans operation. +21. The modeled HT-SIG header preserves HT Length and Aggregation through serialization and independent decode. +22. PREAMBLE queries add no early HEADER or DATA calculation. Failed-header delivery follows the radio's actual reception mode. +23. Aggregate results preserve applicable receive metadata and use the PHY plan's explicit probability contract. +24. Advertised HT20 short-GI aggregates reach MAC validation without an extension of the new long-GI transmit policy. +25. Invalid encoded HT-SIG prevents member outcomes, receipt updates, delivery, and responses through the current header-failure paths. +26. Insufficient modeled PSDU content causes structural DATA refusal without range draws. The valid HEADER result retains its decoded Aggregation property. +27. RTS selection uses the complete PSDU length, including delimiters and padding. Batch reduction reevaluates that decision before complete-cost admission. +28. Numbered, unsent MPDUs remain eligible without another sequence assignment. Aggregate RTS failure produces one contention failure without member retry increments or RTS-triggered member disposal. + +## 4. Proposed design and reasons + +### 4.1 Requirements that control the design + +IEEE Std 802.11-2024 controls the supported HT profile. [Appendix A](#appendix-a-standard-requirements-and-evidence) retains the detailed clauses, canonical corpus IDs, PDF pages, and extraction limits. + +The design preserves these conditions: + +- The actual HT aggregation property distinguishes a singleton A-MPDU from a standalone MPDU. +- The receive contract covers advertised HT20 long-GI and short-GI modes independently of the local transmit policy. +- HT-SIG CRC and field validation precede acceptance of Aggregation, HT Length, and member outcomes. +- Each accepted member needs valid delimiter context, a successful PHY outcome, and a valid FCS. +- One eligible aggregate requests one Compressed Block Ack after the complete PPDU and SIFS. +- Clause 10.25.6.6.2.1 requires release when an applicable condition in (a)(2)(i–iv) holds. Conservative gap retention cannot replace that behavior. +- Table 19-25 specifies an HT `aPPDUMaxTime` of 10 ms. Clause 10.13 applies that bound independently of TXOP admission. +- Clause 10.27.4 also requires the calculated HT mixed-format `L_LENGTH` to remain at or below 4095 octets. +- Clause 10.3.2.3.7 prohibits EIFS when at least one member of an A-MPDU arrives correctly. +- Clause 10.3.5 requires RTS/CTS when the complete PSDU exceeds the applicable RTS threshold in this HT profile. +- Clause 10.23.2.12.1 distinguishes ordinary frame retry accounting from Block Ack operation. It separately requires frame retry increments after internal collisions. + +The source assessment confirmed the commented A-MPDU call at `OriginatorQosMacDataService.cc:309–313`. PDF inspection confirmed the mandatory release text and the 10 ms table value. + +### 4.2 Eligibility and limits + +HCF decides whether the proposed exchange qualifies under the active profile, agreement, and actual PHY mode. The HT policy selects eligible members within those supplied limits. Management and the MIB remain the owners of advertised and negotiated capabilities. The policy does not read unrelated module parameters or invent peer capability state. + +Add minimum MPDU start spacing to local HT capability state and its directional receiver limits. Preserve its encoded value from 0 through 7. Extend equality checks, management conversion, full association, simplified management, and cleanup through the current capability path. Keep the current zero-spacing default. An asymmetric test must prove that the peer receiver's value controls local transmission. + +The aggregate must satisfy all applicable limits: + +- Each member's complete MPDU length fits the HT delimiter limit of 4095 octets. +- The complete PSDU fits the peer maximum and the HT maximum of 65535 octets. +- Member sequence numbers fit the active transmit window and negotiated buffer capacity. +- Alignment and zero-length delimiters meet the peer spacing requirement at the retained DATA mode. +- The selected mode's airtime satisfies the L-SIG length condition, HT PPDU duration bound, and applicable TXOP rule. + +The L-SIG field is the legacy signal field in the HT mixed-format preamble. Its `L_LENGTH` value tells non-HT stations when the PPDU ends. + +The mode API owns airtime. Extend the HT mode contract to expose both duration conditions for the aggregate admission check. Clause 10.27.4 requires `L_LENGTH = ceil((TXTIME - SignalExtension - 20 us) / 4 us) * 3 - 3` to remain at or below 4095. For the supported long-GI profile, this limits `TXTIME - SignalExtension` to 5484 microseconds. The signal extension is zero in 5 GHz and six microseconds in 2.4 GHz when applicable. Table 19-25's separate 10 ms limit also applies. + +In a hypothetical 5 GHz case, an aggregate needs 6 ms and otherwise fits the peer and TXOP limits. Its calculated `L_LENGTH` is 4482, so HCF must reduce the batch or defer it. The 10 ms check alone would accept an illegal HT mixed-format transmission. These are HT requirements; no VHT duration limit supplies either check. The current `getMpduMaxLength()` value does not define the member delimiter limit. + +### 4.3 Preparation, commitment, and ownership + +Extend the current reversible preparation mechanism to retain a batch of candidate MPDUs. New candidates remain in their queues until commitment. `InProgressFrames` retains committed candidates, including transmitted retries and numbered, unsent MPDUs. Preparation owns previews and copied membership keys; it borrows committed canonical members. It stores no second acknowledgment map or lifetime table. + +Retain current EDCAF arbitration and the first eligible peer/TID choice. The HT policy uses the selection order below within one agreement and its current transmit window. This order is an INET policy, not an HT requirement. Current acknowledgment state distinguishes transmitted retries from numbered, unsent candidates. + +| Selection order and source state | Preparation and commitment | +| --- | --- | +| 1. Eligible transmitted retries, in cyclic sequence order. | Borrow canonical members from `InProgressFrames`. Preserve their sequence numbers and original deadlines. Derive the Retry bit from current acknowledgment state. | +| 2. Eligible numbered, unsent MPDUs, in cyclic sequence order. | Borrow canonical members from `InProgressFrames`. Preserve their assigned numbers, recovery state, and deadlines. Keep Retry clear before their first DATA submission. | +| 3. Eligible new members, in queue order. | Retain source MSDUs in their queues. Previews use consecutive candidate numbers without counter advancement. Commitment verifies that reference before actual assignment. | + +The current internal collision handler can extract and number one frame before any DATA transmission. Preserve that single-frame recovery path, including its counter update and terminal disposal. It must not prepare or commit an aggregate for the EDCAF that loses the collision. A frame that remains after collision recovery retains `FRAME_NOT_YET_TRANSMITTED` in the acknowledgment handler. Aggregate preparation accepts it through the second row above without another allocation. + +In a hypothetical case, an internal collision assigns sequence number 100 to one frame but transmits no DATA. Later aggregate preparation selects that retained frame and a queued new member. Only the new member receives sequence number 101 at DATA submission. Member 100 retains its deadline and collision recovery state. Its first DATA transmission keeps Retry clear. + +HCF selects one actual DATA mode through the current fixed-rate DATA rules. Existing interface-wide or per-receiver rate settings supply that choice. HCF supplies the selected member's recipient and header context, without a delimiter envelope or a size-aware rate-control API. The service then calculates delimiter spacing and exact aggregate length at that retained mode. HCF can reduce the proposed batch without a second rate decision. A reduced batch requires another length and airtime calculation, not another rate selection. + +HCF rejects aggregate transmit opt-in during initialization when its optional rate-control submodule exists. This includes a controller whose rate selection a fixed-rate override would bypass, because HCF still sends feedback to that controller. AARF can change its probe state after the first member callback. A later callback for the same PPDU can then describe a probe at a rate that no transmission used. Fixed-rate aggregate transmission avoids that false result without a new feedback API or changes to existing rate algorithms. + +In a hypothetical AARF case, nine successes precede a two-member aggregate at rate R. The increase threshold is ten, and a faster rate exists. The first member succeeds, so its callback selects the faster rate and sets probe state. The second member fails at R, but its callback treats that failure as a failed probe at the faster rate. The fixed-rate profile rejects this controller configuration before any aggregate attempt. + +For a hypothetical peer with nonzero minimum spacing, a faster selected mode can require more zero-length delimiters between short MPDUs. HCF therefore obtains the mode before the service calculates that padding. If the padded batch exceeds a limit, HCF removes candidates and checks the smaller batch at the same mode. The selector receives no claim that the preliminary candidate size equals the final aggregate size. + +A new batch normally starts with two members. A batch with a transmitted retry can contain one member and retain aggregate response semantics. A numbered, unsent singleton can use the current individual-frame path. If no batch qualifies, the current individual-frame path can proceed under its own conditions. + +Here, DATA submission means the actual call that sends the aggregate from Tx to the radio. Acceptance of a delayed request by Tx does not commit source MSDUs. At actual submission, HCF checks agreement state, mode permissions, candidate membership, and complete-cost admission. The service checks queue identities, sequence references, and deadlines through their current owners. One synchronous commit assigns sequence numbers only to queued new members and transfers them to `InProgressFrames`. The commit preserves all previously assigned numbers and original deadlines. + +HCF sets each member's Retry bit, ACK policy, and common Duration/ID before Tx finalizes the member. Tx applies the local TA and configured FCS mode through a shared MPDU finalizer. For computed FCS, Tx calculates each member's FCS over that member's final header and payload. Header or trailer edits use copy-on-write before the new envelope takes references. The aggregate builder then combines those complete MPDUs with delimiters and padding. Tx sends that envelope without an outer MAC header, outer FCS, or another ordinary MPDU finalization pass. + +`InProgressFrames` owns canonical committed MPDUs until acknowledgment, expiration, or terminal disposal. The aggregate envelope owns delimiter chunks and references to immutable member content. Envelope destruction releases only its own content references. It does not destroy the canonical MPDUs. Region tags retain the correct member offsets and lengths. Aggregate names do not encode protocol identity. + +Extend the aggregate Tx contract with a start callback to HCF and a cancellation result. For delayed submission, Tx invokes that callback at its existing `endIfsTimer` boundary, before it copies or sends the PSDU. With zero IFS, Tx invokes the same callback synchronously. HCF validates the batch before the service commits it and Tx finalizes its members. Tx then submits the complete envelope to the radio in that synchronous call chain. Tx reports actual submission once so HCF can record each transmitted member. + +The frame sequence context owns the preparation until submission or cancellation. Agreement retirement marks an unsent preparation as cancelled. Tx clears its pending callback before it reports refusal to the frame sequence handler. Refusal ends the pending aggregate step without DATA failure feedback or an implicit-response probe. Reset must cancel a pending aggregate request through Tx before it releases the context. Ordinary synchronous calls consume no simulation time; this extension adds no timer, zero-delay event, or generation counter. + +Tx reports `hasTransmission()` while the aggregate request awaits its start or physical completion. It derives that result from the retained request or transmitted envelope. This preserves the current deferral of radio configuration commands. Commitment also preserves current queue notifications. + +In a hypothetical case, an originator inactivity deadline falls between CTS reception and the prepared aggregate's DATA start. The [current inactivity handler](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) retires that agreement through `beginTeardown()`. At the existing Tx timer event, HCF refuses the cancelled preparation. No aggregate reaches the radio, and no new source receives a sequence number. Independent expiry or teardown can still dispose of frames through their current owners. Section 4.7 defines aggregate RTS failure without commitment or member retry accounting. + +### 4.4 PHY representation and partial reception + +The [PHY plan](ieee80211-ampdu-phy-reception.md#4-proposed-design-and-reasons) owns the HT aggregation property and cached delimiter and MPDU outcomes. Its D1 gate supplies deterministic reception through the real radio and receiver. This feature consumes that result without a second error draw. Member count and transmit-only tags cannot replace the decoded HT property. + +PHY P1 also owns the modeled HT-SIG fields and serializer. Its wire fixture must prove HT Length and Aggregation through golden bytes and independent decode. A1 consumes that representation for singleton and multiple-member aggregates. The work covers the modeled HT-SIG header without a new waveform model. [HT-SIG representation](ieee80211-ampdu-phy-reception.md#41-representation-and-bounded-ranges). + +The radio already declares a 48-bit HT header. PHY P0 records this length and the current mode/PSDU duration path. P1 preserves the declared length through serialization and independent decode. Ordinary HT controls must preserve airtime under identical mode and PSDU inputs. Byte or fingerprint changes require separate evidence; they establish no necessary airtime change. + +PHY P1 defines one stateless HT-SIG validator; P2 applies it at the receiver's HEADER boundary. Invalid CRC or unsupported fields prevent delimiter and member draws. MAC receives no accepted Aggregation property from that header. Current header-failure paths prevent receipt updates, delivery, and responses. Encoded-header rejection needs separate evidence from probabilistic header loss. [HT-SIG receive validation](ieee80211-ampdu-phy-reception.md#ht-sig-receive-validation). + +The PHY separately bounds valid HT Length against the available modeled PSDU before range calculation or length-based decapsulation. Insufficient content denotes malformed model input. HEADER retains success and its decoded Aggregation property; DATA refuses the content without range outcomes or draws. The radio skips length-based trailer removal and supplies a failure container. MAC refuses that content before header or trailer peeks. This case establishes bounds safety, with no claim about physical carrier loss or acceptance of a received prefix. + +PHY P2 defines PREAMBLE, HEADER, DATA, and WHOLE decisions at their actual radio boundaries. PREAMBLE must not construct HEADER or DATA. A2 accepts the mode-specific failed-header paths and applicable receive metadata. The PHY plan owns the aggregate probability fields; MAC must not present an aggregate estimate as a member estimate. [Decision and metadata contracts](ieee80211-ampdu-phy-reception.md#43-decision-ownership-and-random-draws). + +PHY P0 must close the audit of aggregate metadata consumers before P2 implements its probability contract. The proposed `NaN` fields follow `ErrorRateInd`'s documented contract for unknown probabilities. A reachable incompatible reader blocks that implementation until the PHY plan records its resolution. Omission requires evidence that all affected readers accept an absent tag. Ordinary MPDU metadata retains its current behavior. + +The PHY plan keeps its optional WLAN contract separate from generic `IErrorModel`. Its shared WLAN implementation reuses the current per-length success calculation for NIST, Yans, and compatible custom subclasses. A present custom HT model outside that base also needs the aggregate role, even for ordinary MPDU operation. Its mode-support query must cover advertised HT20 long-GI and short-GI reception without a probability call or random draw. Non-HT custom models retain ordinary MPDU reception without that role. + +BerTable remains outside this HT aggregate profile and receives no aggregate role. Its current initializer already rejects HT operation strings before the proposed role check. The PHY plan owns its named compatibility decision, migration text, non-HT parent control, and expected HT refusal case. That current refusal supplies no evidence for the new custom-model diagnostic. [BerTable compatibility](ieee80211-ampdu-phy-reception.md#5-affected-components-and-compatibility). + +An absent error model follows the current error-free abstraction after PHY acquisition, possibility, attempt, and SNIR checks. The receiver records successful physical ranges without error-model calls or random draws only after those checks succeed. MAC delimiter, FCS, address, and agreement checks still control acceptance. An absent model needs no substitute role or module. + +D1 permits MAC integration and deterministic exchange checks. It includes the shared NIST/Yans implementation before the early HT check becomes active. D2 completes the broader NIST/Yans and compatibility evidence. A7 requires D2 before the feature claims the full NIST/Yans profile. The abstraction uses common PHY acquisition and header success with independent range outcomes under scalar SNIR reduction. It makes no claim about correlated FEC errors or interference within each member. + +### 4.5 Receive validation and one response per PPDU + +The MAC and Rx recognize aggregate context before the ordinary header and trailer peeks. MAC rejects a delivered failure container after common header failure before those peeks. That failure does not establish a decoded aggregation property. The shared decoder from the PHY plan bounds every delimiter, MPDU length, alignment interval, and zero-length delimiter against the PSDU. Each iteration must advance. Invalid input must cause a bounded refusal or resynchronization, never an out-of-range read. + +Separate-part PREAMBLE or HEADER failure aborts the radio's attempted reception before any container reaches MAC. Existing radio state notifications let HCF invalidate the relevant physical history. Whole-signal mode can supply a failure container that MAC must reject. Both paths prevent acceptance, responses, and range draws. Do not add a failure event solely to produce identical container delivery. + +Delimiter recovery scans valid alignment positions for a valid signature and CRC. It cannot use an unchecked length or the transmitter's private member list to bypass corruption. Record any broken delimiter chain even when a later member becomes recoverable. This distinction controls the reorder release rules. + +The decoder creates a separate Packet for each recoverable complete MPDU. Before it deletes the envelope, it projects the typed range outcome onto that member. It calls `setBitError(true)` on a failed member Packet. The [Rx FCS predicate](../../src/inet/linklayer/ieee80211/mac/Rx.cc) rejects that flag before declared-correct, declared-incorrect, and computed FCS branches. + +This uses the public Packet API without a false checksum or shared chunk mutation. Partial DATA failure must not mark the entire envelope incorrect or copy one global error flag onto every member. A failed delimiter still prevents member acceptance until valid bounded resynchronization. + +Rx validates each complete member through its current FCS predicate. A successful FCS check cannot override the member's PHY error flag. An invalid or unaddressed member cannot update receipt state, refresh inactivity, or trigger a response. Retain the applicable received NAV behavior for valid overheard members. + +The aggregate Rx entry must separate member checks from ordinary corrupt-frame callbacks. Rx records member rejection without an EIFS notification for each failed member. After all member checks, Rx reports one aggregate outcome for contention. If any member passes delimiter, PHY, and FCS checks, Clause 10.3.2.3.7 prohibits EIFS. This decision also counts valid overheard members and valid DATA without an agreement. With no correctly received member, Rx invokes the existing corruption procedure once for that PPDU. + +A partial member failure must not invoke `Hcf::corruptedFrameReceived()` or erase valid aggregate history. HCF receives the aggregate context with its member failures and delimiter facts. Common PHY failure still invalidates history through the current owner. In the main scenario, failed MPDU 101 causes neither EIFS nor loss of valid history for 100, 102, and 103. A separate all-member-failure case must exercise the existing corruption procedure without a Block Ack response. + +HCF processes valid members in receive order with explicit aggregate context. That context identifies PPDU membership, member position, delimiter continuity, and the valid member. The ordinary `NORMAL_ACK` path must not send individual ACKs for these members. The agreement handler records the valid DATA under the agreement even though its policy bits equal `00`. + +Validate the shared address, TID, policy, and Duration/ID conditions before agreement or delivery updates. A malformed context cannot produce success. For a valid addressed implicit aggregate under an active Basic agreement, report the profile conflict before receipt or reorder updates. Do not send a Basic response or silently reinterpret the implicit request. An absent agreement follows the separate recovery policy below. + +After the entire PPDU, HCF requests one immediate Compressed Block Ack when at least one valid addressed member qualifies. The response procedure uses the updated recipient scoreboard and its actual window start. Delivery does not erase receipt evidence. If all members fail, the recipient sends no Block Ack. + +For valid addressed Implicit BAR DATA without an agreement, the recipient discards the DATA. It sends no Block Ack or individual ACK. That DATA also triggers no DELBA, receipt state, reorder state, or upper delivery. Clause 11.5.4 explicitly names Block Ack-policy DATA in its absent-agreement DELBA rule. This first profile does not extend that rule to Implicit BAR DATA. + +Silence leaves the originator without immediate agreement-loss information. Finite batches already have a recovery trigger in [HCF](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc). The lifetime timer expires DATA and invokes `completeTransfers()` when no exchange runs. Exchange completion also expires DATA and invokes that check. An accepted agreement with transmitted DATA retires when its peer/TID has no queued or numbered DATA. + +That trigger works with inactivity timeout zero. The new aggregate submission must retain each actual member's `recordTransmittedData()` update. This preserves the agreement's first-transmission condition and teardown boundary. HCF then uses its current originator-role DELBA procedure. Later DATA uses the current Normal Ack and ADDBA procedures. + +Continuous arrivals can prevent the empty-transfer condition. A failed implicit response therefore arms the explicit probe in [Section 4.7](#47-originator-exchange-timing-and-recovery). The recipient retains silent discard for implicit DATA. A later explicit BAR without an agreement retains S5's recipient-role DELBA response. + +In a hypothetical case, the recipient loses its agreement while fresh DATA continues to arrive at the originator. The recipient silently discards an implicit aggregate. The failed response wait arms one probe, which takes priority over further DATA for that agreement. The recipient receives the explicit BAR and sends DELBA. The originator retires its stale agreement and can establish a later agreement without queue drain. + +With an active agreement, valid Implicit BAR DATA refreshes recipient inactivity under Clause 11.5.4. A duplicate can refresh inactivity without a second delivery. Invalid members cannot refresh it. Preserve the current S5 behavior for an explicit BAR without an agreement. + +### 4.6 Reorder release and physical history + +Replace the single interframe boolean at the aggregate call boundary with the facts that the release decision needs. Reuse the S5 physical timing snapshots for real PPDU intervals. HCF retains previous aggregate delimiter facts and completed Block Ack history through its current history owner. The reorder service remains the owner of delivery decisions. + +Implement the applicable conditions in 10.25.6.6.2.1(a)(2)(i–iv), as well as the current individual-MPDU condition (v). The checks must distinguish a first member, a later member, and a standalone MPDU. A zero-length spacing delimiter does not become a DATA member. The receipt bit immediately before the scoreboard start and the required delimiter chain remain separate conditions. + +These are mandatory conditional actions within the supported HT-immediate profile. The clause states that the record `shall be modified as follows` before its release instructions. The [history table](#release-history-required-by-the-supported-profile) maps the fields to those conditions. Retain each history field only for a reachable release condition. A deferred condition needs evidence that the declared profile cannot reach it. + +Clear the relevant history after unrelated or abandoned receptions. Clear it after PHY acquisition or header failure. Receptions that overlap and incompatible local transmissions also invalidate the relevant history. A failed member alone does not erase valid PPDU history. Preserve its failure and delimiter facts for the applicable release check. + +A completed Block Ack can establish the history that the aggregate rules permit. No RIFS transmit scheduler enters this change. Reuse the current HT/BSS RIFS permission checks when a received sequence requires them. + +Tests must distinguish receipt from delivery. A positive Block Ack bit proves reception; it does not prove immediate upper delivery. No test may impose unconditional gap retention where an applicable aggregate release rule requires delivery. + +### 4.7 Originator exchange, timing, and recovery + +Add an aggregate transmit step followed by a Block Ack receive step. The exchange context identifies the peer, TID, transmitted member keys, and expected response kind. It reuses the current frame sequence timer. It does not construct an unsent BAR to obtain a timeout or response mode. + +The RXSTART deadline follows Clause 10.23.2.2: SIFS plus slot time plus the PHY receive-start delay, measured from PHY transmission completion. After an eligible reception starts, the step waits for its reception end and validates the response. Reuse the current HCF start/end reception mechanism. Do not replace it with an arbitrary whole-response delay. + +After actual aggregate submission, record every transmitted canonical member's allocation index through the current agreement owner. Queue commitment alone does not establish transmission. This preserves first-DATA tracking and the monotonic teardown boundary. + +All members use wire ACK policy bits `00`. The aggregate context determines that these bits mean Implicit BAR. The acknowledgment handler sets a Block Ack wait for each submitted member. Ordinary standalone MPDUs retain their current policy interpretation. + +Factor response-rate selection and response construction so explicit and implicit callers share the legal Compressed response rules. The implicit caller supplies the actual aggregate PPDU mode and valid response context. It must not pass a fabricated BAR or the mode of an unrelated member. Prediction and actual response selection must agree on legal format, rate, and airtime. + +The initial profile has no STBC or HT Control conditions that permit an HT/VHT control response. Block Ack therefore uses non-HT OFDM or ERP-OFDM under Clause 10.6.6.1. Choose the highest permitted BSS basic rate at or below the actual HT non-HT reference rate. If none qualifies, use the highest permitted mandatory rate at or below that same reference rate. Clause 10.6.6.5.2 applies this upper limit to both choices. Retain S5's explicit fallback for unknown BSS rate state. + +An alternate must preserve the primary response duration and modulation class under Clause 10.6.6.5.4. In a hypothetical HT MCS 0 case, no BSS basic rate qualifies. The available mandatory OFDM rates are 6, 12, and 24 Mbps. The non-HT reference rate is 6 Mbps, so the recipient selects 6 Mbps. A 24 Mbps fallback would exceed the reference rate. + +For aggregate protection, use legal non-HT RTS and CTS. A forced incompatible control format must prevent aggregate submission with a clear diagnostic. It must not create a new control-format violation. This restriction applies to the new profile; general control-response repair remains separate work. + +Clause 10.3.5 requires RTS/CTS when the complete PSDU exceeds `dot11RTSThreshold` in this HT profile. The complete length includes every member, delimiter, alignment interval, and zero-length spacing delimiter. A single member's length cannot supply that decision. Equality does not require protection under that clause, but the current RTS policy also selects protection at equality. Retain that permitted policy choice and ordinary-frame behavior. + +After mode-dependent spacing, preparation constructs an aggregate preview with the exact PSDU length. HCF passes that preview and a valid selected-member header to the current RTS policy. The preview supplies length; the separate header supplies frame kind and receiver address. The preview uses copied member content before finalization and carries no outer MAC header. It establishes no commitment or transmission attempt and never reaches the radio. Every batch reduction rebuilds that preview and reevaluates protection before complete-cost admission at the same retained DATA mode. + +In a hypothetical case, one retained retry and one new preview each contain a complete 1500-octet MPDU. Zero extra spacing gives a complete PSDU length of 3008 octets. With an RTS threshold of 2346 octets, HCF requires RTS/CTS although neither member exceeds that threshold. If CTS does not arrive, HCF records one contention failure. It discards the unused previews without commitment of the queued source. The retained member keeps its retry state and deadline. + +HCF checks the complete aggregate exchange before transmission: optional RTS/CTS, required interframe spaces, DATA PPDU, and the expected Block Ack. The retained mode and exact delimiter padding control DATA airtime. All members receive the same Duration/ID value, referenced to PPDU end. Recipient response transmission retains the current local NAV choice. + +A zero TXOP limit permits one A-MPDU DATA PPDU with its required protection and acknowledgment under Clause 10.23.2.9. It does not permit a second DATA PPDU. For a positive limit, every multi-MPDU aggregate must fit, even when all members are retries. The same-size retry exception can apply to a singleton aggregate only when no other DATA or management frame enters that TXOP. An initial singleton ordinary MSDU under the agreement can use its specified exception. A first-attempt A-MSDU cannot use that exception. + +Validate Block Ack addresses, profile, TID, length, fragment field, and bitmap before success. Reuse S5 modulo-4096 mapping and its rule that positive bits apply only to transmitted MPDUs. A partial bitmap releases only positively acknowledged canonical members. Absent or invalid responses end the batch wait without false success or inactivity refresh. They arm the probe before DATA retry. + +Response reception must satisfy the active frame sequence's receive interval and expected peer, TID, and profile. A response outside that interval cannot complete the wait. A callback from a retired local context cannot complete a later wait. The supported peer sends each immediate response at the required SIFS boundary. No additional exchange identifier exists in the supported Compressed Block Ack format. + +In a hypothetical injected case, an old probe response enters a later active interval with identical addresses, TID, SSN, and bitmap. Observable fields cannot distinguish that frame from a valid response to the later exchange. Apply normal response validation and transmitted-only bitmap updates; do not promise rejection based on its hidden origin. This profile adds no simulator-only correlation tag or replay detector. + +Use DATA retransmission for unacknowledged members, as permitted by 10.25.6.7.1. A singleton A-MPDU can carry the last retry member. An absent or invalid implicit response first causes one explicit Compressed BAR probe. A valid Block Ack with zero positive bits completes the response exchange and does not arm that probe. + +The required probe is an INET policy choice beyond the standard's requirements. Clause 10.25.6.7.1 also permits direct DATA retransmission after a lost Block Ack. This version retains one probe after the first failed implicit response to expose a stale agreement under continuous traffic. Each submitted probe adds BAR airtime, channel access delay, and a Block Ack response exchange or timeout. A healthy agreement incurs that cost too. Transfer completion can retire an empty agreement before probe submission. + +When the implicit wait ends without a valid matched Block Ack, HCF sets one pending-probe flag on the current originator agreement. It ends the sequence and returns to contention. The BAR policy prioritizes that peer/TID's probe before further DATA for the same agreement. Other eligible peers and TIDs can continue. + +Represent the pending state with one boolean in the current originator agreement. HCF derives its EDCAF from the agreement's TID through current EDCA classification. BAR selection compares that derived category with the candidate EDCAF. Only that EDCAF can submit or count the probe. The fixed TID mapping needs no retained category or second mapping table. + +The pending flag survives member expiry and admission refusal until submission or agreement retirement. This state is necessary because the next contention grant occurs after the failure. The flag belongs to the current agreement; add no separate recovery map, failure counter, or timer. Empty-transfer completion takes priority over an unsent probe. + +The probe uses the agreement's current transmit-window start and the actual explicit Compressed BAR exchange. It bypasses ordinary BAR threshold deferral. The acknowledgment handler attaches retained transmitted members within its bitmap range to that BAR wait. Selection must not depend only on `BLOCK_ACK_NOT_YET_REQUESTED`. + +Actual probe submission consumes the pending flag. A valid probe response applies the ordinary transmitted-only bitmap rules and permits eligible DATA retry. A failed probe returns to DATA retry through current control recovery if the agreement remains active. It does not arm another probe by itself. For each agreement, at most one submitted probe occurs between DATA attempts. + +A valid recipient-role DELBA uses the current lifecycle handler to retire the agreement. Reset and teardown clear an unsent probe with its agreement. An accepted probe retains its physical completion context under S5's retirement rules. [Appendix C](#appendix-c-recovery-transitions-and-acceptance-cases) defines the transitions and direct acceptance cases. + +Recovery counters and rate-control feedback describe different outcomes. A valid matched Block Ack completes one successful response exchange, even when its bitmap has no positive bits. This follows the response-based success definition in Clause 10.23.2.2. Unacknowledged members still need retry. An absent or invalid response produces one contention failure, not one failure per member. Preserve the current HCF choice to end the sequence and return to contention after response failure. + +Extend the recovery owner's API to separate per-member attempt counts from access-category contention updates. Do not call `dataFrameTransmissionFailed()` once per member: that method also changes station counters and CW. Use current member keys and count storage where their meanings fit. Keep Block Ack DATA retries subject to the current lifetime bound; add no new member retry limit. + +For an active agreement, aggregate RTS failure before DATA submission applies one ordinary control contention failure through the current recovery owner. This rule covers batches of new members, committed members, and both together. It adds no member retry increment, DATA attempt, DATA outcome, or pending probe. Queued sources remain queued; committed members retain their numbers, acknowledgment state, recovery state, and deadlines. Preparation releases its previews. Expiry and agreement retirement remain independent disposal causes. + +An aggregate RTS failure does not invoke the current per-frame RTS retry limit or discard a representative member. At the access-category retry boundary, the recovery owner applies the current contention reset without member disposal. This aggregate policy extends the current uncommitted-preview path to every aggregate composition. Clause 10.23.2.12.1 requires associated-RTS frame retry increments for DATA outside a Block Ack agreement; it does not require them here. Current individual-frame RTS recovery and internal collision recovery retain their existing counter and disposal rules. Current lifecycle resolution suppresses obsolete completion feedback. + +Record each attempted member's outcome through the current recovery and observation owners. Positive bitmap members report success; other attempted members report failure and retain eligibility until expiry or other current terminal disposal. Report terminal disposal once. The first aggregate transmit profile has no rate-control submodule, so these outcomes cause no `IRateControl::frameTransmitted()` calls. Current individual-frame configurations with rate control retain their existing callbacks. Adaptive aggregate feedback requires a separate design that preserves the actual PPDU mode across all member results. + +A probe adds no DATA attempt or duplicate per-member feedback. Its own contention outcome follows ordinary BAR accounting. + +### 4.8 Reuse and justified additions + +These choices apply [minimal design](../../doc/project/rule/quality.md#qr-design-minimal), [reuse](../../doc/project/rule/architecture.md#ar-ext-reuse), and [contract purity](../../doc/project/rule/architecture.md#ar-org-contract-purity). + +| Addition or extension | Required owner and consumers | Why current state is insufficient | +| --- | --- | --- | +| `HtMpduAggregationPolicy` and supplied selection limits. | QoS data service and replaceable policy. | The default policy deliberately selects no aggregate. An explicit HT policy preserves that default. | +| Batch preparation and aggregate transmit step. | Data service, `InProgressFrames`, and frame sequence context. | One-MPDU preparation cannot retain independent members and one PPDU response wait. | +| Aggregate start callback and cancellation result. | Tx calls HCF through the retained frame sequence context at the existing IFS boundary. | Current Tx copies an MPDU before SIFS and cannot revalidate an aggregate at its actual start. | +| Shared MPDU finalizer and aggregate Tx entry. | Tx finalizes members before the builder constructs the envelope. | Ordinary Tx processing assumes one header and one FCS. It cannot finalize a delimiter envelope. | +| Complete aggregate outcome for contention. | Rx supplies one outcome after member validation; HCF retains member history. | Ordinary rejection would invoke EIFS and clear history for an individual failed member. | +| HT aggregation property and receive indication, owned by the PHY plan. | WLAN PHY supplies values to MAC receive entry and HCF. | Policy bits and member count cannot distinguish standalone DATA from a singleton aggregate. | +| Cached aggregate reception, owned by the PHY plan. | WLAN receiver and current medium cache supply the result to MAC. | Whole-Packet corruption cannot report partial reception or delimiter continuity. | +| Aggregate reorder context and history extension. | HCF and reorder service. | A single interframe boolean cannot represent the additional mandatory release conditions. | +| Shared Compressed response source context. | Rate selection, recipient Block Ack procedure, and receive step. | Current public calls require an explicit BAR, which an implicit exchange does not transmit. | +| Aggregate preview for RTS selection. | Preparation supplies exact PSDU length; the current RTS policy uses its separate member-header argument. | One member's length can omit required protection. The existing callable contract needs no outer aggregate MAC header or second threshold selector. | +| One pending-probe flag in the current originator agreement. | HCF and the BAR policy retain a probe requirement across contention. | Continuous arrivals can prevent transfer completion. Member expiry must not erase the probe requirement while fresh DATA remains queued. | + +Keep new interfaces pure. Put reusable calculations in implementations. Add no parallel agreement store, acknowledgment map, expiry timer, or generic Packet extension. The new metadata and classes belong in the WLAN MAC or PHY packages that own their facts. + +## 5. Affected components and compatibility + +| Change surface | Declarations and consumers | +| --- | --- | +| Capability propagation | MIB C++/NED, HT capability structures, management conversion, association and simplified-management consumers, serializer checks. | +| Transmit preparation | QoS data-service contract and implementation, MPDU policy C++/NED contract, new HT policy, aggregate builder, `InProgressFrames`, lifetime handoff. | +| PHY dependency | The PHY plan owns HT header/tag MSG inputs, HT-SIG serialization and validation, receiver, radio, and the error-model contract/base. It also owns the MAC coverage handoff before the MIB update, per-part decisions, receive metadata, and shared delimiter parsing. | +| MAC receive path | MAC, Rx contract/implementation, aggregate decoder, recipient QoS data service and agreement handler, reorder contract and implementation. | +| Exchanges | HCF, frame sequence declarations/steps/context, acknowledgment handler, recovery procedure, RTS policy consumers, Compressed response policy/procedure, response-rate contracts, Tx contract/implementation and callbacks. The aggregate transmit profile requires fixed DATA rates. | +| Representation and observations | Current WLAN serializers and dissector, member region tags, semantic outcome signals, protocol-test observation boundary. | +| User documentation | `WHATSNEW`, user guide, migration guide, a focused example, and scoped Wi-Fi evidence. | + +The proposed transmit configuration is: + +```ini +**.mac.hcf.isBlockAckSupported = true +**.mac.hcf.blockAckVariant = "compressed" +**.mac.hcf.rateControl.typename = "" +**.mac.hcf.rateSelection.dataFrameBitrate = 6.5Mbps +**.mac.hcf.rateSelection.dataFrameBandwidth = 20MHz +**.mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1 +**.mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +``` + +`HtMpduAggregationPolicy` does not exist yet. The fixed rate above selects HT MCS 0 with one spatial stream under the required HT20 long-GI configuration. These settings also require compatible modes, usable peer HT state, and accepted agreements. The example must configure those conditions explicitly. The initial policy adds no local count or byte cap. It derives those limits from the agreement, peer, and PHY. + +Custom data services, MPDU policies, Tx/Rx modules, response policies, and response-rate selectors can need interface updates. The migration guide must list each changed method and distinguish unsupported capability from an empty valid result. It must cover aggregate start, cancellation, member finalization, and the complete receive outcome. The DATA rate-control API remains unchanged; aggregate transmit opt-in requires its HCF submodule to be absent. Current `BasicMpduAggregationPolicy` configurations retain their rate-control behavior. The PHY plan owns error-model migration and preserves operation without an error model. + +Custom RTS policies retain the current callable signature but must accept an aggregate preview with a separate valid member header. The supplied Packet represents the complete PSDU for length checks. It has no outer MAC header. The migration guide must explain that distinction and the aggregate RTS recovery rule. Current individual-frame recovery remains the compatibility control. + +Use current owner-emitted simulation signals for actual transitions. Aggregate-level observations count one PPDU; member-level observations identify each MPDU. Document that boundary wherever a recorder or protocol assertion consumes it. No synthetic per-member PHY transmission event may imply multiple PPDUs. + +The current [seal registry](../../doc/project/audit/seal-list.md) seals `src/inet/common/packet/`. This design uses its current public API and proposes no edit there. Recheck seals before implementation. General MAC stop/start recovery remains a current limitation; ordinary agreement reset and object destruction must still dispose of the new transient state safely. + +## 6. Implementation steps and dependencies + +Each step becomes one coherent commit or a short series with its tests and migration text. This plan defines the MAC feature PR. The PHY plan defines separate receiver implementation and broader evidence deliveries. Contract changes and their required consumers remain buildable together. + +The PHY plan defines two gates. D1 proves cached aggregate reception with deterministic probabilities through the production receiver and includes the shared NIST/Yans implementation. D1 also preserves default HT initialization and compatible ordinary reception. D2 completes the broader NIST/Yans and PHY compatibility evidence. A2 accepts D1; A6 can close deterministic integration before D2. A7 requires both A6 and D2. + +| Step and purpose | Responsible components and proposed change | Expected result and verification | Dependency | +| --- | --- | --- | --- | +| A0: Establish the merged implementation base. | Check source claims and record dependency heads now. Before implementation, require merged #1343, #1344, and #1345. Pin their integrated base and compare contracts. | Confirm the commented call, default policy, owners, and resolved choices. Record the feature-off baseline before source changes. Revise changed contracts or owners. | Read-only checks can start now. Closure requires all three merges. | +| A1: Preserve capabilities and construct legal aggregates. | Extend MIB/management spacing state. Consume PHY P1 representation, HT-SIG serialization and validation, and bounded parsing. Implement aggregate construction calculations for spacing, serialization, and region-tag rules. | Capability and representation checks prove directional limits, valid aggregate bytes, and singleton identity after byte conversion. The PHY plan owns the shared wire fixture and HT-SIG round trips. | A0; PHY P1. | +| A2: Accept deterministic PHY reception. | MAC/Rx consumers adopt the PHY D1 indication and aggregation property. Accept the four per-part decisions, header rejection, structural refusal, actual failure paths, and receive metadata contract. | Valid long-GI and short-GI aggregates supply copied PHY outcomes without a second error draw. Failure containers stop before MAC header or trailer peeks. Incomplete advertised receive-mode support fails before the MIB update. An absent model follows its supported error-free case. MAC receipt and response acceptance belong to A4 and A5. | A1; PHY D1. | +| A3: Prepare and retain independent members. | Add the HT policy, dynamic member selection, and batch preparation. Require fixed DATA rates and reject aggregate transmit opt-in with a rate-control submodule. Select one mode before spacing and batch reduction. Apply A1's construction calculations at that mode. Include numbered, unsent candidates through current acknowledgment state. Preserve single-frame internal collision recovery and current queue/lifetime handoff. | Unsupported rate-control combinations fail before DATA attempts. Refusal preserves source ownership and sequence state. Numbered, unsent members retain their assigned numbers and first-DATA Retry value. Commitment retains independent deadlines. | A1. | +| A4: Receive aggregates and apply mandatory release. | Project range outcomes onto separate member Packet flags before Rx validation. Integrate one contention outcome, receipt updates, reorder context, and history. | Physical reception proves FCS rejection, correct EIFS behavior, delimiter continuity, mandatory release, and exactly-once delivery. Silent discard creates no receive state. | A1, A2. | +| A5: Complete the implicit exchange and probe recovery. | Add aggregate steps, Tx start/cancellation, member finalization, Block Ack wait, response calculation, admission, and transmitted-member records. Select RTS from the complete aggregate preview after each reduction. Apply one contention outcome after aggregate RTS failure without member retry accounting. Derive the probe EDCAF from TID. Apply the observable response acceptance rules. | Exchanges prove computed FCS, SIFS cancellation, selective retry, response validation, probe priority, unchanged deadlines, and both HT duration conditions. Threshold cases prove PSDU-based protection. Mixed-batch RTS failure preserves member state at the contention retry boundary. A short-GI aggregate updates MAC receipt and receives one Compressed response after SIFS. At most one probe occurs between DATA attempts. | A2, A3, A4. | +| A6: Verify negotiation, recovery, and compatibility. | Add infrastructure and compatibility coverage. Verify absent-agreement recovery for finite batches and continuous arrivals with zero and nonzero inactivity values. Verify DATA progress for a healthy agreement under controlled response loss. | Real management establishes limits. Tests prove transfer completion, probe-driven retirement without queue drain, later setup, continued DATA transmission, and historical compatibility. | A5. | +| A7: Document and verify the supported profile. | Add the example, user and migration text, release note, and execution record. Reconcile relevant expected-failure declarations under separate authorization. | A6 and PHY D2 evidence support the documented profile. Required publication checks pass before any separately authorized publication. | A6; PHY D2. | + +A1 and A3 can supply reviewed preparation changes before the complete feature exists. A5 and A6 establish deterministic integration after A4. They do not establish NIST/Yans support. The final feature claim requires A7. Dependencies describe delivery order; they assign no concurrent agents. + +## 7. Verification methods and expected results + +### Proposed direct checks + +The seven fixtures below belong to this feature plan. The [PHY plan](ieee80211-ampdu-phy-reception.md#7-verification-methods-and-expected-results) owns `Ieee80211AmpduWire_1.test` and `Ieee80211AmpduPhyReception_1.test`. Together, the plans retain the original nine proposed fixtures. None exists at this revision. + +Fixed causal cases use seed 0. Injected agreements or deterministic error models establish only the stated boundary. Infrastructure cases separately prove production negotiation. [Appendix B](#appendix-b-verification-commands-and-campaigns) contains commands, campaign bounds, and evidence requirements. + +| Proposed fixture and category | Trigger and production boundary | Required observation | +| --- | --- | --- | +| `Ieee80211AmpduCapabilities_1.test`, module. | Full and simplified management with asymmetric receive limits. Include an absent aggregate role, a role without advertised short-GI support, and an absent error model. Use exact MAC inputs with a one-antenna limit and catalog modes outside that limit. | Exponents 0–3 and spacing values 0–7 reach the correct directional consumer; reset removes old peer limits. Absent roles fail before advertisement; incomplete coverage fails before the MIB changes local HT capability. Unsupported unadvertised modes do not cause rejection. An absent model retains valid HT initialization and negotiation. Compatible models retain advertised HT20 short-GI support. | +| `Ieee80211AmpduPreparation_1.test`, module. | Production queues, HT policy, fixed DATA rates, batch preparation, and commitment. Include internal collision survivors and aggregate transmit opt-in with AARF. | Source identities, sequence wrap, independent deadlines, count/window/byte limits, and refusal before extraction. Numbered, unsent members keep their allocation and first-DATA Retry value. Internal collision terminal disposal still affects its selected frame only. Batch reduction retains one rate decision. AARF fails initialization with and without fixed-rate overrides. | +| `Ieee80211AmpduReordering_1.test`, module. | Physical reception, member Packet flags, Rx FCS modes, and copied PPDU history. | Separate cases cover each reachable condition in 10.25.6.6.2.1(a)(2)(i–iv), retained condition (v), delimiter chains, and receipt evidence before the window. Declared-correct and computed FCS cannot accept a PHY-failed member. Partial loss preserves valid history and suppresses EIFS. Required release cannot become unconditional gap retention. | +| `Ieee80211AmpduExchange_1.test`, module. | Production HCF, frame sequences, Tx/Rx, PHY, and recipient response. | Exactly one response after PPDU end and SIFS; no per-member ACK or successful-path BAR; singleton aggregate response remains Block Ack. Successful initial transmission and selective retry verify each member's final header and computed FCS. Without a qualifying basic rate, the recipient selects a mandatory fallback at or below the HT reference rate. | +| `Ieee80211AmpduRecovery_1.test`, module. | Aggregate RTS failure, bitmap results, implicit response loss, probe refusal/results, expiry, DELBA, and reset. Cases cover new, committed, and mixed batches. Other cases cover absent or healthy agreements under finite or continuous traffic. | One contention outcome after RTS failure, unchanged member counters, no RTS-triggered member disposal, and no DATA outcome or probe. Other cases prove selective recovery, unchanged deadlines, safe disposal, derived probe ownership, and at most one probe between DATA attempts. No case permits duplicate DATA feedback. Finite and continuous traffic permit later setup. Healthy agreements retain DATA progress. | +| `Ieee80211AmpduAdmission_1.test`, module. | Actual aggregate transmission under zero and positive TXOP limits, with and without RTS/CTS. Include threshold boundaries and batch reduction. | Complete-cost admission, separate L-SIG and 10 ms checks, one retained mode, and correct common Duration/ID. Complete PSDU length controls RTS selection after spacing and each reduction. Originator inactivity expiry during SIFS cancels DATA before new commitment or DATA attempt accounting. | +| `N_AmpduImplicitBa.test`, protocol. | Production association and application traffic through AP and STA paths. | Negotiated limits, aggregate contents, implicit response, selective retry, and exactly-once upper delivery. | + +A2 accepts copied PHY indications from valid long-GI and short-GI aggregates through the real radio. Its checks stop at that indication and refusal boundary. A4 supplies member validation and MAC receipt. A5 owns the complete short-GI receive exchange in `Ieee80211AmpduExchange_1.test`, after A4. A2 requires neither MAC receipt updates nor a Block Ack response for closure. + +For A5, a fixture peer supplies legal aggregate bytes at an advertised HT20 short-GI mode through the real radio and MAC. Verify valid member receipt and one Compressed response after SIFS. Keep the local aggregate transmit policy at long GI. This case proves receive coverage; it does not establish short-GI selection from production transmit queues. A6 separately verifies the production capability negotiation. + +The PHY fixture separately supplies invalid encoded HT-SIG with successful header probabilities and without an error model. A2 verifies HEADER failure and refusal of any delivered container before MAC header or trailer peeks. Invalid CRC and unsupported field combinations use the current header-failure paths. A separate malformed-input case retains HEADER success but refuses insufficient modeled PSDU content at DATA. A4 and A5 verify no receipt update, delivery, or response after either refusal. + +The current [N_Ampdu](../../tests/protocol/wifi/11n/N_Ampdu.test) presence assertion needs the Compressed profile and supported HT configuration. Retain its aggregate observation and add completion evidence; do not replace it with a declaration. The current [Ac_Ampdu](../../tests/protocol/wifi/11ac/Ac_Ampdu.test) requirement remains deferred for actual VHT PPDUs. An inherited HT transmission from an `ac` interface cannot close that VHT requirement. + +Retain the current Compressed admission, exchange, input, interframe, and originator fixtures. Retain Block Ack scheduling, lifetime, lifecycle, association reset, fragment retirement, Basic, and disabled-feature checks. Map each changed contract to an explicit fixture before execution. A fixture with injected HCF responses does not prove PHY reception or association. + +The receive cases include partial loss, all-member failure, common header failure, and an overheard aggregate while local DATA remains queued. At least one correct member must suppress EIFS regardless of its address or agreement state. A delivered container with no correct member must invoke the existing corruption procedure once. Separate-part common header failure instead preserves the radio's abort and HCF history invalidation. Member rejection must not clear valid aggregate history through the ordinary HCF corruption callback. + +The computed-FCS exchange starts with valid production DATA and verifies a successful aggregate before it injects a selective member loss. Its retry changes the Retry bit and can change Duration/ID. Every transmitted member must pass the receiver's computed-FCS check after those edits. No outer FCS may replace a member FCS. + +Drive internal collisions through production EDCAF arbitration before aggregate preparation. Verify one numbered, unsent survivor without an aggregate commitment or DATA attempt. Later aggregate submission must preserve its number, deadline, and collision recovery state. Its first DATA transmission keeps Retry clear. A separate retry-limit case verifies current collision disposal before aggregate selection. + +For aggregate RTS failure, cover batches of new members, committed members, and both together. Include a committed candidate that remains `FRAME_NOT_YET_TRANSMITTED` and a transmitted retry. Withhold CTS through the access-category retry boundary. Verify one contention update per failed RTS and the current boundary reset. Verify unchanged member counters, numbers, acknowledgment states, and deadlines. No member disposal, DATA outcome, or pending probe may result from that failure alone. + +Absent-agreement recovery is an A6 acceptance gate. Cover finite batches and continuous arrivals with zero and nonzero negotiated inactivity values. For the finite case, force probe failure so DATA expiry reaches transfer completion. For continuous traffic, keep fresh DATA queued and provide a legal probe admission opportunity. Observe actual BAR, recipient DELBA, retirement, and later successful setup without queue drain. + +A valid zero-bit Block Ack must cause retry without a probe. Probe failure must permit a DATA attempt before another probe. Refusal must preserve the pending flag and DATA deadlines. Response tests cover frames outside an active receive interval, wrong peer/TID/profile, retired local callbacks, and an indistinguishable valid frame inside a later interval. The last case follows ordinary validation; no hidden exchange identity controls acceptance. [Appendix C](#appendix-c-recovery-transitions-and-acceptance-cases) maps the recovery cases to their expected results. + +A6 must also prove DATA progress for a healthy agreement under deterministic response loss. Keep fresh DATA queued with inactivity timeout zero. Appendix C separates full, partial, and failed probe cases and defines the required DATA observations. A5 checks the state transitions and counters for these cases. + +### Evidence status + +The source assessment checked the commented invocation, error-model APIs, mandatory release text, HT duration table, and prerequisite PR state. These are source and standards observations. No INET build, module test, protocol test, or simulation ran for this revision. Document checks cannot establish PHY or MAC behavior. + +All 144 local links resolve across the three documents. Changed prose passed sentence-length and paragraph checks. Hash checks confirmed preservation of the seven unrelated local files. These checks establish document properties only. + +The documents contain 12 Mermaid diagrams. One diagram label now states the aggregate RTS failure rule. No parser or browser check ran for this revision. + +## 8. Risks, unresolved decisions, and implementation scope + +The proposed transmit scope is HT20 with long GI. Reception also covers advertised HT20 short-GI modes. Other decisions include fixed DATA rates, explicit transmit opt-in, full-state receipt records, and cached partial PHY outcomes. Recovery uses DATA retry after one response-failure probe. These are model and implementation choices. They do not redefine IEEE ACK policy bits or the mandatory release conditions within the supported path. + +A threshold for consecutive failures remains optional follow-up work because it adds history and reset rules. Probe-cost measurements can guide a later trigger change. + +The source and standard checks resolve the main exchange choices: + +| Decision | Confirmed requirement or source behavior | Proposed implementation | +| --- | --- | --- | +| Implicit response format and rate. | 10.6.6.1 requires non-HT format for this profile. 10.6.6.5.2 explicitly covers Implicit BAR. | Factor the S5 selector around actual PPDU mode and addresses. Preserve primary/alternate rules. | +| Absent agreement after aggregate reception. | 11.5.4 explicitly covers Block Ack-policy DATA. This profile does not extend that DELBA rule to implicit DATA. | Discard implicit DATA silently. Current completion handles a drained transfer; the new probe handles continuous arrivals. A6 proves later setup. | +| Aggregate TXOP exceptions. | 10.23.2.9 excludes every multi-MPDU aggregate from the listed overrun exceptions. | Require full fit for multiple members. Check singleton composition and TXOP history before an exception. | +| Response-failure probe. | 10.25.6.7.1 permits BAR or direct DATA retransmission after response loss. Current BAR selection omits failed implicit waits. Continuous arrivals can prevent transfer completion. | Require one probe as INET policy before further DATA. Consume it on submission; probe failure returns to DATA retry. A6 checks a healthy agreement under controlled response loss. | +| Aggregate recovery counters. | 10.23.2.2 defines response success independently of bitmap delivery. Clause 10.23.2.12.1 separates ordinary associated-RTS retry increments from Block Ack operation. | Apply one contention outcome after aggregate RTS failure without member retry increments or disposal. Preserve current individual-frame and internal collision recovery. | +| Aggregate RTS selection. | 10.3.5 applies the threshold to the complete PSDU. The current policy accepts a Packet and a separate MAC header. | Supply an exact aggregate preview and valid member header. Reevaluate protection after each reduction. Retain the current permitted equality policy. | +| Aggregate rate control. | AARF can change rate and probe state after one member callback without knowledge of the actual PPDU mode. | Require fixed DATA rates and no HCF rate-control submodule for aggregate transmission. Leave adaptive aggregate feedback for a separate design. | +| Response correlation. | Clauses 9.3.1.8.1 and 9.3.1.8.2 define no identifier for an individual exchange. | Validate the active receive interval and observable fields. Reject retired local callbacks. Apply ordinary rules to an indistinguishable valid frame. | +| HT error-model compatibility. | HT length exponent zero advertises 8191 octets. Short-GI capability covers HT PPDU reception. MAC supplies effective limits to the MIB at link-layer initialization. BerTable already rejects HT operation strings. | Check role presence at PHY initialization. Validate exact MAC inputs before the MIB update. Preserve absent-model operation. Include shared NIST/Yans support for advertised HT20 receive modes in D1. Document BerTable's HT exclusion and compare non-HT parent controls. | +| HT-SIG receive validation and content bounds. | Clause 19.3.21 distinguishes invalid HT-SIG CRC from physical carrier loss after a valid header. Current radio validation omits the CRC check. | P1 defines a shared stateless header validator. P2 applies it through current HEADER failure paths. A separate DATA bounds check refuses insufficient modeled content without a carrier-loss claim. | +| HT mixed-format duration. | 10.27.4 limits calculated `L_LENGTH` to 4095. The separate 10 ms bound also applies. | Check both conditions through the HT mode contract before commitment and actual submission. | +| Partial aggregate reception. | 10.3.2.3.7 prohibits EIFS when any member arrives correctly. Ordinary MAC rejection also clears HCF history. | Separate member rejection from one complete receive outcome. Preserve valid aggregate history. | +| Deferred aggregate submission. | Current Tx copies and finalizes one MPDU before its IFS timer expires. | Use the existing timer boundary for HCF validation, commitment, member finalization, and actual aggregate submission. | + +Silent absent-agreement discard, one probe after a failed implicit wait, and the PHY independence assumption are model choices. The standard evidence does not establish measured error accuracy or performance. A materially different owner, PHY abstraction, or supported profile requires a plan revision before its implementation. + +The PHY prerequisite contains the partial reception risk. D1 must pass before the MAC exchange can claim deterministic selective recovery. It includes the NIST/Yans implementation and basic compatibility checks. D2 must pass before the full NIST/Yans profile forms part of the feature claim. A whole-PPDU failure plus a MAC-injected bitmap does not establish this feature. A second risk is incorrect aggregate history: a valid later delimiter must not repair a broken continuity condition silently. + +The current short-GI, VHT negotiation, control-response, channel-width, LDPC, and Minstrel topic branches are not assumed prerequisites. The new transmit profile retains its stated limits. The short-GI receive checks use current mode calculations; they establish no new short-GI transmit or duration-repair claim. Reconcile shared interfaces against their actual heads before any later integration. This plan does not authorize a merge or a rebase of those branches. + +The authorized deliverable is this document revision and the linked PHY plan. Implementation, expectation changes, protected-source edits, commits, and publication retain their separate task scope. The current design needs no protected Packet API edit. If that changes, update the design and obtain the permission that the seal owner requires. + +## Appendix A. Standard requirements and evidence + +IEEE Std 802.11-2024 is the normative reference for this profile. Its local source is `80211ax-2024.pdf`; the filename does not identify the document revision correctly. The corpus document ID is `ieee80211-2024`. Physical PDF pages below differ from printed page numbers. + +| Requirement | Normative source | Physical PDF pages and corpus locator | +| --- | --- | --- | +| ACK policy bits `00` mean Implicit BAR inside the applicable aggregate context. | Clause 9.2.4.5.4; Table 9-13. | 676–679; `ieee80211-2024:clause:9.2.4.5.4`, `ieee80211-2024:table:9-13`. | +| The modeled HT-SIG header preserves PSDU length, Aggregation, field positions, and the specified CRC. | Clause 19.3.9.4.3; Table 19-11; Figure 19-6; Clause 19.3.9.4.4. | 3431–3434; `ieee80211-2024:clause:19.3.9.4.3`, `ieee80211-2024:table:19-11`, `ieee80211-2024:figure:19-6`, `ieee80211-2024:clause:19.3.9.4.4`. | +| Invalid HT-SIG CRC prevents PHY-RXSTART. Unsupported field combinations also require rejection through the PHY receive procedure. | Clause 19.3.21. | 3486–3487; `ieee80211-2024:clause:19.3.21`; PDF fallback for the receive validation text. | +| Signal loss after a valid header produces CarrierLost. A short modeled PSDU fixture does not establish that physical behavior. | Clause 19.3.21. | 3486–3487; `ieee80211-2024:clause:19.3.21`; PDF fallback for the carrier-loss distinction. | +| Compressed Block Ack carries addresses, TID, sequence control, and bitmap, without an identifier for an individual exchange. | Clauses 9.3.1.8.1 and 9.3.1.8.2. | 722–723; `ieee80211-2024:clause:9.3.1.8.1`, `ieee80211-2024:clause:9.3.1.8.2`. | +| Each member has a delimiter and its own MPDU/FCS. Nonfinal HT subframes align to four octets; the final subframe has no alignment padding. | Clause 9.7.1; Figures 9-1326 through 9-1331; Table 9-659. | 1840–1843; `ieee80211-2024:clause:9.7`, `ieee80211-2024:figure:9-1326`, `ieee80211-2024:table:9-659`. | +| An HT delimiter uses the 12-bit low length field. Its CRC covers the previous 16 bits; the signature is `0x4E`. | Clause 9.7.1; Table 9-659. | 1841–1842; `ieee80211-2024:table:9-659`. | +| Members share the applicable address, ACK policy, and Duration/ID conditions. | Clause 9.7.2; Clause 10.12.1. | 1843 and 1976; PDF fallback for the exact subclauses. | +| The receiver advertises maximum length and minimum MPDU start spacing. Maximum HT length is `2^(13 + exponent) - 1` octets. | Table 9-225; Clauses 10.12.2 and 10.12.3. | 1126, 1976–1979; `ieee80211-2024:table:9-225`, `ieee80211-2024:clause:10.12.3`; PDF fallback for 10.12.2. | +| Short-GI capability describes reception of HT PPDUs, without a separate restriction to standalone MPDUs. | Table 9-224. | 1124–1125; `ieee80211-2024:table:9-224`. | +| Additional spacing uses zero-length delimiters. The selected PHY data rate controls the required spacing. | Clause 10.12.3, Equation 10-12. | 1977–1979; `ieee80211-2024:clause:10.12.3`. | +| This HT profile requires RTS/CTS when the complete PSDU exceeds the RTS threshold. Additional protection remains permitted. | Clause 10.3.5. | 1930; `ieee80211-2024:clause:10.3.5`. | +| Associated-RTS frame retry increments apply to DATA outside a Block Ack agreement. Internal collisions separately increment the affected frame retry counts. | Clause 10.23.2.12.1. | 2016–2017; `ieee80211-2024:clause:10.23.2.12.1`. | +| HT PPDU duration must satisfy its PHY limit; TXOP conditions apply separately. | Clause 10.13; Table 19-25; Clause 10.23.2.9. | 1982–1983, 3493–3494, and 2012–2014; `ieee80211-2024:clause:10.13`, `ieee80211-2024:table:19-25`, `ieee80211-2024:clause:10.23.2.9`. | +| HT mixed format also requires calculated `L_LENGTH` at or below 4095, with the signal extension excluded from that calculation. | Clause 10.27.4; Equation 10-18. | 2091–2092; `ieee80211-2024:clause:10.27.4`. | +| One or more correctly received aggregate members prohibit EIFS. | Clause 10.3.2.3.7. | 1891–1892; `ieee80211-2024:clause:10.3.2.3.7`. | +| This profile's Block Ack uses non-HT OFDM or ERP-OFDM. Both basic-rate selection and mandatory-rate fallback remain at or below the HT non-HT reference rate. An alternate preserves the required duration and modulation class. | Clauses 10.6.6.1, 10.6.6.5.2, and 10.6.6.5.4. | 1942–1947 and 1950; canonical clause IDs use `ieee80211-2024:clause:`. | +| The recipient updates its scoreboard before one Block Ack response after SIFS. At least one valid member must exist. | Clauses 10.25.6.3, 10.25.6.5, and 10.25.6.7.1. | 2060–2064 and 2068–2070; canonical clause IDs use `ieee80211-2024:clause:`. | +| Mandatory aggregate release depends on delimiter validity and previous aggregate or Block Ack history. | Clause 10.25.6.6.2.1(a)(2)(i–iv). | 2065–2066; `ieee80211-2024:clause:10.25.6.6.2.1`. | +| A lost Block Ack permits DATA retransmission. Received bits update only the applicable transmitted MPDUs. | Clauses 10.25.6.7.1 and 10.25.6.8. | 2068–2072; canonical clause IDs use `ieee80211-2024:clause:`. | +| EDCA distinguishes a received response from absent reception; contention state belongs to the exchange. | Clause 10.23.2.2. | 1999–2001; `ieee80211-2024:clause:10.23.2.2`. | +| Valid Implicit BAR DATA refreshes recipient inactivity. The explicit absent-agreement DELBA rule names Block Ack-policy DATA. | Clause 11.5.4. | 2566; `ieee80211-2024:clause:11.5.4`. | + +The corpus was rebuilt with the tracked standards launcher. Lint reports 76 heading ambiguities and 425 unresolved references across the corpus. This is not a clean global corpus. Structural retrieval lacks separate nodes for 9.7.1, 10.12.1, and 10.12.2. PDF text supplied their relevant requirements. Visual inspection of Table 9-13 confirmed the two distinct meanings of bits `00`. + +The retrieved references from 10.25.6.5 resolve, but the extractor omits some inline clause references from its reference list. Direct retrieval separately confirmed 10.25.6.3, 10.25.6.4, and 10.25.6.7.1. Partial-state and DMG/TDD requirements do not enter this profile. No absent corpus edge establishes a protocol exception. + +The review assessment also inspected physical PDF page 2065 and Table 19-25 on physical PDF page 3493. The release instruction is mandatory when its conditions hold. The table specifies `aPPDUMaxTime = 10 ms`. The Clause 10.13 reference to Table 19-25 resolves. Its unresolved 10.12.2 corpus edge does not alter the directly checked HT duration requirement. + +The latest review retrieved normative Clauses 10.27.4 and 10.3.2.3.7 through their canonical nodes. Visual inspection of physical PDF page 2092 confirmed the ceiling operation in Equation 10-18 and the 4095-octet prohibition. Clause 10.27.4 references to 6.7.4, 6.7.5, and Table 19-25 resolve. The extracted 10.3.2.3.7 reference to 10.3.7 also resolves. Its EIFS prohibition required no PDF fallback. These retrieved clauses add requirements that the separate 10 ms table value does not replace. + +The response review retrieved normative Clauses 9.3.1.8.1 and 9.3.1.8.2, plus Table 9-225. Their corpus text establishes the frame fields and the minimum advertised HT aggregate length. The references from 9.3.1.8.2 to Figures 9-54 and 9-48, and Clause 10.25.6.5, resolve. Table 9-225's reference to 10.12.3 also resolves. These checks required no additional PDF inspection. + +The serialization correction retrieved normative Clauses 19.3.9.4.3 and 19.3.9.4.4, Table 19-11, and Figure 19-6. Their corpus locators and physical pages appear in the table above. The clause references to Table 19-11 and Figure 19-8 resolve. The extracted text establishes the fields and CRC without additional PDF inspection. P1 must verify the actual encoded bytes against those requirements. + +The receive-contract review retrieved normative Table 9-224 and Clause 19.3.21. Table 9-224 defines short GI as a receive capability. Its reference to 19.1.4 resolves; its reference to 10.11 remains unresolved. Clause 19.3.21 references Figures 19-25 through 19-27, which resolve. The extractor places later receive text under Figure 19-27. PDF text inspection of physical page 3486 confirmed the invalid-CRC rule without reliance on that extraction boundary. + +The RTS and recovery correction retrieved normative Clauses 10.3.5, 10.23.2.12.1, and 10.23.2.2 through their canonical nodes. Their physical PDF pages appear above. The extracted references to 26.2.1, 10.27, and 10.3.2.11 resolve. Clause 10.23.2.2's extracted references also resolve. No additional PDF inspection was necessary for these text requirements. The aggregate RTS rule and retained internal collision path remain distinct implementation decisions within that evidence. + +### Release history required by the supported profile + +The table maps Clause 10.25.6.6.2.1(a)(2) to the required history. Here, `WinStartR` is the receipt window start; `WinStartB` is the reorder window start. The prior receipt bit is the bit for `WinStartR - 1`. Release across a gap also requires `SN > WinStartB` and the clause's other profile conditions. + +| Condition | Required facts | Reachable in this profile? | +| --- | --- | --- | +| (i) | The received MPDU is a later aggregate member. The prior receipt bit is set. Delimiters from the MPDU at that sequence number to this member are valid. | Yes. A later member in the same aggregate supplies the proposed case. | +| (ii) | The first aggregate member follows an aggregate after SIFS/RIFS, or a Block Ack transmission after SIFS. The prior receipt bit is set. All delimiters after the MPDU at that sequence number in the prior aggregate are valid. | Yes. A first aggregate member can follow the prior Block Ack after SIFS within a positive TXOP. | +| (iii) | The received MPDU follows an aggregate after SIFS/RIFS, or a Block Ack transmission after SIFS. The prior receipt bit is set. All delimiters after the MPDU at that sequence number in the prior aggregate are valid. | Yes. Individual fallback can follow Block Ack after SIFS within a positive TXOP. | +| (iv) | The first aggregate member follows an MPDU after SIFS/RIFS, or an ACK transmission after SIFS. The prior receipt bit is set. | Yes. An aggregate can follow individual Block Ack-policy DATA after SIFS. | +| (v), retained from S5 | The individual MPDU follows an MPDU after SIFS/RIFS, or an ACK transmission after SIFS. The prior receipt bit is set. | Yes. The retained individual-MPDU path supplies a SIFS case. | + +These are proposed reachability cases, not executed evidence. A4 must verify each case through physical reception. No condition is deferred in this revision. Any later deferral must identify the excluded path and its source or fixture evidence. + +HCF supplies member position, valid delimiter history, prior event kind, and physical intervals. The reorder service owns the release decision. These facts explain the history extension; they do not require a second receipt map or timer. + +## Appendix B. Verification commands and campaigns + +The bounded timing campaign uses both 2.4 GHz and 5 GHz, HT MCS 0 and 7, long GI, and a legal fixed non-HT response. It covers no protection and RTS/CTS under both current protection mechanisms. Test one case immediately below, at, and above each applicable admission bound. Derive boundary values from the selected mode. Separate clock tolerance from protocol airtime; do not add the HT signal extension twice. + +Set the RTS threshold immediately below, equal to, and above the same complete PSDU length. Verify required protection above the threshold and the current policy's permitted protection at equality. Include two individually short members whose aggregate exceeds the threshold. Add nonzero spacing that crosses the threshold. Reduce a batch across that threshold and verify renewed protection selection, complete-cost admission, and one retained DATA mode. + +Include the HT mixed-format boundary at `TXTIME - SignalExtension = 5484 us` where the selected mode can reach it. Verify that HCF refuses a 6 ms 5 GHz candidate despite its duration below 10 ms. Test the separate 10 ms predicate directly because legal HT mixed-format transmission reaches the L-SIG bound first. + +Place the originator inactivity deadline after CTS reception but before the delayed aggregate's SIFS timer expires. Let the production inactivity handler retire the agreement. Verify that the start callback refuses the cancelled preparation. No DATA submission, source commitment, sequence assignment, member failure feedback, or response-failure probe may result from that cancelled request. Independently scheduled expiry and teardown retain their current disposal effects. A separate reset case verifies cancellation before context release and no callback after release. + +Use two peers and two TIDs in isolation controls. Exercise sequence numbers around 4095/0 and buffer sizes 1, 2, and 64. Cover aggregate completion before, at, and after DATA expiry where those orders are reachable. Use deterministic probabilities for the essential selective-loss cases. The PHY plan owns NIST/Yans seeds 0, 1, and 2. Its campaign checks invariants and reproducibility, not statistical goodput. + +The current checkout provides the module, protocol, and fingerprint runners. Their CLI and selection rules were inspected. The commands below are planned; new fixture selectors cannot run until those fixtures exist. Use the checkout's normal OMNeT++ environment. A zero-case selection is `NOT_RUN`. + +```sh +make MODE=debug -j$(nproc) + +inet_run_module_tests -m debug \ + -f 'Ieee80211Ampdu(Capabilities|Preparation|Reordering|Exchange|Recovery|Admission)_1\.test$' + +inet_run_module_tests -m debug \ + -f 'Ieee80211(CompressedBlockAck.*|BlockAck.*|Edca.*Lifetime.*)_1\.test$' + +inet_run_protocol_tests -p inet -m debug -w '^tests/protocol/wifi$' \ + -f '/(N_AmpduImplicitBa|N_Ampdu|N_BlockAck|Ac_BlockAck|Ac_BlockAckFallback)\.test$' \ + --log-file /tmp/inet-ampdu-protocol.log + +( cd tests/fingerprint && ./fingerprinttest \ + -m '(showcases/wireless/(blockack|aggregation|fragmentation|qos|txop)|examples/(wireless/qos|adhoc/qos))' ) +``` + +Preview each new selector with the runner's `--dry-run` option. Reconcile selected files and executed configurations. Do not run protocol runners concurrently against shared generated directories. Preserve logs and generated artifacts before a later run can replace them. + +Run the full Wi-Fi protocol suite once after the focused cases pass. Separate observed passes, declared expected failures, unexpected failures, and setup errors. Expected-failure declarations for unrelated unsupported features remain visible. A changed marker or expected result follows [baseline rules](../../doc/project/rule/testing.md#tr-baseline-deliberate); source approval alone does not authorize that change. + +For each result, record HEAD, local source diff, environment, library mode, exact command, selected files, configuration, run, seed, verdict, and artifact path. Compare affected behavior with the pinned parent under identical inputs. Fingerprint differences require causal explanation and direct correctness evidence. Graphical `tyf` coverage needs its own environment and must not receive an inferred pass. + +Before publication, follow the [gate procedure](../../doc/project/guide/run-the-gates.md). It requires debug and release compilation, scoped correctness evidence, and the applicable architecture, naming, interface, seal, and series checks. Use the actual implementation base for range checks. No publication command forms part of this plan request. + +## Appendix C. Recovery transitions and acceptance cases + +The pending probe is one boolean in the originator agreement. It exists because response failure and the next admission occur at different events. Member expiry can occur between those events. Current EDCA classification derives the responsible access category from the agreement's TID. HCF coordinates the state with the current BAR policy and acknowledgment handler. It creates no retained category, second mapping table, separate agreement store, or periodic recovery task. + +| Trigger | Required state change and result | +| --- | --- | +| An implicit wait ends without a valid matched Block Ack. | Set the agreement's pending-probe flag. End the sequence with one contention failure. Defer further DATA for that peer/TID until the probe attempt or retirement. | +| A valid matched implicit Block Ack has no positive bits. | Leave the probe flag clear. Complete one successful response exchange. Retain unresolved members for DATA retry. | +| Probe admission refuses transmission. | Retain the pending flag. Preserve all DATA deadlines and sequence state. Other eligible traffic remains available. | +| The radio accepts the explicit probe. | Consume the pending flag. Only the EDCAF derived from the agreement's TID submits and counts the attempt. Retain its physical context and mark applicable transmitted members for that actual BAR wait. Use the current agreement window start. | +| A valid matched Block Ack answers the probe. | Apply transmitted-only bitmap updates. Release acknowledged canonical members. Permit unresolved or new DATA under normal eligibility. Do not repeat DATA feedback. | +| The probe ends without a valid matched response and its agreement remains active. | Apply ordinary BAR control recovery. Return unresolved members to DATA retry. Do not re-arm a probe until another implicit DATA wait fails. | +| A valid recipient-role DELBA arrives. | Use current lifecycle retirement and Action invalidation. Clear unsent probe state. Preserve any accepted physical completion context. | +| A finite transfer becomes empty at a safe boundary. | Run current transfer completion before an unsent probe. Retire the accepted agreement and send originator-role DELBA independently of inactivity timeout. | +| Reset or teardown retires the agreement. | Remove its pending flag with that agreement. Another peer/TID retains its state. | + +Continuous-traffic recovery assumes a responsive peer and a legal BAR admission opportunity. A6 must keep fresh DATA queued while the probe occurs. A BAR received without a recipient agreement triggers S5's DELBA path. The originator then retires its stale agreement before later setup. + +The finite-batch case must reach the current completion trigger even if probes fail. Preserve actual-member transmission records so the completion predicate can succeed. Withhold probe recovery responses until DATA expires, then permit normal teardown completion. This is a deterministic fixture condition, not a claim that radio loss always ends within a fixed time. + +Healthy-agreement recovery is a separate A6 case. Production management establishes accepted agreements at both peers. Fresh DATA remains queued with inactivity timeout zero. Deterministic PHY outcomes cause selected implicit Block Ack losses. The partial-bitmap case also causes selected DATA reception failures. Each case provides legal access for the probe and subsequent DATA. + +| Probe result under a healthy agreement | Required observation | +| --- | --- | +| A valid probe Block Ack acknowledges all retained transmitted members. | Release those members. Observe a new DATA transmission before another probe. | +| A valid probe Block Ack acknowledges some retained transmitted members. | Release only those members. Retain unresolved members for retry. Observe the next eligible DATA transmission before another probe. | +| The probe response is absent or invalid. | Observe an eligible DATA transmission before another probe while the agreement remains active. | + +In every case, the agreement remains active while fresh DATA remains queued. Each required DATA observation belongs to the tested agreement. Probes preserve DATA deadlines and add no DATA attempt or duplicate member feedback. Once normal responses resume, the recipient delivers each accepted MSDU once. The cases prove DATA progress under controlled access and loss conditions. They establish no general fairness or goodput bound. + +Expire the members from the failed DATA attempt before probe admission while fresh DATA remains queued. The probe must still transmit. This case proves that member expiry does not erase the agreement's retained probe requirement. A second access category must neither submit that probe nor receive its contention outcome. + +The probe waits for Block Ack. DELBA follows the current Action path and can arrive after that wait. It still retires the agreement. Current lifecycle resolution suppresses obsolete probe completion feedback. + +The probe is a submitted control exchange, not a synthetic input for implicit response calculations. It adds no DATA transmission attempt. Its positive bitmap cannot acknowledge an unsent or already discarded member. A result from a retired local context cannot resolve another exchange. Received frames follow the active receive interval and observable validation rules in [Section 4.7](#47-originator-exchange-timing-and-recovery). No probe result restarts a DATA lifetime. diff --git a/plan/pending/ieee80211-ampdu-phy-reception.md b/plan/pending/ieee80211-ampdu-phy-reception.md new file mode 100644 index 00000000000..97fe712cac9 --- /dev/null +++ b/plan/pending/ieee80211-ampdu-phy-reception.md @@ -0,0 +1,363 @@ +# Implementation plan: partial PHY reception for HT A-MPDU + +> **Kind:** procedure · **Status:** draft · **Seal:** none · **Owns:** — · **Stands on:** [S5 execution record](ieee80211-compressed-blockack-s5-execution.md), [implementation plan procedure](../../doc/project/guide/write-an-implementation-plan.md), [IEEE 802.11 rules](../../doc/project/domain/ieee80211.md) + +Checkout: `/home/user/omnetpp_ws/inet-compressed-blockack-s5`, branch `work/compressed-blockack-s5`, HEAD `4fa5cc0de15ee57388bcb3f20e866cab5972a670`. + +Plan revision: 11, 2026-10-17. The user's `proceed, including the optional simplification` authorizes the reviewed document corrections. This document accompanies feature revision 12 and its revised summary. The feature plan defines PSDU-based RTS selection, recovery before DATA submission, and a boolean probe requirement with a derived access category. This PHY revision synchronizes those references; its behavior and delivery gates remain unchanged. Implementation, expectation changes, commits, and publication remain outside this authorization. + +The project plan procedure remains a draft. + +Execution status, 2026-10-17: P0, P1, and P2 are complete under the user's approved exception to the merge prerequisite. The [execution record](ieee80211-ampdu-phy-execution.md) identifies the active checkout, implementation, checks, and limits. The proposal below retains its pre-implementation design and evidence status. P3 and P4 remain pending. + +## 1. Problem and intended behavior + +The WLAN receiver currently produces a whole-data success result. That result cannot describe a failed MPDU beside valid MPDUs in the same A-MPDU. The [MAC feature plan](ieee80211-ampdu-implicit-blockack.md) needs those separate results before it can acknowledge and retry members correctly. + +This hypothetical case defines the required result. One HT PPDU carries MPDUs 100 through 103. PHY acquisition and header reception succeed, but MPDU 101 fails. The receiver must preserve valid outcomes for 100, 102, and 103. Two later reads of that reception result must return the same outcomes without additional random draws. + +The PHY reports reception facts. The MAC separately checks delimiters, FCS values, addresses, and agreement state before acceptance. This plan supplies no Block Ack response or upper delivery by itself. + +```mermaid +flowchart TD + RX["One received HT PPDU"] --> H{"Do PHY acquisition and
header reception succeed?"} + H -->|No| FAIL["Report no valid aggregate content"] + H -->|Yes| R["Obtain bounded delimiter
and MPDU ranges"] + R --> MODEL{"Is an error model present?"} + MODEL -->|Yes| E["Obtain each range probability
from the selected error model"] + MODEL -->|No| GOOD["Record physical success
Retain delimiter and FCS checks"] + E --> C["Sample when necessary
Retain immutable cached outcomes"] + GOOD --> C + C --> I["Radio supplies a typed indication
with copied range outcomes"] + I --> MAC["MAC applies delimiter, FCS,
address, and agreement checks"] +``` + +This diagram describes proposed behavior. It is not an executed trace. + +## 2. Current implementation and evidence + +The source assessment established the facts below at the pinned revision. The companion plan's [standards appendix](ieee80211-ampdu-implicit-blockack.md#appendix-a-standard-requirements-and-evidence) retains the common normative evidence. + +| Source and current behavior | Consequence | +| --- | --- | +| The PER operation in [IErrorModel](../../src/inet/physicallayer/wireless/common/contract/packetlevel/IErrorModel.h) accepts an SNIR object and signal part. It has no arbitrary range-length argument. | An aggregate calculation needs an explicit callable range boundary. A generic whole-DATA call cannot score each member. | +| [Ieee80211ErrorModelBase](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.h) declares protected header and DATA success calculations with a bit length. | The shared WLAN implementation can reuse those calculations for range probabilities. | +| [NIST](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h) and [Yans](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.h) derive from that WLAN base. | One base implementation can support both models and compatible custom subclasses. | +| [BerTable](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211BerTableErrorModel.h) derives directly from the generic base. Its [initializer](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211BerTableErrorModel.cc) rejects HT operation strings at the local stage. | BerTable remains outside the HT aggregate profile. Its current HT refusal must remain distinct from the new role check. | +| [Ieee80211Receiver](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.cc) delegates reception results to the common receiver path. | Aggregate reception needs its own outcomes before whole-DATA failure can discard valid members. | +| [Ieee80211PhyHeader.msg](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader.msg) has no modeled HT aggregation field. | A PHY property must distinguish an A-MPDU from a standalone MPDU. This also applies to a singleton aggregate. | +| The HT methods in [Ieee80211PhyHeaderSerializer](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeaderSerializer.cc) write no fields and reconstruct an empty header. | P1 must extend the typed HT-SIG header and serializer together. A new MSG field alone cannot survive conversion to bytes. | +| [Ieee80211Radio](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.cc) validates some PHY headers but performs no HT CRC check. | Correct serialization alone cannot establish rejection of an invalid received HT-SIG. P2 needs receive validation before range outcomes. | +| [MpduDeaggregation](../../src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc) creates separate member Packets, but assumes valid lengths and uses the aggregate name. | Shared bounded parsing must replace unchecked range discovery. Feature A4 projects the PHY outcome onto each member Packet. | +| [CommunicationCacheBase](../../src/inet/physicallayer/wireless/common/base/packetlevel/CommunicationCacheBase.cc) stores decision pointers per receiver, transmission, and signal part. It deletes replaced decisions and retained decisions at entry destruction. | The cache can own a derived WLAN decision. Separate signal-part slots need explicit sample ownership. | +| [RadioMedium](../../src/inet/physicallayer/wireless/common/medium/RadioMedium.cc) caches decision lookups, but directly computes `isReceptionSuccessful()`. Its result path requests a WHOLE decision. | Aggregate queries must share cached samples across both paths and signal parts. Generic cache presence alone does not prevent repeated draws. | +| Separate-part reception in [Radio](../../src/inet/physicallayer/wireless/common/radio/packetlevel/Radio.cc) queries PREAMBLE before HEADER. A failed PREAMBLE or HEADER removes the attempted reception. | Preserve the per-part checks without early HEADER or DATA calculation. That aborted attempt supplies no result to MAC. | +| [FlatReceiverBase](../../src/inet/physicallayer/wireless/common/base/packetlevel/FlatReceiverBase.cc) attaches error-rate metadata through the old whole-PSDU calculation. [ReceiverBase](../../src/inet/physicallayer/wireless/common/base/packetlevel/ReceiverBase.cc) supplies power, SNIR, and reception times. | Aggregate result construction needs an explicit probability contract. It must preserve the other applicable receive metadata. | +| [Rx](../../src/inet/linklayer/ieee80211/mac/Rx.cc) rejects a Packet bit-error flag before its FCS-mode branches. | A failed member can use its own Packet flag without a false checksum or shared chunk mutation. | +| [Ieee80211Receiver](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.cc) sets its mode set at local initialization. [FlatReceiverBase](../../src/inet/physicallayer/wireless/common/base/packetlevel/FlatReceiverBase.cc) resolves its error model at that stage. | The receiver can check role presence at the physical-layer stage. That stage does not supply the exact limits for capability advertisement. | +| [Ieee80211Mac](../../src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc) calculates effective channel widths and NSS at link-layer initialization, before its MIB update. | Exact coverage validation belongs at that handoff, with the same mode set and effective limits. | +| [FlatReceiverBase](../../src/inet/physicallayer/wireless/common/base/packetlevel/FlatReceiverBase.cc) permits reception without an error model after its SNIR check. The [VHT/HT fixture](../../tests/module/Ieee80211VhtHtSupport_1.test) uses this path with transmit aggregation disabled. | An absent error model is a supported case. The new interface check must preserve it. | +| [Ieee80211Radio](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.ned) selects NIST by default for scalar and dimensional reception. | D1 needs the shared implementation before it enables the HT interface check. Otherwise, ordinary default HT configurations fail initialization. | +| [Ieee80211Mib](../../src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc) derives local HT capability from the mode set and effective radio limits. This includes short GI. | Receive support must cover those advertised modes before capability publication. HT length exponent zero still advertises 8191 octets. | + +The feature plan and its human summary are local draft documents. Other local changes affect `AGENTS.md` and earlier Block Ack plans and records. This plan preserves those unrelated files. No source change or new runtime result supports the proposed behavior yet. + +## 3. Scope and acceptance criteria + +The scope is packet-level `Ieee80211Radio` with scalar or dimensional reception and HT mixed format at 20 MHz. Reception covers long GI and short GI at the advertised MCS and NSS values. The MAC feature's aggregate transmit policy remains limited to long GI. D1 supplies receiver integration, the shared NIST/Yans implementation, and basic compatibility checks. Deterministic probabilities establish its partial-reception evidence. D2 completes the NIST/Yans and compatibility evidence under the documented scalar SNIR abstraction. + +The plan owns PHY representation, shared bounded delimiter parsing, the optional aggregate error-model role, cached decisions, and receive indications. The MAC feature plan owns member selection, negotiated spacing, canonical MPDU ownership, release rules, responses, and recovery. + +The required results are: + +1. A decoded HT aggregation property survives radio encapsulation and decapsulation. +2. A singleton aggregate retains aggregate identity. +3. Header failure prevents valid aggregate content. +4. A failed delimiter or member does not automatically discard every later recoverable member. +5. Each outcome belongs to a bounded byte range in the actual PSDU. +6. Repeated decision and result access causes no additional random draw. +7. After successful header reception, whole-signal and separate-part reception produce consistent aggregate outcomes. +8. Compatible ordinary MPDU reception preserves its calculations and random draw sequence. +9. A present HT model without the aggregate role or required receive-mode coverage fails before capability advertisement, independently of local transmit aggregation. +10. NIST and Yans share the WLAN base implementation without duplicate aggregate algorithms. +11. Spacing delimiters receive outcomes, but alignment padding consumes no separate random draw. +12. The indication permits a failed member Packet to retain its error without an incorrect whole envelope. +13. The WHOLE summary does not replace the MAC's member validation or its complete receive outcome for contention. +14. Non-HT custom models retain ordinary MPDU reception without the optional aggregate role. +15. An absent error model retains PHY acquisition and SNIR checks without new error draws or an interface requirement. +16. D1 preserves default NIST initialization, configured Yans initialization, and compatible ordinary MPDU reception before D2 extends the evidence. +17. PREAMBLE queries preserve per-part acquisition checks without HEADER or DATA draws. +18. HT-SIG serialization preserves length and aggregation for standalone, singleton, and multiple-member cases. +19. Aggregate error-rate metadata follows the explicit probability contract in Section 4.3. +20. Advertised HT20 short-GI reception has aggregate support even when the local transmit policy uses long GI or selects no aggregate. +21. Invalid HT-SIG CRC or unsupported fields cause HEADER failure before delimiter or member draws. +22. A valid header with insufficient modeled PSDU content causes bounded DATA refusal without range draws. Its HEADER result remains valid. + +This plan excludes correlated FEC errors, bit-level decoding, interference reconstruction within each member, and statistical accuracy or goodput claims. It cannot represent errors confined to alignment padding. It adds no MAC recovery timer, agreement store, or sealed Packet API change. + +## 4. Proposed design and reasons + +### 4.1 Representation and bounded ranges + +Extend the modeled HT PHY header with its aggregation property. The radio derives the receive indication from that property. A transmit-only tag or the member count cannot substitute for decoded state. + +HT-SIG is the HT signal field that carries PSDU length and other PHY control values. The packet-level model represents its fields without a waveform model. + +P1 owns the HT-SIG representation and [HT PHY header serializer](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeaderSerializer.cc). Extend the typed header and its serializer together. The existing `lengthField` remains the sole PSDU length value. The serializer maps that value to HT Length. New typed fields represent the other HT-SIG values, including Aggregation. The radio obtains mode-dependent values from the selected mode. + +IEEE Std 802.11-2024, Table 19-11 and Figure 19-6, define the fields and their positions. Clause 19.3.9.4.4 defines the HT-SIG CRC. Serialization must preserve the standard's field, reserved, CRC, and tail conditions. The encoded header must match the mode's 48-bit HT-SIG length. P1 must check golden bytes and independent reconstruction of standalone, singleton, and multiple-member cases. Full preamble waveform representation and VHT headers remain outside this profile. + +Current [radio encapsulation](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.cc) already assigns 48 bits from the selected HT header mode. The [HT length calculation](../../src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.cc) supplies that value despite the empty serializer. P1 preserves this declared length and completes byte conversion within it. Fresh decode must consume those same 48 bits. The [transmitter](../../src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.cc) calculates airtime from the selected mode and PSDU length. P1 preserves those duration inputs and calculations for ordinary HT MPDUs. + +In a hypothetical singleton case, the radio sets Aggregation to one and HT Length to the complete PSDU length. Conversion to bytes must preserve both values. A fresh decode must recover them without tags, names, or access to the original typed header. The recipient must therefore retain aggregate identity after that conversion. A typed-object copy alone cannot establish this result. + +#### HT-SIG receive validation + +The WLAN PHY owns one stateless HT-SIG validator beside the header representation and serializer. The serializer preserves the received CRC; decode must not replace it with a newly calculated CRC. The radio calculates the transmit CRC after all HT-SIG fields reach their final values. P1 defines this validator and its wire checks. P2 calls it at the receiver's HEADER decision boundary. + +At that boundary, the receiver checks CRC, supported field combinations, and agreement between encoded mode fields and the actual PHY mode. Invalid CRC or unsupported fields cause HEADER failure without delimiter or member draws. The radio reuses the validator before decapsulation relies on HT Length. On failure, decapsulation must not use the untrusted length for PHY trailer removal. + +An invalid header supplies no accepted Aggregation property. Separate-part reception uses the current abort; whole-signal reception uses the current failure-container path. MAC rejects that container before any MAC header or trailer peek. These header checks apply Clause 19.3.21 within the packet-level model without a new radio event or PHY primitive. + +A separate bounds check compares a valid header's HT Length with the available modeled PSDU before range calculation or length-based decapsulation. Insufficient content denotes malformed model input. The HEADER decision retains success and its decoded Aggregation property. The DATA decision reports failure with no range outcomes or range draws. The radio uses the current failure-container path without length-based trailer removal. MAC rejects that refused content before header or trailer peeks. + +This structural refusal does not represent physical signal loss. Clause 19.3.21 distinguishes invalid HT-SIG CRC from carrier loss after a valid header. The short-content fixture proves bounds safety only. It establishes no carrier-loss behavior or acceptance of a physically received prefix. Physical carrier-loss behavior remains outside this plan. + +Bad encoded bytes and probabilistic header loss remain separate test causes. In a hypothetical case, the error model reports header success, but the transmitted HT-SIG has an invalid CRC. The receiver rejects that header before any member draw or Block Ack response. Repeat the case without an error model. A successful probability result cannot override invalid encoded content. + +Extend the current aggregate decoder with bounded delimiter inspection that the WLAN receiver and MAC can reuse. Check every length, alignment interval, zero-length delimiter, CRC, and signature against the available PSDU. Each scan must advance. A malformed length cannot produce an accepted range or an out-of-bounds read. + +The shared parser supplies range facts, not delivery permission. The MAC must apply the received delimiter outcome before it trusts a boundary. A later recovered delimiter does not erase an earlier continuity break. The parser must not use names or a transmitter-private membership list to bypass corruption. + +The indication identifies each scored range by kind, byte offset, byte length, and outcome. It also retains common header success. A spacing delimiter has a four-octet delimiter range and no MPDU range. These values define the member-error projection before P2 starts. + +#### Scored ranges + +These choices define the packet-level error abstraction. They do not claim that the standard specifies independent error draws. + +| PSDU content | Probability and outcome rule | +| --- | --- | +| Each four-octet delimiter. | Score 32 bits once. This includes every zero-length spacing delimiter. Its failure breaks the applicable delimiter-continuity chain. | +| Each nonzero MPDU range. | Score its complete header, payload, and FCS once. Its outcome belongs to that member only. | +| Alignment padding. | Do not score it. It contributes airtime but has no error outcome or separate error draw. | + +Evaluate common acquisition and header success first. Header failure prevents all delimiter and member draws. After header success, process the bounded transmitted ranges in wire order: delimiter, member if present, padding, and the next delimiter. Probabilities zero and one give fixed outcomes without an RNG draw. An intermediate probability consumes one draw. + +A failed delimiter does not stop the physical calculation for known later ranges. MAC delimiter validation and bounded resynchronization still control which members it can accept. The range indication cannot authorize a jump through a failed delimiter. + +The wire fixture covers HT-SIG serialization, validation, delimiters, member limits, alignment, and bounded recovery. Feature A1 owns capability propagation and aggregate construction calculations for spacing, serialization, and member layout. Feature A3 owns dynamic member selection, spacing at the retained DATA mode, batch reduction, and canonical member ownership. + +### 4.2 Optional role and shared implementation + +Add a paired pure C++/NED WLAN contract for aggregate error probabilities. Its caller supplies the selected mode, modeled SNIR, and bounded delimiter or member ranges. The role distinguishes supported probabilities, invalid input, and unsupported aggregate reception. A pure mode-support query lets the receiver check required coverage before capability publication. That query performs no probability calculation or random draw. + +An implementation must support every advertised HT20 receive mode, whether it uses long GI or short GI. The MAC supplies its mode set, effective channel widths, and NSS limit to the receiver's coverage operation before the MIB update. These are the same values that the MAC supplies to `updateLocalHtCapabilities()`. Validation follows that operation's current MCS and GI rules. It adds no second capability store or independent filter. Unsupported input denotes modes or reception detail outside this contract. + +Table 9-224 defines short-GI support for reception of HT PPDUs. It supplies no separate short-GI permission for standalone MPDUs and aggregates. A model cannot advertise short-GI reception and refuse an otherwise valid short-GI aggregate. HT40 and VHT aggregate reception remain outside this plan. A later extension of advertised receive modes requires receiver support for those modes before advertisement. + +Keep the generic `IErrorModel` API free of WLAN dependencies. The receiver calls aggregate probability operations only for aggregate reception. When an error model is present, HT operation requires the role because advertised HT capability includes aggregate reception. Non-HT custom models retain their ordinary MPDU path without the new role. Custom HT models need the role even when local transmit aggregation remains disabled. + +This plan adds no aggregate role to `Ieee80211BerTableErrorModel`. Its current HT refusal precedes the new role check. The plan claims no loss of supported HT reception through BerTable. P0 records that boundary and a non-HT parent control. P2 compares the control and verifies the expected HT refusal. Tests for the new role diagnostic use the custom model, whose local initialization permits HT operation. + +Place the reusable probability calculation in `Ieee80211ErrorModelBase`. That implementation calls the current protected `getDataSuccessRate()` for each range length at the selected scalar SNIR. The pure contract contains no default method body. NIST, Yans, and compatible custom subclasses inherit the shared implementation. P2 includes this implementation before it enables the HT compatibility check. P3 extends its evidence rather than its interface availability. + +An absent error model retains the current error-free abstraction after PHY acquisition, possibility, attempt, and SNIR checks. After those checks succeed, the receiver records successful physical outcomes for bounded delimiter and member ranges without error-model calls or random draws. Delimiter CRC, bounds, and member FCS checks still control MAC acceptance. A failed common PHY check still prevents valid aggregate content. This case adds no substitute error-model module or support flag. + +The deterministic test model implements the same role with probabilities of zero or one. Thus, tests control error conditions while the production receiver still creates the reception outcomes. Models outside the WLAN base can supply their own implementation. + +The new role has concrete substitutes: the deterministic model and the shared WLAN implementation for NIST/Yans. A new callable boundary is necessary because the public generic API cannot accept an arbitrary member length. No synthetic reception object or temporary PHY length change supplies that absent argument. + +### 4.3 Decision ownership and random draws + +The current [medium lookup](../../src/inet/physicallayer/wireless/common/medium/RadioMedium.cc) computes a decision on a cache miss. The [cache implementation](../../src/inet/physicallayer/wireless/common/base/packetlevel/CommunicationCacheBase.cc) retains the decision's dynamic type. Its key contains the receiver, transmission, and signal part. A result lookup can request WHOLE after a DATA lookup. The direct success-query path can also bypass the decision cache. + +P0 must confirm these paths against the merged implementation base. Record cache insertion, replacement, entry destruction, and result consumption. The current `receivePacket()` consumes the cached result but leaves its decision entries. The sample guarantee applies for as long as those entries exist. The copied receive indication remains valid after cache cleanup. + +For aggregates, retain a PREAMBLE decision in its current cache slot. Its calculation preserves current per-part acquisition, possibility, attempt, and SNIR checks. It does not request HEADER or DATA. Shared WLAN NIST/Yans calculations add no PREAMBLE error draw. Direct PREAMBLE queries reuse that decision. + +HEADER first checks the cached PREAMBLE result before its own calculation. It retains common header success once the header decision boundary permits that calculation. An immutable WLAN decision in DATA retains the bounded delimiter and member outcomes, or structural refusal without ranges. A DATA lookup first obtains the cached HEADER result. A failed prerequisite or structural refusal prevents range draws. A WHOLE lookup derives its summary from these entries at the valid result boundary. + +| Query | Required calculation and retained result | +| --- | --- | +| PREAMBLE | Apply current per-part checks. Retain its decision without HEADER or DATA calculation. | +| HEADER | Reuse PREAMBLE. Retain one header outcome at the header boundary. | +| DATA | Reuse HEADER. Refuse insufficient modeled content before range draws. Otherwise, retain each bounded delimiter and member outcome once after successful header reception. | +| WHOLE | Reuse prerequisite decisions. Derive the summary without another error draw. | + +The WHOLE slot owns a separate summary decision. It does not own the DATA pointer. Aggregate result construction reads the DATA outcomes and copies them into the WLAN indication. This design uses the current cache and adds no second outcome store. + +The WLAN receiver must route aggregate `computeIsReceptionSuccessful()` queries through those cached decisions. Its aggregate `computeReceptionDecision()` override constructs misses through calculation helpers. Construction must not call the cache-backed query recursively. Ordinary MPDU branches retain their current calculation and draw order. + +For aggregate DATA, bypass the inherited whole-PSDU error draw. WHOLE success requires common PHY success, valid PSDU bounds, and success for every scored range. This is a PPDU summary only. Aggregate result construction preserves the envelope's intact content after partial DATA failure. It must not invoke whole-Packet corruption or mark the envelope incorrect for one failed member. + +The WHOLE summary does not decide whether the MAC invokes EIFS. Feature A4 applies delimiter, member PHY, and FCS checks before it reports one aggregate outcome for contention. A correct member suppresses EIFS even when the WHOLE summary reports failure. The feature plan owns that rule and the preservation of valid HCF history after partial loss. [Aggregate receive outcome](ieee80211-ampdu-implicit-blockack.md#45-receive-validation-and-one-response-per-ppdu). + +The radio converts retained facts into a typed WLAN indication with copied values. It retains no pointer to a reception or transmission whose lifetime can end first. Feature A4 maps a failed complete member to that member's `Packet::setBitError(true)` before the normal Rx FCS predicate. + +In separate-part reception, a failed PREAMBLE or HEADER makes `Radio::continueReception()` abort the attempted reception. That attempt supplies no result or failure container to MAC. Existing radio state notifications let HCF invalidate its physical history. If whole-signal reception supplies a container after header failure, MAC rejects it before format-specific header or trailer peeks. Its indication reports failure without a decoded aggregation property. Both paths prevent aggregate acceptance, responses, range draws, and stale history without a new notification event. + +#### Aggregate error-rate metadata + +The current [result path](../../src/inet/physicallayer/wireless/common/base/packetlevel/FlatReceiverBase.cc) obtains `ErrorRateInd` through a whole-PSDU probability calculation. That estimate includes content outside the new scored ranges. It does not describe the selected range model. With a present error model, the aggregate result retains `ErrorRateInd` with `packetErrorRate`, `bitErrorRate`, and `symbolErrorRate` set to `NaN`. The typed WLAN indication separately supplies the retained outcomes. This first profile exposes no aggregate probability estimate. + +The [tag contract](../../src/inet/physicallayer/wireless/common/contract/packetlevel/SignalTag.msg) permits `NaN` for unknown probabilities. P0 must trace aggregate results through direct readers, [result filters](../../src/inet/common/ResultFilters.cc), and the [configured radio recorders](../../src/inet/physicallayer/wireless/common/radio/packetlevel/Radio.ned). The [network configurator](../../src/inet/networklayer/configurator/base/L3NetworkConfiguratorBase.cc) requires the tag for an ordinary probe; this read alone establishes no aggregate path. P0 must verify behavior with unknown values and absent tags for reachable consumers. A reachable incompatibility blocks P2's metadata implementation until the plan records its resolution. Tag omission requires evidence that all affected consumers accept absence. + +The aggregate result path must not call the old WHOLE probability operations to populate those fields. It also must not substitute a realized success or failure for a probability. Without an error model, preserve the common base's existing tag presence and exact values. Preserve applicable power, SNIR, reception times, transmission identity, mode, and channel metadata in both cases. Ordinary MPDU reception retains its current metadata calculations and values. + +In a hypothetical partial reception with a present model, MPDU 101 fails beside valid MPDUs 100, 102, and 103. The typed indication reports those distinct outcomes. The aggregate's probability fields remain `NaN` because the first profile supplies no aggregate estimate. A member must not inherit an aggregate probability as its own probability. The receiver needs no probability cache or additional error-model call for this metadata policy. + +### 4.4 Model detail and diagnostics + +The first abstraction has common PHY acquisition and header success, followed by independent delimiter and MPDU outcomes. Each range uses the current scalar SNIR reduction. The calculation adds no separate PHY header to every member. + +This abstraction does not model correlated FEC errors or variation of interference within a member. It cannot represent errors confined to alignment padding. Padding still contributes to PSDU length and PPDU airtime. More detailed error models remain separate work. NIST/Yans integration reuses current calculations; it does not establish new PHY accuracy. + +The WLAN receiver owns the HT compatibility operations. At `INITSTAGE_PHYSICAL_LAYER`, it rejects a present HT model if the aggregate role is absent. This stage follows local error-model initialization. Exact coverage validation occurs later, before the MAC updates local HT capability at `INITSTAGE_LINK_LAYER`. Both checks precede management capability advertisements and apply independently of the local transmit policy. Exponent zero cannot disable advertised A-MPDU reception because it represents 8191 octets under Table 9-225. + +The MAC calculates effective channel widths from transmitter and receiver support. It calculates the NSS limit from antenna count and its mode set. Before `updateLocalHtCapabilities()`, the MAC calls the receiver's pure coverage operation with those exact values and the same mode set. The receiver checks the HT20 MCS and GI combinations that those inputs advertise. Failure prevents the MIB update and capability publication. No probability call or random draw occurs. + +In a hypothetical configuration, one antenna limits advertisement to one spatial stream. The mode catalog also contains modes for more spatial streams. A model with complete support for the advertised modes must pass validation. Unsupported modes outside those effective limits must not cause rejection. This case prevents an incorrect coverage requirement for the full catalog. + +After initialization, `setModeSet()` checks role presence before it accepts an HT set. That setter alone cannot establish exact advertised-mode coverage. The current capability-update caller exists only in MAC initialization. Any later capability-update path must validate its exact inputs before the MIB changes local HT capability. This plan adds no runtime capability-update mechanism or second capability store. + +The check must not clear short-GI capability to obtain model compatibility. A present model must not substitute uniform success or one whole-PSDU result for the required aggregate outcomes. An absent model follows the explicit error-free case in Section 4.2. No new capability bit or mutable support flag represents this local compatibility condition. + +In a hypothetical configuration, a custom model supports ordinary HT MPDUs but lacks the aggregate role. The default transmit policy still selects no A-MPDU. Initialization must fail before any capability advertisement or association, rather than at the first received aggregate. The custom model needs an aggregate implementation before this HT configuration can run. The same model can retain its current non-HT MPDU operation without that role. + +In another hypothetical case, a custom model supplies the role but supports only long GI. The effective limits permit advertised HT20 short-GI reception. The mode-support query must cause initialization failure before the MIB update or advertisement. With complete support, a peer's short-GI aggregate must produce a valid PHY indication. Feature A5 separately verifies MAC receipt and the response. The local transmitter can retain long GI throughout this case. + +### 4.5 Reuse and justified additions + +| Addition | Responsible component and consumer | Reuse decision | +| --- | --- | --- | +| HT-SIG fields, serializer, validator, and typed indication. | WLAN radio and receiver validate header fields before MAC/Rx receives aggregate content. | Current PHY state cannot distinguish singleton aggregates. Its empty HT serializer cannot preserve the new property through bytes. Current radio validation omits HT CRC. | +| Optional aggregate error-model role. | WLAN receiver checks receive-mode support before it calls deterministic or shared WLAN probability implementations. | Generic `IErrorModel` has no range-length argument. Interface presence alone cannot establish coverage of advertised receive modes. | +| Shared probability implementation. | `Ieee80211ErrorModelBase` serves NIST, Yans, and compatible custom subclasses. | Current protected per-length calculations already supply the required arithmetic. | +| Immutable aggregate decision. | Current medium cache owns outcomes for receiver and radio consumers. | Recomputed random decisions would change repeated observations. No second cache is necessary. | +| Aggregate error-rate metadata. | WLAN receiver preserves applicable receive tags and reports unspecified probability fields through `NaN`. | The old whole-PSDU estimate describes a different calculation. This policy needs no new probability store. | +| Bounded delimiter inspection. | Current decoder supplies common range rules to PHY and MAC. | Unchecked lengths cannot establish valid ranges or delimiter continuity. | +| Early HT compatibility checks. | WLAN receiver checks role presence. MAC supplies exact advertised-mode inputs for receiver coverage validation before the MIB update. | PHY initialization lacks the effective advertisement limits. A runtime aggregate diagnostic occurs after capability advertisement. Exponent zero cannot represent absent aggregate reception. | +| Explicit case without an error model. | WLAN receiver preserves current PHY checks and supplies bounded physical outcomes. | The current error-free abstraction needs no new role, module, or random draw. | + +These choices follow [minimal design](../../doc/project/rule/quality.md#qr-design-minimal), [reuse](../../doc/project/rule/architecture.md#ar-ext-reuse), and [contract purity](../../doc/project/rule/architecture.md#ar-org-contract-purity). + +## 5. Affected components and compatibility + +Changes affect MSG inputs for the HT PHY header and WLAN receive tag. They also affect the HT header serializer, receiver, radio, WLAN error-model contracts/base, NIST/Yans declarations, and aggregate decoder. The MAC adds the receiver coverage call before its current MIB update. P2 owns that required consumer with the receiver operation. Generated files follow the normal build procedure. Tests exercise the real medium and receiver. + +HT-SIG serialization completes byte conversion for ordinary HT MPDUs as well as aggregates within the current 48-bit header length. P0 records that declared length and the current mode/PSDU duration path. P1 verifies 48-bit serialization and decode; ordinary HT controls verify unchanged airtime under identical mode and PSDU inputs. Record byte changes separately from reception calculations, frame sequences, and random draws. Any fingerprint change needs its own causal explanation. Any affected recorded expectation follows the current baseline rules and authorization scope. + +D1 changes no default transmit aggregation policy. It includes the shared NIST/Yans implementation before the early HT check becomes active. D1 must retain default HT initialization and compatible ordinary MPDU reception. Its deterministic test model establishes partial-reception integration. Those deterministic results alone do not establish the full NIST/Yans profile; D2 completes that evidence. + +The early diagnostic changes compatibility for present custom HT models without the role or required receive-mode coverage. This includes configurations that previously used only ordinary MPDUs. Those configurations require model migration. Compatible ordinary MPDU calculations retain their current behavior and draws. Non-HT custom configurations need no aggregate implementation. Invalid encoded HT-SIG content now causes reception failure; valid ordinary HT content retains its current calculations. + +BerTable receives no HT support in this delivery. Its current initializer rejects `opMode="n"` and the HT operation strings that the radio supplies before the new role check. The migration guide lists this current limit and directs supported HT configurations to NIST or Yans. It must distinguish the current initializer error from the new diagnostic for an otherwise valid custom HT model. Non-HT BerTable controls compare initialization and reception with the pinned parent; they add no aggregate-role requirement. A failure in the parent remains a prior limitation, with no inferred compatibility pass. + +An absent error model remains valid for ordinary HT operation, including current `Ieee80211UnitDiskRadio` configurations. The receiver preserves their current PHY checks without error draws. The aggregate profile remains scalar or dimensional reception under the declared HT conditions. This compatibility requirement adds no aggregate support claim for unit-disk reception. + +The migration guide must identify the optional role, mode-support query, shared base, typed indication, range semantics, and early HT diagnostics. It must explain the MAC-to-receiver coverage handoff before the MIB update. It must distinguish absent, compatible, and incompatible models, such as a present role with incomplete receive-mode coverage. It must separate HT20 short-GI reception from the long-GI transmit policy. The current [seal registry](../../doc/project/audit/seal-list.md) protects `src/inet/common/packet/`. This plan uses its public API. + +The guide must explain HT-SIG byte conversion, header validation, per-part failure delivery, and the aggregate probability fields. It must distinguish structural PSDU refusal from header failure and physical carrier loss. + +General MAC stop/start recovery remains outside this plan. Current agreement reset and object destruction must safely release new transient metadata through their current owners. + +## 6. Implementation steps and dependencies + +Each step forms a buildable commit or short series with its required consumers and tests. D1 and D2 are separately reviewable deliveries. D1 supplies receiver integration without an intermediate loss of default HT operation. D2 completes the NIST/Yans and compatibility evidence for the declared profile. + +| Step and purpose | Responsible component and proposed change | Expected result and verification | Dependency | +| --- | --- | --- | --- | +| P0: Establish the merged base and cache contract. | Retain the agreed merge gate. Pin the integrated base. Trace all signal parts, direct success queries, result construction, failure delivery, and cache lifetime. Audit header length, the duration path, BerTable controls, and aggregate metadata consumers. | Record keys, insertion, replacement, destruction, result consumption, and shared-sample paths. Record the current 48-bit header length, duration inputs, and BerTable parent controls. Close the audit of aggregate metadata consumers before P2 implements its contract. Confirm error-model APIs and the feature-off baseline. | Read-only preparation can start now. Closure requires all three merges. | +| P1: Define representation and scored ranges. | Extend typed HT-SIG state and its serializer together. Define the shared stateless validator. Define range kinds, offsets, outcomes, and member-error projection. Harden shared delimiter inspection. Fix scoring and evaluation order. | Golden bytes and independent decode preserve HT Length and Aggregation within the current 48-bit header length. Ordinary HT controls preserve airtime for identical mode and PSDU inputs. Wire checks distinguish invalid headers from insufficient modeled PSDU content. Other wire cases prove limits, truncation, alignment, and singleton identity. Spacing delimiters receive outcomes; padding has no outcome or draw. | P0. | +| P2: Deliver receiver integration and basic compatibility. | Add the optional role, mode-support query, and shared WLAN implementation for NIST/Yans. Preserve reception without an error model. Include the role check and MAC coverage handoff with their required implementations. Apply HT-SIG validation at HEADER and structural content bounds at DATA. Add the deterministic model, per-part decisions, WHOLE summary, cache-backed queries, copied indication, and defined metadata. | Actual reception proves partial loss, delimiter failure, per-part failure delivery, query consistency, cache lifetime, and metadata without duplicate draws or probability calls. Invalid headers and structural refusal prevent range draws through distinct decisions. Advertised HT20 short-GI aggregates produce valid PHY indications. Default NIST, configured Yans, absent-model operation, and non-HT BerTable controls match their documented parent behavior. Incompatible present models fail before advertisement; BerTable's current HT refusal remains distinct. This closes D1 without MAC receipt or response acceptance. | P1. Close the metadata audit before its dependent implementation. Cache reuse, scored ranges, and member-error projection must be defined first. | +| P3: Verify NIST/Yans aggregate outcomes. | Exercise the shared implementation from P2 through the real receiver. Compare range probabilities with the current per-length calculations. | Deterministic reference checks and fixed-seed runs prove cache use, repeatability, and supported model selection. No additional interface implementation is necessary to restore default HT initialization. | D1. Feature A3–A6 need not wait. | +| P4: Close PHY compatibility evidence. | Complete migration text, affected receiver controls, and the execution record. Compare feature-off calculations and draws with the pinned parent. | NIST/Yans and unsupported-model cases match the documented boundary. Scoped checks close D2. Feature A7 requires D2. | P3. | + +```mermaid +flowchart TD + M["Merged #1343, #1344, #1345
P0: Refresh the base"] --> P1 + P1["P1: Representation and bounded ranges"] --> P2 + P1 --> A1["Feature A1 and A3
Capabilities and preparation"] + P2["P2 / D1: Receiver integration
Shared models and basic compatibility"] --> A4 + A1 --> A4["Feature A2 and A4 to A6
Reception, mandatory release, and exchanges"] + P2 --> P3["P3 and P4 / D2
NIST/Yans and PHY compatibility evidence"] + A4 --> A7["Feature A7
Document and verify the supported profile"] + P3 --> A7 +``` + +D1 includes the shared NIST/Yans implementation and basic compatibility checks. D2 can follow deterministic MAC integration because it extends the evidence. That exchange still needs MAC receive step A4 and all applicable release conditions. Completion of the documented profile requires D2 and feature A7. + +## 7. Verification methods and expected results + +Both fixture names are proposed. Neither exists at this revision. The feature plan owns seven additional fixtures; the combined inventory remains nine. + +| Proposed fixture | Boundary and required observations | +| --- | --- | +| `Ieee80211AmpduWire_1.test`, unit/serializer. | HT-SIG golden bytes and independent decode preserve length, Aggregation, CRC, and the current 48-bit header length. Cover standalone, singleton, and multiple-member cases. Validator cases reject invalid CRC and unsupported field combinations. A separate bounds case refuses content shorter than valid HT Length. Real delimiter/member layouts prove CRC/signature, lengths 0/4095/4096, every alignment remainder, no final HT padding, truncation, and bounded resynchronization. | +| `Ieee80211AmpduPhyReception_1.test`, module. | Actual reception proves all-good, first/middle/last member loss, regular/spacing delimiter failure, all-member failure, per-part header failure, and query consistency. It distinguishes HT-SIG rejection from structural DATA refusal before range draws. It also verifies copied indication lifetime, metadata with reachable consumers, and HT20 short-GI indications without MAC response acceptance. D1 checks NIST/Yans initialization, ordinary reception, absent-model operation, BerTable controls, and exact coverage at the MAC handoff. Absent roles and incomplete advertised coverage fail; unsupported unadvertised modes do not cause failure. D2 extends NIST/Yans aggregate evidence. | + +Use deterministic probabilities and seed 0 for the causal cases. Cover whole-signal and separate-part reception with scalar and dimensional models. Verify indication values after the producer's source objects leave their normal lifetime. + +Add a fixed probability between zero and one for cache checks. Record random draw counts before and after repeated reads. Those reads must add no draws. Count error-model calls to distinguish cached access from repeated probability calculations. + +Exercise PREAMBLE, HEADER, DATA, and WHOLE lookups, direct success queries, result creation, and repeated access in each supported reception configuration. At the production PREAMBLE boundary, verify no HEADER or DATA calculation or draw. Repeat that query without a new draw. Query WHOLE before DATA in a separate case at the valid result boundary. Both later lookup orders must use the same retained outcomes and add no duplicate draws. Verify result consumption and cache cleanup against P0's recorded ownership. + +Force PREAMBLE and HEADER failure separately through the production radio in separate-part mode. Verify that the failed attempt supplies no container to MAC. Verify no later range draws, response, accepted member, or retained physical history. In whole-signal mode, verify rejection of any delivered failure container before aggregate or ordinary MAC header parsing. These checks preserve the existing event boundaries and require no synthetic failure delivery. + +With a present model, check all three `ErrorRateInd` fields for `NaN` after aggregate result construction and repeated reads. Count the old WHOLE probability calls; aggregate metadata must add none. Check power, SNIR, reception times, transmission identity, mode, and channel at their existing boundaries. Without a model, compare tag presence and exact values with the current common-base behavior. Ordinary MPDU controls must retain their existing metadata. Member results must never present an aggregate probability as a member estimate. + +P0 records each metadata consumer, its aggregate reachability, and its behavior with unknown probabilities or an absent tag. The PHY module fixture exercises the reachable consumers that P0 identifies, with the configured filters and recorders. An unresolved incompatibility in P0 blocks P2's metadata implementation. A fixture failure blocks D1 until its documented resolution passes. Verify safe behavior with unknown values before D1 closes. Do not replace `NaN` with an absent tag without evidence that affected readers accept absence. + +P1's controls compare ordinary HT header length and PPDU duration with the pinned parent under identical mode and PSDU inputs. Verify the 48-bit header length before byte conversion and after independent decode. Verify unchanged PPDU airtime separately from changed bytes or fingerprint values. The wire fixture supplies representation evidence; the PHY module fixture verifies actual transmission duration. P1 adds ordinary HT duration controls to the PHY module fixture. P2 extends that fixture with partial-reception cases. + +The wire fixture must decode fresh HT-SIG bytes without access to the original typed header. Check Aggregation zero for standalone MPDUs and one for singleton or multiple-member aggregates. Check HT Length against the complete PSDU length. Golden bytes must also establish the reserved, CRC, tail, and field-position conditions in the cited standard. Compare the encoded length with the mode's HT-SIG length. + +Corrupt an encoded HT-SIG bit without repair of its CRC. Separately encode an unsupported field combination with a valid CRC. Run both cases through the production receiver with successful header probabilities and without an error model. Verify HEADER failure, no accepted Aggregation property, and no delimiter or member draws. Preserve the current separate-part abort and whole-signal failure-container paths. + +Separately supply a valid HT-SIG whose HT Length exceeds the available modeled PSDU. Verify HEADER success and preservation of the decoded Aggregation property. Verify DATA refusal with no range outcomes or draws. Verify bounded decapsulation and MAC refusal before header or trailer peeks in both reception modes. Repeat this case without an error model. This malformed-input check establishes no physical carrier-loss result. + +Vary alignment padding without a separate outcome or draw. Add zero-length spacing delimiters and verify their extra scored ranges. A failed spacing delimiter must preserve the continuity break after later recovery. The feature's A4 fixture separately proves rejection under declared-correct and computed FCS modes. + +Feature A4 also verifies EIFS suppression after partial reception and one corruption notification after total failure. Feature A5 owns production member finalization, computed-FCS retry checks, and aggregate cancellation during SIFS. The PHY wire fixture does not establish those MAC transmission results. [Feature acceptance fixtures](ieee80211-ampdu-implicit-blockack.md#proposed-direct-checks). + +P3 also compares range probabilities against each model's current per-length calculation. NIST/Yans runs use seeds 0, 1, and 2 to check invariants and reproducibility. These runs establish no statistical goodput or error-accuracy claim. Repeated cache access must leave later random draws unchanged. + +Feature-off controls compare compatible ordinary MPDU results and subsequent draws with the pinned parent under identical inputs. A non-HT custom model without the role must retain ordinary MPDU reception. Its HT configuration must fail initialization before any capability advertisement, also with the default transmit policy. After initialization, a change to an HT mode set without the required role must fail before receiver acceptance. The feature capability fixture separately proves the absence of management advertisements and association after the initialization failure. + +Use a custom model that exposes the role but supports only long GI. Use exact MAC inputs that permit short-GI advertisement. Verify initialization failure before the MIB changes local HT capability. The mode-support query must add no probability call or random draw. Also verify success with one antenna and unsupported modes outside the effective NSS limit. These checks must use the production MAC handoff and its exact mode set, channel widths, and NSS limit. + +With complete coverage, receive a valid HT20 short-GI aggregate through the production radio. D1 and feature A2 verify the copied PHY indication and member outcomes. Feature A5 separately verifies MAC receipt and one Compressed response after SIFS. The local aggregate transmit policy remains at long GI. Any later capability-update caller must use the same validation boundary; this plan adds no such runtime caller. + +D1 also checks ordinary HT reception with an absent error model and with each shared NIST/Yans implementation. Compare results and subsequent draws with the pinned parent. Retain the current VHT/HT fixture's absent-model configuration. Within the aggregate profile, an absent model produces successful physical ranges only after all common PHY checks succeed. Failed acquisition or SNIR checks still prevent valid aggregate content. Delimiter and FCS rejection remain active without a model, and no error draw occurs. + +The PHY module fixture includes a non-HT BerTable control and an expected HT refusal case. Supply a valid table file so that a file error cannot mask the operation-mode refusal. Compare the non-HT control with P0's parent evidence. Record any parent failure separately from feature regressions. Verify that BerTable's current error at local initialization precedes the new role check. Keep the custom HT model case as the direct proof of that new check. + +The planned commands use the current runners. They cannot establish a result before the fixtures exist: + +```sh +make MODE=debug -j$(nproc) + +inet_run_unit_tests -m debug -f 'Ieee80211AmpduWire_1\.test$' + +inet_run_module_tests -m debug -f 'Ieee80211AmpduPhyReception_1\.test$' +``` + +Preview each selector with `--dry-run`. Record selected files, configurations, seeds, exact commands, HEAD, local source diff, library mode, verdicts, and artifacts. A zero-case selection is `NOT_RUN`. Compare the actual changed receiver dependencies before any broader campaign. + +Use the [gate procedure](../../doc/project/guide/run-the-gates.md) before publication under separate authorization. Coordinate final Wi-Fi coverage with the feature plan so one unchanged revision does not need duplicate broad runs. Release compilation remains required; debug behavioral evidence does not establish release behavioral coverage. + +The [feature plan's evidence status](ieee80211-ampdu-implicit-blockack.md#evidence-status) records this revision's document checks. No build, fixture, simulation, or noisy-channel campaign ran. + +## 8. Risks, decisions, and implementation scope + +The main risks are accidental whole-PSDU rejection, repeated random draws, unbounded delimiter parsing, and confusion between singleton aggregates and standalone MPDUs. D1 addresses those risks before MAC exchange integration. + +The scalar SNIR and independent-range assumptions are explicit model choices. Mandatory MAC release conditions remain in the feature plan. This split does not make those conditions optional. + +P1 owns HT-SIG representation and validation so that aggregate identity survives byte conversion without acceptance of invalid headers. P2 applies the validator through current HEADER failure paths. A separate DATA bounds check refuses malformed modeled content without a carrier-loss claim. The first profile reports aggregate outcomes through typed metadata and leaves probability estimates unspecified when an error model is present. PREAMBLE caching and current failed-header aborts preserve actual radio boundaries. These choices add no probability store, failure event, or expanded waveform model. + +Feature step A2 accepts D1. This plan owns the PHY implementation work, including the shared NIST/Yans implementation in P2. Broader NIST/Yans evidence can follow deterministic MAC integration. The documented profile requires D2; default HT operation must remain valid at D1. + +The full merge gate is the agreed delivery policy for one integrated S5 baseline. It keeps both plans on the same contracts and verification parent. Pure PHY calculations do not inherently require the MAC agreement lifecycle changes. An independent PHY base would need its own pinned dependencies and compatibility evidence. + +Implementation requires merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). P0 must pin their integrated base. Read-only preparation does not satisfy that gate. A changed owner, result contract, or model-detail assumption requires a plan revision before the dependent implementation. From d2df372532b94c7c96f293187783da214c4089de Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:53:04 +0200 Subject: [PATCH 19/41] ieee80211: fix: create VHT headers for VHT signal modes Before this commit, VHT signal mode constructs an HT PHY header. The header type therefore disagrees with the selected PHY mode. After this commit, VHT signal mode constructs the existing VHT PHY header. For example, a VHT transmission retains its VHT header identity instead of entering later HT validation with no HT MCS. The HT/VHT support fixture supplies the production control. This prerequisite adds no VHT serializer or aggregate profile. Plan: plan/pending/ieee80211-ampdu-phy-reception.md Change: src.ieee80211 | behavior.change.fix | whatsnew | ieee80211-ampdu-phy-reception --- WHATSNEW | 4 ++++ .../physicallayer/wireless/ieee80211/mode/Ieee80211VhtMode.h | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/WHATSNEW b/WHATSNEW index 8cebaec1905..6b5c96f7057 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -494,6 +494,10 @@ Notable backward incompatible changes are the following: Commitment of ordinary DATA now preserves normal queue service effects. Queue output statistics count the departure, and the retained preview includes elapsed queueing time and queue events. This also applies when a deferred head causes selection of a later eligible frame. +58. VHT PHY header identity + + VHT signal modes now create the existing VHT PHY header type. This corrects their former use of the HT header type. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211VhtMode.h b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211VhtMode.h index 3767f5d8001..58294878ce8 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211VhtMode.h +++ b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211VhtMode.h @@ -100,7 +100,7 @@ class INET_API Ieee80211VhtSignalMode : public IIeee80211HeaderMode, public Ieee virtual const Ieee80211OfdmModulation *getModulation() const override { return modulation; } virtual const Ieee80211VhtCode *getCode() const { return code; } - virtual Ptr createHeader() const override { return makeShared(); } + virtual Ptr createHeader() const override { return makeShared(); } }; /* From 0fe439f77a49a6afc5fc8c8f77829623680ad5c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:54:02 +0200 Subject: [PATCH 20/41] ieee80211: add: preserve HT-SIG and bounded MPDU ranges Before this commit, HT header conversion supplies no HT-SIG bytes. A byte-backed singleton aggregate therefore cannot retain its aggregate identity. Deaggregation lacks a shared bounded description of delimiters and complete MPDUs. After this commit, the radio assigns HT-SIG fields and CRC from the selected mode and aggregate identity. The serializer preserves all 48 bits. Validation refuses invalid CRC, unsupported fields, and insufficient content before trailer removal. The shared delimiter inspector supplies bounded ranges for deaggregation and later PHY outcomes. For example, an invalid delimiter starts bounded recovery across a typed MPDU header. The inspector permits explicit byte reinterpretation of each delimiter candidate instead of a failing typed conversion. Typed and byte representations retain the same later complete MPDU ranges. Existing typed delimiter error flags remain effective. The wire fixture checks independent bytes, CRC, singleton identity, length limits, alignment, truncation, and typed delimiter recovery. Ordinary valid HT duration inputs remain unchanged. The preceding prerequisite already corrects VHT header identity. MAC aggregate acceptance remains outside this commit. Plan: plan/pending/ieee80211-ampdu-phy-reception.md Change: src.ieee80211 | behavior.add | test whatsnew migration | ieee80211-ampdu-phy-reception --- WHATSNEW | 6 +- doc/src/migration-guide/index.rst | 7 + .../mac/aggregation/MpduAggregationUtils.cc | 57 ++++++ .../mac/aggregation/MpduAggregationUtils.h | 34 ++++ .../mac/aggregation/MpduDeaggregation.cc | 18 +- .../packetlevel/Ieee80211HtSignalField.cc | 62 ++++++ .../packetlevel/Ieee80211HtSignalField.h | 19 ++ .../packetlevel/Ieee80211PhyHeader.msg | 14 ++ .../Ieee80211PhyHeaderSerializer.cc | 20 ++ .../ieee80211/packetlevel/Ieee80211Radio.cc | 17 ++ tests/unit/Ieee80211AmpduWire_1.test | 185 ++++++++++++++++++ 11 files changed, 427 insertions(+), 12 deletions(-) create mode 100644 src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc create mode 100644 src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h create mode 100644 src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.cc create mode 100644 src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h create mode 100644 tests/unit/Ieee80211AmpduWire_1.test diff --git a/WHATSNEW b/WHATSNEW index 6b5c96f7057..ab7973592a6 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -494,9 +494,11 @@ Notable backward incompatible changes are the following: Commitment of ordinary DATA now preserves normal queue service effects. Queue output statistics count the departure, and the retained preview includes elapsed queueing time and queue events. This also applies when a deferred head causes selection of a later eligible frame. -58. VHT PHY header identity +58. IEEE 802.11 HT-SIG bytes and aggregate boundaries - VHT signal modes now create the existing VHT PHY header type. This corrects their former use of the HT header type. + HT transmissions now preserve the complete HT-SIG header through byte conversion. Receivers check its CRC, supported fields, and length before length-based trailer removal. Invalid headers mark packets as erroneous. Delimiter inspection supplies bounded MPDU ranges, including singleton aggregates. Ordinary valid HT duration inputs remain unchanged. VHT modes now create their own header type. + + Delimiter recovery now scans across typed MPDU headers. An invalid delimiter no longer causes a chunk conversion error at those headers. Bounded recovery retains later complete MPDU ranges. Notable backward compatible changes are the following: diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 8a171ab7075..4956e2ada11 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -14,6 +14,13 @@ retransmissions do (``synRetries``). When they run out, the connection raises th ``TCP_E_TIMEOUT_CONN_ESTAB``, as the timer did before, so a subclass that handles this event needs no change. +IEEE 802.11 HT-SIG representation +-------------------------------- + +The modeled HT-SIG header preserves all 48 bits through byte conversion. ``lengthField`` supplies HT Length. ``aggregation`` distinguishes an A-MPDU from a standalone MPDU, including singleton aggregates. The radio derives mode fields from the selected mode and calculates the CRC after field assignment. Decode preserves the received CRC. HEADER validation rejects invalid CRC and unsupported fields before delimiter or MPDU outcomes. + +Separate-part reception retains its current abort; whole-signal reception supplies a failed container. DATA separately refuses modeled content shorter than a valid HT Length. This refusal retains the accepted header property but supplies no range outcomes. It represents malformed model input, not physical carrier loss. Decapsulation never uses an invalid header or insufficient content for length-based trailer removal. Ordinary valid HT duration inputs remain unchanged. + Radio medium timing queries -------------------------- diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc new file mode 100644 index 00000000000..aff3649c878 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc @@ -0,0 +1,57 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" + +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" + +namespace inet { +namespace ieee80211 { + +MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length) +{ + MpduLayout layout; + if (offset < B(0) || length < B(0) || offset + length > packet->getDataLength()) { + layout.complete = false; + return layout; + } + B position(0); + // IEEE Std 802.11-2024, 9.7.1: delimiter boundaries are four octets apart after loss of continuity. + while (position < length) { + if (length - position < B(4)) { + layout.complete = false; + break; + } + // Recovery can enter a typed MPDU. Interpret its candidate delimiter bytes explicitly. + const auto& delimiter = packet->peekDataAt(offset + position, B(4), + Chunk::PF_ALLOW_INCORRECT | Chunk::PF_ALLOW_INCOMPLETE | Chunk::PF_ALLOW_IMPROPERLY_REPRESENTED | + Chunk::PF_ALLOW_REINTERPRETATION); + bool valid = delimiter->isCorrect() && delimiter->isComplete() && delimiter->isProperlyRepresented() && + delimiter->getLength() >= 0 && delimiter->getLength() <= 4095 && + B(delimiter->getLength()) <= length - position - B(4); + layout.ranges.push_back({MpduRangeKind::DELIMITER, position, B(4), valid}); + position += B(4); + if (!valid) { + layout.complete = false; + continue; + } + B memberLength(delimiter->getLength()); + if (memberLength == B(0)) + continue; + layout.ranges.push_back({MpduRangeKind::MPDU, position, memberLength, true}); + position += memberLength; + if (position == length) + break; + B padding((4 - memberLength.get() % 4) % 4); + if (padding > length - position) { + layout.complete = false; + break; + } + position += padding; + if (position == length) + layout.complete = false; // HT has no final alignment padding. + } + return layout; +} + +} // namespace ieee80211 +} // namespace inet diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h new file mode 100644 index 00000000000..bff9f954451 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_MPDUAGGREGATIONUTILS_H +#define __INET_MPDUAGGREGATIONUTILS_H + +#include "inet/common/packet/Packet.h" + +namespace inet { +namespace ieee80211 { + +enum class MpduRangeKind { DELIMITER, MPDU }; + +struct INET_API MpduRange +{ + MpduRangeKind kind; + B offset; + B length; + // Delimiter validity includes header flags and member bounds. MPDU validity requires a complete range. + bool valid; +}; + +struct INET_API MpduLayout +{ + std::vector ranges; + bool complete = true; +}; + +// Offsets are relative to the PSDU, without the PHY header or PHY padding. +INET_API MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length); + +} // namespace ieee80211 +} // namespace inet + +#endif diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc b/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc index 01729897c5d..49971063177 100644 --- a/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc @@ -6,6 +6,7 @@ #include "inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" namespace inet { namespace ieee80211 { @@ -16,20 +17,17 @@ std::vector *MpduDeaggregation::deaggregateFrame(Packet *aggregatedFra { EV_DEBUG << "Deaggregating A-MPDU " << *aggregatedFrame << " into multiple packets.\n"; std::vector *frames = new std::vector(); - int paddingLength = 0; + auto layout = inspectMpduAggregate(aggregatedFrame, B(0), B(aggregatedFrame->getDataLength())); cStringTokenizer tokenizer(aggregatedFrame->getName(), "+"); - while (aggregatedFrame->getDataLength() > b(0)) { - aggregatedFrame->setFrontOffset(aggregatedFrame->getFrontOffset() + B(paddingLength == 4 ? 0 : paddingLength)); - const auto& mpduSubframeHeader = aggregatedFrame->popAtFront(); - const auto& mpdu = aggregatedFrame->peekDataAt(b(0), B(mpduSubframeHeader->getLength())); - paddingLength = 4 - (mpduSubframeHeader->getChunkLength() + mpdu->getChunkLength()).get() % 4; - aggregatedFrame->setFrontOffset(aggregatedFrame->getFrontOffset() + mpdu->getChunkLength()); + for (const auto& range : layout.ranges) { + if (range.kind != MpduRangeKind::MPDU) + continue; + const auto& mpdu = aggregatedFrame->peekDataAt(range.offset, range.length); auto frame = new Packet(); - frame->setName(tokenizer.nextToken()); + frame->setName(tokenizer.hasMoreTokens() ? tokenizer.nextToken() : aggregatedFrame->getName()); frame->insertAtBack(mpdu); - frame->getRegionTags().copyTags(aggregatedFrame->getRegionTags(), aggregatedFrame->getFrontOffset() - frame->getDataLength(), frame->getFrontOffset(), frame->getDataLength()); + frame->getRegionTags().copyTags(aggregatedFrame->getRegionTags(), aggregatedFrame->getFrontOffset() + range.offset, frame->getFrontOffset(), range.length); EV_TRACE << "Created " << *frame << " from A-MPDU.\n"; - // TODO check CRC? frames->push_back(frame); } delete aggregatedFrame; diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.cc b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.cc new file mode 100644 index 00000000000..1f01975c047 --- /dev/null +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.cc @@ -0,0 +1,62 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" + +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h" + +namespace inet { +namespace physicallayer { + +uint64_t packIeee80211HtSignalField(const Ieee80211HtPhyHeader& header) +{ + // IEEE Std 802.11-2024, Figure 19-6: each octet holds successive wire bits, LSB first. + auto length = header.getLengthField().get(); + if (length < 0 || length > 65535 || header.getMcs() > 127 || header.getStbc() > 3 || + header.getExtensionSpatialStreams() > 3 || header.getTail() > 63) + throw cRuntimeError("HT-SIG field is outside its encoded range"); + return uint64_t(header.getMcs()) | (uint64_t(header.getChannelWidth40()) << 7) | + (uint64_t(length) << 8) | (uint64_t(header.getSmoothing()) << 24) | + (uint64_t(header.getNotSounding()) << 25) | (uint64_t(header.getReserved()) << 26) | + (uint64_t(header.getAggregation()) << 27) | (uint64_t(header.getStbc()) << 28) | + (uint64_t(header.getFecCoding()) << 30) | (uint64_t(header.getShortGi()) << 31) | + (uint64_t(header.getExtensionSpatialStreams()) << 32) | (uint64_t(header.getCrc()) << 34) | + (uint64_t(header.getTail()) << 42); +} + +uint8_t computeIeee80211HtSignalCrc(const Ieee80211HtPhyHeader& header) +{ + // IEEE Std 802.11-2024, 19.3.9.4.4: process bits 0..33, emit complemented C7 first. + auto bits = packIeee80211HtSignalField(header); + uint8_t remainder = 0xFF; + for (int bit = 0; bit < 34; bit++) { + bool feedback = ((remainder >> 7) ^ (bits >> bit)) & 1; + remainder <<= 1; + if (feedback) + remainder ^= 0x07; + } + uint8_t crc = 0; + uint8_t complemented = ~remainder; + for (int bit = 0; bit < 8; bit++) + crc |= ((complemented >> (7 - bit)) & 1) << bit; + return crc; +} + +bool isIeee80211HtSignalValid(const Ieee80211HtPhyHeader& header, const IIeee80211Mode *mode) +{ + auto htMode = dynamic_cast(mode); + if (htMode == nullptr || header.getChunkLength() != b(48) || !header.isCorrect() || + !header.isComplete() || !header.isProperlyRepresented() || + header.getLengthField() <= B(0) || header.getLengthField() > B(65535) || header.getMcs() > 31 || + header.getStbc() != 0 || header.getFecCoding() || header.getExtensionSpatialStreams() != 0 || + !header.getNotSounding() || !header.getReserved() || header.getTail() != 0) + return false; + // Packet-level profile: BCC, no STBC, no extension streams, no sounding. + auto dataMode = check_and_cast(mode->getDataMode()); + return header.getMcs() == mode->getHtMcsIndex() && + header.getChannelWidth40() == (dataMode->getBandwidth() == MHz(40)) && + header.getShortGi() == (dataMode->getGuardIntervalType() == Ieee80211HtModeBase::HT_GUARD_INTERVAL_SHORT) && + header.getCrc() == computeIeee80211HtSignalCrc(header); +} + +} // namespace physicallayer +} // namespace inet diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h new file mode 100644 index 00000000000..e143671561d --- /dev/null +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_IEEE80211HTSIGNALFIELD_H +#define __INET_IEEE80211HTSIGNALFIELD_H + +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h" +#include "inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h" + +namespace inet { +namespace physicallayer { + +INET_API uint64_t packIeee80211HtSignalField(const Ieee80211HtPhyHeader& header); +INET_API uint8_t computeIeee80211HtSignalCrc(const Ieee80211HtPhyHeader& header); +INET_API bool isIeee80211HtSignalValid(const Ieee80211HtPhyHeader& header, const IIeee80211Mode *mode); + +} // namespace physicallayer +} // namespace inet + +#endif diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader.msg b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader.msg index 4cbde94bba5..517b1aee4b1 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader.msg +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader.msg @@ -138,6 +138,20 @@ class Ieee80211HtPhyPreamble extends Ieee80211PhyPreamble class Ieee80211HtPhyHeader extends Ieee80211PhyHeader { + // IEEE Std 802.11-2024, Table 19-11 and Figure 19-6. + chunkLength = b(48); + uint8_t mcs @bit(7) = 0; + bool channelWidth40 = false; + bool smoothing = true; + bool notSounding = true; + bool reserved = true; + bool aggregation = false; + uint8_t stbc @bit(2) = 0; + bool fecCoding = false; + bool shortGi = false; + uint8_t extensionSpatialStreams @bit(2) = 0; + uint8_t crc = 0; + uint8_t tail @bit(6) = 0; } // IEEE 802.11 21. High Throughput (VHT) diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeaderSerializer.cc b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeaderSerializer.cc index 35f4d0ee3a4..332805354fb 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeaderSerializer.cc +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeaderSerializer.cc @@ -9,6 +9,7 @@ #include "inet/common/packet/serializer/ChunkSerializerRegistry.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211OfdmSignalField.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h" namespace inet { @@ -195,11 +196,30 @@ const Ptr Ieee80211ErpOfdmPhyHeaderSerializer::deserializeFields(MemoryIn void Ieee80211HtPhyHeaderSerializer::serializeFields(MemoryOutputStream& stream, const Ptr& chunk) const { auto htPhyHeader = dynamicPtrCast(chunk); + auto bits = packIeee80211HtSignalField(*htPhyHeader); + for (int byte = 0; byte < 6; byte++) + stream.writeByte((bits >> (8 * byte)) & 0xFF); } const Ptr Ieee80211HtPhyHeaderSerializer::deserializeFields(MemoryInputStream& stream, const std::type_info&) const { auto htPhyHeader = makeShared(); + uint64_t bits = 0; + for (int byte = 0; byte < 6; byte++) + bits |= uint64_t(stream.readByte()) << (8 * byte); + htPhyHeader->setMcs(bits & 0x7F); + htPhyHeader->setChannelWidth40((bits >> 7) & 1); + htPhyHeader->setLengthField(B((bits >> 8) & 0xFFFF)); + htPhyHeader->setSmoothing((bits >> 24) & 1); + htPhyHeader->setNotSounding((bits >> 25) & 1); + htPhyHeader->setReserved((bits >> 26) & 1); + htPhyHeader->setAggregation((bits >> 27) & 1); + htPhyHeader->setStbc((bits >> 28) & 3); + htPhyHeader->setFecCoding((bits >> 30) & 1); + htPhyHeader->setShortGi((bits >> 31) & 1); + htPhyHeader->setExtensionSpatialStreams((bits >> 32) & 3); + htPhyHeader->setCrc((bits >> 34) & 0xFF); + htPhyHeader->setTail((bits >> 42) & 0x3F); return htPhyHeader; } diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.cc b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.cc index ee235f05f2e..f147a4812fd 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.cc +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.cc @@ -10,6 +10,7 @@ #include "inet/common/packet/chunk/BitCountChunk.h" #include "inet/common/ProtocolTag_m.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" #include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211DsssMode.h" #include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211DsssOfdmMode.h" #include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ErpOfdmMode.h" @@ -21,6 +22,7 @@ #include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211VhtMode.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211OfdmSignalField.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" @@ -258,6 +260,13 @@ void Ieee80211Radio::encapsulate(Packet *packet) const staticPtrCast(makeShared()) : mode->getHeaderMode()->createHeader(); phyHeader->setChunkLength(b(mode->getHeaderMode()->getLength())); phyHeader->setLengthField(B(packet->getDataLength())); + if (auto htHeader = dynamicPtrCast(phyHeader)) { + htHeader->setMcs(mode->getHtMcsIndex()); + htHeader->setChannelWidth40(mode->getDataMode()->getBandwidth() == MHz(40)); + htHeader->setShortGi(mode->isHtShortGuardInterval()); + htHeader->setAggregation(dynamicPtrCast(packet->peekAtFront()) != nullptr); + htHeader->setCrc(computeIeee80211HtSignalCrc(*htHeader)); + } if (auto ofdmHeader = dynamicPtrCast(phyHeader)) { auto ofdmMode = check_and_cast(mode); ofdmHeader->setRate(ofdmMode->getSignalMode()->getRate()); @@ -298,6 +307,14 @@ void Ieee80211Radio::decapsulate(Packet *packet) const { auto mode = packet->getTag()->getMode(); const auto& phyHeader = popIeee80211PhyHeaderAtFront(packet, b(-1), Chunk::PF_ALLOW_INCORRECT | Chunk::PF_ALLOW_INCOMPLETE | Chunk::PF_ALLOW_IMPROPERLY_REPRESENTED); + if (auto htHeader = dynamicPtrCast(phyHeader)) { + bool valid = isIeee80211HtSignalValid(*htHeader, mode); + if (!valid || htHeader->getLengthField() > packet->getDataLength()) { + packet->setBitError(true); + packet->addTagIfAbsent()->setProtocol(&Protocol::ieee80211Mac); + return; + } + } if (phyHeader->isIncorrect() || phyHeader->isIncomplete() || phyHeader->isImproperlyRepresented() || !verifyFcs(phyHeader)) packet->setBitError(true); if (auto ofdmHeader = dynamicPtrCast(phyHeader)) { diff --git a/tests/unit/Ieee80211AmpduWire_1.test b/tests/unit/Ieee80211AmpduWire_1.test new file mode 100644 index 00000000000..a94eb25e43d --- /dev/null +++ b/tests/unit/Ieee80211AmpduWire_1.test @@ -0,0 +1,185 @@ +%description: +Check HT-SIG golden bytes against IEEE Std 802.11-2024, Figure 19-6 and 19.3.9.4.4. +Fresh byte-backed packets establish independent decode, including singleton identity. +Bounded delimiter inspection covers lengths, alignment, truncation, and recovery. +Recovery preserves matching ranges across typed and byte representations, including a nonzero PSDU offset. + +%includes: +#include "inet/common/packet/chunk/BytesChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +%global: +static const IIeee80211Mode *findMode(int mcs, bool shortGi) +{ + auto modes = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + for (int i = 0; i < modes->getNumModes(); i++) { + auto mode = modes->getMode(i); + if (mode->getHtMcsIndex() == mcs && mode->getDataMode()->getBandwidth() == MHz(20) && + mode->isHtShortGuardInterval() == shortGi) + return mode; + } + throw cRuntimeError("Missing test mode"); +} + +static void checkSignal(int length, bool aggregation, int mcs, bool shortGi, const std::vector& golden) +{ + auto header = makeShared(); + header->setLengthField(B(length)); + header->setAggregation(aggregation); + header->setMcs(mcs); + header->setShortGi(shortGi); + header->setCrc(computeIeee80211HtSignalCrc(*header)); + Packet output("output", header); + ASSERT(output.peekAllAsBytes()->getBytes() == golden); + Packet input("fresh", makeShared(golden)); + auto decoded = input.popAtFront(B(6)); + ASSERT(input.getDataLength() == B(0)); + ASSERT(decoded->getLengthField() == B(length)); + ASSERT(decoded->getAggregation() == aggregation); + ASSERT(isIeee80211HtSignalValid(*decoded, findMode(mcs, shortGi))); + auto bad = golden; + bad[0] ^= 1; + Packet corrupt("corrupt", makeShared(bad)); + ASSERT(!isIeee80211HtSignalValid(*corrupt.peekAtFront(B(6)), findMode(mcs, shortGi))); + auto unsupported = makeShared(*decoded); + unsupported->setFecCoding(true); + unsupported->setCrc(computeIeee80211HtSignalCrc(*unsupported)); + ASSERT(!isIeee80211HtSignalValid(*unsupported, findMode(mcs, shortGi))); + auto incomplete = makeShared(*decoded); + incomplete->markIncomplete(); + ASSERT(!isIeee80211HtSignalValid(*incomplete, findMode(mcs, shortGi))); + auto improper = makeShared(*decoded); + improper->markImproperlyRepresented(); + ASSERT(!isIeee80211HtSignalValid(*improper, findMode(mcs, shortGi))); + ASSERT(decoded->getChunkLength() == b(48)); +} + +static void appendMember(Packet& packet, int length) +{ + auto delimiter = makeShared(); + delimiter->setLength(length); + packet.insertAtBack(delimiter); + if (length) + packet.insertAtBack(makeShared(std::vector(length, 0))); +} + +%activity: +// CRC constants use polynomial long division, independent of the production shift register. +checkSignal(100, false, 0, false, {0x00, 0x64, 0x00, 0x07, 0xFC, 0x00}); +checkSignal(104, true, 0, false, {0x00, 0x68, 0x00, 0x0F, 0xB4, 0x01}); +checkSignal(218, true, 7, true, {0x07, 0xDA, 0x00, 0x8F, 0x18, 0x02}); +checkSignal(65535, true, 31, false, {0x1F, 0xFF, 0xFF, 0x0F, 0x7C, 0x00}); +for (int length : {0, 1, 2, 3, 4, 4095}) { + Packet packet("layout"); + appendMember(packet, 0); + appendMember(packet, length); + if (length) { + int padding = (4 - length % 4) % 4; + if (padding) + packet.insertAtBack(makeShared(std::vector(padding, 0))); + appendMember(packet, 20); + } + auto layout = inspectMpduAggregate(&packet, B(0), B(packet.getDataLength())); + ASSERT(layout.complete); + ASSERT(layout.ranges.size() == (length ? 5 : 2)); + ASSERT(layout.ranges.front().kind == MpduRangeKind::DELIMITER); + for (const auto& range : layout.ranges) + ASSERT(range.offset + range.length <= packet.getDataLength()); + auto bytes = packet.peekAllAsBytes()->getBytes(); + Packet independent("wire", makeShared(bytes)); + ASSERT(inspectMpduAggregate(&independent, B(0), B(bytes.size())).complete); + if (length) { + bytes.pop_back(); + Packet truncated("truncated", makeShared(bytes)); + ASSERT(!inspectMpduAggregate(&truncated, B(0), B(bytes.size())).complete); + } +} +Packet recovery("recovery", makeShared(std::vector{0, 0, 0, 0})); +appendMember(recovery, 20); +auto recovered = inspectMpduAggregate(&recovery, B(0), B(recovery.getDataLength())); +ASSERT(!recovered.complete && recovered.ranges.size() == 3); +ASSERT(!recovered.ranges[0].valid && recovered.ranges[1].offset == B(4)); +// An invalid length forces delimiter recovery through a typed MAC header. +for (int prefixLength : {0, 6}) { + Packet typed("typed-recovery"); + if (prefixLength) + typed.insertAtBack(makeShared(std::vector(prefixLength, 0))); + auto delimiter = makeShared(); + delimiter->setLength(2000); + typed.insertAtBack(delimiter); + auto member = makeShared(); + member->setSequenceNumber(SequenceNumberCyclic(0)); + typed.insertAtBack(member); + typed.insertAtBack(makeShared(std::vector(100 - member->getChunkLength().get(), 0))); + appendMember(typed, 20); + auto bytes = typed.peekAllAsBytes()->getBytes(); + Packet independent("byte-recovery", makeShared(bytes)); + auto typedLayout = inspectMpduAggregate(&typed, B(prefixLength), B(128)); + auto byteLayout = inspectMpduAggregate(&independent, B(prefixLength), B(128)); + ASSERT(!typedLayout.complete && !byteLayout.complete); + ASSERT(typedLayout.ranges.size() == byteLayout.ranges.size()); + for (size_t i = 0; i < typedLayout.ranges.size(); i++) { + const auto& actual = typedLayout.ranges[i]; + const auto& expected = byteLayout.ranges[i]; + ASSERT(actual.kind == expected.kind && actual.offset == expected.offset && + actual.length == expected.length && actual.valid == expected.valid); + } + const auto& last = typedLayout.ranges.back(); + ASSERT(last.kind == MpduRangeKind::MPDU && last.valid && last.offset == B(108) && last.length == B(20)); +} +// Reinterpretation must not hide an existing typed delimiter's error flag. +auto incorrectDelimiter = makeShared(); +incorrectDelimiter->setLength(0); +incorrectDelimiter->markIncorrect(); +Packet incorrect("incorrect-delimiter", incorrectDelimiter); +appendMember(incorrect, 20); +auto incorrectLayout = inspectMpduAggregate(&incorrect, B(0), B(incorrect.getDataLength())); +ASSERT(!incorrectLayout.complete && !incorrectLayout.ranges.front().valid); +ASSERT(incorrectLayout.ranges.back().kind == MpduRangeKind::MPDU && incorrectLayout.ranges.back().valid); +for (int byte : {2, 3}) { + Packet good("good"); + appendMember(good, 20); + auto bytes = good.peekAllAsBytes()->getBytes(); + bytes[byte] ^= 1; + Packet bad("bad", makeShared(bytes)); + auto layout = inspectMpduAggregate(&bad, B(0), B(bytes.size())); + ASSERT(!layout.complete && !layout.ranges.front().valid); +} +Packet finalPadding("final-padding"); +appendMember(finalPadding, 1); +finalPadding.insertAtBack(makeShared(std::vector(3, 0))); +ASSERT(!inspectMpduAggregate(&finalPadding, B(0), B(finalPadding.getDataLength())).complete); +auto overrun = makeShared(); +overrun->setLength(4095); +Packet missingMember("missing-member", overrun); +auto refusedLayout = inspectMpduAggregate(&missingMember, B(0), B(4)); +ASSERT(!refusedLayout.complete && refusedLayout.ranges.size() == 1 && !refusedLayout.ranges[0].valid); +for (int size : {0, 1, 2, 3}) { + Packet shortInput("short", makeShared(std::vector(size, 0))); + ASSERT(inspectMpduAggregate(&shortInput, B(0), B(size)).ranges.empty()); +} +auto tooLong = makeShared(); +tooLong->setLength(4096); +Packet overflow("overflow", tooLong); +bool refused = false; +try { overflow.peekAllAsBytes(); } +catch (const cRuntimeError&) { refused = true; } +ASSERT(refused); +auto invalidLength = makeShared(); +invalidLength->setLengthField(B(65536)); +Packet excessivePsdu("excessive-psdu", invalidLength); +refused = false; +try { excessivePsdu.peekAllAsBytes(); } +catch (const cRuntimeError&) { refused = true; } +ASSERT(refused); +EV << "A-MPDU wire checks passed\n"; + +%contains: stdout +A-MPDU wire checks passed From dfa51d2a1a3f9ae16b9e4d613723da065f8f7066 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:54:11 +0200 Subject: [PATCH 21/41] ieee80211: add: expose pure HT A-MPDU range probabilities Before this commit, error models expose complete-packet probabilities but no optional contract for HT aggregate ranges. Receiver integration needs a pure mode-support query and per-length success probability. After this commit, the optional WLAN role supplies both operations. NIST and Yans implement the role through their shared base. The range operation uses the existing DATA calculation with the requested length. It rejects unsupported modes and invalid ranges without a random draw. The generic IErrorModel contract remains unchanged. For example, an HT20 MPDU range uses the same probability as the existing DATA calculation for that length and scalar SNIR. Direct checks cover 64 HT20 modes, six lengths, seven SNIR values, and minimum and mean reductions. They also check mode support and unchanged draw counts. The receiver does not use the role until the next commit. Plan: plan/pending/ieee80211-ampdu-phy-reception.md Change: src.ieee80211 | behavior.add | test whatsnew | ieee80211-ampdu-phy-reception --- WHATSNEW | 4 + .../packetlevel/IIeee80211AmpduErrorModel.h | 25 ++++++ .../packetlevel/IIeee80211AmpduErrorModel.ned | 10 +++ .../errormodel/Ieee80211ErrorModelBase.cc | 16 ++++ .../errormodel/Ieee80211ErrorModelBase.h | 6 +- .../errormodel/Ieee80211NistErrorModel.ned | 3 +- .../errormodel/Ieee80211YansErrorModel.ned | 3 +- tests/unit/Ieee80211AmpduProbability_1.test | 85 +++++++++++++++++++ 8 files changed, 149 insertions(+), 3 deletions(-) create mode 100644 src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.h create mode 100644 src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.ned create mode 100644 tests/unit/Ieee80211AmpduProbability_1.test diff --git a/WHATSNEW b/WHATSNEW index ab7973592a6..01548d33a2e 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -500,6 +500,10 @@ Notable backward incompatible changes are the following: Delimiter recovery now scans across typed MPDU headers. An invalid delimiter no longer causes a chunk conversion error at those headers. Bounded recovery retains later complete MPDU ranges. +59. Pure HT aggregate probabilities + + NIST and Yans now expose pure HT20 range probabilities through an optional WLAN error-model role. Receiver activation remains separate. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.h b/src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.h new file mode 100644 index 00000000000..acbcb72e179 --- /dev/null +++ b/src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.h @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_IIEEE80211AMPDUERRORMODEL_H +#define __INET_IIEEE80211AMPDUERRORMODEL_H + +#include "inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h" +#include "inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h" + +namespace inet { +namespace physicallayer { + +class INET_API IIeee80211AmpduErrorModel +{ + public: + virtual ~IIeee80211AmpduErrorModel() = default; + // This query calculates no probability and consumes no random number. + virtual bool supportsAmpduMode(const IIeee80211Mode *mode) const = 0; + // Invalid input and unsupported modes cause a runtime error. The result is in [0, 1]. + virtual double computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *mode, B length) const = 0; +}; + +} // namespace physicallayer +} // namespace inet + +#endif diff --git a/src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.ned b/src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.ned new file mode 100644 index 00000000000..307d9c40b05 --- /dev/null +++ b/src/inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.ned @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +package inet.physicallayer.wireless.ieee80211.contract.packetlevel; + +import inet.physicallayer.wireless.common.contract.packetlevel.IErrorModel; + +// Optional WLAN role for probabilities over bounded A-MPDU ranges. +moduleinterface IIeee80211AmpduErrorModel extends IErrorModel +{ +} diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc index 48783a2badd..2e215193fb9 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc @@ -18,6 +18,22 @@ Ieee80211ErrorModelBase::Ieee80211ErrorModelBase() { } +bool Ieee80211ErrorModelBase::supportsAmpduMode(const IIeee80211Mode *mode) const +{ + return mode != nullptr && mode->getModulationClass() == IIeee80211Mode::ModulationClass::HT && + mode->getHtMcsIndex() >= 0 && mode->getHtMcsIndex() <= 31 && mode->getDataMode()->getBandwidth() == MHz(20); +} + +double Ieee80211ErrorModelBase::computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *mode, B length) const +{ + Enter_Method("computeAmpduRangeSuccessRate"); + if (!supportsAmpduMode(mode)) + throw cRuntimeError("Unsupported HT A-MPDU receive mode"); + if (snir == nullptr || length <= B(0) || length > B(65535)) + throw cRuntimeError("Invalid A-MPDU probability range"); + return getDataSuccessRate(mode, b(length).get(), getScalarSnir(snir)); +} + double Ieee80211ErrorModelBase::computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const { Enter_Method("computePacketErrorRate"); diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.h b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.h index 9b0d634d4c1..0b53872f749 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.h +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.h @@ -10,12 +10,13 @@ #include "inet/physicallayer/wireless/common/base/packetlevel/ErrorModelBase.h" #include "inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h" +#include "inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.h" namespace inet { namespace physicallayer { -class INET_API Ieee80211ErrorModelBase : public ErrorModelBase +class INET_API Ieee80211ErrorModelBase : public ErrorModelBase, public IIeee80211AmpduErrorModel { protected: double spectralEfficiency1bit = 2000000.0 / 1000000.0; // 1 bit per symbol with 1 MSPS @@ -37,6 +38,9 @@ class INET_API Ieee80211ErrorModelBase : public ErrorModelBase public: Ieee80211ErrorModelBase(); + virtual bool supportsAmpduMode(const IIeee80211Mode *mode) const override; + virtual double computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *mode, B length) const override; + virtual double computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const override; virtual double computeBitErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const override; virtual double computeSymbolErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const override; diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.ned b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.ned index fdf6c7710d0..69651c2ad73 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.ned +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.ned @@ -8,8 +8,9 @@ package inet.physicallayer.wireless.ieee80211.packetlevel.errormodel; import inet.physicallayer.wireless.common.base.packetlevel.ErrorModelBase; +import inet.physicallayer.wireless.ieee80211.contract.packetlevel.IIeee80211AmpduErrorModel; -module Ieee80211NistErrorModel extends ErrorModelBase +module Ieee80211NistErrorModel extends ErrorModelBase like IIeee80211AmpduErrorModel { parameters: @class(Ieee80211NistErrorModel); diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.ned b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.ned index 1fde176f539..5f27ba31459 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.ned +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.ned @@ -8,8 +8,9 @@ package inet.physicallayer.wireless.ieee80211.packetlevel.errormodel; import inet.physicallayer.wireless.common.base.packetlevel.ErrorModelBase; +import inet.physicallayer.wireless.ieee80211.contract.packetlevel.IIeee80211AmpduErrorModel; -module Ieee80211YansErrorModel extends ErrorModelBase +module Ieee80211YansErrorModel extends ErrorModelBase like IIeee80211AmpduErrorModel { parameters: @class(Ieee80211YansErrorModel); diff --git a/tests/unit/Ieee80211AmpduProbability_1.test b/tests/unit/Ieee80211AmpduProbability_1.test new file mode 100644 index 00000000000..b9b4b02f233 --- /dev/null +++ b/tests/unit/Ieee80211AmpduProbability_1.test @@ -0,0 +1,85 @@ +%description: +Check pure NIST and Yans HT20 range probabilities before receiver activation. +The matrix uses the existing DATA calculation as an independent result. +Mode support, minimum and mean SNIR, and random draw counts remain explicit. + +%includes: +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" +#include "inet/physicallayer/wireless/common/base/packetlevel/SnirBase.h" + +using namespace inet; +using namespace inet::physicallayer; + +class ProbabilitySnir : public SnirBase { + double value; + public: + ProbabilitySnir(double value) : SnirBase(nullptr, nullptr), value(value) {} + double getMin() const override { return value; } + double getMax() const override { return 2 * value; } + double getMean() const override { return 1.5 * value; } +}; + +template class ProbabilityProbe : public Base { + public: + void check() { + Enter_Method("check"); + auto draws = this->getRNG(0)->getNumbersDrawn(); + auto catalog = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + int checked = 0; + ASSERT(!this->supportsAmpduMode(nullptr)); + for (bool mean : {false, true}) { + this->snirMode = mean ? Base::SnirMode::SM_MEAN : Base::SnirMode::SM_MIN; + for (int i = 0; i < catalog->getNumModes(); i++) { + auto mode = catalog->getMode(i); + bool supported = mode->getHtMcsIndex() >= 0 && mode->getHtMcsIndex() <= 31 && mode->getDataMode()->getBandwidth() == MHz(20); + ASSERT(this->supportsAmpduMode(mode) == supported); + if (!supported) continue; + for (double value : {0.01, 0.1, 1.0, 3.0, 10.0, 100.0, 1000.0}) { + ProbabilitySnir snir(value); + for (int length : {4, 100, 101, 102, 4095, 65535}) { + double expected = Base::getDataSuccessRate(mode, length * 8, mean ? 1.5 * value : value); + double actual = Base::computeAmpduRangeSuccessRate(&snir, mode, B(length)); + ASSERT(actual == expected && actual >= 0 && actual <= 1); + checked++; + } + } + } + } + ASSERT(checked == 2 * 64 * 7 * 6); + ASSERT(this->getRNG(0)->getNumbersDrawn() == draws); + } +}; +class PureNist : public ProbabilityProbe {}; +class PureYans : public ProbabilityProbe {}; +Define_Module(PureNist); +Define_Module(PureYans); + +%file: TestNetwork.ned +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211YansErrorModel; +module PureNist extends Ieee80211NistErrorModel { parameters: @class(::PureNist); } +module PureYans extends Ieee80211YansErrorModel { parameters: @class(::PureYans); } +network TestNetwork { + submodules: + test: Test; + nist: PureNist; + yans: PureYans; +} + +%inifile: omnetpp.ini +[General] +network = TestNetwork +ned-path = .;../../../../src;../../lib +seed-set = 0 +record-vector-results = false +record-scalar-results = false + +%activity: +check_and_cast(getModuleByPath("nist"))->check(); +check_and_cast(getModuleByPath("yans"))->check(); +EV << "Pure probability checks passed.\n"; + +%contains: stdout +Pure probability checks passed. From 3678e89b11782ab85a1a396b49338a75ee63b47e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:54:33 +0200 Subject: [PATCH 22/41] ieee80211: add+change: retain partial HT A-MPDU PHY outcomes Before this commit, the receiver samples an aggregate as one packet. It cannot retain successful members after partial DATA loss. Rx also treats an aggregate container as a standalone MAC frame and can fail during header or FCS checks. After this commit, the medium cache owns common-field decisions and bounded delimiter and MPDU outcomes. Repeated queries reuse those samples. Partial DATA loss preserves the aggregate bytes. A result tag copies outcomes without reception pointers. Rx rejects aggregate containers before standalone checks through its existing drop and contention path. For example, an aggregate with one failed MPDU retains successful neighbors and all range outcomes. The drop signal preserves those outcomes when Rx rejects the container. A standalone CTS still updates NAV. DCF and HCF cases cover typed and byte representations, scalar and dimensional radios, and whole and separate signal parts. The receiver uses the preceding probability role. The MAC supplies exact receive-capability bounds before its MIB update. A present model must cover every advertised HT receive mode within those bounds. The header defines the override contract and required cRuntimeError boundary. Validation cannot change capabilities or consume random draws. Absent error models retain common PHY checks without error draws. Aggregate error-rate estimates remain unknown; ordinary MPDU metadata remains unchanged. Direct fixtures cover cached decisions, malformed headers, insufficient content, missing roles, and incomplete mode coverage. MAC member acceptance and implicit Block Ack remain pending. Plan: plan/pending/ieee80211-ampdu-phy-reception.md Change: src.ieee80211 | behavior.add+change | test whatsnew migration | ieee80211-ampdu-phy-reception --- WHATSNEW | 8 +- doc/src/migration-guide/index.rst | 22 +- plan/pending/ieee80211-ampdu-phy-execution.md | 101 ++++ .../linklayer/ieee80211/mac/Ieee80211Mac.cc | 1 + src/inet/linklayer/ieee80211/mac/Rx.cc | 6 +- .../mac/aggregation/MpduDeaggregation.cc | 2 + .../Ieee80211AmpduReceptionDecision.h | 33 ++ .../packetlevel/Ieee80211Receiver.cc | 170 ++++++- .../ieee80211/packetlevel/Ieee80211Receiver.h | 14 + .../ieee80211/packetlevel/Ieee80211Tag.msg | 20 + .../errormodel/Ieee80211ErrorModelBase.cc | 6 +- tests/module/Ieee80211AmpduMacBoundary_1.test | 229 +++++++++ .../module/Ieee80211AmpduPhyReception_1.test | 478 ++++++++++++++++++ 13 files changed, 1080 insertions(+), 10 deletions(-) create mode 100644 plan/pending/ieee80211-ampdu-phy-execution.md create mode 100644 src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211AmpduReceptionDecision.h create mode 100644 tests/module/Ieee80211AmpduMacBoundary_1.test create mode 100644 tests/module/Ieee80211AmpduPhyReception_1.test diff --git a/WHATSNEW b/WHATSNEW index 01548d33a2e..e76e4d1eeb1 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -498,11 +498,13 @@ Notable backward incompatible changes are the following: HT transmissions now preserve the complete HT-SIG header through byte conversion. Receivers check its CRC, supported fields, and length before length-based trailer removal. Invalid headers mark packets as erroneous. Delimiter inspection supplies bounded MPDU ranges, including singleton aggregates. Ordinary valid HT duration inputs remain unchanged. VHT modes now create their own header type. - Delimiter recovery now scans across typed MPDU headers. An invalid delimiter no longer causes a chunk conversion error at those headers. Bounded recovery retains later complete MPDU ranges. +59. IEEE 802.11 partial HT aggregate reception + + NIST and Yans receivers now retain separate delimiter and MPDU outcomes for HT20 aggregates. Partial DATA loss preserves aggregate bytes for later MAC acceptance. This change does not enable MAC aggregate receipt or implicit Block Ack. Custom HT error models must implement the optional WLAN aggregate contract. Aggregate error-rate estimates can be unknown. The migration guide describes the contract and metadata changes. -59. Pure HT aggregate probabilities + Rx now drops aggregate containers before standalone FCS or MAC header checks. This prevents parser errors for successful and partially failed aggregates. PHY range outcomes remain available in the drop signal. MAC aggregate acceptance remains pending. - NIST and Yans now expose pure HT20 range probabilities through an optional WLAN error-model role. Receiver activation remains separate. + Delimiter recovery now scans across typed MPDU headers. An invalid delimiter no longer causes a chunk conversion error at those headers. Bounded recovery retains later complete MPDU ranges. Notable backward compatible changes are the following: diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 4956e2ada11..9138bcaeca0 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -14,13 +14,31 @@ retransmissions do (``synRetries``). When they run out, the connection raises th ``TCP_E_TIMEOUT_CONN_ESTAB``, as the timer did before, so a subclass that handles this event needs no change. -IEEE 802.11 HT-SIG representation --------------------------------- +IEEE 802.11 HT A-MPDU PHY reception +--------------------------------- + +HT receivers require a present error model to implement ``IIeee80211AmpduErrorModel``. This optional WLAN contract provides pure mode-support queries and probabilities for bounded PSDU ranges. ``Ieee80211ErrorModelBase`` supplies the implementation for NIST and Yans. Custom HT models outside this base must implement the C++ contract and its NED module interface. Non-HT models require no aggregate role. + +An absent error model remains valid. The receiver retains its acquisition, sensitivity, attempt, and SNIR checks without error draws. This includes ordinary HT operation with ``Ieee80211UnitDiskRadio``. The aggregate profile covers scalar and dimensional HT20 reception; it adds no unit-disk aggregate support claim. + +The receiver checks role presence at physical-layer initialization. Before the MIB update, the MAC supplies its exact mode set, channel widths, and spatial-stream limit for receive coverage validation. The model must support the modes that these inputs advertise, including HT20 short GI. Unsupported modes outside the effective stream limit cause no rejection. Runtime mode-set changes also check role presence. Any later capability-update caller must validate its exact inputs before the MIB update. + +BerTable retains its current limit. Its NED type rejects the radio's HT operation string. The allowed ``n`` value reaches its initializer, which also rejects HT. Both failures precede the new role check. BerTable does not gain HT aggregate support. Supported HT configurations can use NIST or Yans. + +The new role diagnostic applies to otherwise valid custom HT models without the contract. The current packet-level BerTable reception path also requires a transmission bit model. Scalar packet-level transmissions do not supply that model. This existing limitation remains outside the HT A-MPDU change. The modeled HT-SIG header preserves all 48 bits through byte conversion. ``lengthField`` supplies HT Length. ``aggregation`` distinguishes an A-MPDU from a standalone MPDU, including singleton aggregates. The radio derives mode fields from the selected mode and calculates the CRC after field assignment. Decode preserves the received CRC. HEADER validation rejects invalid CRC and unsupported fields before delimiter or MPDU outcomes. Separate-part reception retains its current abort; whole-signal reception supplies a failed container. DATA separately refuses modeled content shorter than a valid HT Length. This refusal retains the accepted header property but supplies no range outcomes. It represents malformed model input, not physical carrier loss. Decapsulation never uses an invalid header or insufficient content for length-based trailer removal. Ordinary valid HT duration inputs remain unchanged. +``Ieee80211AmpduInd`` carries copied PHY facts without reception or transmission pointers. Each range identifies a delimiter or complete MPDU by PSDU-relative byte offset, byte length, validity, and physical success. Spacing delimiters have four-byte ranges. Alignment padding has no range outcome or separate draw. MAC delimiter and FCS checks still control acceptance; the PHY indication alone grants no delivery or response permission. + +The default ``Rx`` rejects containers whose PHY indication identifies an aggregate before standalone FCS or MAC header checks. This applies even when every range succeeds. The drop signal retains the PHY outcomes. Custom receive modules must keep aggregate containers separate from standalone frame parsing until they implement member acceptance. MPDU deaggregation can extract bounded recovered members from an incomplete layout. Extraction alone grants no MAC acceptance. + +The medium cache retains each aggregate decision. PREAMBLE calculates no HEADER or DATA outcome. HEADER, DATA, WHOLE, and direct success queries reuse retained prerequisites and samples. WHOLE summarizes all ranges. Partial DATA failure preserves the aggregate bytes for the later MAC receive integration. This change alone does not enable MAC A-MPDU receipt or implicit Block Ack responses. + +With a present model, aggregate ``ErrorRateInd`` fields contain ``NaN`` for unknown probabilities. The receiver does not calculate the former whole-PSDU estimate for these fields. Member outcomes are separate from probability estimates. Without a model, the receiver preserves the common base's tag presence and values. Ordinary MPDUs retain their current metadata. Custom readers of aggregate error-rate fields must accept unknown values. + Radio medium timing queries -------------------------- diff --git a/plan/pending/ieee80211-ampdu-phy-execution.md b/plan/pending/ieee80211-ampdu-phy-execution.md new file mode 100644 index 00000000000..7dd7de6c8ab --- /dev/null +++ b/plan/pending/ieee80211-ampdu-phy-execution.md @@ -0,0 +1,101 @@ +# PHY P0, P1, and P2 execution record + +The user authorizes P0, P1, and P2 on `4fa5cc0de15ee57388bcb3f20e866cab5972a670` before PRs #1343, #1344, and #1345 merge. This exception replaces the merge prerequisite for this execution only. The user also authorizes commits and a branch push. No baseline change forms part of this task. + +The active checkout is `/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack`, on branch `work/ieee80211-ampdu-implicit-blockack`. The implementation uses the approved base. The commit series separates the plans, P1 representation, and P2 reception. + +P0, P1, and P2 are complete on 2026-10-17. The implementation supplies HT-SIG bytes, validation, bounded ranges, and cached partial-reception outcomes. Debug and release compilation pass. The direct fixtures and selected regression controls pass. P3, P4, and MAC acceptance remain pending. + +## Implementation contract + +The radio owns HT-SIG fields and CRC construction. Its serializer preserves all 48 bits, including the received CRC. A shared validator rejects invalid CRC and unsupported fields before any range calculation. The existing mode and PSDU length remain the duration inputs. + +The shared delimiter inspector owns bounded range discovery. It checks delimiter bytes and advances at each scan. Delimiters and complete MPDUs have separate ranges. Alignment padding has no range outcome. MAC acceptance remains outside P1 and P2. + +The WLAN receiver owns PHY outcomes. The medium cache owns the PREAMBLE, HEADER, DATA, and WHOLE decisions. Direct success queries reuse those decisions. DATA retains copied range values; the result tag copies those values without reception pointers. A partial DATA failure preserves the aggregate bytes. + +The optional WLAN error-model contract supplies pure support queries and range probabilities. The shared WLAN base implements this contract for NIST and Yans. The MAC supplies its exact capability inputs before the MIB update. An absent model retains the current common PHY checks without error draws. + +The proposed wire fixture checks independent bytes, CRC, bounded ranges, and singleton identity. The proposed receiver fixture checks actual radio reception, range loss, query reuse, failure boundaries, metadata, and compatibility. Existing HT/VHT controls check ordinary reception. Debug compilation precedes behavioral checks. Scoped architecture checks cover both WLAN subtrees. + +The contract matches the inspected callers and owners. Source edits exclude the sealed `src/inet/common/packet/` subtree. Required input changes include MSG fields, serializer registration consumers, NED contracts, the MAC capability handoff, and migration text. + +## P0 source audit + +The cache key contains receiver, transmission, and signal part. `RadioMedium::getReceptionDecision()` inserts a decision after a cache miss. `CommunicationCacheBase::setCachedReceptionDecision()` deletes a replaced decision. `ReceptionCacheEntry` deletes all retained decisions at destruction. `receivePacket()` removes and deletes the result but retains the decisions. The result owns its packet and decision-vector container; it does not own the decisions. + +The direct `RadioMedium::isReceptionSuccessful()` call bypasses the decision lookup. The WLAN override must route aggregate queries through that lookup. PREAMBLE cannot calculate HEADER or DATA. Separate-part radio reception aborts after PREAMBLE or HEADER failure. Whole-signal result construction requests WHOLE. + +The HT header mode declares 48 bits. The transmitter derives duration from the selected mode and `lengthField`. The empty parent serializer does not alter these duration inputs. + +The metadata audit found three error-rate result filters. Each filter forwards present values without arithmetic. The radio attaches histogram recorders. OMNeT++ `StatisticsRecorder::collect()` ignores `NaN` for unweighted statistics. The receiver fixture must exercise these configured consumers before D1 closes. + +The direct reader in `L3NetworkConfiguratorBase` constructs an ordinary MTU-sized probe. It calls radio encapsulation without an aggregate request or delimiter content. Thus, it does not consume aggregate probability metadata. Ordinary metadata retains its current calculation. Other source matches either produce tags or concern unrelated error-model interfaces. + +BerTable's NED enum rejects the radio's `n(mixed-2.4Ghz)` string before initialization. An isolated BerTable with the allowed `n` value reaches its initializer, which also rejects HT. Both failures precede the new role check. Its packet-level PER calculation also dereferences the transmission bit model. The parent scalar control initializes with a valid table, then crashes at that null access. The feature library produces the same crash. This result establishes a prior limitation, not supported BerTable reception. The inherited receiver stage count covers the physical-layer check. + +## Evidence + +The existing HT/VHT module control exposed a required compatibility correction. `Ieee80211VhtSignalMode::createHeader()` returns an HT header in the parent. HT field construction therefore receives VHT's absent HT MCS value and refuses it. The VHT mode must create its existing VHT header type. This change preserves VHT duration and probability calculations and adds no VHT serializer implementation. The affected mode header is unsealed. The existing HT/VHT control verifies this required extension of the change surface. + +The wire fixture verifies golden bytes from IEEE Std 802.11-2024, Figure 19-6 and Clause 19.3.9.4.4. A polynomial long-division calculation supplied the fixed CRC constants independently of the production shift register. Fresh byte-backed packets establish decode without the original typed header. Cases cover standalone and singleton identity, short GI, invalid CRC, unsupported fields, incomplete headers, and improper representation. HT Length 65535 and MCS 31 survive conversion; length 65536 causes refusal. + +Delimiter cases cover lengths 0 and 4095, refusal of 4096, all alignment remainders, CRC and signature errors, truncation, final padding, and bounded recovery. An overrun delimiter cannot supply a valid member boundary. + +The receiver fixture uses the real radio and medium with scalar and dimensional reception. It executes 31 scenarios in both reception modes, for 124 seed-0 runs. The scenarios cover ordinary NIST/Yans reception, an absent model, partial loss, delimiter and spacing-delimiter failure, total member failure, and failed common parts. Invalid CRC, unsupported fields, and structural refusal use distinct paths. Short-GI aggregate reception preserves the copied indication. An absent-model case with an unmet SNIR threshold supplies no accepted header or ranges and consumes no draws. + +Repeated PREAMBLE, HEADER, DATA, WHOLE, direct success, and result queries add no draws or probability calls. The fixed-probability case consumes seven draws for seven ranges. Endpoint probabilities consume no draws. The fixture checks PREAMBLE before any HEADER or range call. It retains a copied indication after normal cache cleanup. The result preserves power, SNIR, time, mode, channel, and transmission identity. + +The capability cases create a production WirelessHost. A missing role fails at the physical-layer check. Incomplete short-GI coverage fails before the MAC updates the MIB. Complete one-stream coverage passes despite unsupported catalog modes above the antenna limit. An absent model passes, including the unit-disk configuration. A non-HT model without the role retains ordinary reception; its runtime change to an HT set fails. + +Separate cases verify BerTable's NED refusal, initializer refusal, and non-HT initialization. + +The configured radio filters and histogram recorders receive aggregate metadata. The recorded aggregate probability histograms have zero samples because their input values are `NaN`. Ordinary NIST/Yans controls retain a zero PER and unknown BER/SER. Finite-SNIR controls without a model retain no error-rate tag. This evidence closes the metadata consumer audit for the configured paths. + +The isolated parent checkout is `/tmp/inet-ampdu-parent-4fa5cc0de1`. Its six ordinary HT runs pass with NIST, Yans, and no model, in both reception modes. The feature's corresponding scalar controls retain 170 microseconds for a 100-byte PSDU at HT MCS 0 with long GI. NIST/Yans retain PER zero and BER/SER `NaN`. Every corresponding control retains the next RNG value `2357136044`. + +## Commands and artifacts + +Commands run from the active repository root unless this record states another directory. Debug is the behavioral test mode. Every new fixture uses seed 0. Existing fixtures retain their declared runs and seeds. Source changes require a fresh matching library before dependent tests. + +Fixture commands use `MAKEFLAGS=--jobserver-style=pipe` and `MPLCONFIGDIR=/tmp/ampdu-matplotlib`. `/tmp/ampdu-source-sha256.txt` identifies the 22 changed source and test files. Its SHA256 is `6ab4156726c29065523a250443ade2cc67cbedceb220c70627001d7ca1017e16`. The manifest includes the final wire fixture and receiver fixture. Documentation does not form part of that source manifest. + +| Check | Command or selection | Status and artifact | +| --- | --- | --- | +| Debug build | `make MODE=debug -j8` with `MAKEFLAGS=--jobserver-style=pipe`. | Pass, exit 0; `/tmp/ampdu-debug.log`. | +| Release build | `make MODE=release -j6`, followed by `make MODE=release -j8` with the same `MAKEFLAGS`. | Both pass, exit 0; `/tmp/ampdu-release.log` and `/tmp/ampdu-release-final.log`. | +| Wire fixture | `inet_run_unit_tests -m debug -f 'Ieee80211AmpduWire_1\.test$' --no-concurrent`. | Pass, exit 0; `/tmp/ampdu-wire.log`. | +| Receiver fixture | `inet_run_module_tests -m debug -f 'Ieee80211AmpduPhyReception_1\.test$' --no-concurrent`. | All 124 runs pass, exit 0; `/tmp/ampdu-phy.log`. | +| Unit controls | `inet_run_unit_tests -m debug -f 'Ieee80211(AmpduWire\|MpduSubframeHeaderSerializer\|MpduDelimiterWire\|HtModeSet\|HtModeCache\|VhtHtCapabilities)_1\.test$' --no-concurrent`. | Six fixtures pass; `/tmp/ampdu-final-unit.log`. The wire fixture has a later focused refresh. | +| Module controls | `inet_run_module_tests -m debug -f 'Ieee80211(AmpduPhyReception\|VhtHtSupport\|HtAssociation\|HtAntennaRateControl)_1\.test$' --no-concurrent`. | Four fixtures pass, exit 0; `/tmp/ampdu-final-module.log`. That run includes 120 receiver scenarios. The later focused receiver run adds four absent-model SNIR controls. | +| Functional fingerprints | From `tests/fingerprint`: `./fingerprinttest -d -F tyf -t 3 -m 'showcases/wireless/(aggregation\|qos)/' showcases.csv`. | All five configurations pass, exit 0; `/tmp/ampdu-fingerprints.log`. Graphical ingredients are excluded. No expectation changes occur. | +| Architecture | `doc/project/enforcement/check-architecture.sh` for each WLAN subtree. | Both pass; `/tmp/ampdu-phy-architecture.log` and `/tmp/ampdu-mac-architecture.log`. | +| New interface | `doc/project/enforcement/check-interfaces.sh src/inet/physicallayer/wireless/ieee80211/contract`. | One interface passes; `/tmp/ampdu-interfaces.log`. | +| Source protection | `doc/project/enforcement/check-source-seals.sh --diff`. | Pass; `/tmp/ampdu-seals.log`. No sealed source path changes. | +| Naming | Scoped naming checks in the active and parent checkouts. | The same three PHY and 32 MAC candidates remain. The PHY log differs only in one line number. `/tmp/ampdu-phy-naming.log`, `/tmp/ampdu-mac-naming.log`, and their `ampdu-parent-*` controls retain the comparison. | + +The parent build command is `make MODE=debug -j12` from the isolated checkout. Its runner uses the same receiver-fixture selector and debug mode after `source setenv -q`. `/tmp/ampdu-clean-parent-debug.log` and `/tmp/ampdu-parent-controls.log` retain its results. The parent fixture contains only the ordinary controls and the same node setup. + +The isolated BerTable reproduction is `tests/module/Ieee80211AmpduBerTableControl_1.test` in the parent checkout. The parent runner records the failure in `/tmp/ampdu-parent-bertable.log`. The same generated executable also runs with the feature library first in `LD_LIBRARY_PATH`. `/tmp/ampdu-feature-bertable-libraries.log` confirms that library path. `/tmp/ampdu-feature-bertable.log` records the same null-bit-model failure. The fixture supplies all eight table rates. These failures do not count as passing reception controls. + +The runner's dry-run path fails with `ValueError('list.index(x): x not in list')`. Those previews establish no behavioral result. Normal filtered runs select and execute the named fixtures. A FIFO collision also affected an early parallel test build. Later commands use `MAKEFLAGS=--jobserver-style=pipe`. Fixture setup corrections precede the recorded passing runs. + +## Standards evidence and limits + +The local corpus identifies `ieee80211-2024` as IEEE Std 802.11-2024. Table 19-11 spans physical PDF pages 3431–3432. Clause 19.3.9.4.4 is on page 3434. Its Figure 19-8 reference resolves. The corpus cannot resolve Clause 9.7.1, so PDF text on pages 1841–1843 supplies delimiter evidence. PDF text on pages 3486–3487 confirms invalid-CRC and unsupported-mode behavior. These clauses are normative. The corpus linter reports unrelated heading ambiguities and unresolved references; the selected CRC node is unambiguous. Local artifacts `/tmp/ampdu-htsig-clause.json`, `/tmp/ampdu-htsig-table.json`, `/tmp/ampdu-htsig-refs.json`, and `/tmp/ampdu-standards-lint.json` retain the retrieved evidence. + +The implementation does not enable MAC receipt, MPDU release, or an implicit Block Ack response. Feature A2 and A4 retain those acceptance duties. A failed MPDU range must become that member's bit-error flag before the normal Rx FCS check. The aggregate probability fields are not member estimates. P3 and P4 remain pending for broader NIST/Yans and compatibility evidence. The commit and push authorization does not permit baseline changes. + +Independent range draws at the current scalar SNIR are a packet-level model choice. This abstraction does not model correlated FEC errors or interference changes within one member. Alignment padding contributes duration but has no separate outcome. These checks establish representation, integration, and selected regression behavior. They establish no new PHY accuracy result. Release-mode behavioral tests and feature-isolation builds remain unverified. + +The final self-audit traces cache ownership, prerequisite order, result copies, header refusal, structural refusal, capability publication, and the ordinary MPDU branches. It finds no unresolved defect in the implemented scope. The audit uses the current architecture, naming, quality, test, and WLAN guidance. It is a self-audit, not an independent review. + +## Publication checks + +The first publication attempt rejected Git metadata writes with `Read-only file system`. A separate repository at `/tmp/inet-ampdu-publication` held the commit series. Its source and test files matched the tested checkout. The separate `AGENTS.md` edit remained outside the series. Shell access could not resolve GitHub, so that attempt required the GitHub connector. + +The final debug and release builds pass in `/tmp/ampdu-push-debug.log` and `/tmp/ampdu-push-release.log`. The repeated filters pass six unit fixtures and four module fixtures. Their logs are `/tmp/ampdu-push-unit.log` and `/tmp/ampdu-push-module.log`. The new series passes commit, classification, include, and NED parameter checks. The audit supplies no PR description because this task creates no PR. Global architecture, naming, and interface findings match the pinned parent. Source seals pass. These checks establish final-tree behavior; intermediate commits have no separate compilation result. + +The repeated fingerprint filter passes all five controls without expectation changes. Its log is `/tmp/ampdu-push-fingerprints.log`. The full series since `origin/master` also passes its mechanical checks, with notes. The first publication attempt did not complete. The connector rejected the first tree request because tool approval was required and the approval policy was `never`. No remote branch update occurred. The original checkout retained its previous HEAD and local files. + +The user requested a retry after the permissions changed. Git metadata writes and shell access to GitHub now succeed. All 28 prepared files match the active checkout before commit transfer. The active branch now contains the three prepared commits. The separate `AGENTS.md` edit remains outside those commits. Only this publication record changes after the transfer; the tested source and test files remain unchanged. diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc index 5db40af167f..a372f92a72c 100644 --- a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc @@ -90,6 +90,7 @@ void Ieee80211Mac::initialize(int stage) if (transmitter->isHtChannelWidthSupported(channelWidth) && receiver->isHtChannelWidthSupported(channelWidth)) operationalChannelWidths.insert(channelWidth); + receiver->validateHtReceptionCapabilities(modeSet, operationalChannelWidths, operationalHtSpatialStreamLimit); } mib->updateLocalHtCapabilities(modeSet, operationalChannelWidths, operationalHtSpatialStreamLimit); emit(modesetChangedSignal, modeSet); diff --git a/src/inet/linklayer/ieee80211/mac/Rx.cc b/src/inet/linklayer/ieee80211/mac/Rx.cc index b51f7f3edf7..caf03f86200 100644 --- a/src/inet/linklayer/ieee80211/mac/Rx.cc +++ b/src/inet/linklayer/ieee80211/mac/Rx.cc @@ -12,6 +12,7 @@ #include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" #include "inet/linklayer/ieee80211/mac/contract/IContention.h" #include "inet/linklayer/ieee80211/mac/contract/ITx.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" namespace inet { namespace ieee80211 { @@ -104,7 +105,10 @@ bool Rx::lowerFrameReceived(Packet *packet) Enter_Method("lowerFrameReceived(\"%s\")", packet->getName()); take(packet); - bool isFrameOk = isFcsOk(packet); + // Aggregate containers need member acceptance before standalone FCS or header checks. + // Reject them until MAC aggregate reception exists; PHY range outcomes stay separate. + auto aggregate = packet->findTag(); + bool isFrameOk = !(aggregate && aggregate->getAggregation()) && isFcsOk(packet); if (isFrameOk) { EV_INFO << "Received frame from PHY: " << packet << endl; const auto& header = packet->peekAtFront(); diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc b/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc index 49971063177..5dfadcaace3 100644 --- a/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.cc @@ -18,6 +18,8 @@ std::vector *MpduDeaggregation::deaggregateFrame(Packet *aggregatedFra EV_DEBUG << "Deaggregating A-MPDU " << *aggregatedFrame << " into multiple packets.\n"; std::vector *frames = new std::vector(); auto layout = inspectMpduAggregate(aggregatedFrame, B(0), B(aggregatedFrame->getDataLength())); + // An incomplete layout can contain bounded recovered members. Extraction does not establish MAC acceptance. + // The caller must check delimiter validity, PHY outcomes, member FCS, and MAC conditions before acceptance. cStringTokenizer tokenizer(aggregatedFrame->getName(), "+"); for (const auto& range : layout.ranges) { if (range.kind != MpduRangeKind::MPDU) diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211AmpduReceptionDecision.h b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211AmpduReceptionDecision.h new file mode 100644 index 00000000000..f279f6f2c32 --- /dev/null +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211AmpduReceptionDecision.h @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_IEEE80211AMPDURECEPTIONDECISION_H +#define __INET_IEEE80211AMPDURECEPTIONDECISION_H + +#include "inet/physicallayer/wireless/common/radio/packetlevel/ReceptionDecision.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet { +namespace physicallayer { + +class INET_API Ieee80211AmpduReceptionDecision : public ReceptionDecision +{ + protected: + const bool headerSuccessful; + const bool contentComplete; + const std::vector ranges; + + public: + Ieee80211AmpduReceptionDecision(const IReception *reception, IRadioSignal::SignalPart part, + bool possible, bool attempted, bool successful, bool headerSuccessful, bool contentComplete, + const std::vector& ranges) : + ReceptionDecision(reception, part, possible, attempted, successful), + headerSuccessful(headerSuccessful), contentComplete(contentComplete), ranges(ranges) {} + bool isHeaderSuccessful() const { return headerSuccessful; } + bool isContentComplete() const { return contentComplete; } + const std::vector& getRanges() const { return ranges; } +}; + +} // namespace physicallayer +} // namespace inet + +#endif diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.cc b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.cc index 4c9d2ecd6d1..dcdbe05d9a8 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.cc +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.cc @@ -10,11 +10,29 @@ #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h" +#include "inet/physicallayer/wireless/ieee80211/contract/packetlevel/IIeee80211AmpduErrorModel.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211AmpduReceptionDecision.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" namespace inet { namespace physicallayer { +namespace { + +Ptr peekHtHeader(const ITransmission *transmission) +{ + return dynamicPtrCast(Ieee80211Radio::peekIeee80211PhyHeaderAtFront( + transmission->getPacket(), b(-1), Chunk::PF_ALLOW_INCORRECT | Chunk::PF_ALLOW_INCOMPLETE | + Chunk::PF_ALLOW_IMPROPERLY_REPRESENTED)); +} + +} // namespace + Define_Module(Ieee80211Receiver); Ieee80211Receiver::~Ieee80211Receiver() @@ -27,13 +45,15 @@ void Ieee80211Receiver::initialize(int stage) FlatReceiverBase::initialize(stage); if (stage == INITSTAGE_LOCAL) { const char *opMode = par("opMode"); - setModeSet(*opMode ? Ieee80211ModeSet::getModeSet(opMode) : nullptr); + modeSet = *opMode ? Ieee80211ModeSet::getModeSet(opMode) : nullptr; const char *bandName = par("bandName"); setBand(*bandName != '\0' ? Ieee80211CompliantBands::getBand(bandName) : nullptr); int channelNumber = par("channelNumber"); if (channelNumber != -1) setChannelNumber(channelNumber); } + else if (stage == INITSTAGE_PHYSICAL_LAYER) + validateAmpduErrorModel(modeSet); } std::ostream& Ieee80211Receiver::printToStream(std::ostream& stream, int level, int evFlags) const @@ -62,8 +82,35 @@ bool Ieee80211Receiver::computeIsReceptionPossible(const IListening *listening, const IReceptionResult *Ieee80211Receiver::computeReceptionResult(const IListening *listening, const IReception *reception, const IInterference *interference, const ISnir *snir, const std::vector *decisions) const { auto transmission = check_and_cast(reception->getTransmission()); - auto receptionResult = FlatReceiverBase::computeReceptionResult(listening, reception, interference, snir, decisions); + auto header = peekHtHeader(transmission); + bool aggregate = header != nullptr && header->getAggregation(); + bool validHeader = header == nullptr || isIeee80211HtSignalValid(*header, transmission->getMode()); + auto receptionResult = aggregate || !validHeader ? + NarrowbandReceiverBase::computeReceptionResult(listening, reception, interference, snir, decisions) : + FlatReceiverBase::computeReceptionResult(listening, reception, interference, snir, decisions); auto packet = const_cast(receptionResult->getPacket()); + if (aggregate || !validHeader) { + auto indication = packet->addTag(); + if (aggregate) { + auto medium = reception->getReceiverRadio()->getMedium(); + auto decision = check_and_cast(medium->getReceptionDecision( + reception->getReceiverRadio(), listening, transmission, IRadioSignal::SIGNAL_PART_DATA)); + indication->setHeaderSuccessful(decision->isHeaderSuccessful()); + indication->setAggregation(decision->isHeaderSuccessful()); + indication->setContentComplete(decision->isContentComplete()); + indication->setRangesArraySize(decision->getRanges().size()); + for (size_t i = 0; i < decision->getRanges().size(); i++) + indication->setRanges(i, decision->getRanges()[i]); + if (!decision->isHeaderSuccessful() || !decision->isContentComplete() || decision->getRanges().empty()) + packet->setBitError(true); + } + if (errorModel != nullptr) { + auto rates = packet->addTagIfAbsent(); + rates->setPacketErrorRate(NaN); + rates->setBitErrorRate(NaN); + rates->setSymbolErrorRate(NaN); + } + } packet->addTagIfAbsent()->setMode(transmission->getMode()); packet->addTagIfAbsent()->setChannel(transmission->getChannel()); return receptionResult; @@ -71,9 +118,128 @@ const IReceptionResult *Ieee80211Receiver::computeReceptionResult(const IListeni void Ieee80211Receiver::setModeSet(const Ieee80211ModeSet *modeSet) { + validateAmpduErrorModel(modeSet); this->modeSet = modeSet; } +void Ieee80211Receiver::validateAmpduErrorModel(const Ieee80211ModeSet *modes) const +{ + if (modes != nullptr && modes->isHtOperationSupported() && errorModel != nullptr && + dynamic_cast(errorModel) == nullptr) + throw cRuntimeError("HT reception requires IIeee80211AmpduErrorModel on a present error model"); +} + +void Ieee80211Receiver::validateHtReceptionCapabilities(const Ieee80211ModeSet *modes, + const std::set& channelWidths, int spatialStreamLimit) const +{ + Enter_Method("validateHtReceptionCapabilities"); + validateAmpduErrorModel(modes); + if (errorModel == nullptr || modes == nullptr || !modes->isHtOperationSupported()) + return; + auto aggregateModel = check_and_cast(errorModel); + for (int i = 0; i < modes->getNumModes(); i++) { + auto mode = modes->getMode(i); + if (mode->getHtMcsIndex() >= 0 && channelWidths.count(mode->getDataMode()->getBandwidth()) && + mode->getDataMode()->getNumberOfSpatialStreams() <= spatialStreamLimit && + !aggregateModel->supportsAmpduMode(mode)) + throw cRuntimeError("A-MPDU error model does not cover an advertised HT receive mode: MCS %d, short GI %d", + mode->getHtMcsIndex(), mode->isHtShortGuardInterval()); + } +} + +Packet *Ieee80211Receiver::computeReceivedPacket(const ISnir *snir, bool successful) const +{ + auto transmission = check_and_cast(snir->getReception()->getTransmission()); + auto header = peekHtHeader(transmission); + if (header != nullptr && (header->getAggregation() || !isIeee80211HtSignalValid(*header, transmission->getMode()))) + return ReceiverBase::computeReceivedPacket(snir, isIeee80211HtSignalValid(*header, transmission->getMode())); + return FlatReceiverBase::computeReceivedPacket(snir, successful); +} + +bool Ieee80211Receiver::computeIsReceptionSuccessful(const IListening *listening, const IReception *reception, + IRadioSignal::SignalPart part, const IInterference *interference, const ISnir *snir) const +{ + auto transmission = check_and_cast(reception->getTransmission()); + auto header = peekHtHeader(transmission); + if (header != nullptr && header->getAggregation()) + return reception->getReceiverRadio()->getMedium()->getReceptionDecision( + reception->getReceiverRadio(), listening, transmission, part)->isReceptionSuccessful(); + if (header != nullptr && part != IRadioSignal::SIGNAL_PART_PREAMBLE) { + if (!isIeee80211HtSignalValid(*header, transmission->getMode())) + return false; + if ((part == IRadioSignal::SIGNAL_PART_DATA || part == IRadioSignal::SIGNAL_PART_WHOLE) && + header->getChunkLength() + header->getLengthField() > transmission->getPacket()->getDataLength()) + return false; + } + return FlatReceiverBase::computeIsReceptionSuccessful(listening, reception, part, interference, snir); +} + +const IReceptionDecision *Ieee80211Receiver::computeReceptionDecision(const IListening *listening, + const IReception *reception, IRadioSignal::SignalPart part, const IInterference *interference, const ISnir *snir) const +{ + auto transmission = check_and_cast(reception->getTransmission()); + auto packet = transmission->getPacket(); + auto header = peekHtHeader(transmission); + if (header == nullptr || !header->getAggregation()) + return FlatReceiverBase::computeReceptionDecision(listening, reception, part, interference, snir); + auto radio = reception->getReceiverRadio(); + auto medium = radio->getMedium(); + bool possible = computeIsReceptionPossible(listening, reception, part); + bool attempted = possible && computeIsReceptionAttempted(listening, reception, part, interference); + bool successful = attempted; + bool headerSuccessful = false; + bool contentComplete = false; + std::vector ranges; + auto prerequisite = [&](IRadioSignal::SignalPart previous) { + return medium->getReceptionDecision(radio, listening, transmission, previous)->isReceptionSuccessful(); + }; + auto sample = [&](double probability) { + if (!(probability >= 0 && probability <= 1)) + throw cRuntimeError("Invalid A-MPDU success probability: %g", probability); + return probability == 1 || (probability != 0 && dblrand() > 1 - probability); + }; + if (part == IRadioSignal::SIGNAL_PART_PREAMBLE) + successful = successful && FlatReceiverBase::computeIsReceptionSuccessful(listening, reception, part, interference, snir); + else if (part == IRadioSignal::SIGNAL_PART_HEADER) { + successful = successful && prerequisite(IRadioSignal::SIGNAL_PART_PREAMBLE) && + isIeee80211HtSignalValid(*header, transmission->getMode()) && + FlatReceiverBase::computeIsReceptionSuccessful(listening, reception, part, interference, snir); + headerSuccessful = successful; + } + else if (part == IRadioSignal::SIGNAL_PART_DATA) { + headerSuccessful = prerequisite(IRadioSignal::SIGNAL_PART_HEADER); + contentComplete = headerSuccessful && header->getChunkLength() + header->getLengthField() <= packet->getDataLength(); + successful = successful && contentComplete && SnirReceiverBase::computeIsReceptionSuccessful(listening, reception, part, interference, snir); + if (successful) { + auto layout = ieee80211::inspectMpduAggregate(packet, B(header->getChunkLength()), header->getLengthField()); + auto aggregateModel = dynamic_cast(errorModel); + successful = layout.complete; + for (const auto& range : layout.ranges) { + Ieee80211AmpduRange outcome; + outcome.kind = range.kind == ieee80211::MpduRangeKind::DELIMITER ? 0 : 1; + outcome.offset = range.offset; + outcome.length = range.length; + outcome.valid = range.valid; + outcome.successful = sample(aggregateModel == nullptr ? 1 : + aggregateModel->computeAmpduRangeSuccessRate(snir, transmission->getMode(), range.length)); + successful &= outcome.successful && outcome.valid; + ranges.push_back(outcome); + } + } + } + else if (part == IRadioSignal::SIGNAL_PART_WHOLE) { + auto data = check_and_cast(medium->getReceptionDecision( + radio, listening, transmission, IRadioSignal::SIGNAL_PART_DATA)); + successful = successful && data->isReceptionSuccessful(); + headerSuccessful = data->isHeaderSuccessful(); + contentComplete = data->isContentComplete(); + } + else + throw cRuntimeError("Invalid A-MPDU signal part"); + return new Ieee80211AmpduReceptionDecision(reception, part, possible, attempted, successful, + headerSuccessful, contentComplete, ranges); +} + void Ieee80211Receiver::setBand(const IIeee80211Band *band) { if (this->band != band) { diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.h b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.h index 450e8b36c45..79541de5bf8 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.h +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Receiver.h @@ -30,6 +30,11 @@ class INET_API Ieee80211Receiver : public FlatReceiverBase virtual bool computeIsReceptionPossible(const IListening *listening, const ITransmission *transmission) const override; virtual bool computeIsReceptionPossible(const IListening *listening, const IReception *reception, IRadioSignal::SignalPart part) const override; + virtual Packet *computeReceivedPacket(const ISnir *snir, bool isReceptionSuccessful) const override; + virtual bool computeIsReceptionSuccessful(const IListening *listening, const IReception *reception, IRadioSignal::SignalPart part, const IInterference *interference, const ISnir *snir) const override; + virtual const IReceptionDecision *computeReceptionDecision(const IListening *listening, const IReception *reception, IRadioSignal::SignalPart part, const IInterference *interference, const ISnir *snir) const override; + void validateAmpduErrorModel(const Ieee80211ModeSet *modes) const; + virtual const IReceptionResult *computeReceptionResult(const IListening *listening, const IReception *reception, const IInterference *interference, const ISnir *snir, const std::vector *decisions) const override; public: @@ -42,6 +47,15 @@ class INET_API Ieee80211Receiver : public FlatReceiverBase virtual void setChannel(const Ieee80211Channel *channel); virtual void setChannelNumber(int channelNumber); virtual bool isHtChannelWidthSupported(Hz channelWidth) const; + /** + * The MAC calls this method before it updates local HT capabilities in the MIB. + * For HT, a present error model must implement IIeee80211AmpduErrorModel and cover every advertised mode in the supplied bounds. + * The bounds include the supplied channel widths, spatial stream limit, and every guard interval in modes. + * Overrides must preserve this check and throw cRuntimeError before the update for an unsupported mode. + * An absent error model needs no probability coverage. + * Validation must not change capability state or consume random draws. + */ + virtual void validateHtReceptionCapabilities(const Ieee80211ModeSet *modes, const std::set& channelWidths, int spatialStreamLimit) const; }; } // namespace physicallayer diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag.msg b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag.msg index 8a8d2b21a29..dcc7dd48626 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag.msg +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag.msg @@ -6,11 +6,31 @@ import inet.common.INETDefs; import inet.common.TagBase; +import inet.common.Units; import inet.physicallayer.wireless.ieee80211.mode.IIeee80211Mode; import inet.physicallayer.wireless.ieee80211.mode.Ieee80211Channel; namespace inet::physicallayer; +// A value copy of one scored PSDU range. Kind 0 denotes a delimiter; kind 1 denotes an MPDU. +struct Ieee80211AmpduRange +{ + int kind = 0; + B offset = B(0); + B length = B(0); + bool successful = false; + bool valid = false; +} + +// PHY facts only. MAC delimiter and FCS checks still control acceptance. +class Ieee80211AmpduInd extends TagBase +{ + bool headerSuccessful = false; + bool aggregation = false; + bool contentComplete = false; + Ieee80211AmpduRange ranges[]; +} + // // This is an abstract base class that should not be directly added as a tag. // diff --git a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc index 2e215193fb9..bc59b093e0a 100644 --- a/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc +++ b/src/inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211ErrorModelBase.cc @@ -37,14 +37,16 @@ double Ieee80211ErrorModelBase::computeAmpduRangeSuccessRate(const ISnir *snir, double Ieee80211ErrorModelBase::computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const { Enter_Method("computePacketErrorRate"); + if (part == IRadioSignal::SIGNAL_PART_PREAMBLE) + return 0; auto transmission = check_and_cast(snir->getReception()->getTransmission()); auto mode = transmission->getMode(); auto phyHeader = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(transmission->getPacket()); auto headerLength = mode->getHeaderMode()->getLength(); auto dataLength = b(mode->getDataMode()->getCompleteLength(B(phyHeader->getLengthField()))); // TODO check header length and data length for OFDM (signal) field - double headerSuccessRate = getHeaderSuccessRate(mode, headerLength.get(), getScalarSnir(snir)); - double dataSuccessRate = getDataSuccessRate(mode, dataLength.get(), getScalarSnir(snir)); + double headerSuccessRate = part == IRadioSignal::SIGNAL_PART_DATA ? 1 : getHeaderSuccessRate(mode, headerLength.get(), getScalarSnir(snir)); + double dataSuccessRate = part == IRadioSignal::SIGNAL_PART_HEADER ? 1 : getDataSuccessRate(mode, dataLength.get(), getScalarSnir(snir)); switch (part) { case IRadioSignal::SIGNAL_PART_WHOLE: return 1.0 - headerSuccessRate * dataSuccessRate; diff --git a/tests/module/Ieee80211AmpduMacBoundary_1.test b/tests/module/Ieee80211AmpduMacBoundary_1.test new file mode 100644 index 00000000000..8312c02d7cd --- /dev/null +++ b/tests/module/Ieee80211AmpduMacBoundary_1.test @@ -0,0 +1,229 @@ +%description: +The production radio sends aggregate containers to the production MAC and Rx. +Rx rejects successful, partially failed, and entirely failed aggregates before standalone FCS or header checks. +The drop signal retains the PHY range outcomes and the clear container bit-error flag. +A standalone CTS still sets NAV through the normal acceptance path. +Scalar and dimensional radios cover whole-signal and separate-part reception with DCF and HCF. +Malformed delimiters before typed MPDUs permit bounded recovery without a radio exception. +Typed and byte representations preserve the same recovered ranges. + +%extraargs: -r 0..15 + +%file: AmpduMacBoundary.cc +#include "inet/common/ProtocolTag_m.h" +#include "inet/common/Simsignals.h" +#include "inet/common/checksum/Checksum.h" +#include "inet/common/packet/chunk/BytesChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IReception.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +class BoundaryErrorModel : public Ieee80211NistErrorModel +{ + public: + double computePacketErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *, B length) const override { + auto packet = snir->getReception()->getTransmission()->getPacket(); + bool failed = packet->isName("failed") || (packet->isName("partial") && length == B(101)); + return length != B(4) && failed ? 0 : 1; + } +}; +Define_Module(BoundaryErrorModel); + +class BoundaryDriver : public cSimpleModule, public cListener +{ + int sent = 0; + int dropped = 0; + int navSet = 0; + protected: + void initialize() override { + auto rx = getModuleByPath("^.receiver.wlan[0].mac.rx"); + rx->subscribe(packetDroppedSignal, this); + rx->subscribe(Rx::navChangedSignal, this); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("send")); + } + void receiveSignal(cComponent *, simsignal_t signal, cObject *object, cObject *) override { + ASSERT(signal == packetDroppedSignal); + auto packet = check_and_cast(object); + ASSERT(dropped < 4); + ASSERT(packet->isName(dropped == 0 ? "good" : dropped == 1 ? "partial" : dropped == 2 ? "failed" : "malformed")); + ASSERT(!packet->hasBitError()); + auto indication = packet->getTag(); + ASSERT(indication->getAggregation() && indication->getHeaderSuccessful() && indication->getContentComplete()); + if (dropped == 3) { + ASSERT(indication->getRangesArraySize() == 30); + ASSERT(!indication->getRanges(0).valid && indication->getRanges(0).offset == B(0)); + int members = 0; + for (size_t i = 0; i < indication->getRangesArraySize(); i++) { + const auto& range = indication->getRanges(i); + ASSERT(range.offset + range.length <= packet->getDataLength()); + ASSERT(range.successful); + if (range.kind == 1) { + ASSERT(range.valid); + ASSERT(range.offset == (members == 0 ? B(108) : B(216))); + ASSERT(range.length == (members == 0 ? B(101) : B(102))); + members++; + } + } + ASSERT(members == 2); + dropped++; + return; + } + ASSERT(indication->getRangesArraySize() == 6); + int failed = 0; + for (size_t i = 0; i < indication->getRangesArraySize(); i++) { + auto& range = indication->getRanges(i); + ASSERT(range.valid); + failed += !range.successful; + } + ASSERT(failed == (dropped == 0 ? 0 : dropped == 1 ? 1 : 3)); + dropped++; + } + void receiveSignal(cComponent *, simsignal_t signal, const SimTime& value, cObject *) override { + ASSERT(signal == Rx::navChangedSignal); + if (value > SIMTIME_ZERO) { + ASSERT(sent == 5 && dropped == 4); + ASSERT(value == SimTime(50, SIMTIME_US)); + navSet++; + } + } + void handleMessage(cMessage *message) override { + delete message; + auto packet = new Packet(sent == 0 ? "good" : sent == 1 ? "partial" : sent == 2 ? "failed" : sent == 3 ? "malformed" : "ordinary"); + if (sent < 4) { + for (int length : {100, 101, 102}) { + auto delimiter = makeShared(); + delimiter->setLength(sent == 3 && length == 100 ? 2000 : length); + packet->insertAtBack(delimiter); + auto member = makeShared(); + member->setSequenceNumber(SequenceNumberCyclic(0)); + packet->insertAtBack(member); + packet->insertAtBack(makeShared(std::vector(length - member->getChunkLength().get(), 0))); + if (length != 102 && length % 4) + packet->insertAtBack(makeShared(std::vector(4 - length % 4, 0))); + } + } + else { + auto header = makeShared(); + header->setReceiverAddress(MacAddress("02:00:00:00:00:99")); + header->setDurationField(SimTime(50, SIMTIME_US)); + packet->insertAtBack(header); + auto bytes = packet->peekAllAsBytes()->getBytes(); + auto trailer = makeShared(); + trailer->setFcsMode(FCS_COMPUTED); + trailer->setFcs(ethernetFcs(bytes.data(), bytes.size())); + packet->insertAtBack(trailer); + } + packet->addTag()->setProtocol(&Protocol::ieee80211Mac); + auto modes = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + const IIeee80211Mode *selected = nullptr; + for (int i = 0; i < modes->getNumModes(); i++) { + auto mode = modes->getMode(i); + if (mode->getHtMcsIndex() == 0 && mode->getDataMode()->getBandwidth() == MHz(20) && !mode->isHtShortGuardInterval()) + selected = mode; + } + ASSERT(selected); + packet->addTag()->setMode(selected); + sent++; + send(packet, "out"); + if (sent < 5) + scheduleAt(simTime() + SimTime(1, SIMTIME_MS), new cMessage("send")); + } + using cListener::finish; + void finish() override { + ASSERT(sent == 5 && dropped == 4 && navSet == 1); + EV << "MAC aggregate boundary checks passed\n"; + } +}; +Define_Module(BoundaryDriver); + +%file: test.ned +import inet.mobility.static.StationaryMobility; +import inet.node.inet.AdhocHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Radio; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211RadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; + +module BoundaryErrorModel extends Ieee80211NistErrorModel +{ + parameters: + @class(::BoundaryErrorModel); +} +simple BoundaryDriver +{ + parameters: + @class(::BoundaryDriver); + gates: + output out; +} +module BoundarySender +{ + parameters: + @networkNode; + gates: + input in; + input radioIn @directIn; + submodules: + mobility: StationaryMobility; + radio: Ieee80211Radio; + connections allowunconnected: + in --> radio.upperLayerIn; + radioIn --> radio.radioIn; +} +network Test +{ + submodules: + radioMedium: Ieee80211RadioMedium; + driver: BoundaryDriver; + sender: BoundarySender; + receiver: AdhocHost; + connections: + driver.out --> sender.in; +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src +sim-time-limit = 7ms +seed-set = 0 +cmdenv-express-mode = false +**.vector-recording = false +*.receiver.numWlanInterfaces = 1 +*.receiver.wlan[0].opMode = "n(mixed-2.4Ghz)" +*.receiver.wlan[0].mac.qosStation = ${qos=false,true} +*.receiver.wlan[0].radio.receiver.errorModel.typename = "BoundaryErrorModel" +*.receiver.wlan[0].radio.separateReceptionParts = ${parts=false,true} +*.sender.radio.separateReceptionParts = ${parts} +*.sender.radio.opMode = "n(mixed-2.4Ghz)" +*.sender.radio.initialRadioMode = "transmitter" +*.sender.radio.antenna.mobilityModule = "^.^.mobility" +*.sender.radio.sendRawBytes = ${raw=false,true} +*.radioMedium.signalAnalogRepresentation = ${analog="scalar","dimensional"} +**.radio.signalAnalogRepresentation = ${analog} +**.radio.receiver.bandwidth = 20MHz +*.radioMedium.backgroundNoise.power = -110dBm +**.mobility.initFromDisplayString = false +**.mobility.initialX = 10m +**.mobility.initialY = 10m +**.mobility.initialZ = 0m +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m + +%contains: stdout +MAC aggregate boundary checks passed + +%contains: stdout +Run statistics: total 16, successful 16 diff --git a/tests/module/Ieee80211AmpduPhyReception_1.test b/tests/module/Ieee80211AmpduPhyReception_1.test new file mode 100644 index 00000000000..96fd83e1945 --- /dev/null +++ b/tests/module/Ieee80211AmpduPhyReception_1.test @@ -0,0 +1,478 @@ +%description: +Real HT20 radios preserve separate delimiter and MPDU outcomes after partial loss. +Scalar and dimensional controls use whole-signal and separate-part reception with seed 0. +Repeated decision and result queries must reuse probabilities and draws. +Invalid headers and insufficient content must prevent member outcomes through distinct decisions. +Production MAC initialization must refuse absent roles and incomplete advertised receive coverage before the MIB update. +Ordinary NIST, Yans, absent-model, and non-HT controls retain their defined behavior and metadata. + +%extraargs: -r 0..123 + +%file: AmpduPhyReception.cc +#include "inet/common/ProtocolTag_m.h" +#include "inet/common/Simsignals.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/common/packet/chunk/BytesChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h" +#include "inet/physicallayer/wireless/common/signal/WirelessSignal.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211AmpduReceptionDecision.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" + +using namespace inet; +using namespace inet::physicallayer; + +class AmpduDeterministicModel : public Ieee80211NistErrorModel +{ + public: + mutable int rangeCalls = 0; + mutable int headerCalls = 0; + mutable int preambleCalls = 0; + mutable int wholeCalls = 0; + double computePacketErrorRate(const ISnir *, IRadioSignal::SignalPart part) const override { + int scenario = par("scenario"); + if (part == IRadioSignal::SIGNAL_PART_PREAMBLE) { preambleCalls++; return scenario == 11 ? 1 : 0; } + if (part == IRadioSignal::SIGNAL_PART_HEADER) { headerCalls++; return scenario == 10 ? 1 : 0; } + wholeCalls++; + return 0; + } + double computeAmpduRangeSuccessRate(const ISnir *, const IIeee80211Mode *, B length) const override { + int index = rangeCalls++; + int scenario = par("scenario"); + if (scenario == 16) return 0.5; + if ((scenario == 4 && length == B(100)) || (scenario == 5 && length == B(101)) || + (scenario == 6 && length == B(102)) || (scenario == 7 && index == 0) || + (scenario == 8 && index == 2) || (scenario == 9 && length != B(4))) + return 0; + return 1; + } +}; +Define_Module(AmpduDeterministicModel); + +class AmpduLimitedModel : public Ieee80211NistErrorModel +{ + public: + mutable int probabilityCalls = 0; + bool supportsAmpduMode(const IIeee80211Mode *mode) const override { + return Ieee80211NistErrorModel::supportsAmpduMode(mode) && + (!par("longOnly").boolValue() || !mode->isHtShortGuardInterval()) && + mode->getDataMode()->getNumberOfSpatialStreams() == 1; + } + double computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const override { + probabilityCalls++; + return Ieee80211NistErrorModel::computePacketErrorRate(snir, part); + } + double computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *mode, B length) const override { + probabilityCalls++; + return Ieee80211NistErrorModel::computeAmpduRangeSuccessRate(snir, mode, length); + } +}; +Define_Module(AmpduLimitedModel); + +class AmpduNoRoleModel : public ErrorModelBase +{ + public: + double computePacketErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeBitErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeSymbolErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } +}; +Define_Module(AmpduNoRoleModel); + +class AmpduProbeRadio : public Ieee80211Radio +{ + protected: + void encapsulate(Packet *packet) const override { + Ieee80211Radio::encapsulate(packet); + int scenario = par("scenario"); + if (scenario == 12 || scenario == 13 || scenario == 14 || scenario == 17 || scenario == 18 || scenario == 19) { + auto header = packet->removeAtFront(); + if (scenario == 12 || scenario == 17) + header->setCrc(header->getCrc() ^ 1); + else if (scenario == 13 || scenario == 18) { + header->setFecCoding(true); + header->setCrc(computeIeee80211HtSignalCrc(*header)); + } + else { + header->setLengthField(B(600)); + header->setCrc(computeIeee80211HtSignalCrc(*header)); + } + packet->insertAtFront(header); + } + } + void continueReception(cMessage *timer) override { + Ieee80211Radio::continueReception(timer); + auto model = dynamic_cast(getSubmodule("receiver")->getSubmodule("errorModel")); + if (model != nullptr && timer->getKind() == IRadioSignal::SIGNAL_PART_HEADER) { + ASSERT(model->headerCalls == 0); + ASSERT(model->rangeCalls == 0); + } + } + void endReception(cMessage *timer) override { + auto signal = check_and_cast(timer->getControlInfo()); + if (getParentModule()->getIndex() == 1 && par("scenario").intValue() >= 3 && + par("scenario").intValue() != 21 && par("scenario").intValue() != 10 && par("scenario").intValue() != 11 && + par("scenario").intValue() != 30 && + !(par("separateReceptionParts").boolValue() && + (par("scenario").intValue() == 12 || par("scenario").intValue() == 13 || par("scenario").intValue() == 17 || par("scenario").intValue() == 18))) { + auto transmission = signal->getTransmission(); + auto listening = signal->getListening(); + auto whole = medium->getReceptionDecision(this, listening, transmission, IRadioSignal::SIGNAL_PART_WHOLE); + auto model = dynamic_cast(getSubmodule("receiver")->getSubmodule("errorModel")); + int calls = model ? model->rangeCalls : 0; + auto draws = getSubmodule("receiver")->getRNG(0)->getNumbersDrawn(); + auto result = medium->getReceptionResult(this, listening, transmission); + for (int repeat = 0; repeat < 3; repeat++) { + for (auto part : {IRadioSignal::SIGNAL_PART_PREAMBLE, IRadioSignal::SIGNAL_PART_HEADER, + IRadioSignal::SIGNAL_PART_DATA, IRadioSignal::SIGNAL_PART_WHOLE}) { + auto decision = medium->getReceptionDecision(this, listening, transmission, part); + ASSERT(medium->isReceptionSuccessful(this, transmission, part) == decision->isReceptionSuccessful()); + } + ASSERT(medium->getReceptionDecision(this, listening, transmission, IRadioSignal::SIGNAL_PART_WHOLE) == whole); + ASSERT(medium->getReceptionResult(this, listening, transmission) == result); + } + ASSERT(draws == getSubmodule("receiver")->getRNG(0)->getNumbersDrawn()); + ASSERT(model == nullptr || calls == model->rangeCalls); + } + Ieee80211Radio::endReception(timer); + } +}; +Define_Module(AmpduProbeRadio); + +class AmpduPhyDriver : public cSimpleModule, public cListener +{ + protected: + int received = 0; + simtime_t duration; + Ptr retained; + int scenario() const { return par("scenario"); } + bool ordinary() const { return scenario() < 3 || scenario() == 21 || scenario() == 29; } + void checkCapabilities() { + auto type = cModuleType::get("inet.node.inet.WirelessHost"); + auto host = type->create("probe", getParentModule()); + bool failed = false; + try { + host->finalizeParameters(); + host->buildInside(); + host->scheduleStart(simTime()); + host->callInitialize(); + } + catch (const cRuntimeError& error) { + failed = true; + std::string message(error.what()); + EV << "Capability initialization error: " << message << "\n"; + if (scenario() == 22) + ASSERT(message.find("requires IIeee80211AmpduErrorModel") != std::string::npos); + else if (scenario() == 23) + ASSERT(message.find("does not cover an advertised") != std::string::npos); + else if (scenario() == 28) + ASSERT(message.find("Value \"n(mixed-2.4Ghz)\" is not allowed") != std::string::npos); + else + throw; + auto mib = check_and_cast(host->getSubmodule("wlan", 0)->getSubmodule("mib")); + ASSERT(!mib->isHtOperationSupported()); + } + ASSERT(failed == (scenario() == 22 || scenario() == 23 || scenario() == 28)); + if (!failed) { + auto radio = check_and_cast(host->getSubmodule("wlan", 0)->getSubmodule("radio")); + auto model = dynamic_cast(radio->getSubmodule("receiver")->getSubmodule("errorModel")); + if (model) ASSERT(model->probabilityCalls == 0); + if (scenario() == 26) { + auto receiver = check_and_cast(radio->getSubmodule("receiver")); + bool refused = false; + try { receiver->setModeSet(Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)")); } + catch (const cRuntimeError& error) { refused = std::string(error.what()).find("requires IIeee80211AmpduErrorModel") != std::string::npos; } + ASSERT(refused); + } + } + host->deleteModule(); + if (scenario() == 28) { + auto model = cModuleType::get("inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211BerTableErrorModel")->create("berProbe", getParentModule()); + model->par("opMode").setStringValue("n"); + model->par("berTableFile").setStringValue("berTable.dat"); + bool refused = false; + try { + model->finalizeParameters(); + model->buildInside(); + model->callInitialize(); + } + catch (const cRuntimeError& error) { refused = std::string(error.what()).find("Unknown opMode") != std::string::npos; } + ASSERT(refused); + model->deleteModule(); + } + EV << "PHY capability checks passed\n"; + } + void initialize() override { + getModuleByPath("^.node[0].radio")->subscribe(transmissionStartedSignal, this); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("send")); + } + void receiveSignal(cComponent *, simsignal_t, cObject *object, cObject *) override { + auto transmission = check_and_cast(object); + if (scenario() != 29) + ASSERT(transmission->getPacket()->peekAtFront()->getChunkLength() == b(48)); + duration = transmission->getEndTime() - transmission->getStartTime(); + if (scenario() < 3 || scenario() == 21) + ASSERT(duration == SimTime(170, SIMTIME_US)); + } + void handleMessage(cMessage *message) override { + if (message->isSelfMessage()) { + delete message; + if (scenario() >= 22 && scenario() <= 28) { + checkCapabilities(); + endSimulation(); + return; + } + auto packet = new Packet("input"); + if (ordinary()) + packet->insertAtBack(makeShared(B(100))); + else { + for (int length : {100, 0, 101, 102}) { + auto delimiter = makeShared(); + delimiter->setLength(length); + packet->insertAtBack(delimiter); + if (length) + packet->insertAtBack(makeShared(std::vector(length, 0))); + if (length == 101) + packet->insertAtBack(makeShared(std::vector(3, 0))); + } + } + packet->addTag()->setProtocol(&Protocol::ieee80211Mac); + auto modes = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + if (scenario() == 29) + packet->addTag()->setMode(Ieee80211ModeSet::getModeSet("g(mixed)")->getMode(Mbps(6))); + for (int i = 0; scenario() != 29 && i < modes->getNumModes(); i++) { + auto mode = modes->getMode(i); + if (mode->getHtMcsIndex() == 0 && mode->getDataMode()->getBandwidth() == MHz(20) && mode->isHtShortGuardInterval() == (scenario() == 15)) { + packet->addTag()->setMode(mode); + break; + } + } + send(packet, "out", 0); + } + else { + auto packet = check_and_cast(message); + bool refused = scenario() == 10 || scenario() == 11 || scenario() == 12 || scenario() == 13 || + scenario() == 14 || scenario() == 17 || scenario() == 18 || scenario() == 19 || scenario() == 30; + ASSERT(packet->hasBitError() == refused); + if (ordinary()) + ASSERT(packet->getDataLength() == B(100)); + else { + auto indication = packet->getTag(); + ASSERT(packet->getDataLength() == B(322)); + retained = makeShared(*indication); + bool badHeader = refused && scenario() != 14 && scenario() != 19; + ASSERT(indication->getHeaderSuccessful() == !badHeader); + ASSERT(indication->getAggregation() == !badHeader); + ASSERT(indication->getContentComplete() == !refused); + ASSERT(indication->getRangesArraySize() == (refused ? 0 : 7)); + if (!refused) { + int failed = 0; + for (size_t i = 0; i < indication->getRangesArraySize(); i++) + failed += !indication->getRanges(i).successful; + if (scenario() >= 4 && scenario() <= 8) ASSERT(failed == 1); + else if (scenario() == 9) ASSERT(failed == 3); + else if (scenario() != 16) ASSERT(failed == 0); + } + } + ASSERT(packet->getTag()->getMode()->getHtMcsIndex() == (scenario() == 29 ? -1 : 0)); + ASSERT(packet->getTag()->getChannel() != nullptr); + ASSERT(packet->getTag()->getPower() > W(0)); + ASSERT(packet->getTag()->getMinimumSnir() > 0); + ASSERT(packet->getTag()->getTransmissionId() >= 0); + ASSERT(packet->getTag()->getEndTime() - packet->getTag()->getStartTime() == duration); + auto error = packet->findTag(); + if (scenario() >= 3 && scenario() <= 16) { + ASSERT(error != nullptr); + ASSERT(std::isnan(error->getPacketErrorRate())); + ASSERT(std::isnan(error->getBitErrorRate())); + ASSERT(std::isnan(error->getSymbolErrorRate())); + } + if ((scenario() >= 17 && scenario() <= 20) || scenario() == 30) + ASSERT(error == nullptr); + if (error) + EV << "ordinary PER=" << error->getPacketErrorRate() << " BER=" << error->getBitErrorRate() << " SER=" << error->getSymbolErrorRate() << "\n"; + received++; + delete packet; + } + } + using cListener::finish; + void finish() override { + if (scenario() >= 22 && scenario() <= 28) { + EV << "PHY reception checks passed\n"; + return; + } + bool headerFailure = scenario() == 10 || scenario() == 11 || scenario() == 12 || scenario() == 13 || scenario() == 17 || scenario() == 18 || scenario() == 30; + bool separate = getModuleByPath("^.node[1].radio")->par("separateReceptionParts"); + ASSERT(received == (headerFailure && separate ? 0 : 1)); + auto rx = getModuleByPath("^.node[1].radio.receiver"); + if (scenario() == 30) ASSERT(rx->getRNG(0)->getNumbersDrawn() == 0); + auto model = dynamic_cast(rx->getSubmodule("errorModel")); + if (model) { + ASSERT(model->wholeCalls == 0); + ASSERT(model->rangeCalls == (scenario() >= 10 && scenario() <= 14 ? 0 : 7)); + if (scenario() == 11) ASSERT(model->headerCalls == 0); + ASSERT(rx->getRNG(0)->getNumbersDrawn() == (scenario() == 16 ? 7 : 0)); + } + auto medium = check_and_cast(getModuleByPath("^.radioMedium")); + ASSERT(medium->getCommunicationCache()->getNumTransmissions() == 0); + if (retained && !headerFailure && scenario() != 14 && scenario() != 19) + ASSERT(retained->getRangesArraySize() == 7); + auto radio = check_and_cast(getModuleByPath("^.node[1].radio")); + EV << "ordinary next RNG=" << radio->getSubmodule("receiver")->getRNG(0)->intRand() << "\n"; + EV << "PHY reception checks passed\n"; + } +}; +Define_Module(AmpduPhyDriver); + +%file: test.ned +import inet.mobility.static.StationaryMobility; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Radio; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211RadioMedium; +import inet.physicallayer.wireless.common.medium.RadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +import inet.physicallayer.wireless.common.base.packetlevel.ErrorModelBase; + +module AmpduLimitedModel extends Ieee80211NistErrorModel +{ + parameters: + bool longOnly; + @class(::AmpduLimitedModel); +} +module AmpduNoRoleModel extends ErrorModelBase +{ + parameters: + @class(::AmpduNoRoleModel); +} + +module AmpduDeterministicModel extends Ieee80211NistErrorModel +{ + parameters: + int scenario; + @class(::AmpduDeterministicModel); +} +module AmpduProbeRadio extends Ieee80211Radio +{ + parameters: + int scenario; + receiver.errorModel.typename = default(scenario == 29 ? "AmpduNoRoleModel" : (scenario == 0 ? "Ieee80211NistErrorModel" : (scenario == 1 || scenario == 21 ? "Ieee80211YansErrorModel" : (scenario == 2 || scenario >= 17 ? "" : "AmpduDeterministicModel")))); + @class(::AmpduProbeRadio); +} +module AmpduCapabilityRadio extends Ieee80211Radio +{ + parameters: + int scenario; + signalAnalogRepresentation = default(scenario == 25 ? "unitDisk" : "scalar"); + radioMediumModule = default(scenario == 25 ? "unitDiskMedium" : "radioMedium"); + receiver.errorModel.typename = default(scenario == 22 || scenario == 26 ? "AmpduNoRoleModel" : (scenario == 23 || scenario == 24 ? "AmpduLimitedModel" : (scenario == 27 || scenario == 28 ? "Ieee80211BerTableErrorModel" : ""))); +} + +simple AmpduPhyDriver +{ + parameters: + @class(::AmpduPhyDriver); + int scenario; + gates: + input in[2]; + output out[2]; +} +module AmpduPhyNode +{ + parameters: + @networkNode; + gates: + input in; + output out; + input radioIn @directIn; + submodules: + mobility: StationaryMobility; + radio: AmpduProbeRadio; + connections: + in --> radio.upperLayerIn; + radio.upperLayerOut --> out; + radioIn --> radio.radioIn; +} +network Test +{ + submodules: + radioMedium: Ieee80211RadioMedium; + unitDiskMedium: RadioMedium { + signalAnalogRepresentation = "unitDisk"; + } + driver: AmpduPhyDriver; + node[2]: AmpduPhyNode; + connections: + for i=0..1 { + driver.out[i] --> node[i].in; + node[i].out --> driver.in[i]; + } +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src +sim-time-limit = 20ms +seed-set = 0 +cmdenv-express-mode = false +**.scalar-recording = true +**.vector-recording = false +*.node[*].radio.opMode = ${scenario} == 29 ? "g(mixed)" : "n(mixed-2.4Ghz)" +*.node[*].radio.initialRadioMode = "transceiver" +*.driver.scenario = ${scenario=0..30} +*.node[*].radio.scenario = ${scenario} +*.node[*].radio.receiver.errorModel.scenario = ${scenario} +*.node[*].radio.separateReceptionParts = ${parts=false,true} +*.node[*].radio.signalAnalogRepresentation = ${analog="scalar","dimensional"} +*.radioMedium.signalAnalogRepresentation = ${analog} +*.node[*].radio.sendRawBytes = ${scenario} >= 3 && ${scenario} < 22 +*.node[*].radio.receiver.bandwidth = 20MHz +*.node[*].radio.receiver.snirThreshold = ${scenario} == 30 ? 100dB : 4dB +*.node[*].radio.antenna.mobilityModule = "^.^.mobility" +*.node[*].mobility.initFromDisplayString = false +*.node[*].mobility.initialX = 10m + parentIndex() * 1m +*.node[*].mobility.initialY = 10m +*.node[*].mobility.initialZ = 0m +*.node[*].mobility.constraintAreaMinX = 0m +*.node[*].mobility.constraintAreaMinY = 0m +*.node[*].mobility.constraintAreaMinZ = 0m +*.node[*].mobility.constraintAreaMaxX = 100m +*.node[*].mobility.constraintAreaMaxY = 100m +*.node[*].mobility.constraintAreaMaxZ = 0m +*.radioMedium.backgroundNoise.power = -110dBm +*.probe.wlan[0].opMode = ${scenario} == 26 || ${scenario} == 27 ? "g(mixed)" : "n(mixed-2.4Ghz)" +*.probe.wlan[0].radio.typename = "AmpduCapabilityRadio" +*.probe.wlan[0].radio.scenario = ${scenario} +*.probe.wlan[0].radio.receiver.bandwidth = 20MHz +*.probe.wlan[0].radio.transmitter.analogModel.communicationRange = 100m +*.probe.wlan[0].radio.receiver.errorModel.longOnly = ${scenario} == 23 +*.probe.wlan[0].radio.receiver.errorModel.berTableFile = "berTable.dat" +*.probe.wlan[0].mac.qosStation = true +*.probe.wlan[0].mgmt.typename = "Ieee80211MgmtAdhoc" +*.probe.mobility.initFromDisplayString = false +*.probe.mobility.initialX = 20m +*.probe.mobility.initialY = 10m +*.probe.mobility.initialZ = 0m +*.probe.mobility.constraintAreaMinX = 0m +*.probe.mobility.constraintAreaMinY = 0m +*.probe.mobility.constraintAreaMinZ = 0m +*.probe.mobility.constraintAreaMaxX = 100m +*.probe.mobility.constraintAreaMaxY = 100m +*.probe.mobility.constraintAreaMaxZ = 0m + +%file: berTable.dat +$self add Mode6Mb 128 0 0 +$self add Mode9Mb 128 0 0 +$self add Mode12Mb 128 0 0 +$self add Mode18Mb 128 0 0 +$self add Mode24Mb 128 0 0 +$self add Mode36Mb 128 0 0 +$self add Mode48Mb 128 0 0 +$self add Mode54Mb 128 0 0 + +%contains: stdout +PHY reception checks passed From 2976c233550f72c25fc2fc993110a81788c7fdb9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:54:50 +0200 Subject: [PATCH 23/41] tests: add: verify seeded NIST and Yans aggregate reception Before this commit, pure calculation checks cover range probabilities, but deterministic receiver checks do not verify seeded NIST and Yans outcomes. The real models need direct checks through the production receiver. After this commit, test subclasses call the real implementations through the receiver. Each range probability must equal the existing DATA calculation. Independent generators replay HEADER and range draws. The fixture compares cached outcomes, draw counts, and subsequent random values. Repeated PREAMBLE, decision, and result queries must reuse cached samples. For example, a second DATA query must retain every outcome and leave the random generator at its expected next value. The reference matrix covers 64 HT20 modes, six lengths, seven SNIR values, and minimum and mean reductions. The receiver campaign uses scalar and dimensional radios, both signal-part modes, and seeds 0, 1, and 2. These checks establish no error-accuracy or goodput claim. The complete receiver fixture now contains the pure probability matrix from the earlier prerequisite. The temporary independent fixture is removed. Production behavior and stored fingerprint expectations remain unchanged. Plan: plan/pending/ieee80211-ampdu-phy-reception.md Change: tests | behavior.add | - | ieee80211-ampdu-phy-reception --- .../module/Ieee80211AmpduPhyReception_1.test | 204 +++++++++++++++++- tests/unit/Ieee80211AmpduProbability_1.test | 85 -------- 2 files changed, 195 insertions(+), 94 deletions(-) delete mode 100644 tests/unit/Ieee80211AmpduProbability_1.test diff --git a/tests/module/Ieee80211AmpduPhyReception_1.test b/tests/module/Ieee80211AmpduPhyReception_1.test index 96fd83e1945..34f8532a3bb 100644 --- a/tests/module/Ieee80211AmpduPhyReception_1.test +++ b/tests/module/Ieee80211AmpduPhyReception_1.test @@ -1,12 +1,14 @@ %description: Real HT20 radios preserve separate delimiter and MPDU outcomes after partial loss. -Scalar and dimensional controls use whole-signal and separate-part reception with seed 0. +Scalar and dimensional controls use whole-signal and separate-part reception with seeds 0, 1, and 2. Repeated decision and result queries must reuse probabilities and draws. Invalid headers and insufficient content must prevent member outcomes through distinct decisions. Production MAC initialization must refuse absent roles and incomplete advertised receive coverage before the MIB update. Ordinary NIST, Yans, absent-model, and non-HT controls retain their defined behavior and metadata. -%extraargs: -r 0..123 +%extraargs: -r 0..467 + +%postrun-command: python3 check-models.py %file: AmpduPhyReception.cc #include "inet/common/ProtocolTag_m.h" @@ -23,11 +25,94 @@ Ordinary NIST, Yans, absent-model, and non-HT controls retain their defined beha #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211AmpduReceptionDecision.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.h" +#include "inet/physicallayer/wireless/common/base/packetlevel/SnirBase.h" #include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" using namespace inet; using namespace inet::physicallayer; +class AmpduReferenceSnir : public SnirBase +{ + double value; + public: + explicit AmpduReferenceSnir(double value) : SnirBase(nullptr, nullptr), value(value) {} + double getMin() const override { return value; } + double getMax() const override { return 2 * value; } + double getMean() const override { return 1.5 * value; } +}; + +class AmpduModelAudit +{ + public: + virtual ~AmpduModelAudit() = default; + mutable int rangeCalls = 0; + mutable int headerCalls = 0; + mutable int preambleCalls = 0; + mutable int wholeCalls = 0; + mutable double headerError = NaN; + mutable std::vector probabilities; + std::vector outcomes; +}; + +template class AmpduSharedModel : public Base, public AmpduModelAudit +{ + protected: + void initialize(int stage) override { + Base::initialize(stage); + if (stage != INITSTAGE_PHYSICAL_LAYER || !this->par("referenceMatrix").boolValue()) + return; + auto draws = this->getRNG(0)->getNumbersDrawn(); + int checked = 0; + auto modes = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + ASSERT(!this->supportsAmpduMode(nullptr)); + for (int i = 0; i < modes->getNumModes(); i++) { + auto mode = modes->getMode(i); + bool supported = mode->getHtMcsIndex() >= 0 && mode->getHtMcsIndex() <= 31 && mode->getDataMode()->getBandwidth() == MHz(20); + ASSERT(this->supportsAmpduMode(mode) == supported); + if (!supported) + continue; + for (double value : {0.01, 0.1, 1.0, 3.0, 10.0, 100.0, 1000.0}) { + AmpduReferenceSnir snir(value); + double scalar = (this->par("snirMode").stdstringValue() == "min" ? value : 1.5 * value) * + inet::math::dB2fraction(this->par("snirOffset")); + for (int length : {4, 100, 101, 102, 4095, 65535}) { + double expected = Base::getDataSuccessRate(mode, length * 8, scalar); + double actual = Base::computeAmpduRangeSuccessRate(&snir, mode, B(length)); + ASSERT(actual == expected && actual >= 0 && actual <= 1); + checked++; + } + } + } + ASSERT(checked == 64 * 7 * 6); + ASSERT(this->getRNG(0)->getNumbersDrawn() == draws); + ASSERT(rangeCalls == 0 && headerCalls == 0 && preambleCalls == 0 && wholeCalls == 0); + } + public: + double computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const override { + double probability = Base::computePacketErrorRate(snir, part); + if (part == IRadioSignal::SIGNAL_PART_PREAMBLE) preambleCalls++; + else if (part == IRadioSignal::SIGNAL_PART_HEADER) { headerCalls++; headerError = probability; } + else wholeCalls++; + return probability; + } + double computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *mode, B length) const override { + auto draws = this->getRNG(0)->getNumbersDrawn(); + double actual = Base::computeAmpduRangeSuccessRate(snir, mode, length); + double expected = Base::getDataSuccessRate(mode, b(length).template get(), this->getScalarSnir(snir)); + ASSERT(actual == expected); + ASSERT(this->getRNG(0)->getNumbersDrawn() == draws); + probabilities.push_back(expected); + rangeCalls++; + return actual; + } +}; + +class AmpduNistProbe : public AmpduSharedModel {}; +class AmpduYansProbe : public AmpduSharedModel {}; +Define_Module(AmpduNistProbe); +Define_Module(AmpduYansProbe); + class AmpduDeterministicModel : public Ieee80211NistErrorModel { public: @@ -112,6 +197,18 @@ class AmpduProbeRadio : public Ieee80211Radio ASSERT(model->headerCalls == 0); ASSERT(model->rangeCalls == 0); } + auto audit = dynamic_cast(getSubmodule("receiver")->getSubmodule("errorModel")); + if (audit && timer->getKind() == IRadioSignal::SIGNAL_PART_HEADER) { + ASSERT(audit->preambleCalls == 1 && audit->headerCalls == 0 && audit->rangeCalls == 0 && audit->wholeCalls == 0); + auto signal = check_and_cast(timer->getControlInfo()); + auto draws = getSubmodule("receiver")->getRNG(0)->getNumbersDrawn(); + for (int repeat = 0; repeat < 3; repeat++) { + ASSERT(medium->getReceptionDecision(this, signal->getListening(), signal->getTransmission(), IRadioSignal::SIGNAL_PART_PREAMBLE)->isReceptionSuccessful()); + ASSERT(medium->isReceptionSuccessful(this, signal->getTransmission(), IRadioSignal::SIGNAL_PART_PREAMBLE)); + } + ASSERT(audit->preambleCalls == 1 && audit->headerCalls == 0 && audit->rangeCalls == 0 && audit->wholeCalls == 0); + ASSERT(draws == getSubmodule("receiver")->getRNG(0)->getNumbersDrawn()); + } } void endReception(cMessage *timer) override { auto signal = check_and_cast(timer->getControlInfo()); @@ -124,7 +221,9 @@ class AmpduProbeRadio : public Ieee80211Radio auto listening = signal->getListening(); auto whole = medium->getReceptionDecision(this, listening, transmission, IRadioSignal::SIGNAL_PART_WHOLE); auto model = dynamic_cast(getSubmodule("receiver")->getSubmodule("errorModel")); + auto audit = dynamic_cast(getSubmodule("receiver")->getSubmodule("errorModel")); int calls = model ? model->rangeCalls : 0; + int auditCalls = audit ? audit->rangeCalls + audit->headerCalls + audit->preambleCalls + audit->wholeCalls : 0; auto draws = getSubmodule("receiver")->getRNG(0)->getNumbersDrawn(); auto result = medium->getReceptionResult(this, listening, transmission); for (int repeat = 0; repeat < 3; repeat++) { @@ -138,6 +237,11 @@ class AmpduProbeRadio : public Ieee80211Radio } ASSERT(draws == getSubmodule("receiver")->getRNG(0)->getNumbersDrawn()); ASSERT(model == nullptr || calls == model->rangeCalls); + if (audit) { + ASSERT(auditCalls == audit->rangeCalls + audit->headerCalls + audit->preambleCalls + audit->wholeCalls); + auto data = check_and_cast(medium->getReceptionDecision(this, listening, transmission, IRadioSignal::SIGNAL_PART_DATA)); + audit->outcomes = data->getRanges(); + } } Ieee80211Radio::endReception(timer); } @@ -247,7 +351,8 @@ class AmpduPhyDriver : public cSimpleModule, public cListener packet->addTag()->setMode(Ieee80211ModeSet::getModeSet("g(mixed)")->getMode(Mbps(6))); for (int i = 0; scenario() != 29 && i < modes->getNumModes(); i++) { auto mode = modes->getMode(i); - if (mode->getHtMcsIndex() == 0 && mode->getDataMode()->getBandwidth() == MHz(20) && mode->isHtShortGuardInterval() == (scenario() == 15)) { + if (mode->getHtMcsIndex() == (scenario() >= 35 ? 7 : 0) && mode->getDataMode()->getBandwidth() == MHz(20) && + mode->isHtShortGuardInterval() == (scenario() == 15 || (scenario() >= 31 && (scenario() - 31) % 4 >= 2))) { packet->addTag()->setMode(mode); break; } @@ -256,6 +361,17 @@ class AmpduPhyDriver : public cSimpleModule, public cListener } else { auto packet = check_and_cast(message); + if (scenario() >= 31) { + auto indication = packet->getTag(); + retained = makeShared(*indication); + ASSERT(packet->getDataLength() == B(322)); + ASSERT(packet->hasBitError() == !indication->getHeaderSuccessful()); + auto error = packet->getTag(); + ASSERT(std::isnan(error->getPacketErrorRate()) && std::isnan(error->getBitErrorRate()) && std::isnan(error->getSymbolErrorRate())); + received++; + delete packet; + return; + } bool refused = scenario() == 10 || scenario() == 11 || scenario() == 12 || scenario() == 13 || scenario() == 14 || scenario() == 17 || scenario() == 18 || scenario() == 19 || scenario() == 30; ASSERT(packet->hasBitError() == refused); @@ -308,8 +424,36 @@ class AmpduPhyDriver : public cSimpleModule, public cListener } bool headerFailure = scenario() == 10 || scenario() == 11 || scenario() == 12 || scenario() == 13 || scenario() == 17 || scenario() == 18 || scenario() == 30; bool separate = getModuleByPath("^.node[1].radio")->par("separateReceptionParts"); - ASSERT(received == (headerFailure && separate ? 0 : 1)); auto rx = getModuleByPath("^.node[1].radio.receiver"); + if (scenario() >= 31) { + auto audit = check_and_cast(rx->getSubmodule("errorModel")); + auto reference = getRNG(1); + bool header = audit->headerError == 0 || (audit->headerError != 1 && reference->doubleRand() > audit->headerError); + ASSERT(audit->preambleCalls == 1 && audit->headerCalls == 1 && audit->wholeCalls == 0); + ASSERT(audit->rangeCalls == (header ? 7 : 0)); + ASSERT(received == (separate && !header ? 0 : 1)); + std::string bits; + for (size_t i = 0; i < audit->probabilities.size(); i++) { + double probability = audit->probabilities[i]; + bool expected = probability == 1 || (probability != 0 && reference->doubleRand() > 1 - probability); + ASSERT(audit->outcomes.at(i).successful == expected); + ASSERT(retained && retained->getRanges(i).successful == expected); + bits += expected ? '1' : '0'; + } + auto draws = rx->getRNG(0)->getNumbersDrawn(); + ASSERT(draws == reference->getNumbersDrawn()); + auto next = rx->getRNG(0)->intRand(); + ASSERT(next == reference->intRand()); + auto cache = check_and_cast(getModuleByPath("^.radioMedium"))->getCommunicationCache(); + ASSERT(cache->getNumTransmissions() == 0); + EV << "MODEL_RESULT scenario=" << scenario() << " seed=" << par("seed").intValue() + << " analog=" << getModuleByPath("^.radioMedium")->par("signalAnalogRepresentation").stdstringValue() + << " parts=" << separate << " header=" << header << " bits=" << (bits.empty() ? "none" : bits) + << " draws=" << draws << " next=" << next << "\n"; + EV << "PHY reception checks passed\n"; + return; + } + ASSERT(received == (headerFailure && separate ? 0 : 1)); if (scenario() == 30) ASSERT(rx->getRNG(0)->getNumbersDrawn() == 0); auto model = dynamic_cast(rx->getSubmodule("errorModel")); if (model) { @@ -335,8 +479,21 @@ import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Radio; import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211RadioMedium; import inet.physicallayer.wireless.common.medium.RadioMedium; import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211YansErrorModel; import inet.physicallayer.wireless.common.base.packetlevel.ErrorModelBase; +module AmpduNistProbe extends Ieee80211NistErrorModel +{ + parameters: + bool referenceMatrix = default(false); + @class(::AmpduNistProbe); +} +module AmpduYansProbe extends Ieee80211YansErrorModel +{ + parameters: + bool referenceMatrix = default(false); + @class(::AmpduYansProbe); +} module AmpduLimitedModel extends Ieee80211NistErrorModel { parameters: @@ -359,7 +516,7 @@ module AmpduProbeRadio extends Ieee80211Radio { parameters: int scenario; - receiver.errorModel.typename = default(scenario == 29 ? "AmpduNoRoleModel" : (scenario == 0 ? "Ieee80211NistErrorModel" : (scenario == 1 || scenario == 21 ? "Ieee80211YansErrorModel" : (scenario == 2 || scenario >= 17 ? "" : "AmpduDeterministicModel")))); + receiver.errorModel.typename = default(scenario >= 31 ? ((scenario - 31) % 2 == 0 ? "AmpduNistProbe" : "AmpduYansProbe") : (scenario == 29 ? "AmpduNoRoleModel" : (scenario == 0 ? "Ieee80211NistErrorModel" : (scenario == 1 || scenario == 21 ? "Ieee80211YansErrorModel" : (scenario == 2 || scenario >= 17 ? "" : "AmpduDeterministicModel"))))); @class(::AmpduProbeRadio); } module AmpduCapabilityRadio extends Ieee80211Radio @@ -376,6 +533,7 @@ simple AmpduPhyDriver parameters: @class(::AmpduPhyDriver); int scenario; + int seed; gates: input in[2]; output out[2]; @@ -417,21 +575,29 @@ network Test network = Test ned-path = .;../../../../src sim-time-limit = 20ms -seed-set = 0 +seed-set = ${seed=0,1,2} +num-rngs = 2 +seed-0-mt = ${seed} +seed-1-mt = ${seed} cmdenv-express-mode = false **.scalar-recording = true **.vector-recording = false *.node[*].radio.opMode = ${scenario} == 29 ? "g(mixed)" : "n(mixed-2.4Ghz)" *.node[*].radio.initialRadioMode = "transceiver" -*.driver.scenario = ${scenario=0..30} +*.driver.scenario = ${scenario=0..38} +*.driver.seed = ${seed} *.node[*].radio.scenario = ${scenario} *.node[*].radio.receiver.errorModel.scenario = ${scenario} +*.node[1].radio.receiver.errorModel.referenceMatrix = (${scenario} == 31 || ${scenario} == 32) && !${parts} && ${seed} == 0 +*.node[*].radio.receiver.errorModel.snirMode = ${analog} == "scalar" ? "min" : "mean" +*.node[*].radio.receiver.errorModel.cmdenv-log-level = off *.node[*].radio.separateReceptionParts = ${parts=false,true} *.node[*].radio.signalAnalogRepresentation = ${analog="scalar","dimensional"} *.radioMedium.signalAnalogRepresentation = ${analog} *.node[*].radio.sendRawBytes = ${scenario} >= 3 && ${scenario} < 22 *.node[*].radio.receiver.bandwidth = 20MHz -*.node[*].radio.receiver.snirThreshold = ${scenario} == 30 ? 100dB : 4dB +*.node[*].radio.receiver.energyDetection = ${scenario} >= 35 ? -49dBm : (${scenario} >= 31 ? -29dBm : -85dBm) +*.node[*].radio.receiver.snirThreshold = ${scenario} == 30 ? 100dB : (${scenario} >= 31 ? -10dB : 4dB) *.node[*].radio.antenna.mobilityModule = "^.^.mobility" *.node[*].mobility.initFromDisplayString = false *.node[*].mobility.initialX = 10m + parentIndex() * 1m @@ -443,7 +609,7 @@ cmdenv-express-mode = false *.node[*].mobility.constraintAreaMaxX = 100m *.node[*].mobility.constraintAreaMaxY = 100m *.node[*].mobility.constraintAreaMaxZ = 0m -*.radioMedium.backgroundNoise.power = -110dBm +*.radioMedium.backgroundNoise.power = ${scenario} >= 35 ? -50dBm : (${scenario} >= 31 ? -30dBm : -110dBm) *.probe.wlan[0].opMode = ${scenario} == 26 || ${scenario} == 27 ? "g(mixed)" : "n(mixed-2.4Ghz)" *.probe.wlan[0].radio.typename = "AmpduCapabilityRadio" *.probe.wlan[0].radio.scenario = ${scenario} @@ -476,3 +642,23 @@ $self add Mode54Mb 128 0 0 %contains: stdout PHY reception checks passed + +%file: check-models.py +from pathlib import Path +import re + +text = Path("test.out").read_text() +assert "Run statistics: total 468, successful 468" in text +rows = [dict(re.findall(r"(\w+)=([^ ]+)", line)) for line in text.splitlines() if line.startswith("MODEL_RESULT ")] +assert len(rows) == 96, len(rows) +groups = {} +for row in rows: + key = tuple(row[name] for name in ("scenario", "seed", "analog")) + outcome = tuple(row[name] for name in ("header", "bits", "draws", "next")) + groups.setdefault(key, []).append(outcome) +assert len(groups) == 48 +assert all(len(values) == 2 and values[0] == values[1] for values in groups.values()) +for model in (0, 1): + selected = [row for row in rows if (int(row["scenario"]) - 31) % 2 == model] + assert any("0" in row["bits"] and "1" in row["bits"] for row in selected), selected +print("NIST/Yans references, seeded outcomes, and signal-part equivalence passed.") diff --git a/tests/unit/Ieee80211AmpduProbability_1.test b/tests/unit/Ieee80211AmpduProbability_1.test deleted file mode 100644 index b9b4b02f233..00000000000 --- a/tests/unit/Ieee80211AmpduProbability_1.test +++ /dev/null @@ -1,85 +0,0 @@ -%description: -Check pure NIST and Yans HT20 range probabilities before receiver activation. -The matrix uses the existing DATA calculation as an independent result. -Mode support, minimum and mean SNIR, and random draw counts remain explicit. - -%includes: -#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" -#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211YansErrorModel.h" -#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" -#include "inet/physicallayer/wireless/common/base/packetlevel/SnirBase.h" - -using namespace inet; -using namespace inet::physicallayer; - -class ProbabilitySnir : public SnirBase { - double value; - public: - ProbabilitySnir(double value) : SnirBase(nullptr, nullptr), value(value) {} - double getMin() const override { return value; } - double getMax() const override { return 2 * value; } - double getMean() const override { return 1.5 * value; } -}; - -template class ProbabilityProbe : public Base { - public: - void check() { - Enter_Method("check"); - auto draws = this->getRNG(0)->getNumbersDrawn(); - auto catalog = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); - int checked = 0; - ASSERT(!this->supportsAmpduMode(nullptr)); - for (bool mean : {false, true}) { - this->snirMode = mean ? Base::SnirMode::SM_MEAN : Base::SnirMode::SM_MIN; - for (int i = 0; i < catalog->getNumModes(); i++) { - auto mode = catalog->getMode(i); - bool supported = mode->getHtMcsIndex() >= 0 && mode->getHtMcsIndex() <= 31 && mode->getDataMode()->getBandwidth() == MHz(20); - ASSERT(this->supportsAmpduMode(mode) == supported); - if (!supported) continue; - for (double value : {0.01, 0.1, 1.0, 3.0, 10.0, 100.0, 1000.0}) { - ProbabilitySnir snir(value); - for (int length : {4, 100, 101, 102, 4095, 65535}) { - double expected = Base::getDataSuccessRate(mode, length * 8, mean ? 1.5 * value : value); - double actual = Base::computeAmpduRangeSuccessRate(&snir, mode, B(length)); - ASSERT(actual == expected && actual >= 0 && actual <= 1); - checked++; - } - } - } - } - ASSERT(checked == 2 * 64 * 7 * 6); - ASSERT(this->getRNG(0)->getNumbersDrawn() == draws); - } -}; -class PureNist : public ProbabilityProbe {}; -class PureYans : public ProbabilityProbe {}; -Define_Module(PureNist); -Define_Module(PureYans); - -%file: TestNetwork.ned -import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; -import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211YansErrorModel; -module PureNist extends Ieee80211NistErrorModel { parameters: @class(::PureNist); } -module PureYans extends Ieee80211YansErrorModel { parameters: @class(::PureYans); } -network TestNetwork { - submodules: - test: Test; - nist: PureNist; - yans: PureYans; -} - -%inifile: omnetpp.ini -[General] -network = TestNetwork -ned-path = .;../../../../src;../../lib -seed-set = 0 -record-vector-results = false -record-scalar-results = false - -%activity: -check_and_cast(getModuleByPath("nist"))->check(); -check_and_cast(getModuleByPath("yans"))->check(); -EV << "Pure probability checks passed.\n"; - -%contains: stdout -Pure probability checks passed. From 56b75c959af104b5db931bef022bdfe5578eead9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sat, 17 Oct 2026 22:55:06 +0200 Subject: [PATCH 24/41] tests: add: verify ordinary PHY compatibility with the parent Before this commit, ordinary reception controls lack a fixture that compiles unchanged on the pinned parent and the feature branch. The earlier receiver fixture cannot provide that independent compatibility comparison. After this commit, one fixture records ordinary reception with identical inputs on both revisions. NIST, Yans, absent-model, and non-HT custom controls cover three noise levels and seeds 0, 1, and 2. The campaign uses scalar and dimensional radios with whole and separate signal parts. Each record includes outcomes, duration, metadata, draw counts, and subsequent random values. For example, a failed ordinary reception must retain the same metadata and next random value as its parent control. The migration guide states the independent-range abstraction and its limits. Plan records close the declared PHY verification stages. MAC aggregate receipt and implicit Block Ack remain pending. BerTable retains its documented parent crash, which supplies no successful reception evidence. The additional fixture and records change no production contract or stored expectation. Execution results belong in the PR description and execution record. Plan: plan/pending/ieee80211-ampdu-phy-reception.md Change: tests | behavior.add | - | ieee80211-ampdu-phy-reception --- doc/src/migration-guide/index.rst | 2 + ...ee80211-ampdu-implicit-blockack-summary.md | 10 +- .../ieee80211-ampdu-implicit-blockack.md | 2 +- plan/pending/ieee80211-ampdu-phy-execution.md | 59 ++++- plan/pending/ieee80211-ampdu-phy-reception.md | 5 +- .../Ieee80211AmpduPhyCompatibility_1.test | 226 ++++++++++++++++++ 6 files changed, 295 insertions(+), 9 deletions(-) create mode 100644 tests/module/Ieee80211AmpduPhyCompatibility_1.test diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 9138bcaeca0..1bc0127f048 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -39,6 +39,8 @@ The medium cache retains each aggregate decision. PREAMBLE calculates no HEADER With a present model, aggregate ``ErrorRateInd`` fields contain ``NaN`` for unknown probabilities. The receiver does not calculate the former whole-PSDU estimate for these fields. Member outcomes are separate from probability estimates. Without a model, the receiver preserves the common base's tag presence and values. Ordinary MPDUs retain their current metadata. Custom readers of aggregate error-rate fields must accept unknown values. +NIST and Yans calculate each range probability from its byte length and the configured scalar SNIR reduction. The receive profile includes HT20 long GI and short GI. Each range uses an independent draw when its success probability lies strictly between zero and one. This model does not represent correlated FEC errors or interference changes within one member. Alignment padding contributes duration but receives no separate outcome. The model checks establish no new error-accuracy or goodput claim. + Radio medium timing queries -------------------------- diff --git a/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md b/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md index 55bd58dea82..39d36d79585 100644 --- a/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md +++ b/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md @@ -8,6 +8,8 @@ This summary describes revision 12 of the [feature plan](ieee80211-ampdu-implici The PHY plan supplies aggregate reception before the MAC feature uses it. Its first gate proves deterministic member outcomes and includes the shared NIST/Yans implementation. It also preserves default HT operation and reception without an error model. Its second gate extends the NIST/Yans and compatibility evidence. The MAC feature can reach deterministic integration between those gates. +Execution status, 2026-10-17: PHY P0 through P4 and gates D1 and D2 are complete under the user's approved merge exception. The [execution record](ieee80211-ampdu-phy-execution.md) states the checks and limits. P3 verifies NIST/Yans range probabilities and seeded outcomes. P4 compares 576 ordinary reception records with the pinned parent. All records match exactly. MAC aggregate receipt and implicit Block Ack remain pending. + Implementation waits for merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). Read-only source checks can occur now. Both plans require a refreshed merged base before source implementation. This is the agreed delivery policy for one shared S5 baseline. ## What changes after S5 @@ -333,7 +335,7 @@ flowchart TD D2 --> A7 ``` -The two plans retain nine proposed fixtures across unit, module, and protocol tests. The PHY plan owns two; the feature plan owns seven. They must check wire bytes, capability propagation, source ownership, partial PHY reception, reorder release, complete exchanges, recovery, timing, and production negotiation. Current Basic, explicit Compressed, lifetime, reset, and disabled-feature checks provide regression coverage. Compatible configurations with disabled transmit aggregation must preserve current frame sequences and random draws. [Verification methods](ieee80211-ampdu-implicit-blockack.md#7-verification-methods-and-expected-results). +The two plans now contain ten fixtures across unit, module, and protocol tests. The PHY plan owns three implemented fixtures; the feature plan owns seven proposed fixtures. P4 adds the parent-compatible ordinary reception fixture. The complete feature still needs source ownership, reorder release, exchanges, recovery, timing, and production negotiation checks. Current Basic, explicit Compressed, lifetime, reset, and disabled-feature checks provide regression coverage. Compatible configurations with disabled transmit aggregation must preserve current frame sequences and random draws. [Verification methods](ieee80211-ampdu-implicit-blockack.md#7-verification-methods-and-expected-results). Direct exchange assertions must prove one DATA PPDU, one response after SIFS, correct receipt bits, selective retry, and exactly-once upper delivery. Physical reception tests must produce the partial results through the real receiver. An injected bitmap cannot prove that PHY integration. Fingerprints can detect a changed trajectory; they cannot replace these assertions. @@ -343,9 +345,11 @@ The corrected checks also cover production member FCS before and after selective RTS checks use complete PSDU lengths below, equal to, and above the configured threshold. Spacing and batch reduction must cause renewed protection selection. Recovery checks cover mixed batches, numbered unsent members, internal collision survivors, and terminal collision disposal. Repeated aggregate RTS failure reaches the contention retry boundary without member retry increments, member disposal, DATA outcomes, or a pending probe. Probe checks derive ownership from the agreement's TID after member expiry. These cases remain proposed verification. -PHY checks also prove HT-SIG golden bytes and independent decode, PREAMBLE query order, and the two failed-header delivery paths. Invalid CRC and unsupported fields cause HEADER failure with successful header probabilities and without an error model. A separate malformed-input case retains HEADER success but refuses insufficient modeled PSDU content at DATA. Metadata checks verify the aggregate probability fields and the applicable receive tags without another probability call or random draw. The same proposed fixtures own these cases; the inventory remains nine. None of these checks establishes physical carrier-loss behavior. +PHY checks also prove HT-SIG golden bytes and independent decode, PREAMBLE query order, and the two failed-header delivery paths. Invalid CRC and unsupported fields cause HEADER failure with successful header probabilities and without an error model. A separate malformed-input case retains HEADER success but refuses insufficient modeled PSDU content at DATA. Metadata checks verify the aggregate probability fields and the applicable receive tags without another probability call or random draw. The PHY fixtures own these cases. None of these checks establishes physical carrier-loss behavior. + +The proposed MAC checks reject aggregate transmit opt-in with AARF. Proposed response checks separate observable mismatches and retired callbacks from indistinguishable valid frames inside an active interval. MAC FCS acceptance remains pending. -Configuration checks reject aggregate transmit opt-in with AARF. They also reject absent aggregate roles and incomplete advertised receive-mode coverage before capability advertisement. D1 controls preserve ordinary HT reception with NIST, Yans, and an absent error model. Aggregate checks without an error model retain PHY checks, delimiter validation, and FCS rejection without new error draws. Response checks separate observable mismatches and retired callbacks from indistinguishable valid frames inside an active interval. These are proposed checks; no runtime evidence establishes their results yet. +Completed PHY checks reject absent aggregate roles and incomplete advertised receive-mode coverage before the MIB update. The PHY controls preserve ordinary HT reception with NIST, Yans, and an absent error model. Aggregate checks without an error model retain common PHY checks without new error draws. The PHY execution record states the direct evidence and its limits. A fixture peer supplies a valid HT20 short-GI aggregate through the real radio. D1 and A2 verify copied PHY indications without MAC receipt or response requirements. After A4 supplies member validation, A5 verifies MAC receipt and one Compressed response after SIFS. A6 verifies production capability negotiation with the local aggregate transmit policy at long GI. This receive case does not establish short-GI selection from production transmit queues. [Receive acceptance cases](ieee80211-ampdu-implicit-blockack.md#proposed-direct-checks). diff --git a/plan/pending/ieee80211-ampdu-implicit-blockack.md b/plan/pending/ieee80211-ampdu-implicit-blockack.md index 99e45df8099..2a95af3b58f 100644 --- a/plan/pending/ieee80211-ampdu-implicit-blockack.md +++ b/plan/pending/ieee80211-ampdu-implicit-blockack.md @@ -424,7 +424,7 @@ A1 and A3 can supply reviewed preparation changes before the complete feature ex ### Proposed direct checks -The seven fixtures below belong to this feature plan. The [PHY plan](ieee80211-ampdu-phy-reception.md#7-verification-methods-and-expected-results) owns `Ieee80211AmpduWire_1.test` and `Ieee80211AmpduPhyReception_1.test`. Together, the plans retain the original nine proposed fixtures. None exists at this revision. +The seven fixtures below belong to this feature plan and remain proposed. The [PHY plan](ieee80211-ampdu-phy-reception.md#7-verification-methods-and-expected-results) owns three implemented fixtures: `Ieee80211AmpduWire_1.test`, `Ieee80211AmpduPhyReception_1.test`, and `Ieee80211AmpduPhyCompatibility_1.test`. P4 adds the third fixture for parent-compatible ordinary reception comparisons. The combined inventory is ten. The [PHY execution record](ieee80211-ampdu-phy-execution.md) states the completed PHY evidence and its limits. That evidence does not establish MAC feature completion. Fixed causal cases use seed 0. Injected agreements or deterministic error models establish only the stated boundary. Infrastructure cases separately prove production negotiation. [Appendix B](#appendix-b-verification-commands-and-campaigns) contains commands, campaign bounds, and evidence requirements. diff --git a/plan/pending/ieee80211-ampdu-phy-execution.md b/plan/pending/ieee80211-ampdu-phy-execution.md index 7dd7de6c8ab..7c4deb650a2 100644 --- a/plan/pending/ieee80211-ampdu-phy-execution.md +++ b/plan/pending/ieee80211-ampdu-phy-execution.md @@ -1,10 +1,10 @@ -# PHY P0, P1, and P2 execution record +# PHY P0 through P4 execution record The user authorizes P0, P1, and P2 on `4fa5cc0de15ee57388bcb3f20e866cab5972a670` before PRs #1343, #1344, and #1345 merge. This exception replaces the merge prerequisite for this execution only. The user also authorizes commits and a branch push. No baseline change forms part of this task. The active checkout is `/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack`, on branch `work/ieee80211-ampdu-implicit-blockack`. The implementation uses the approved base. The commit series separates the plans, P1 representation, and P2 reception. -P0, P1, and P2 are complete on 2026-10-17. The implementation supplies HT-SIG bytes, validation, bounded ranges, and cached partial-reception outcomes. Debug and release compilation pass. The direct fixtures and selected regression controls pass. P3, P4, and MAC acceptance remain pending. +P0 through P4 are complete on 2026-10-17. The implementation supplies HT-SIG bytes, validation, bounded ranges, and cached partial-reception outcomes. P3 verifies NIST/Yans probabilities and seeded outcomes. P4 closes ordinary reception comparisons with the pinned parent. D1 and D2 are complete for the declared PHY profile. MAC acceptance and implicit Block Ack remain pending. ## Implementation contract @@ -84,7 +84,7 @@ The runner's dry-run path fails with `ValueError('list.index(x): x not in list') The local corpus identifies `ieee80211-2024` as IEEE Std 802.11-2024. Table 19-11 spans physical PDF pages 3431–3432. Clause 19.3.9.4.4 is on page 3434. Its Figure 19-8 reference resolves. The corpus cannot resolve Clause 9.7.1, so PDF text on pages 1841–1843 supplies delimiter evidence. PDF text on pages 3486–3487 confirms invalid-CRC and unsupported-mode behavior. These clauses are normative. The corpus linter reports unrelated heading ambiguities and unresolved references; the selected CRC node is unambiguous. Local artifacts `/tmp/ampdu-htsig-clause.json`, `/tmp/ampdu-htsig-table.json`, `/tmp/ampdu-htsig-refs.json`, and `/tmp/ampdu-standards-lint.json` retain the retrieved evidence. -The implementation does not enable MAC receipt, MPDU release, or an implicit Block Ack response. Feature A2 and A4 retain those acceptance duties. A failed MPDU range must become that member's bit-error flag before the normal Rx FCS check. The aggregate probability fields are not member estimates. P3 and P4 remain pending for broader NIST/Yans and compatibility evidence. The commit and push authorization does not permit baseline changes. +The implementation does not enable MAC receipt, MPDU release, or an implicit Block Ack response. Feature A2 and A4 retain those acceptance duties. A failed MPDU range must become that member's bit-error flag before the normal Rx FCS check. The aggregate probability fields are not member estimates. P3 and P4 supply the additional evidence below. The commit and push authorization does not permit baseline changes. Independent range draws at the current scalar SNIR are a packet-level model choice. This abstraction does not model correlated FEC errors or interference changes within one member. Alignment padding contributes duration but has no separate outcome. These checks establish representation, integration, and selected regression behavior. They establish no new PHY accuracy result. Release-mode behavioral tests and feature-isolation builds remain unverified. @@ -99,3 +99,56 @@ The final debug and release builds pass in `/tmp/ampdu-push-debug.log` and `/tmp The repeated fingerprint filter passes all five controls without expectation changes. Its log is `/tmp/ampdu-push-fingerprints.log`. The full series since `origin/master` also passes its mechanical checks, with notes. The first publication attempt did not complete. The connector rejected the first tree request because tool approval was required and the approval policy was `never`. No remote branch update occurred. The original checkout retained its previous HEAD and local files. The user requested a retry after the permissions changed. Git metadata writes and shell access to GitHub now succeed. All 28 prepared files match the active checkout before commit transfer. The active branch now contains the three prepared commits. The separate `AGENTS.md` edit remains outside those commits. Only this publication record changes after the transfer; the tested source and test files remain unchanged. + +## P3 and P4 execution + +The user requested P3 and P4 after publication of P1 and P2. The active HEAD is `0221daf515e1bdc7dcaa79b12b6547c11a977d75`. The comparison parent remains `4fa5cc0de15ee57388bcb3f20e866cab5972a670`. The active checkout and branch remain those recorded above. This execution changes tests, migration text, and plan records. It changes no production source, interface, ownership rule, model assumption, or stored fingerprint expectation. The separate `AGENTS.md` edit remains unchanged. + +The additional module fixture separates ordinary reception from the new aggregate interfaces. The same fixture source compiles on both revisions. This necessary test separation adds one PHY fixture, so the combined PHY and MAC inventory increases from nine to ten. The MAC feature's seven fixtures remain proposed. + +### P3: NIST/Yans probabilities and seeded outcomes + +The extended `Ieee80211AmpduPhyReception_1.test` executes 468 runs. Its original 31 scenarios now run with seeds 0, 1, and 2. Eight additional scenarios cover NIST and Yans, MCS 0 and 7, and long GI and short GI. Every scenario uses scalar and dimensional reception with whole and separate signal parts. The bounded campaign adds no distributional or error-accuracy claim. + +Test subclasses call the unchanged NIST and Yans implementations through the production receiver. Each range probability must equal the existing per-length DATA calculation at the configured scalar SNIR. The subclasses observe calls; they do not substitute probabilities. A separate reference matrix checks all 64 HT20 modes, including MCS 0 through 31 with both guard intervals. Each mode uses seven SNIR inputs and lengths 4, 100, 101, 102, 4095, and 65535 bytes. The minimum and mean reductions use distinct synthetic SNIR values. The four matrix instances execute 10752 exact comparisons without random draws. This matrix establishes calculation coverage; actual aggregate radio runs use MCS 0 and 7. + +For example, a three-member aggregate includes a spacing delimiter and three alignment bytes. Seven scored ranges use the real model probabilities. An independent generator with the same seed replays the HEADER draw and each eligible range draw. The fixture compares every retained outcome, draw count, and subsequent random value with that reference. Partial member failure preserves the envelope and copied outcomes. Alignment padding causes no eighth range or extra draw. + +At the PREAMBLE boundary, repeated cached and direct success queries cause no HEADER or DATA call or draw. At the result boundary, repeated queries reuse all retained outcomes and metadata. The fixture also checks indication values after cache cleanup. All 96 real-model records match between whole and separate signal parts. A repeated execution produces the same 96 records. The campaign contains 76 all-good records and 20 partial-failure records. Both models produce partial failure in this campaign. + +### P4: Ordinary reception and compatibility limits + +`Ieee80211AmpduPhyCompatibility_1.test` executes 576 runs on each revision. The inputs cover NIST, Yans, an absent model, and a non-HT custom model without the aggregate role. The HT controls select MCS 0 or 7 with either guard interval. The custom model selects ERP OFDM at 6 Mbit/s. Each input uses scalar or dimensional reception, whole or separate signal parts, and seeds 0, 1, and 2. The non-HT controls repeat the unused MCS and GI labels but always select that same ERP mode. + +Three noise levels distinguish all-good controls, fractional probabilities, and failures. The low-noise power is -110 dBm. The two higher powers are -30 and -28 dBm for MCS 0, or -50 and -43 dBm for MCS 7. The receiver's energy threshold exceeds the configured noise power. This condition avoids an initialization failure that would supply no reception evidence. The SNIR threshold remains -10 dB for these bounded controls. + +All 576 records match the parent exactly. The comparison includes delivery count, packet error, duration, PER, BER, SER, received power, minimum SNIR, reception endpoints, draw count, and subsequent random value. Assertions also check mode, channel presence, and transmission identity availability. The records include 498 successful receptions, 66 delivered failure containers, and 12 attempts without a delivered container. NIST supplies the twelve separate-part header aborts. The absent and non-HT custom models add no error draws. + +The ordinary record stream has SHA-256 `f62dbea0e379e33e13df3246a2213d53ba6e52cc4a46852510f7f61bd5a01869`. `/tmp/ampdu-p4-comparison.json` records the fixture hash, revisions, counts, and equality result. The parent executable resolves `libINET_dbg.so` and `libtest_dbg.so` from the parent checkout. The active executable resolves the corresponding active libraries. + +The extended reception fixture retains the unsupported-model checks from P2. The production MAC handoff refuses a missing role and incomplete short-GI coverage before its MIB update. It accepts unsupported modes outside the effective NSS limit. The fixture retains absent-model, runtime mode-set, non-HT custom, and BerTable initialization controls. The migration guide now states independent range draws, scalar SNIR reduction, guard intervals, padding treatment, and accuracy limits. + +The separate BerTable reproduction still exits with SIGSEGV, status 139, on both revisions. Both logs identify `bitModel->getDataLength()` at line 62 with a null bit model. They are `/tmp/ampdu-p4-bertable-parent.log` and `/tmp/ampdu-p4-bertable-feature.log`. This comparison confirms the documented prior limitation. It is not a passing reception result. P4 does not repair BerTable or claim support for that configuration. + +### Commands and evidence + +All active commands run from `/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack` unless a command names another directory. Debug compilation precedes the tests. Release compilation also passes. The final source tree equals the published P2 source tree. The debug library has SHA-256 `3df8db6dba916c23bada8ea83583b41e9a425c81fc5a3bf90c83f7b75566044d`. The parent debug library has SHA-256 `877fa150f8cc41a21c765277aeb0ec478f99a6a9092a60462110496a68c99841`. + +```sh +MAKEFLAGS=--jobserver-style=pipe make MODE=debug -j8 +MAKEFLAGS=--jobserver-style=pipe make MODE=release -j8 +MAKEFLAGS=--jobserver-style=pipe MPLCONFIGDIR=/tmp/ampdu-matplotlib inet_run_unit_tests -m debug -f 'Ieee80211(AmpduWire|MpduSubframeHeaderSerializer|MpduDelimiterWire|HtModeSet|HtModeCache|VhtHtCapabilities)_1\.test$' --no-concurrent +MAKEFLAGS=--jobserver-style=pipe MPLCONFIGDIR=/tmp/ampdu-matplotlib inet_run_module_tests -m debug -f 'Ieee80211(AmpduPhyReception|AmpduPhyCompatibility|VhtHtSupport|HtAssociation|HtAntennaRateControl)_1\.test$' --no-concurrent +``` + +The build logs are `/tmp/ampdu-p34-debug.log` and `/tmp/ampdu-p34-release.log`. Six unit fixtures and five module fixtures pass. The unit log is `/tmp/ampdu-p34-units.log`. The final module log is `/tmp/ampdu-p34-final-modules.log`. The direct compatibility logs are `/tmp/ampdu-p4-feature.log` and `/tmp/ampdu-p4-parent.log`. + +The parent command uses the identical compatibility fixture at `/tmp/inet-ampdu-parent-4fa5cc0de1`, after `source setenv -q`, with the explicit filter `Ieee80211AmpduPhyCompatibility_1\.test$`. Its debug build remains the clean P0 parent build. The receiver's first model records are `/tmp/ampdu-p3-first-model-results.txt`. Later records match them exactly. + +The module fixture writes its detailed output under `tests/module/work//test.out` in each checkout. To reproduce the comparison, select the lines that start with `CONTROL ` from each compatibility output. Require exactly 576 lines in each file. Compare the lines byte for byte in their original order. The fixture's post-run checker separately requires all 576 successful simulation runs and unique input combinations. The reception fixture's checker requires all 468 successful simulation runs and equality across signal-part modes. + +Scoped architecture checks pass for both WLAN subtrees. Their logs are `/tmp/ampdu-p34-architecture-phy.log` and `/tmp/ampdu-p34-architecture-mac.log`. The source-seal check reports no changed production files. `git diff --check` passes. The earlier filtered fingerprint results remain evidence for the unchanged production source. This test-only extension requires no new fingerprint baseline or broad fingerprint campaign. + +Early fixture revisions failed on invalid noise thresholds, typename expression syntax, and an incorrect ERP header-length assumption. A post-run check also exposed insufficient ordinary failure coverage. The final fixture corrects those setup and coverage defects. The earlier mixed batches retain their actual failure status. They do not replace the final clean runs. + +The self-audit checks actual model dispatch, byte-to-bit conversion, mode coverage, SNIR reduction, probability bounds, cache order, sample reuse, metadata, and normal cleanup. It also checks identical parent inputs and library selection. It finds no unresolved defect in the requested scope. This result is a self-audit. Release behavioral tests, feature-isolation builds, correlated FEC behavior, and MAC acceptance remain outside this evidence. P4 closes D2 for the declared PHY profile, not the complete MAC feature. diff --git a/plan/pending/ieee80211-ampdu-phy-reception.md b/plan/pending/ieee80211-ampdu-phy-reception.md index 97fe712cac9..5851cf79ce9 100644 --- a/plan/pending/ieee80211-ampdu-phy-reception.md +++ b/plan/pending/ieee80211-ampdu-phy-reception.md @@ -8,7 +8,7 @@ Plan revision: 11, 2026-10-17. The user's `proceed, including the optional simpl The project plan procedure remains a draft. -Execution status, 2026-10-17: P0, P1, and P2 are complete under the user's approved exception to the merge prerequisite. The [execution record](ieee80211-ampdu-phy-execution.md) identifies the active checkout, implementation, checks, and limits. The proposal below retains its pre-implementation design and evidence status. P3 and P4 remain pending. +Execution status, 2026-10-17: P0 through P4 are complete under the user's approved exception to the merge prerequisite. D1 and D2 are complete for the declared PHY profile. The [execution record](ieee80211-ampdu-phy-execution.md) identifies the active checkout, checks, and limits. P4 adds one parent-compatible module fixture for exact ordinary reception comparisons. This test addition changes no production contract. The proposal below retains its original design context. MAC acceptance and the feature stages remain pending. ## 1. Problem and intended behavior @@ -289,12 +289,13 @@ D1 includes the shared NIST/Yans implementation and basic compatibility checks. ## 7. Verification methods and expected results -Both fixture names are proposed. Neither exists at this revision. The feature plan owns seven additional fixtures; the combined inventory remains nine. +The PHY plan now owns three fixtures. P1 and P2 supplied the wire and partial-reception fixtures. P4 adds `Ieee80211AmpduPhyCompatibility_1.test` because its ordinary controls must compile on the parent without the new PHY interfaces. The feature plan owns seven proposed fixtures, so the combined inventory is ten. The execution record separates current PHY evidence from proposed MAC evidence. | Proposed fixture | Boundary and required observations | | --- | --- | | `Ieee80211AmpduWire_1.test`, unit/serializer. | HT-SIG golden bytes and independent decode preserve length, Aggregation, CRC, and the current 48-bit header length. Cover standalone, singleton, and multiple-member cases. Validator cases reject invalid CRC and unsupported field combinations. A separate bounds case refuses content shorter than valid HT Length. Real delimiter/member layouts prove CRC/signature, lengths 0/4095/4096, every alignment remainder, no final HT padding, truncation, and bounded resynchronization. | | `Ieee80211AmpduPhyReception_1.test`, module. | Actual reception proves all-good, first/middle/last member loss, regular/spacing delimiter failure, all-member failure, per-part header failure, and query consistency. It distinguishes HT-SIG rejection from structural DATA refusal before range draws. It also verifies copied indication lifetime, metadata with reachable consumers, and HT20 short-GI indications without MAC response acceptance. D1 checks NIST/Yans initialization, ordinary reception, absent-model operation, BerTable controls, and exact coverage at the MAC handoff. Absent roles and incomplete advertised coverage fail; unsupported unadvertised modes do not cause failure. D2 extends NIST/Yans aggregate evidence. | +| `Ieee80211AmpduPhyCompatibility_1.test`, module. | The same source runs on the pinned parent and feature branch. NIST, Yans, absent-model, and non-HT custom controls expose exact outcomes, duration, metadata, draw counts, and subsequent random values. Three noise levels and seeds 0, 1, and 2 cover scalar and dimensional reception with whole and separate signal parts. | Use deterministic probabilities and seed 0 for the causal cases. Cover whole-signal and separate-part reception with scalar and dimensional models. Verify indication values after the producer's source objects leave their normal lifetime. diff --git a/tests/module/Ieee80211AmpduPhyCompatibility_1.test b/tests/module/Ieee80211AmpduPhyCompatibility_1.test new file mode 100644 index 00000000000..c739c7944c1 --- /dev/null +++ b/tests/module/Ieee80211AmpduPhyCompatibility_1.test @@ -0,0 +1,226 @@ +%description: +Ordinary MPDU controls use the same source on the pinned parent and feature branch. +NIST, Yans, absent-model, and non-HT custom controls cover three noise levels and seeds 0, 1, and 2. +Scalar and dimensional radios cover whole-signal and separate-part reception. +CONTROL records expose outcomes, duration, metadata, draw counts, and the next random value for exact comparison. + +%extraargs: -r 0..575 + +%postrun-command: python3 check-controls.py + +%file: Compatibility.cc +#include +#include "inet/common/ProtocolTag_m.h" +#include "inet/common/Simsignals.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/physicallayer/wireless/common/base/packetlevel/ErrorModelBase.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" + +using namespace inet; +using namespace inet::physicallayer; + +class CompatibilityNoRole : public ErrorModelBase +{ + public: + double computePacketErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeBitErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeSymbolErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } +}; +Define_Module(CompatibilityNoRole); + +class CompatibilityDriver : public cSimpleModule, public cListener +{ + int received = 0; + bool error = false; + simtime_t duration; + std::string metadata = "absent"; + protected: + void initialize() override { + getModuleByPath("^.node[0].radio")->subscribe(transmissionStartedSignal, this); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("send")); + } + void receiveSignal(cComponent *, simsignal_t, cObject *object, cObject *) override { + auto transmission = check_and_cast(object); + auto header = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(transmission->getPacket()); + ASSERT(header->getChunkLength() == transmission->getMode()->getHeaderMode()->getLength()); + duration = transmission->getEndTime() - transmission->getStartTime(); + } + void handleMessage(cMessage *message) override { + if (message->isSelfMessage()) { + delete message; + auto packet = new Packet("ordinary", makeShared(B(100))); + packet->addTag()->setProtocol(&Protocol::ieee80211Mac); + auto modes = Ieee80211ModeSet::getModeSet(par("model").intValue() == 3 ? "g(mixed)" : "n(mixed-2.4Ghz)"); + const IIeee80211Mode *selected = nullptr; + if (par("model").intValue() == 3) + selected = modes->getMode(Mbps(6)); + else { + for (int i = 0; i < modes->getNumModes(); i++) { + auto mode = modes->getMode(i); + if (mode->getHtMcsIndex() == par("mcs").intValue() && mode->getDataMode()->getBandwidth() == MHz(20) && + mode->isHtShortGuardInterval() == par("shortGi").boolValue()) + selected = mode; + } + } + ASSERT(selected); + packet->addTag()->setMode(selected); + send(packet, "out", 0); + return; + } + auto packet = check_and_cast(message); + ASSERT(packet->getDataLength() == B(100)); + auto mode = packet->getTag()->getMode(); + ASSERT(mode->getHtMcsIndex() == (par("model").intValue() == 3 ? -1 : par("mcs").intValue())); + ASSERT(packet->getTag()->getChannel() != nullptr); + auto time = packet->getTag(); + ASSERT(time->getTransmissionId() >= 0); + ASSERT(time->getEndTime() - time->getStartTime() == duration); + std::ostringstream output; + output << std::setprecision(17); + auto rate = packet->findTag(); + ASSERT((rate != nullptr) == (par("model").intValue() != 2)); + if (rate) + output << "per:" << rate->getPacketErrorRate() << ",ber:" << rate->getBitErrorRate() << ",ser:" << rate->getSymbolErrorRate(); + else + output << "absent"; + output << ",power:" << packet->getTag()->getPower().get() + << ",snir:" << packet->getTag()->getMinimumSnir() + << ",start:" << time->getStartTime().raw() << ",end:" << time->getEndTime().raw(); + metadata = output.str(); + error = packet->hasBitError(); + received++; + delete packet; + } + using cListener::finish; + void finish() override { + ASSERT(received <= 1); + if (par("noise").intValue() == 0 || par("model").intValue() >= 2) + ASSERT(received == 1 && !error); + auto rng = getModuleByPath("^.node[1].radio.receiver")->getRNG(0); + auto draws = rng->getNumbersDrawn(); + if (par("model").intValue() >= 2) ASSERT(draws == 0); + EV << "CONTROL model=" << par("model").intValue() << " mcs=" << par("mcs").intValue() + << " gi=" << par("shortGi").boolValue() << " noise=" << par("noise").intValue() + << " seed=" << par("seed").intValue() << " parts=" << par("parts").boolValue() + << " analog=" << par("analog").stdstringValue() << " received=" << received << " error=" << error + << " duration=" << duration.raw() << " metadata=" << metadata << " draws=" << draws << " next=" << rng->intRand() << "\n"; + } +}; +Define_Module(CompatibilityDriver); + +%file: test.ned +import inet.mobility.static.StationaryMobility; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Radio; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211RadioMedium; +import inet.physicallayer.wireless.common.base.packetlevel.ErrorModelBase; + +module CompatibilityNoRole extends ErrorModelBase { parameters: @class(::CompatibilityNoRole); } +module CompatibilityRadio extends Ieee80211Radio +{ + parameters: + int model; + receiver.errorModel.typename = default(model == 0 ? "Ieee80211NistErrorModel" : (model == 1 ? "Ieee80211YansErrorModel" : (model == 2 ? "" : "CompatibilityNoRole"))); +} +simple CompatibilityDriver +{ + parameters: + @class(::CompatibilityDriver); + int model; + int mcs; + bool shortGi; + int noise; + int seed; + bool parts; + string analog; + gates: + input in[2]; + output out[2]; +} +module CompatibilityNode +{ + parameters: + @networkNode; + gates: + input in; + output out; + input radioIn @directIn; + submodules: + mobility: StationaryMobility; + radio: CompatibilityRadio; + connections: + in --> radio.upperLayerIn; + radio.upperLayerOut --> out; + radioIn --> radio.radioIn; +} +network Test +{ + submodules: + radioMedium: Ieee80211RadioMedium; + driver: CompatibilityDriver; + node[2]: CompatibilityNode; + connections: + for i=0..1 { + driver.out[i] --> node[i].in; + node[i].out --> driver.in[i]; + } +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src +sim-time-limit = 20ms +seed-set = ${seed=0,1,2} +seed-0-mt = ${seed} +cmdenv-express-mode = false +**.vector-recording = false +**.scalar-recording = false +*.driver.model = ${model=0,1,2,3} +*.driver.mcs = ${mcs=0,7} +*.driver.shortGi = ${gi=false,true} +*.driver.noise = ${noise=0,1,2} +*.driver.seed = ${seed} +*.driver.parts = ${parts=false,true} +*.driver.analog = ${analog="scalar","dimensional"} +*.node[*].radio.opMode = ${model} == 3 ? "g(mixed)" : "n(mixed-2.4Ghz)" +*.node[*].radio.initialRadioMode = "transceiver" +*.node[*].radio.separateReceptionParts = ${parts} +*.node[*].radio.signalAnalogRepresentation = ${analog} +*.radioMedium.signalAnalogRepresentation = ${analog} +*.node[*].radio.model = ${model} +*.node[*].radio.receiver.bandwidth = 20MHz +*.node[*].radio.receiver.energyDetection = ${noise} == 0 ? -85dBm : (${noise} == 1 ? (${mcs} == 0 ? -29dBm : -49dBm) : (${mcs} == 0 ? -27.9dBm : -42.9dBm)) +*.node[*].radio.receiver.snirThreshold = -10dB +*.node[*].radio.antenna.mobilityModule = "^.^.mobility" +*.node[*].mobility.initFromDisplayString = false +*.node[*].mobility.initialX = 10m + parentIndex() * 1m +*.node[*].mobility.initialY = 10m +*.node[*].mobility.initialZ = 0m +*.node[*].mobility.constraintAreaMinX = 0m +*.node[*].mobility.constraintAreaMinY = 0m +*.node[*].mobility.constraintAreaMinZ = 0m +*.node[*].mobility.constraintAreaMaxX = 100m +*.node[*].mobility.constraintAreaMaxY = 100m +*.node[*].mobility.constraintAreaMaxZ = 0m +*.radioMedium.backgroundNoise.power = ${noise} == 0 ? -110dBm : (${noise} == 1 ? (${mcs} == 0 ? -30dBm : -50dBm) : (${mcs} == 0 ? -28dBm : -43dBm)) + +%contains: stdout +CONTROL model= + +%file: check-controls.py +from pathlib import Path +import re + +text = Path("test.out").read_text() +assert "Run statistics: total 576, successful 576" in text +rows = [dict(re.findall(r"(\w+)=([^ ]+)", line)) for line in text.splitlines() if line.startswith("CONTROL ")] +keys = [tuple(row[name] for name in ("model", "mcs", "gi", "noise", "seed", "parts", "analog")) for row in rows] +assert len(rows) == len(set(keys)) == 576 +for model in ("0", "1"): + selected = [row for row in rows if row["model"] == model] + assert any(int(row["draws"]) > 0 for row in selected) + assert any(row["error"] == "1" or row["received"] == "0" for row in selected) +print("All 576 ordinary reception controls passed.") From bd856658354735c010c3d2ea65a05a83442f4a95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 25/41] ieee80211: fix: permit cyclic sequence arithmetic across zero Before this commit, valid sequence arithmetic can produce an intermediate value of minus one. The shared helper rejects that value, so 0 - 1 fails instead of returning sequence 4095. After this commit, the helper reduces every valid intermediate modulo 4096. Constructors and arithmetic operators still reject an unspecified source. The unit fixture checks every sequence value with positive and negative offsets. Aggregate reorder advancement needs this correction at sequence wrap. Plan: plan/pending/ieee80211-ampdu-implicit-blockack.md Change: src.ieee80211 | behavior.change.fix | test | ieee80211-implicit-blockack --- .../ieee80211/mac/common/Ieee80211Defs.h | 2 +- .../unit/Ieee80211SequenceNumberCyclic_1.test | 36 +++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 tests/unit/Ieee80211SequenceNumberCyclic_1.test diff --git a/src/inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h b/src/inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h index a2ebabd6644..f9927401f68 100644 --- a/src/inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h +++ b/src/inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h @@ -27,7 +27,7 @@ struct SequenceNumberCyclic SequenceNumber value; private: - SequenceNumber modulo4096(SequenceNumber value) const { ASSERT(value != -1); return (value % 4096 + 4096) % 4096; } // always returns positive result + SequenceNumber modulo4096(SequenceNumber value) const { return (value % 4096 + 4096) % 4096; } // always returns positive result SequenceNumber distance4096(SequenceNumber other) const { ASSERT(0 <= other && other < 4096); return (value - other + 4096) % 4096; } public: diff --git a/tests/unit/Ieee80211SequenceNumberCyclic_1.test b/tests/unit/Ieee80211SequenceNumberCyclic_1.test new file mode 100644 index 00000000000..b0fb1057e9e --- /dev/null +++ b/tests/unit/Ieee80211SequenceNumberCyclic_1.test @@ -0,0 +1,36 @@ +%description: +All specified sequence numbers support cyclic addition and subtraction across zero. +An intermediate value of minus one maps to 4095. It does not represent an unspecified source object. +The operators retain refusal of an unspecified source object. + +%includes: +#include "inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h" +using namespace inet::ieee80211; + +%activity: +int checked = 0; +for (int value = 0; value < 4096; value++) { + SequenceNumberCyclic sequence(value); + for (int offset : {-4096, -4095, -2048, -64, -2, -1, 0, 1, 2, 63, 64, 2047, 2048, 4095, 4096}) { + auto normalize = [](int number) { return (number % 4096 + 4096) % 4096; }; + ASSERT((sequence + offset).get() == normalize(value + offset)); + ASSERT((sequence - offset).get() == normalize(value - offset)); + checked += 2; + } +} +SequenceNumberCyclic unspecified; +ASSERT(!unspecified.isSpecified()); +for (bool subtract : {false, true}) { + bool refused = false; + try { + auto result = subtract ? unspecified - 1 : unspecified + 1; + (void)result; + } + catch (const omnetpp::cRuntimeError&) { refused = true; } + ASSERT(refused); +} +ASSERT(checked == 4096 * 15 * 2); +EV << "Cyclic sequence arithmetic and unspecified-source guards passed.\n"; + +%contains: stdout +Cyclic sequence arithmetic and unspecified-source guards passed. From 4ea03bdcf943124a4f28cad458297e150bb075bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 26/41] ieee80211: add: retain directional HT MPDU spacing limits Before this commit, negotiated HT state lacks the receiver's minimum MPDU start spacing. An aggregate builder therefore cannot apply that receiver limit. After this commit, full and simplified management preserve the encoded spacing in each negotiated direction. The MIB exposes the local receiver setting. The transmitter can obtain the peer receiver's limit before aggregate construction. Capability fixtures check asymmetric limits, encoding, initialization, and reset. Plan: plan/pending/ieee80211-ampdu-implicit-blockack.md Change: src.ieee80211 | behavior.add | test whatsnew migration | ieee80211-implicit-blockack --- .../ieee80211/mgmt/Ieee80211HtMgmtElements.h | 4 + .../ieee80211/mib/Ieee80211HtCapabilities.h | 7 +- .../linklayer/ieee80211/mib/Ieee80211Mib.cc | 3 + .../linklayer/ieee80211/mib/Ieee80211Mib.ned | 1 + .../module/Ieee80211AmpduCapabilities_1.test | 124 ++++++++++++++++++ tests/module/Ieee80211HtAssociation_1.test | 14 ++ ...0211MgmtStaSimplifiedInitialization_1.test | 19 +++ .../Ieee80211AmpduCapabilityEncoding_1.test | 68 ++++++++++ 8 files changed, 239 insertions(+), 1 deletion(-) create mode 100644 tests/module/Ieee80211AmpduCapabilities_1.test create mode 100644 tests/unit/Ieee80211AmpduCapabilityEncoding_1.test diff --git a/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h b/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h index fb62285460e..acc0c2e6fb8 100644 --- a/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h +++ b/src/inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h @@ -23,6 +23,7 @@ inline Ieee80211HtCapabilitiesElement makeHtCapabilitiesElement(const Ieee80211H element.shortGi20 = capabilities.shortGi20; element.shortGi40 = capabilities.shortGi40; element.maxAmpduLengthExponent = capabilities.maxAmpduLengthExponent; + element.minimumMpduStartSpacing = capabilities.minimumMpduStartSpacing; for (int i = 0; i < 77; i++) element.rxMcsSupported[i] = capabilities.rxMcsSupported[i]; element.txMcsSetDefined = capabilities.txMcsSetDefined; @@ -46,6 +47,8 @@ inline Ieee80211HtCapabilities makeHtCapabilities(const Ieee80211HtCapabilitiesE { if (element.maxAmpduLengthExponent < 0 || element.maxAmpduLengthExponent > 3) throw cRuntimeError("Invalid Maximum A-MPDU Length Exponent: %d", element.maxAmpduLengthExponent); + if (element.minimumMpduStartSpacing < 0 || element.minimumMpduStartSpacing > 7) + throw cRuntimeError("Invalid Minimum MPDU Start Spacing: %d", element.minimumMpduStartSpacing); if (!element.txMcsSetDefined && (element.txRxMcsSetNotEqual || element.txMaxNss != 0 || element.txUnequalModulation)) throw cRuntimeError("Malformed undefined HT Tx MCS Set"); if (element.txMcsSetDefined && !element.txRxMcsSetNotEqual && @@ -63,6 +66,7 @@ inline Ieee80211HtCapabilities makeHtCapabilities(const Ieee80211HtCapabilitiesE capabilities.shortGi20 = element.shortGi20; capabilities.shortGi40 = element.shortGi40; capabilities.maxAmpduLengthExponent = element.maxAmpduLengthExponent; + capabilities.minimumMpduStartSpacing = element.minimumMpduStartSpacing; capabilities.txMcsSetDefined = element.txMcsSetDefined; capabilities.txRxMcsSetNotEqual = element.txRxMcsSetNotEqual; capabilities.txMaxNss = element.txMaxNss; diff --git a/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h b/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h index 26a27315c11..86699066b71 100644 --- a/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h +++ b/src/inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h @@ -53,13 +53,15 @@ struct Ieee80211HtCapabilities bool shortGi20 = false; bool shortGi40 = false; int maxAmpduLengthExponent = 0; + int minimumMpduStartSpacing = 0; // Encoded receiver limit, 0..7 (IEEE Std 802.11-2024, Table 9-225). bool operator==(const Ieee80211HtCapabilities& other) const { return supportedChannelWidths == other.supportedChannelWidths && rxMcsSupported == other.rxMcsSupported && txMcsSetDefined == other.txMcsSetDefined && txRxMcsSetNotEqual == other.txRxMcsSetNotEqual && txMaxNss == other.txMaxNss && txUnequalModulation == other.txUnequalModulation && txMcsNss.maxMcsPerNss == other.txMcsNss.maxMcsPerNss && ldpc == other.ldpc && greenfield == other.greenfield && - shortGi20 == other.shortGi20 && shortGi40 == other.shortGi40 && maxAmpduLengthExponent == other.maxAmpduLengthExponent; + shortGi20 == other.shortGi20 && shortGi40 == other.shortGi40 && maxAmpduLengthExponent == other.maxAmpduLengthExponent && + minimumMpduStartSpacing == other.minimumMpduStartSpacing; } }; @@ -90,6 +92,7 @@ struct Ieee80211HtDirectionalCapabilities bool receiverShortGi20 = false; bool receiverShortGi40 = false; int receiverMaxAmpduLengthExponent = 0; + int receiverMinimumMpduStartSpacing = 0; // Encoded receiver limit, 0..7. }; struct Ieee80211NegotiatedHtCapabilities @@ -140,6 +143,8 @@ inline Ieee80211NegotiatedHtCapabilities negotiateHtCapabilities(const Ieee80211 negotiated.localRxPeerTx.receiverShortGi40 = local.shortGi40; negotiated.localTxPeerRx.receiverMaxAmpduLengthExponent = peer.maxAmpduLengthExponent; negotiated.localRxPeerTx.receiverMaxAmpduLengthExponent = local.maxAmpduLengthExponent; + negotiated.localTxPeerRx.receiverMinimumMpduStartSpacing = peer.minimumMpduStartSpacing; + negotiated.localRxPeerTx.receiverMinimumMpduStartSpacing = local.minimumMpduStartSpacing; // The HT Operation width is the BSS maximum. A 20 MHz-only STA may join a // 20/40 MHz BSS, so validity requires a common usable width, not equality // with the advertised BSS width (IEEE Std 802.11-2024, 11.15.2). diff --git a/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc b/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc index f57837295d2..e25d07a2ece 100644 --- a/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc +++ b/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.cc @@ -188,6 +188,9 @@ void Ieee80211Mib::updateLocalHtCapabilities(const physicallayer::Ieee80211ModeS localHtCapabilities.maxAmpduLengthExponent = par("htMaxAmpduLengthExponent"); if (localHtCapabilities.maxAmpduLengthExponent < 0 || localHtCapabilities.maxAmpduLengthExponent > 3) throw cRuntimeError("htMaxAmpduLengthExponent must be between 0 and 3"); + localHtCapabilities.minimumMpduStartSpacing = par("htMinimumMpduStartSpacing"); + if (localHtCapabilities.minimumMpduStartSpacing < 0 || localHtCapabilities.minimumMpduStartSpacing > 7) + throw cRuntimeError("htMinimumMpduStartSpacing must be between 0 and 7"); configuredSecondaryChannelOffset = par("htSecondaryChannelOffset"); if (configuredSecondaryChannelOffset != 0 && configuredSecondaryChannelOffset != 1 && configuredSecondaryChannelOffset != 3) diff --git a/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.ned b/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.ned index 8430c1e17fc..557e5dd412c 100644 --- a/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.ned +++ b/src/inet/linklayer/ieee80211/mib/Ieee80211Mib.ned @@ -25,6 +25,7 @@ simple Ieee80211Mib extends SimpleModule @signal[rateStateChanged](type=bool); // Model-backed subset of IEEE Std 802.11-2024 HT capability/operation state; not a full Annex C MIB. int htMaxAmpduLengthExponent = default(0); // maximum received A-MPDU length exponent (0..3) + int htMinimumMpduStartSpacing = default(0); // encoded receiver limit: 0=no restriction, 1=0.25us, 2=0.5us, 3=1us, 4=2us, 5=4us, 6=8us, 7=16us int htSecondaryChannelOffset = default(0); // BSS operation policy: 0=20 MHz, 1=40 MHz above, 3=40 MHz below; bounded by the mode set int htProtectionMode = default(0); // 0=none, 1=nonmember, 2=20 MHz, 3=non-HT mixed displayStringTextFormat = default("Address: {address}{ssidStr}\n{modeStr}{stationTypeStr}{qosStr}{associatedStr}"); diff --git a/tests/module/Ieee80211AmpduCapabilities_1.test b/tests/module/Ieee80211AmpduCapabilities_1.test new file mode 100644 index 00000000000..67dec4d175e --- /dev/null +++ b/tests/module/Ieee80211AmpduCapabilities_1.test @@ -0,0 +1,124 @@ +%description: +Production simplified management preserves all four HT length exponents and eight spacing encodings. +Opposite receiver limits must reach the local transmit direction. +Peer cleanup must remove the old limits before a replacement peer state arrives. +The separate full association fixture checks management frame exchange. + +%extraargs: -r 0..31 + +%file: AmpduCapabilities.cc +#include +#include "inet/common/InitStages.h" +#include "inet/common/packet/chunk/BytesChunk.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" + +using namespace inet; +using namespace inet::ieee80211; + +class AmpduCapabilities : public cSimpleModule +{ + protected: + virtual int numInitStages() const override { return NUM_INIT_STAGES; } + + virtual void initialize(int stage) override + { + if (stage != INITSTAGE_LAST) + return; + auto ap = check_and_cast(getModuleByPath("^.ap.wlan[0].mib")); + auto sta = check_and_cast(getModuleByPath("^.sta.wlan[0].mib")); + ASSERT(ap->findPeerHtState(sta->address) != nullptr); + ASSERT(sta->findPeerHtState(ap->address) != nullptr); + const auto& tx = sta->findPeerHtState(ap->address)->negotiatedCapabilities.localTxPeerRx; + const auto& rx = sta->findPeerHtState(ap->address)->negotiatedCapabilities.localRxPeerTx; + ASSERT(tx.receiverMinimumMpduStartSpacing == ap->par("htMinimumMpduStartSpacing").intValue()); + ASSERT(rx.receiverMinimumMpduStartSpacing == sta->par("htMinimumMpduStartSpacing").intValue()); + ASSERT(tx.receiverMaxAmpduLengthExponent == ap->par("htMaxAmpduLengthExponent").intValue()); + ASSERT(rx.receiverMaxAmpduLengthExponent == sta->par("htMaxAmpduLengthExponent").intValue()); + Packet first("first", makeShared(std::vector(30, 0))); + Packet second("second", makeShared(std::vector(30, 0))); + std::vector sources = {&first, &second}; + const physicallayer::IIeee80211Mode *mode = nullptr; + auto modes = physicallayer::Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + for (int i = 0; i < modes->getNumModes(); i++) { + auto candidate = modes->getMode(i); + if (candidate->getHtMcsIndex() == 7 && !candidate->isHtShortGuardInterval() && + candidate->getDataMode()->getBandwidth() == MHz(20)) + mode = candidate; + } + ASSERT(mode != nullptr); + MpduAggregation builder; + auto envelope = builder.aggregateFrames(sources, mode, tx.receiverMinimumMpduStartSpacing, + B((1 << (13 + tx.receiverMaxAmpduLengthExponent)) - 1)); + ASSERT(envelope != nullptr); + const int EXPECTED_DISTANCE[] = {36, 36, 36, 36, 36, 36, 68, 132}; + ASSERT(envelope->getDataLength() == B(EXPECTED_DISTANCE[ap->par("htMinimumMpduStartSpacing").intValue()] + 34)); + delete envelope; + auto saved = ap->localHtCapabilities; + auto operation = ap->getHtOperation(); + sta->clearBssAndPeerState(ap->address); + ASSERT(sta->findPeerHtState(ap->address) == nullptr); + saved.minimumMpduStartSpacing = (saved.minimumMpduStartSpacing + 1) % 8; + sta->setPeerHtCapabilities(ap->address, saved, operation); + ASSERT(sta->findPeerHtState(ap->address)->negotiatedCapabilities.localTxPeerRx.receiverMinimumMpduStartSpacing == + saved.minimumMpduStartSpacing); + std::cout << "HT aggregate receiver limits passed\n"; + } +}; + +Define_Module(AmpduCapabilities); + +%file: test.ned +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; + +simple AmpduCapabilities +{ + parameters: + @class(::AmpduCapabilities); +} + +network AmpduCapabilitiesNetwork +{ + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + ap: AccessPoint; + sta: WirelessHost; + checker: AmpduCapabilities; +} + +%inifile: omnetpp.ini +[General] +network = AmpduCapabilitiesNetwork +ned-path = .;../../../../src;../../lib +sim-time-limit = 0s +seed-set = 0 +cmdenv-express-mode = true +**.vector-recording = false +**.scalar-recording = false +*.ap.wlan[0].mgmt.typename = "Ieee80211MgmtApSimplified" +*.sta.wlan[0].mgmt.typename = "Ieee80211MgmtStaSimplified" +**.wlan[0].agent.typename = "" +*.ap.wlan[0].address = "02:00:00:00:00:01" +*.sta.wlan[0].address = "02:00:00:00:00:02" +*.sta.wlan[0].mgmt.accessPointAddress = "02:00:00:00:00:01" +*.ap.wlan[0].mib.htMaxAmpduLengthExponent = ${exponent=0..3} +*.sta.wlan[0].mib.htMaxAmpduLengthExponent = 3 - ${exponent} +*.ap.wlan[0].mib.htMinimumMpduStartSpacing = ${spacing=0..7} +*.sta.wlan[0].mib.htMinimumMpduStartSpacing = 7 - ${spacing} +**.wlan[0].opMode = "n(mixed-2.4Ghz)" +**.wlan[0].bitrate = 65Mbps +**.wlan[0].radio.bandName = "2.4 GHz" +**.wlan[0].radio.channelNumber = 1 +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m + +%contains: stdout +HT aggregate receiver limits passed diff --git a/tests/module/Ieee80211HtAssociation_1.test b/tests/module/Ieee80211HtAssociation_1.test index aeee34722e2..a9cf55dc583 100644 --- a/tests/module/Ieee80211HtAssociation_1.test +++ b/tests/module/Ieee80211HtAssociation_1.test @@ -136,6 +136,16 @@ class Ieee80211HtAssociationChecker : public SimpleModule, public cListener // cannot operate a primary/secondary compound channel and must not // advertise that width. ASSERT(staMib->localHtCapabilities.shortGi20); + ASSERT(staMib->localHtCapabilities.minimumMpduStartSpacing == 1); + ASSERT(apMib->localHtCapabilities.minimumMpduStartSpacing == 7); + const auto& apLimits = apMib->findPeerHtState(staAddress)->negotiatedCapabilities; + const auto& staLimits = staMib->findPeerHtState(apMib->address)->negotiatedCapabilities; + ASSERT(apLimits.localTxPeerRx.receiverMinimumMpduStartSpacing == 1); + ASSERT(apLimits.localRxPeerTx.receiverMinimumMpduStartSpacing == 7); + ASSERT(staLimits.localTxPeerRx.receiverMinimumMpduStartSpacing == 7); + ASSERT(staLimits.localRxPeerTx.receiverMinimumMpduStartSpacing == 1); + ASSERT(apLimits.localTxPeerRx.receiverMaxAmpduLengthExponent == 1); + ASSERT(staLimits.localTxPeerRx.receiverMaxAmpduLengthExponent == 3); ASSERT(!staMib->localHtCapabilities.shortGi40); ASSERT(apMib->localHtCapabilities.shortGi20); ASSERT(!apMib->localHtCapabilities.shortGi40); @@ -231,6 +241,10 @@ record-scalar-results = false **.mobility.initialZ = 0m **.wlan[*].opMode = "n(mixed-2.4Ghz)" +*.ap.wlan[0].mib.htMinimumMpduStartSpacing = 7 +*.sta.wlan[0].mib.htMinimumMpduStartSpacing = 1 +*.ap.wlan[0].mib.htMaxAmpduLengthExponent = 3 +*.sta.wlan[0].mib.htMaxAmpduLengthExponent = 1 **.wlan[*].bitrate = 65Mbps *.sta.wlan[0].radio.channelNumber = 6 **.wlan[*].radio.bandName = "2.4 GHz" diff --git a/tests/module/Ieee80211MgmtStaSimplifiedInitialization_1.test b/tests/module/Ieee80211MgmtStaSimplifiedInitialization_1.test index acc48310936..8cefba0b7c0 100644 --- a/tests/module/Ieee80211MgmtStaSimplifiedInitialization_1.test +++ b/tests/module/Ieee80211MgmtStaSimplifiedInitialization_1.test @@ -28,6 +28,18 @@ class TestInitializationObserver : public cSimpleModule protected: virtual int numInitStages() const override { return NUM_INIT_STAGES; } + void checkReceiverLimits(ieee80211::Ieee80211Mib *apMib, ieee80211::Ieee80211Mib *staMib) + { + const auto& ap = apMib->findPeerHtState(staMib->address)->negotiatedCapabilities; + const auto& sta = staMib->findPeerHtState(apMib->address)->negotiatedCapabilities; + ASSERT(ap.localTxPeerRx.receiverMinimumMpduStartSpacing == 1); + ASSERT(ap.localRxPeerTx.receiverMinimumMpduStartSpacing == 7); + ASSERT(sta.localTxPeerRx.receiverMinimumMpduStartSpacing == 7); + ASSERT(sta.localRxPeerTx.receiverMinimumMpduStartSpacing == 1); + ASSERT(ap.localTxPeerRx.receiverMaxAmpduLengthExponent == 1); + ASSERT(sta.localTxPeerRx.receiverMaxAmpduLengthExponent == 3); + } + virtual void initialize(int stage) override { if (stage == INITSTAGE_NETWORK_CONFIGURATION || stage == INITSTAGE_LAST) { @@ -54,6 +66,7 @@ class TestInitializationObserver : public cSimpleModule else { ASSERT(apMib->findPeerHtState(staMib->address) != nullptr); ASSERT(staMib->findPeerHtState(apMib->address) != nullptr); + checkReceiverLimits(apMib, staMib); ASSERT(apMib->findPeerHtState(staMib->address)->negotiatedCapabilities.operation.primaryChannel == 6); ASSERT(staMib->findPeerHtState(apMib->address)->negotiatedCapabilities.operation.primaryChannel == 6); std::cout << "Simplified STA HT peer state installed at last initialization stage.\n"; @@ -81,6 +94,7 @@ class TestInitializationObserver : public cSimpleModule std::cout << "Simplified STA AP-side association and HT peer state removed after shutdown.\n"; } else if (!strcmp(message->getName(), "checkShutdownRestart")) { + checkReceiverLimits(apMib, staMib); ASSERT(staMib->bssStationData.isAssociated); ASSERT(staMib->bssData.ssid == apMib->bssData.ssid); ASSERT(apMib->bssAccessPointData.stations.at(staMib->address) == ieee80211::Ieee80211Mib::ASSOCIATED); @@ -96,6 +110,7 @@ class TestInitializationObserver : public cSimpleModule std::cout << "Simplified STA AP-side association and HT peer state removed after resolvable crash.\n"; } else if (!strcmp(message->getName(), "checkCrashRestart")) { + checkReceiverLimits(apMib, staMib); ASSERT(staMib->bssStationData.isAssociated); ASSERT(staMib->bssData.ssid == apMib->bssData.ssid); ASSERT(apMib->bssAccessPointData.stations.at(staMib->address) == ieee80211::Ieee80211Mib::ASSOCIATED); @@ -187,6 +202,10 @@ record-scalar-results = false *.ap.wlan[0].radio.channelNumber = 6 *.sta.wlan[0].mgmt.accessPointAddress = "02:00:00:00:00:01" **.wlan[0].opMode = "n(mixed-2.4Ghz)" +*.ap.wlan[0].mib.htMinimumMpduStartSpacing = 7 +*.sta.wlan[0].mib.htMinimumMpduStartSpacing = 1 +*.ap.wlan[0].mib.htMaxAmpduLengthExponent = 3 +*.sta.wlan[0].mib.htMaxAmpduLengthExponent = 1 **.hasStatus = true **.scenarioManager.script = xmldoc("scenario.xml") **.wlan[0].bitrate = 65Mbps diff --git a/tests/unit/Ieee80211AmpduCapabilityEncoding_1.test b/tests/unit/Ieee80211AmpduCapabilityEncoding_1.test new file mode 100644 index 00000000000..0731250f456 --- /dev/null +++ b/tests/unit/Ieee80211AmpduCapabilityEncoding_1.test @@ -0,0 +1,68 @@ +%description: +Verify all HT receive length exponents and MPDU spacing encodings through management conversion and bytes. +Asymmetric negotiation preserves the receiver's limits in each direction. +Invalid encoded spacing cannot enter capability state through management conversion. + +%includes: +#include "inet/common/packet/Packet.h" +#include "inet/common/packet/chunk/BytesChunk.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211HtMgmtElements.h" + +using namespace inet; +using namespace inet::ieee80211; + +%activity: +for (int exponent = 0; exponent < 4; exponent++) { + for (int spacing = 0; spacing < 8; spacing++) { + Ieee80211HtCapabilities local; + local.supportedChannelWidths.insert(MHz(20)); + local.rxMcsSupported[0] = true; + local.txMcsNss.maxMcsPerNss[0] = 0; + local.maxAmpduLengthExponent = exponent; + local.minimumMpduStartSpacing = spacing; + auto peer = local; + peer.maxAmpduLengthExponent = 3 - exponent; + peer.minimumMpduStartSpacing = 7 - spacing; + ASSERT(!(local == peer)); + auto element = makeHtCapabilitiesElement(local); + ASSERT(element.minimumMpduStartSpacing == spacing); + ASSERT(makeHtCapabilities(element) == local); + auto response = makeShared(); + response->setStatusCode(SC_SUCCESSFUL); + response->setAid(1); + Ieee80211SupportedRatesElement rates; + rates.numRates = 1; + rates.rate[0] = 6; + response->setSupportedRates(rates); + setHtCapabilities(response, local); + response->setChunkLength(B(37)); + Packet output("response", response); + auto bytes = output.peekAllAsBytes()->getBytes(); + ASSERT(bytes.size() == 37); + ASSERT(bytes[13] == (exponent | (spacing << 2))); + Packet input("fresh", makeShared(bytes)); + auto decoded = input.popAtFront(B(37)); + ASSERT(makeHtCapabilities(decoded->getHtCapabilities()) == local); + auto negotiated = negotiateHtCapabilities(local, peer, Ieee80211HtOperation()); + ASSERT(negotiated.localTxPeerRx.valid && negotiated.localRxPeerTx.valid); + ASSERT(negotiated.localTxPeerRx.receiverMaxAmpduLengthExponent == 3 - exponent); + ASSERT(negotiated.localRxPeerTx.receiverMaxAmpduLengthExponent == exponent); + ASSERT(negotiated.localTxPeerRx.receiverMinimumMpduStartSpacing == 7 - spacing); + ASSERT(negotiated.localRxPeerTx.receiverMinimumMpduStartSpacing == spacing); + auto changed = local; + changed.minimumMpduStartSpacing = (spacing + 1) % 8; + ASSERT(!(local == changed)); + } +} +for (int spacing : {-1, 8}) { + Ieee80211HtCapabilitiesElement element; + element.minimumMpduStartSpacing = spacing; + Ieee80211HtCapabilities result; + std::string reason; + ASSERT(!decodeHtCapabilities(element, result, reason)); + ASSERT(reason.find("Minimum MPDU Start Spacing") != std::string::npos); +} +EV << "HT aggregate capability checks passed\n"; + +%contains: stdout +HT aggregate capability checks passed From adab03c9a151f92e96fdd995ba41c0f04ef3e829 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 27/41] ieee80211: add+change: construct HT aggregates within receiver limits Before this commit, aggregate construction cannot preview spacing at the selected DATA mode while it preserves the source MPDUs. It also lacks the complete HT duration admission calculation. After this commit, the builder borrows source references and copies their data and region tags. Alignment padding and zero-length delimiters satisfy negotiated spacing. Construction checks the receiver byte limit, PPDU duration, and L-SIG length. Singleton aggregates retain their delimiter. Bounded delimiter inspection retains invalid ranges for later MAC history checks. The wire and construction fixtures check serialization, spacing boundaries, source preservation, and malformed layouts. These operations prepare the later exchange without enabling the default MPDU policy. Plan: plan/pending/ieee80211-ampdu-implicit-blockack.md Change: src.ieee80211 | behavior.add+change | test whatsnew migration | ieee80211-implicit-blockack --- .../mac/aggregation/MpduAggregation.cc | 77 +++++-- .../mac/aggregation/MpduAggregation.h | 7 + .../mac/aggregation/MpduAggregationUtils.cc | 12 +- .../mac/aggregation/MpduAggregationUtils.h | 5 +- .../ieee80211/mac/contract/IMpduAggregation.h | 10 + .../ieee80211/mode/Ieee80211HtMode.cc | 30 +++ .../wireless/ieee80211/mode/Ieee80211HtMode.h | 9 + tests/unit/Ieee80211AmpduConstruction_1.test | 188 ++++++++++++++++++ tests/unit/Ieee80211AmpduWire_1.test | 8 +- 9 files changed, 329 insertions(+), 17 deletions(-) create mode 100644 tests/unit/Ieee80211AmpduConstruction_1.test diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.cc b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.cc index a0c8384d539..f1906962eb0 100644 --- a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.cc +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.cc @@ -8,6 +8,7 @@ #include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" #include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h" namespace inet { namespace ieee80211 { @@ -16,30 +17,82 @@ Register_Class(MpduAggregation); Packet *MpduAggregation::aggregateFrames(std::vector *frames) { - EV_DEBUG << "Aggregating " << frames->size() << " packets into A-MPDU.\n"; - auto aggregatedFrame = new Packet(); + auto aggregate = buildAggregate(*frames, B(0)); + for (auto frame : *frames) + delete frame; + return aggregate; +} + +B MpduAggregation::computeAggregateLength(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + int minimumMpduStartSpacing) const +{ + auto htMode = dynamic_cast(mode); + if (htMode == nullptr) + return B(0); + B minimumDistance = htMode->getMinimumMpduStartDistance(minimumMpduStartSpacing); + B length(0); + for (size_t i = 0; i < frames.size(); i++) { + auto bits = frames[i]->getDataLength(); + // IEEE Std 802.11-2024, 9.7.1: each nonzero HT member has a 12-bit octet length. + if (bits <= b(0) || bits.get() % 8 != 0 || bits > B(4095)) + return B(0); + B subframeLength = B(4) + B(bits); + if (i + 1 != frames.size()) + subframeLength = B((std::max(subframeLength, minimumDistance).get() + 3) / 4 * 4); + length += subframeLength; + if (length > B(65535)) + return B(0); + } + return length; +} + +Packet *MpduAggregation::aggregateFrames(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + int minimumMpduStartSpacing, B maxAggregateLength) +{ + if (maxAggregateLength < B(0)) + throw cRuntimeError("Maximum aggregate length must be nonnegative"); + B length = computeAggregateLength(frames, mode, minimumMpduStartSpacing); + if (length == B(0) || length > maxAggregateLength) + return nullptr; + auto htMode = check_and_cast(mode); + if (!htMode->isPpduDurationValid(length)) + return nullptr; + return buildAggregate(frames, htMode->getMinimumMpduStartDistance(minimumMpduStartSpacing)); +} + +Packet *MpduAggregation::buildAggregate(const std::vector& frames, B minimumStartDistance) const +{ + EV_DEBUG << "Aggregating " << frames.size() << " packets into A-MPDU.\n"; + auto aggregatedFrame = std::make_unique(); std::string aggregatedName; - for (size_t i = 0; i < frames->size(); i++) { + for (size_t i = 0; i < frames.size(); i++) { auto mpduSubframeHeader = makeShared(); - auto frame = frames->at(i); - auto mpdu = frame->peekAll(); + auto frame = frames.at(i); + auto mpdu = frame->peekData(); mpduSubframeHeader->setLength(mpdu->getChunkLength().get()); aggregatedFrame->insertAtBack(mpduSubframeHeader); aggregatedFrame->insertAtBack(mpdu); - aggregatedFrame->getRegionTags().copyTags(frame->getRegionTags(), B(0), aggregatedFrame->getFrontOffset() - frame->getDataLength(), frame->getDataLength()); - int paddingLength = 4 - (mpduSubframeHeader->getChunkLength() + mpdu->getChunkLength()).get() % 4; - if (i + 1 != frames->size() && paddingLength != 4) { - auto padding = makeShared(B(paddingLength)); - aggregatedFrame->insertAtBack(padding); + aggregatedFrame->getRegionTags().copyTags(frame->getRegionTags(), frame->getFrontOffset(), + aggregatedFrame->getBackOffset() - frame->getDataLength(), frame->getDataLength()); + if (i + 1 != frames.size()) { + // IEEE Std 802.11-2024, 9.7.1 and 10.12.3: alignment precedes zero-length delimiters. + B subframeLength = B(4) + B(mpdu->getChunkLength()); + B alignedLength((subframeLength.get() + 3) / 4 * 4); + B paddingLength = alignedLength - subframeLength; + if (paddingLength != B(0)) + aggregatedFrame->insertAtBack(makeShared(paddingLength, 0)); + while (alignedLength < minimumStartDistance) { + aggregatedFrame->insertAtBack(makeShared()); + alignedLength += B(4); + } } if (i != 0) aggregatedName.append("+"); aggregatedName.append(frame->getName()); - delete frame; } aggregatedFrame->setName(aggregatedName.c_str()); EV_TRACE << "Created A-MPDU " << *aggregatedFrame << ".\n"; - return aggregatedFrame; + return aggregatedFrame.release(); } } /* namespace ieee80211 */ diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h index 6828d518e60..64bc3fa4a96 100644 --- a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h @@ -15,8 +15,15 @@ namespace ieee80211 { class INET_API MpduAggregation : public IMpduAggregation, public cObject { + protected: + Packet *buildAggregate(const std::vector& frames, B minimumStartDistance) const; + public: virtual Packet *aggregateFrames(std::vector *frames) override; + virtual B computeAggregateLength(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + int minimumMpduStartSpacing) const override; + virtual Packet *aggregateFrames(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + int minimumMpduStartSpacing, B maxAggregateLength) override; }; } /* namespace ieee80211 */ diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc index aff3649c878..b16044a11c4 100644 --- a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.cc @@ -7,7 +7,8 @@ namespace inet { namespace ieee80211 { -MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length) +MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length, + const std::function& delimiterSuccessful) { MpduLayout layout; if (offset < B(0) || length < B(0) || offset + length > packet->getDataLength()) { @@ -18,6 +19,7 @@ MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length) // IEEE Std 802.11-2024, 9.7.1: delimiter boundaries are four octets apart after loss of continuity. while (position < length) { if (length - position < B(4)) { + layout.ranges.push_back({MpduRangeKind::DELIMITER, position, length - position, false}); layout.complete = false; break; } @@ -27,7 +29,8 @@ MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length) Chunk::PF_ALLOW_REINTERPRETATION); bool valid = delimiter->isCorrect() && delimiter->isComplete() && delimiter->isProperlyRepresented() && delimiter->getLength() >= 0 && delimiter->getLength() <= 4095 && - B(delimiter->getLength()) <= length - position - B(4); + B(delimiter->getLength()) <= length - position - B(4) && + (!delimiterSuccessful || delimiterSuccessful(position, B(4))); layout.ranges.push_back({MpduRangeKind::DELIMITER, position, B(4), valid}); position += B(4); if (!valid) { @@ -43,12 +46,15 @@ MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length) break; B padding((4 - memberLength.get() % 4) % 4); if (padding > length - position) { + layout.ranges.push_back({MpduRangeKind::DELIMITER, position, length - position, false}); layout.complete = false; break; } position += padding; - if (position == length) + if (position == length) { + layout.ranges.push_back({MpduRangeKind::DELIMITER, position - padding, padding, false}); layout.complete = false; // HT has no final alignment padding. + } } return layout; } diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h index bff9f954451..7f58c37b6e2 100644 --- a/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h +++ b/src/inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h @@ -3,6 +3,8 @@ #ifndef __INET_MPDUAGGREGATIONUTILS_H #define __INET_MPDUAGGREGATIONUTILS_H +#include + #include "inet/common/packet/Packet.h" namespace inet { @@ -26,7 +28,8 @@ struct INET_API MpduLayout }; // Offsets are relative to the PSDU, without the PHY header or PHY padding. -INET_API MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length); +INET_API MpduLayout inspectMpduAggregate(const Packet *packet, B offset, B length, + const std::function& delimiterSuccessful = {}); } // namespace ieee80211 } // namespace inet diff --git a/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h b/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h index 62d812498ba..8a7d457a643 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h @@ -12,6 +12,9 @@ #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" namespace inet { +namespace physicallayer { +class IIeee80211Mode; +} namespace ieee80211 { class INET_API IMpduAggregation @@ -20,6 +23,13 @@ class INET_API IMpduAggregation virtual ~IMpduAggregation() {} virtual Packet *aggregateFrames(std::vector *frames) = 0; + + // These HT operations borrow the sources. Zero length or nullptr means refusal without source changes. + // Spacing is the receiver's encoded value (0..7). The byte limit includes delimiters and padding. + virtual B computeAggregateLength(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + int minimumMpduStartSpacing) const = 0; + virtual Packet *aggregateFrames(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + int minimumMpduStartSpacing, B maxAggregateLength) = 0; }; } // namespace ieee80211 diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.cc b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.cc index 5f86f6ad39c..86b76c1a9b3 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.cc +++ b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.cc @@ -19,6 +19,36 @@ namespace inet { namespace physicallayer { +B Ieee80211HtMode::getMinimumMpduStartDistance(int minimumMpduStartSpacing) const +{ + // IEEE Std 802.11-2024, Table 9-225 and Equation (10-12). + static const int SPACING_NS[] = {0, 250, 500, 1000, 2000, 4000, 8000, 16000}; + if (minimumMpduStartSpacing < 0 || minimumMpduStartSpacing > 7) + throw cRuntimeError("Minimum MPDU Start Spacing must be between 0 and 7"); + return B(int64_t(ceil(dataMode->getNetBitrate().get() * SPACING_NS[minimumMpduStartSpacing] / 8e9))); +} + +int Ieee80211HtMode::getLSigLength(b dataLength) const +{ + if (preambleMode->getPreambleFormat() != Ieee80211HtPreambleMode::HT_PREAMBLE_MIXED) + throw cRuntimeError("L-SIG length requires HT mixed format"); + // IEEE Std 802.11-2024, 10.27.4, Equation (10-17). Exact ticks preserve the symbol boundary. + auto remaining = getDuration(dataLength) - getSignalExtensionTime() - SimTime(20, SIMTIME_US); + auto symbol = SimTime(4, SIMTIME_US); + return (remaining.raw() + symbol.raw() - 1) / symbol.raw() * 3 - 3; +} + +bool Ieee80211HtMode::isPpduDurationWithinLimit(b dataLength) const +{ + return getDuration(dataLength) <= SimTime(10, SIMTIME_MS); +} + +bool Ieee80211HtMode::isPpduDurationValid(b dataLength) const +{ + return isPpduDurationWithinLimit(dataLength) && + (preambleMode->getPreambleFormat() != Ieee80211HtPreambleMode::HT_PREAMBLE_MIXED || getLSigLength(dataLength) <= 4095); +} + OPP_THREAD_LOCAL const Ieee80211HtCompliantModes Ieee80211HtCompliantModes::singleton; bps Ieee80211HtMode::getNonHtReferenceRate() const diff --git a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h index ee6c0a76685..27b0162ba9c 100644 --- a/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h +++ b/src/inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h @@ -268,6 +268,15 @@ class INET_API Ieee80211HtMode : public Ieee80211ModeBase virtual int getMpduMaxLength() const override { return 65535; } // in octets virtual BandMode getCenterFrequencyMode() const { return centerFrequencyMode; } + // IEEE Std 802.11-2024, 10.12.3 and Table 9-225. The input is the encoded receiver limit (0..7). + B getMinimumMpduStartDistance(int minimumMpduStartSpacing) const; + // IEEE Std 802.11-2024, 10.27.4. The result is the L-SIG LENGTH field in octets, before its 4095 limit. + int getLSigLength(b dataLength) const; + // IEEE Std 802.11-2024, Table 19-25. This predicate checks the separate 10 ms bound. + bool isPpduDurationWithinLimit(b dataLength) const; + // Both the 10 ms bound and the mixed-format L-SIG bound apply. + bool isPpduDurationValid(b dataLength) const; + virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + dataMode->getDuration(dataLength) + getSignalExtensionTime(); } }; diff --git a/tests/unit/Ieee80211AmpduConstruction_1.test b/tests/unit/Ieee80211AmpduConstruction_1.test new file mode 100644 index 00000000000..fb8bccc4dbf --- /dev/null +++ b/tests/unit/Ieee80211AmpduConstruction_1.test @@ -0,0 +1,188 @@ +%description: +Verify HT aggregate construction with all receiver spacing encodings at two DATA modes. +Independent bytes prove alignment, zero-length delimiters, and the absence of final padding. +Source Packets retain their content and region tags after construction and refusal. +HT-SIG byte conversion preserves singleton identity through the P1 representation. + +%includes: +#include "inet/common/TimeTag_m.h" +#include "inet/common/packet/chunk/BytesChunk.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduDeaggregation.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211HtSignalField.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +%global: +static const Ieee80211HtMode *findMode(int mcs, bool use24Ghz = false) +{ + const Ieee80211Htmcs *parameters = mcs == 0 ? &Ieee80211HtmcsTable::htMcs0BW20MHz : + mcs == 7 ? &Ieee80211HtmcsTable::htMcs7BW20MHz : &Ieee80211HtmcsTable::htMcs15BW20MHz; + return Ieee80211HtCompliantModes::getCompliantMode(parameters, + use24Ghz ? Ieee80211HtMode::BAND_2_4GHZ : Ieee80211HtMode::BAND_5GHZ, + Ieee80211HtPreambleMode::HT_PREAMBLE_MIXED, Ieee80211HtModeBase::HT_GUARD_INTERVAL_LONG); +} + +static Packet *makeMember(int length, int prefix = 0) +{ + auto packet = new Packet("member", makeShared(std::vector(length + prefix, 0xA5))); + packet->addRegionTag(B(prefix + 2), B(3)); + if (prefix) + packet->popAtFront(B(prefix)); + return packet; +} + +%activity: +MpduAggregation builder; +const int spacingNanoseconds[] = {0, 250, 500, 1000, 2000, 4000, 8000, 16000}; +for (int mcs : {0, 7}) { + auto mode = findMode(mcs); + const int rate = mcs == 0 ? 6500000 : 65000000; + for (int spacing = 0; spacing < 8; spacing++) { + for (int length : {29, 30, 31, 32}) { + std::vector frames = {makeMember(length, 6), makeMember(33)}; + int alignedDistance = ((length + 4 + 3) / 4) * 4; + int minimumDistance = (int64_t(spacingNanoseconds[spacing]) * rate + 7999999999LL) / 8000000000LL; + int distance = std::max(alignedDistance, ((minimumDistance + 3) / 4) * 4); + int extraDelimiters = (distance - alignedDistance) / 4; + ASSERT(mode->getMinimumMpduStartDistance(spacing) == B(minimumDistance)); + B expectedLength(distance + 4 + 33); + ASSERT(builder.computeAggregateLength(frames, mode, spacing) == expectedLength); + auto aggregate = builder.aggregateFrames(frames, mode, spacing, B(65535)); + ASSERT(aggregate != nullptr && aggregate->getDataLength() == expectedLength); + auto tags = aggregate->getAllRegionTags(); + ASSERT(tags.size() == 2); + ASSERT(tags[0].getStartOffset() == B(6) && tags[0].getLength() == B(3)); + ASSERT(tags[1].getStartOffset() == B(distance + 6) && tags[1].getLength() == B(3)); + auto bytes = aggregate->peekAllAsBytes()->getBytes(); + ASSERT(bytes.size() == expectedLength.get()); + ASSERT(bytes[0] == uint8_t(length << 4) && bytes[1] == (length >> 4) && bytes[3] == 0x4E); + for (int i = 0; i < length; i++) + ASSERT(bytes[4 + i] == 0xA5); + for (int i = length + 4; i < alignedDistance; i++) + ASSERT(bytes[i] == 0); + for (int i = 0; i < extraDelimiters; i++) { + int offset = alignedDistance + 4 * i; + ASSERT(bytes[offset] == 0 && bytes[offset + 1] == 0 && bytes[offset + 3] == 0x4E); + } + Packet independent("wire", makeShared(bytes)); + auto layout = inspectMpduAggregate(&independent, B(0), expectedLength); + ASSERT(layout.complete && layout.ranges.size() == size_t(4 + extraDelimiters)); + ASSERT(layout.ranges.back().offset == B(distance + 4)); + ASSERT(layout.ranges.back().length == B(33)); + auto refused = builder.aggregateFrames(frames, mode, spacing, expectedLength - B(1)); + ASSERT(refused == nullptr); + MpduDeaggregation deaggregation; + auto extracted = deaggregation.deaggregateFrame(aggregate->dup()); + ASSERT(extracted->size() == 2); + for (auto frame : *extracted) { + auto memberTags = frame->getAllRegionTags(); + ASSERT(memberTags.size() == 1); + ASSERT(memberTags.front().getStartOffset() == B(2)); + ASSERT(memberTags.front().getLength() == B(3)); + delete frame; + } + delete extracted; + for (auto frame : frames) { + ASSERT(frame->peekAllAsBytes()->getBytes().front() == 0xA5); + ASSERT(frame->getAllRegionTags().size() == 1); + delete frame; + } + // The envelope retains immutable member content after source disposal. + ASSERT(aggregate->peekAllAsBytes()->getBytes() == bytes); + delete aggregate; + } + } +} +auto mode = findMode(7); +std::vector singleton = {makeMember(31)}; +auto aggregate = builder.aggregateFrames(singleton, mode, 7, B(35)); +ASSERT(aggregate != nullptr && aggregate->getDataLength() == B(35)); +auto ht = makeShared(); +ht->setLengthField(B(35)); +ht->setAggregation(true); +ht->setMcs(7); +ht->setCrc(computeIeee80211HtSignalCrc(*ht)); +aggregate->insertAtFront(ht); +Packet fresh("fresh", makeShared(aggregate->peekAllAsBytes()->getBytes())); +auto decoded = fresh.popAtFront(B(6)); +ASSERT(decoded->getAggregation() && decoded->getLengthField() == B(35)); +ASSERT(isIeee80211HtSignalValid(*decoded, mode)); +ASSERT(inspectMpduAggregate(&fresh, B(0), B(35)).complete); +delete aggregate; +delete singleton.front(); +std::vector empty; +ASSERT(builder.aggregateFrames(empty, mode, 0, B(65535)) == nullptr); +for (int length : {4095, 4096}) { + std::vector frames = {makeMember(length)}; + auto result = builder.aggregateFrames(frames, mode, 0, B(65535)); + ASSERT((result != nullptr) == (length == 4095)); + delete result; + delete frames.front(); +} +// 15 * (4 + 4092) + (4 + 4091) = 65535 octets, without final padding. +std::vector maximum; +for (int i = 0; i < 15; i++) + maximum.push_back(makeMember(4092)); +maximum.push_back(makeMember(4091)); +ASSERT(builder.computeAggregateLength(maximum, mode, 0) == B(65535)); +auto maximumAggregate = builder.aggregateFrames(maximum, findMode(15), 0, B(65535)); +ASSERT(maximumAggregate != nullptr); +delete maximumAggregate; +maximum.push_back(makeMember(30)); +ASSERT(builder.aggregateFrames(maximum, mode, 0, B(65535)) == nullptr); +for (auto frame : maximum) + delete frame; +// A low DATA rate reaches the L-SIG limit before the separate 10 ms limit. +auto slow = findMode(0); +auto slow24 = findMode(0, true); +bool sawLastValid = false; +for (int length = 4000; length < 5000; length++) { + auto duration = slow->getDuration(B(length)) - slow->getSignalExtensionTime(); + ASSERT(slow->isPpduDurationValid(B(length)) == (duration <= SimTime(5484, SIMTIME_US))); + ASSERT(slow24->getDuration(B(length)) == slow->getDuration(B(length)) + SimTime(6, SIMTIME_US)); + ASSERT(slow24->getLSigLength(B(length)) == slow->getLSigLength(B(length))); + ASSERT(slow24->isPpduDurationValid(B(length)) == slow->isPpduDurationValid(B(length))); + if (duration == SimTime(5484, SIMTIME_US)) { + ASSERT(slow->getLSigLength(B(length)) == 4095); + sawLastValid = true; + } +} +ASSERT(sawLastValid); +bool sawTenMilliseconds = false; +for (int length = 8000; length < 8200; length++) { + auto duration = slow->getDuration(B(length)); + ASSERT(slow->isPpduDurationWithinLimit(B(length)) == (duration <= SimTime(10, SIMTIME_MS))); + if (duration == SimTime(10, SIMTIME_MS)) + sawTenMilliseconds = true; +} +ASSERT(sawTenMilliseconds); +std::vector slowBatch = {makeMember(4000), makeMember(1000)}; +ASSERT(slow->getDuration(B(5008)) < SimTime(10, SIMTIME_MS)); +ASSERT(builder.aggregateFrames(slowBatch, slow, 0, B(65535)) == nullptr); +for (auto frame : slowBatch) + delete frame; +for (int spacing : {-1, 8}) { + bool rejected = false; + try { mode->getMinimumMpduStartDistance(spacing); } + catch (const cRuntimeError&) { rejected = true; } + ASSERT(rejected); +} +std::vector consumed = {makeMember(29, 6), makeMember(31)}; +auto legacy = builder.aggregateFrames(&consumed); +ASSERT(legacy->getDataLength() == B(71)); +ASSERT(inspectMpduAggregate(legacy, B(0), B(71)).complete); +auto legacyTags = legacy->getAllRegionTags(); +ASSERT(legacyTags.size() == 2); +ASSERT(legacyTags[0].getStartOffset() == B(6)); +ASSERT(legacyTags[1].getStartOffset() == B(42)); +delete legacy; +EV << "HT aggregate construction checks passed\n"; + +%contains: stdout +HT aggregate construction checks passed diff --git a/tests/unit/Ieee80211AmpduWire_1.test b/tests/unit/Ieee80211AmpduWire_1.test index a94eb25e43d..3a7d3f3266f 100644 --- a/tests/unit/Ieee80211AmpduWire_1.test +++ b/tests/unit/Ieee80211AmpduWire_1.test @@ -163,7 +163,13 @@ auto refusedLayout = inspectMpduAggregate(&missingMember, B(0), B(4)); ASSERT(!refusedLayout.complete && refusedLayout.ranges.size() == 1 && !refusedLayout.ranges[0].valid); for (int size : {0, 1, 2, 3}) { Packet shortInput("short", makeShared(std::vector(size, 0))); - ASSERT(inspectMpduAggregate(&shortInput, B(0), B(size)).ranges.empty()); + auto layout = inspectMpduAggregate(&shortInput, B(0), B(size)); + ASSERT(layout.ranges.size() == (size == 0 ? 0 : 1)); + ASSERT(layout.complete == (size == 0)); + if (size != 0) { + ASSERT(layout.ranges[0].kind == MpduRangeKind::DELIMITER); + ASSERT(!layout.ranges[0].valid && layout.ranges[0].length == B(size)); + } } auto tooLong = makeShared(); tooLong->setLength(4096); From 85f17114b35333d07b99d0a60f60900c42157e8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 28/41] ieee80211: fix: refuse failed PHY containers before MAC peeks Before this commit, Rx excludes a decoded aggregate from standalone FCS checks. A failed common header can lack that decoded property, so its container can reach an unsafe MAC peek. After this commit, Rx also checks common-header success and complete content before standalone parsing. The boundary fixture supplies malformed containers and proves refusal before the FCS predicate. Correct standalone reception retains its existing path. Plan: plan/pending/ieee80211-ampdu-implicit-blockack.md Change: src.ieee80211 | behavior.change.fix | test | ieee80211-implicit-blockack --- src/inet/linklayer/ieee80211/mac/Rx.cc | 7 +- tests/module/Ieee80211AmpduRxBoundary_1.test | 161 +++++++++++++++++++ 2 files changed, 165 insertions(+), 3 deletions(-) create mode 100644 tests/module/Ieee80211AmpduRxBoundary_1.test diff --git a/src/inet/linklayer/ieee80211/mac/Rx.cc b/src/inet/linklayer/ieee80211/mac/Rx.cc index caf03f86200..48355834103 100644 --- a/src/inet/linklayer/ieee80211/mac/Rx.cc +++ b/src/inet/linklayer/ieee80211/mac/Rx.cc @@ -105,10 +105,11 @@ bool Rx::lowerFrameReceived(Packet *packet) Enter_Method("lowerFrameReceived(\"%s\")", packet->getName()); take(packet); - // Aggregate containers need member acceptance before standalone FCS or header checks. - // Reject them until MAC aggregate reception exists; PHY range outcomes stay separate. + // A failed HT header supplies no decoded Aggregation property. Refuse its container before MAC peeks. + // Aggregate containers use the separate member acceptance path. auto aggregate = packet->findTag(); - bool isFrameOk = !(aggregate && aggregate->getAggregation()) && isFcsOk(packet); + bool isFrameOk = !(aggregate && (!aggregate->getHeaderSuccessful() || !aggregate->getContentComplete() || + aggregate->getAggregation())) && isFcsOk(packet); if (isFrameOk) { EV_INFO << "Received frame from PHY: " << packet << endl; const auto& header = packet->peekAtFront(); diff --git a/tests/module/Ieee80211AmpduRxBoundary_1.test b/tests/module/Ieee80211AmpduRxBoundary_1.test new file mode 100644 index 00000000000..5f447a161aa --- /dev/null +++ b/tests/module/Ieee80211AmpduRxBoundary_1.test @@ -0,0 +1,161 @@ +%description: +Rx rejects an unsuccessful PHY header or incomplete content before the standalone FCS check. +The rejection applies when the PHY clears the aggregation flag after header failure. +Seven PHY flag combinations use one-byte bodies with a clear Packet bit-error flag. +Each rejection emits one drop with unchanged copied PHY tags and one corruption notification. +A valid standalone CTS reaches the production FCS check, with and without a nonaggregate PHY indication. +This fixture tests the Rx entry point. The PHY reception fixture tests the real radio path. + +%file: AmpduRxBoundary.cc +#include "inet/common/Simsignals.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/linklayer/ieee80211/mac/contract/IContention.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +class RxBoundaryContention : public IContention +{ + public: + int corruptions = 0; + void startContention(int, simtime_t, simtime_t, simtime_t, ICallback *) override { ASSERT(false); } + bool isContentionInProgress() override { return false; } + void mediumStateChanged(bool) override {} + void corruptedFrameReceived() override { corruptions++; } +}; + +class AmpduRxBoundary : public Rx, public cListener +{ + RxBoundaryContention contention; + mutable int fcsCalls = 0; + int drops = 0; + bool expectedHeader = false; + bool expectedComplete = false; + bool expectedAggregation = false; + Ptr retained; + + protected: + int numInitStages() const override { return 1; } + void initialize(int stage) override { + Rx::initialize(stage); + address = MacAddress("02:00:00:00:00:01"); + registerContention(&contention); + subscribe(packetDroppedSignal, this); + scheduleAt(SIMTIME_ZERO, new cMessage("exercise")); + } + bool isFcsOk(Packet *packet) const override { + fcsCalls++; + return Rx::isFcsOk(packet); + } + void receiveSignal(cComponent *, simsignal_t signal, cObject *object, cObject *details) override { + ASSERT(signal == packetDroppedSignal); + auto packet = check_and_cast(object); + ASSERT(check_and_cast(details)->getReason() == INCORRECTLY_RECEIVED); + ASSERT(packet->getDataLength() == B(1) && !packet->hasBitError()); + ASSERT(fcsCalls == 0); + auto indication = packet->getTag(); + ASSERT(indication->getHeaderSuccessful() == expectedHeader); + ASSERT(indication->getContentComplete() == expectedComplete); + ASSERT(indication->getAggregation() == expectedAggregation); + ASSERT(indication->getRangesArraySize() == 1); + const auto& range = indication->getRanges(0); + ASSERT(range.kind == 1 && range.offset == B(0) && range.length == B(1)); + ASSERT(range.valid && !range.successful); + ASSERT(packet->getTag()->getPower() == W(0.001)); + ASSERT(packet->getTag()->getMinimumSnir() == 42); + auto time = packet->getTag(); + ASSERT(time->getStartTime() == SIMTIME_ZERO && time->getEndTime() == SimTime(1, SIMTIME_US)); + ASSERT(time->getTransmissionId() == 73); + retained = makeShared(*indication); + drops++; + } + void handleMessage(cMessage *message) override { + delete message; + for (int flags = 0; flags < 8; flags++) { + expectedHeader = flags & 1; + expectedComplete = flags & 2; + expectedAggregation = flags & 4; + if (expectedHeader && expectedComplete && !expectedAggregation) + continue; + auto source = new Packet("short-phy-result", makeShared(B(1))); + auto indication = source->addTag(); + indication->setHeaderSuccessful(expectedHeader); + indication->setContentComplete(expectedComplete); + indication->setAggregation(expectedAggregation); + indication->setRangesArraySize(1); + Ieee80211AmpduRange range; + range.kind = 1; + range.offset = B(0); + range.length = B(1); + range.valid = true; + range.successful = false; + indication->setRanges(0, range); + source->addTag()->setPower(W(0.001)); + source->addTag()->setMinimumSnir(42); + auto time = source->addTag(); + time->setStartTime(SIMTIME_ZERO); + time->setEndTime(SimTime(1, SIMTIME_US)); + time->setTransmissionId(73); + auto input = source->dup(); + delete source; + int previousDrops = drops; + int previousCorruptions = contention.corruptions; + ASSERT(!lowerFrameReceived(input)); + ASSERT(drops == previousDrops + 1 && contention.corruptions == previousCorruptions + 1); + ASSERT(fcsCalls == 0); + ASSERT(retained && retained->getRanges(0).length == B(1)); + ASSERT(retained->getHeaderSuccessful() == expectedHeader); + } + for (bool tagged : {false, true}) { + auto frame = new Packet("valid-standalone"); + auto header = makeShared(); + header->setReceiverAddress(address); + frame->insertAtBack(header); + auto trailer = makeShared(); + trailer->setFcsMode(FCS_DECLARED_CORRECT); + frame->insertAtBack(trailer); + if (tagged) { + auto indication = frame->addTag(); + indication->setHeaderSuccessful(true); + indication->setContentComplete(true); + indication->setAggregation(false); + } + int previousFcsCalls = fcsCalls; + ASSERT(lowerFrameReceived(frame)); + ASSERT(fcsCalls == previousFcsCalls + 1); + ASSERT(drops == 7 && contention.corruptions == 7); + delete frame; + } + EV << "Rx PHY boundary checks passed: seven rejections and two standalone acceptances\n"; + } +}; +Define_Module(AmpduRxBoundary); + +%file: test.ned +simple AmpduRxBoundary +{ + parameters: + @class(::AmpduRxBoundary); +} +network Test +{ + submodules: + rx: AmpduRxBoundary; +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src +sim-time-limit = 1ms +seed-set = 0 +cmdenv-express-mode = false +**.scalar-recording = false +**.vector-recording = false + +%contains: stdout +Rx PHY boundary checks passed: seven rejections and two standalone acceptances From 5b7e1c6cfd5c3331e65c974d825d8869ae805e3a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 29/41] ieee80211: add: prepare independent HT aggregate members Before this commit, the QoS service can prepare one DATA transmission but cannot retain independent previews beside canonical retry members. An aggregate selection must preserve sources until actual submission. After this commit, the HT policy selects borrowed members under supplied peer, window, mode, spacing, and length limits. The service gives each queued member an independent preview. Batch commitment validates every source before extraction. Canonical members retain their sequence numbers and deadlines. Forwarded previews use the local transmitter address without changing queued headers or ordinary A-MSDU construction. HCF rejects aggregate opt-in with a rate-control submodule at initialization. The default Basic policy remains disabled. Preparation fixtures check refusal, wrap, deadlines, limits, retained members, and both AARF rejection configurations. Plan: plan/pending/ieee80211-ampdu-implicit-blockack.md Change: src.ieee80211 | behavior.add | test whatsnew migration | ieee80211-implicit-blockack --- .../aggregation/BasicMpduAggregationPolicy.h | 2 + .../aggregation/HtMpduAggregationPolicy.cc | 46 +++ .../mac/aggregation/HtMpduAggregationPolicy.h | 24 ++ .../aggregation/HtMpduAggregationPolicy.ned | 14 + .../mac/contract/IMpduAggregationPolicy.h | 16 + .../contract/IOriginatorQosMacDataService.h | 15 + .../ieee80211/mac/coordinationfunction/Hcf.cc | 2 + .../originator/OriginatorQosMacDataService.cc | 95 ++++- .../originator/OriginatorQosMacDataService.h | 8 + .../ieee80211/mac/queue/InProgressFrames.cc | 9 + .../ieee80211/mac/queue/InProgressFrames.h | 1 + tests/module/Ieee80211AmpduPreparation_1.test | 373 ++++++++++++++++++ 12 files changed, 604 insertions(+), 1 deletion(-) create mode 100644 src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.cc create mode 100644 src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.h create mode 100644 src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.ned create mode 100644 tests/module/Ieee80211AmpduPreparation_1.test diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/BasicMpduAggregationPolicy.h b/src/inet/linklayer/ieee80211/mac/aggregation/BasicMpduAggregationPolicy.h index 782034b515c..125c2c35dc5 100644 --- a/src/inet/linklayer/ieee80211/mac/aggregation/BasicMpduAggregationPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/aggregation/BasicMpduAggregationPolicy.h @@ -21,6 +21,8 @@ class INET_API BasicMpduAggregationPolicy : public IMpduAggregationPolicy, publi public: virtual std::vector *computeAggregateFrames(std::vector *frames) override; + virtual bool isEnabled() const override { return false; } + virtual std::vector selectFrames(const std::vector& candidates, const MpduAggregationLimits& limits) const override { return {}; } }; } /* namespace ieee80211 */ diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.cc b/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.cc new file mode 100644 index 00000000000..1dc290d83a2 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.cc @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#include "inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.h" + +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h" + +namespace inet { +namespace ieee80211 { + +Define_Module(HtMpduAggregationPolicy); + +std::vector HtMpduAggregationPolicy::selectFrames(const std::vector& candidates, + const MpduAggregationLimits& limits) const +{ + auto mode = dynamic_cast(limits.mode); + if (!mode || mode->getDataMode()->getBandwidth() != MHz(20) || mode->isHtShortGuardInterval() || + mode->getPreambleMode()->getPreambleFormat() != physicallayer::Ieee80211HtPreambleMode::HT_PREAMBLE_MIXED) + return {}; + std::vector selected; + MpduAggregation builder; + std::set sequences; + for (auto packet : candidates) { + auto header = dynamicPtrCast(packet->peekAtFront()); + if (!header || header->getType() != ST_DATA_WITH_QOS || header->getReceiverAddress().isMulticast() || + header->getReceiverAddress() != limits.receiver || header->getTransmitterAddress() != limits.transmitter || + header->getTid() != limits.tid || header->getAMsduPresent() || header->getMoreFragments() || + header->getFragmentNumber() != 0 || !header->getSequenceNumber().isSpecified()) + break; + int distance = OriginatorBlockAckAgreement::computeSequenceDistance(limits.windowStart, header->getSequenceNumber()); + if (distance >= limits.windowSize || !sequences.insert(header->getSequenceNumber().get()).second || + selected.size() >= size_t(std::min(64, limits.windowSize))) + break; + selected.push_back(packet); + B length = builder.computeAggregateLength(selected, mode, limits.minimumMpduStartSpacing); + if (length == B(0) || length > limits.maxLength || !mode->isPpduDurationValid(length)) { + selected.pop_back(); + break; + } + } + return selected; +} + +} // namespace ieee80211 +} // namespace inet diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.h b/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.h new file mode 100644 index 00000000000..e6d1e00ae85 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.h @@ -0,0 +1,24 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_HTMPDUAGGREGATIONPOLICY_H +#define __INET_HTMPDUAGGREGATIONPOLICY_H + +#include "inet/common/SimpleModule.h" +#include "inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h" + +namespace inet { +namespace ieee80211 { + +class INET_API HtMpduAggregationPolicy : public SimpleModule, public IMpduAggregationPolicy +{ + public: + virtual bool isEnabled() const override { return true; } + // The legacy consuming path has no negotiated context and cannot enable HT aggregation. + virtual std::vector *computeAggregateFrames(std::vector *frames) override { return nullptr; } + virtual std::vector selectFrames(const std::vector& candidates, const MpduAggregationLimits& limits) const override; +}; + +} // namespace ieee80211 +} // namespace inet + +#endif diff --git a/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.ned b/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.ned new file mode 100644 index 00000000000..fe1492cbf09 --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/aggregation/HtMpduAggregationPolicy.ned @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +package inet.linklayer.ieee80211.mac.aggregation; + +import inet.common.SimpleModule; +import inet.linklayer.ieee80211.mac.contract.IMpduAggregationPolicy; + +// Selects independent HT20 long-GI members within the caller's negotiated receiver limits. +simple HtMpduAggregationPolicy extends SimpleModule like IMpduAggregationPolicy +{ + parameters: + @class(HtMpduAggregationPolicy); + @display("i=block/control"); +} diff --git a/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h b/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h index 0f2f8529bdd..ed29db863c5 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h @@ -12,14 +12,30 @@ #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" namespace inet { +namespace physicallayer { class IIeee80211Mode; } namespace ieee80211 { +struct INET_API MpduAggregationLimits +{ + MacAddress receiver; + MacAddress transmitter; + Tid tid = -1; + SequenceNumberCyclic windowStart; + int windowSize = 0; + B maxLength = B(0); + int minimumMpduStartSpacing = 0; // Encoded peer receiver limit, 0..7. + const physicallayer::IIeee80211Mode *mode = nullptr; +}; + class INET_API IMpduAggregationPolicy { public: virtual ~IMpduAggregationPolicy() {} virtual std::vector *computeAggregateFrames(std::vector *frames) = 0; + virtual bool isEnabled() const = 0; + // The result borrows an eligible prefix of the supplied candidates. No source state changes. + virtual std::vector selectFrames(const std::vector& candidates, const MpduAggregationLimits& limits) const = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h index 04f0ecda71b..dd6019cc3dd 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h @@ -11,6 +11,7 @@ #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h" +#include "inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h" namespace inet { namespace ieee80211 { @@ -28,6 +29,13 @@ struct INET_API PreparedQosData : public cObject Packet *releasePacket(); }; +/** Owns queued previews and borrows canonical members. The order is the proposed transmit order. */ +struct INET_API PreparedQosBatch +{ + std::vector> queued; + std::vector members; +}; + class INET_API IOriginatorQosMacDataService : public IOriginatorMacDataService { public: @@ -35,6 +43,13 @@ class INET_API IOriginatorQosMacDataService : public IOriginatorMacDataService virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const = 0; virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const = 0; virtual bool hasAMsduAggregation() const = 0; + virtual bool hasAMpduAggregation() const = 0; + virtual std::unique_ptr prepareBatch(queueing::IPacketQueue *queue, + const std::vector& retained, const MpduAggregationLimits& limits) = 0; + virtual bool isBatchValid(const PreparedQosBatch& batch, simtime_t start) const = 0; + // Success transfers each new member to the caller; canonical members remain borrowed. + virtual bool commitPreparedBatch(PreparedQosBatch& batch, std::vector& committed) = 0; + virtual Packet *buildAggregate(const PreparedQosBatch& batch, const MpduAggregationLimits& limits) const = 0; // These QoS DATA methods separate reversible preparation from extraction and sequence assignment. virtual std::unique_ptr prepareFrame(queueing::IPacketQueue *queue, bool allowAggregation) = 0; virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const = 0; diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index 601eb39739e..3cd1655b0fa 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -87,6 +87,8 @@ void Hcf::initialize(int stage) } } else if (stage == INITSTAGE_LAST) { + if (check_and_cast(originatorDataService)->hasAMpduAggregation() && dataAndMgmtRateControl) + throw cRuntimeError("HT A-MPDU transmission requires fixed DATA rates without a rate-control submodule"); if (blockAckVariant == BlockAckVariant::COMPRESSED && par("isBlockAckSupported").boolValue()) { interframeRadio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); auto radioModule = check_and_cast(interframeRadio.get()); diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc index c3612e1c969..4d4404e20e1 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc @@ -12,6 +12,7 @@ #include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" #include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" #include "inet/linklayer/ieee80211/mac/aggregation/MsduAggregation.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" #include "inet/linklayer/ieee80211/mac/channelaccess/Edca.h" #include "inet/linklayer/ieee80211/mac/fragmentation/Fragmentation.h" #include "inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h" @@ -108,11 +109,20 @@ std::unique_ptr OriginatorQosMacDataService::prepareFrame(queue } bool OriginatorQosMacDataService::isPreparationValid(const PreparedQosData& preparation, simtime_t start) const +{ + if (!preparation.packet) + return false; + auto header = preparation.packet->peekAtFront(); + return isPreparationValidForSequence(preparation, start, getNextSequenceNumber(header->getReceiverAddress(), header->getTid())); +} + +bool OriginatorQosMacDataService::isPreparationValidForSequence(const PreparedQosData& preparation, + simtime_t start, SequenceNumberCyclic sequence) const { if (!preparation.packet || !preparation.queue || preparation.sourceIds.empty()) return false; auto header = preparation.packet->peekAtFront(); - if (header->getSequenceNumber() != getNextSequenceNumber(header->getReceiverAddress(), header->getTid())) + if (header->getSequenceNumber() != sequence) return false; for (auto id : preparation.sourceIds) { Packet *source = nullptr; @@ -136,6 +146,11 @@ Packet *OriginatorQosMacDataService::commitPreparedFrame(PreparedQosData& prepar Enter_Method("commitPreparedFrame"); if (!isPreparationValid(preparation, simTime())) return nullptr; + return commitValidatedFrame(preparation); +} + +Packet *OriginatorQosMacDataService::commitValidatedFrame(PreparedQosData& preparation) +{ std::vector sources; std::vector trackedIds; simtime_t deadline = SIMTIME_MAX; @@ -190,6 +205,84 @@ Packet *OriginatorQosMacDataService::commitPreparedFrame(PreparedQosData& prepar return packet; } +std::unique_ptr OriginatorQosMacDataService::prepareBatch(queueing::IPacketQueue *queue, + const std::vector& retained, const MpduAggregationLimits& limits) +{ + Enter_Method("prepareBatch"); + if (!hasAMpduAggregation()) + return nullptr; + auto batch = std::make_unique(); + std::vector candidates = retained; + auto sequence = getNextSequenceNumber(limits.receiver, limits.tid); + for (int i = 0; i < queue->getNumPackets() && candidates.size() < size_t(std::min(64, limits.windowSize)); i++) { + auto source = queue->getPacket(i); + auto header = dynamicPtrCast(source->peekAtFront()); + if (!header || header->getType() != ST_DATA_WITH_QOS || header->getReceiverAddress() != limits.receiver || + header->getTid() != limits.tid || + header->getAMsduPresent() || header->getMoreFragments() || header->getFragmentNumber() != 0 || + source->getDataLength() > B(4095) || + (lifetimeHandler && lifetimeHandler->isExpired(source)) || (extractionEligible && !extractionEligible(source))) + continue; + int distance = OriginatorBlockAckAgreement::computeSequenceDistance(limits.windowStart, sequence); + if (distance >= limits.windowSize) + break; + auto preview = std::make_unique(); + preview->queue = queue; + preview->sourceIds.push_back(source->getId()); + preview->setPacket(source->dup()); + auto updated = preview->packet->removeAtFront(); + // IEEE Std 802.11-2024, 9.3.2.1.2: preview the local TA that Tx assigns before its FCS calculation. + updated->setTransmitterAddress(limits.transmitter); + updated->setSequenceNumber(sequence); + updated->setRetry(false); + updated->setAckPolicy(NORMAL_ACK); + preview->packet->insertAtFront(updated); + candidates.push_back(preview->packet.get()); + batch->queued.push_back(std::move(preview)); + sequence = sequence + 1; + } + batch->members = aMpduAggregationPolicy->selectFrames(candidates, limits); + batch->queued.erase(std::remove_if(batch->queued.begin(), batch->queued.end(), [&batch](const auto& preview) { + return std::find(batch->members.begin(), batch->members.end(), preview->packet.get()) == batch->members.end(); + }), batch->queued.end()); + return batch->members.empty() ? nullptr : std::move(batch); +} + +bool OriginatorQosMacDataService::isBatchValid(const PreparedQosBatch& batch, simtime_t start) const +{ + if (batch.members.empty()) + return false; + if (batch.queued.empty()) + return true; + auto first = batch.queued.front()->packet->peekAtFront(); + auto sequence = getNextSequenceNumber(first->getReceiverAddress(), first->getTid()); + for (const auto& preview : batch.queued) { + if (!preview->packet || std::find(batch.members.begin(), batch.members.end(), preview->packet.get()) == batch.members.end() || + !isPreparationValidForSequence(*preview, start, sequence)) + return false; + sequence = sequence + 1; + } + return true; +} + +bool OriginatorQosMacDataService::commitPreparedBatch(PreparedQosBatch& batch, std::vector& committed) +{ + Enter_Method("commitPreparedBatch"); + if (!isBatchValid(batch, simTime())) + return false; + // One synchronous validation precedes all extraction. Each member retains its own lifetime entry. + for (auto& preview : batch.queued) + committed.push_back(commitValidatedFrame(*preview)); + batch.queued.clear(); + return true; +} + +Packet *OriginatorQosMacDataService::buildAggregate(const PreparedQosBatch& batch, const MpduAggregationLimits& limits) const +{ + return aMpduAggregation ? aMpduAggregation->aggregateFrames(batch.members, limits.mode, + limits.minimumMpduStartSpacing, limits.maxLength) : nullptr; +} + Packet *OriginatorQosMacDataService::aMsduAggregateIfNeeded(queueing::IPacketQueue *pendingQueue, Packet *selected) { auto subframes = aMsduAggregationPolicy->computeAggregateFrames(pendingQueue); diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h index cddf0af45be..4b6941521ee 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h @@ -53,6 +53,8 @@ class INET_API OriginatorQosMacDataService : public IOriginatorQosMacDataService virtual std::vector *fragmentIfNeeded(Packet *frame); virtual Packet *aMsduAggregateIfNeeded(queueing::IPacketQueue *pendingQueue, Packet *selected); virtual Packet *aMpduAggregateIfNeeded(std::vector *fragments); + bool isPreparationValidForSequence(const PreparedQosData& preparation, simtime_t start, SequenceNumberCyclic sequence) const; + Packet *commitValidatedFrame(PreparedQosData& preparation); public: void setFragmentationPermission(std::function permission) { fragmentationPermitted = permission; } @@ -63,6 +65,12 @@ class INET_API OriginatorQosMacDataService : public IOriginatorQosMacDataService virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const override; virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const override; virtual bool hasAMsduAggregation() const override { return aMsduAggregationPolicy != nullptr; } + virtual bool hasAMpduAggregation() const override { return aMpduAggregationPolicy && aMpduAggregationPolicy->isEnabled(); } + virtual std::unique_ptr prepareBatch(queueing::IPacketQueue *queue, + const std::vector& retained, const MpduAggregationLimits& limits) override; + virtual bool isBatchValid(const PreparedQosBatch& batch, simtime_t start) const override; + virtual bool commitPreparedBatch(PreparedQosBatch& batch, std::vector& committed) override; + virtual Packet *buildAggregate(const PreparedQosBatch& batch, const MpduAggregationLimits& limits) const override; virtual std::unique_ptr prepareFrame(queueing::IPacketQueue *queue, bool allowAggregation) override; virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const override; virtual Packet *commitPreparedFrame(PreparedQosData& preparation) override; diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc index 190afe1d5c6..dd63aa884cb 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc @@ -69,6 +69,15 @@ bool InProgressFrames::isEligibleToTransmit(Packet *packet) ackHandler->isEligibleToTransmit(packet->peekAtFront()); } +std::vector InProgressFrames::getEligibleFrames() +{ + std::vector eligible; + for (auto packet : inProgressFrames) + if (isEligibleToTransmit(packet)) + eligible.push_back(packet); + return eligible; +} + void InProgressFrames::ensureHasFrameToTransmit() { if (!hasEligibleFrameToTransmit()) { diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h index 4804e562628..bd7264fffd3 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h @@ -63,6 +63,7 @@ class INET_API InProgressFrames : public SimpleModule virtual bool hasInProgressFrames() { ensureHasFrameToTransmit(); return hasEligibleFrameToTransmit(); } virtual std::vector getOutstandingFrames(); + std::vector getEligibleFrames(); virtual void clearDroppedFrames(); }; diff --git a/tests/module/Ieee80211AmpduPreparation_1.test b/tests/module/Ieee80211AmpduPreparation_1.test new file mode 100644 index 00000000000..b831c42a15f --- /dev/null +++ b/tests/module/Ieee80211AmpduPreparation_1.test @@ -0,0 +1,373 @@ +%description: +The production QoS data service prepares independent MPDUs through a production PacketQueue and HT aggregation policy. +Twelve deterministic cases check cancellation, refusal, commitment, sequence wrap, retained members, aggregate limits, and forwarded DATA previews. +Preparation preserves queued identities, owners, headers, deadlines, and sequence state. +Commitment preserves each deadline. Retained unsent and retry members preserve their numbers and Retry values. +Production InProgressFrames and QosAckHandler supply eligible retained members. +The fixture tests the service boundary. It does not test HCF aggregate arbitration or internal collision disposal. +Two postrun controls require HCF initialization to reject AARF with aggregate transmission, with and without fixed-rate overrides. + +%extraargs: -c Preparation -r 0..11 + +%postrun-command: python3 check-preparation.py + +%file: AmpduPreparation.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h" +#include "inet/linklayer/ieee80211/mac/originator/QosAckHandler.h" +#include "inet/linklayer/ieee80211/mac/queue/InProgressFrames.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h" +#include "inet/queueing/queue/PacketQueue.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +class AmpduPreparationService : public OriginatorQosMacDataService +{ + std::unique_ptr ownedLifetime; + protected: + void initialize() override { + OriginatorQosMacDataService::initialize(); + auto lifetime = SimTime(1, SIMTIME_S); + ownedLifetime = std::make_unique(lifetime, lifetime, lifetime, lifetime); + setLifetimeHandler(ownedLifetime.get(), {}); + setEligibility([](Packet *) { return true; }, [](Packet *) { return true; }); + } + public: + EdcaTransmitLifetimeHandler *lifetime() const { return ownedLifetime.get(); } + int64_t allocations() const { return nextDataAllocationIndex; } + // Advance the real sequence owner without a queue extraction or allocation. + void advanceTo(MacAddress peer, Tid tid, int next) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->setReceiverAddress(peer); + header->setTid(tid); + while (getNextSequenceNumber(peer, tid) != SequenceNumberCyclic(next)) + assignSequenceNumber(header); + } +}; +Define_Module(AmpduPreparationService); + +class AmpduPreparationTest : public cSimpleModule +{ + const MacAddress peer{"02:00:00:00:00:02"}; + const MacAddress sender{"02:00:00:00:00:01"}; + AmpduPreparationService *service = nullptr; + queueing::PacketQueue *queue = nullptr; + InProgressFrames *inProgress = nullptr; + QosAckHandler *ack = nullptr; + struct Source { + Packet *packet; + int64_t id; + cObject *owner; + simtime_t deadline; + }; + std::vector sources; + std::string operation() const { return par("operation").stdstringValue(); } + + Packet *enqueue(int index, bool nested = false) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(peer); + header->setTransmitterAddress(operation() == "forwarded" ? MacAddress("02:00:00:00:00:03") : sender); + header->setAddress3(peer); + header->setTid(0); + header->setSequenceNumber(SequenceNumberCyclic(77)); + header->setAMsduPresent(nested); + auto packet = new Packet("queued-msdu", header); + packet->insertAtBack(makeShared(B(100))); + packet->insertAtBack(makeShared()); + packet->setArrivalTime(simTime()); + queue->enqueuePacket(packet); + auto deadline = operation() == "expired" ? SimTime(2, SIMTIME_MS) : SimTime(100 + index, SIMTIME_MS); + service->lifetime()->registerFragments({packet}, deadline); + sources.push_back({packet, packet->getId(), packet->getOwner(), deadline}); + return packet; + } + void checkSources(int nextSequence, int64_t allocations) const { + ASSERT(queue->getNumPackets() == int(sources.size())); + ASSERT(service->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(nextSequence)); + ASSERT(service->allocations() == allocations); + for (size_t i = 0; i < sources.size(); i++) { + const auto& source = sources[i]; + ASSERT(queue->getPacket(i) == source.packet && source.packet->getId() == source.id); + ASSERT(source.packet->getOwner() == source.owner); + ASSERT(source.packet->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(source.packet->peekAtFront()->getTransmitterAddress() == + (operation() == "forwarded" ? MacAddress("02:00:00:00:00:03") : sender)); + ASSERT(!source.packet->findTag()); + ASSERT(service->lifetime()->findFrame(source.id) == source.packet); + ASSERT(service->lifetime()->getDeadline(source.packet) == source.deadline); + } + } + void dispose(Packet *packet) { + service->lifetime()->forgetFrame(packet->getId()); + take(packet); + delete packet; + } + MpduAggregationLimits limits() const { + MpduAggregationLimits result; + result.receiver = peer; + result.transmitter = sender; + result.tid = 0; + result.windowStart = SequenceNumberCyclic(0); + result.windowSize = 64; + result.maxLength = B(65535); + auto modes = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + for (int i = 0; i < modes->getNumModes(); i++) { + auto mode = modes->getMode(i); + if (mode->getHtMcsIndex() == 7 && mode->getDataMode()->getBandwidth() == MHz(20) && !mode->isHtShortGuardInterval()) + result.mode = mode; + } + ASSERT(result.mode); + return result; + } + std::vector retainTwo() { + for (int i = 0; i < 2; i++) { + enqueue(i); + auto preview = service->prepareFrame(queue, false); + ASSERT(preview); + auto frame = service->commitPreparedFrame(*preview); + ASSERT(frame); + sources.clear(); + inProgress->adoptPreparedFrame(frame); + if (i == 1) { + ack->processTransmittedDataOrMgmtFrame(frame->peekAtFront()); + ack->processFailedFrame(frame->peekAtFront()); + auto header = frame->removeAtFront(); + header->setRetry(true); + frame->insertAtFront(header); + } + } + auto retained = inProgress->getEligibleFrames(); + ASSERT(retained.size() == 2); + ASSERT(ack->getQoSDataAckStatus(retained[0]->peekAtFront()) == QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED); + ASSERT(ack->getQoSDataAckStatus(retained[1]->peekAtFront()) == QosAckHandler::Status::NORMAL_ACK_NOT_ARRIVED); + return retained; + } + + public: + AmpduPreparationTest() : cSimpleModule(65536) {} + protected: + void activity() override { + wait(SimTime(1, SIMTIME_MS)); + service = check_and_cast(getModuleByPath("^.service")); + queue = check_and_cast(getModuleByPath("^.queue")); + inProgress = check_and_cast(getModuleByPath("^.inProgress")); + ack = check_and_cast(getModuleByPath("^.ack")); + inProgress->setLifetimeHandler(service->lifetime()); + ASSERT(service->hasAMpduAggregation() && service->hasAMsduAggregation()); + std::vector retained; + if (operation() == "retained") + retained = retainTwo(); + int start = operation() == "wrap" ? 4095 : (retained.empty() ? 0 : 2); + if (operation() == "wrap") + service->advanceTo(peer, 0, start); + auto bounds = limits(); + bounds.windowStart = SequenceNumberCyclic(operation() == "wrap" ? 4095 : 0); + int count = operation() == "count" ? 66 : 3; + for (int i = 0; i < count; i++) + enqueue(10 + i, operation() == "nested" && i == 1); + int expected = count; + if (operation() == "window") { + bounds.windowSize = 2; + expected = 2; + } + if (operation() == "count") expected = 64; + if (operation() == "nested") expected = 2; + if (operation() == "bytes") { + MpduAggregation builder; + bounds.maxLength = builder.computeAggregateLength({sources[0].packet, sources[1].packet}, bounds.mode, 0) - B(1); + expected = 1; + } + auto allocationBase = service->allocations(); + auto noFit = bounds; + noFit.maxLength = B(0); + ASSERT(!service->prepareBatch(queue, retained, noFit)); + checkSources(start, allocationBase); + auto batch = service->prepareBatch(queue, retained, bounds); + ASSERT(batch && batch->queued.size() == size_t(expected)); + ASSERT(batch->members.size() == retained.size() + expected); + for (size_t i = 0; i < retained.size(); i++) ASSERT(batch->members[i] == retained[i]); + for (int i = 0; i < expected; i++) { + auto& preview = batch->queued[i]; + ASSERT(!preview->aggregate && preview->sourceIds.size() == 1); + ASSERT(preview->sourceIds[0] == sources[operation() == "nested" && i == 1 ? 2 : i].id); + auto header = preview->packet->peekAtFront(); + ASSERT(header->getSequenceNumber() == SequenceNumberCyclic((start + i) % 4096)); + ASSERT(header->getTransmitterAddress() == sender); + ASSERT(!header->getAMsduPresent() && !header->getRetry()); + } + checkSources(start, allocationBase); + auto aggregate = service->buildAggregate(*batch, bounds); + ASSERT(aggregate && aggregate->getDataLength() <= bounds.maxLength); + ASSERT(check_and_cast(bounds.mode)->isPpduDurationValid(aggregate->getDataLength())); + delete aggregate; + ASSERT(service->isBatchValid(*batch, simTime())); + wait(SimTime(2, SIMTIME_MS)); + checkSources(start, allocationBase); + std::vector committed; + if (operation() == "staleSource") { + auto packet = sources[0].packet; + queue->removePacket(packet); + dispose(packet); + sources.erase(sources.begin()); + } + if (operation() == "staleSequence") { + service->advanceTo(peer, 0, start + 1); + start++; + } + bool refused = operation() == "staleSource" || operation() == "staleSequence" || operation() == "expired"; + if (refused) { + ASSERT(!service->isBatchValid(*batch, simTime())); + ASSERT(!service->commitPreparedBatch(*batch, committed)); + ASSERT(committed.empty()); + checkSources(start, allocationBase); + } + else if (operation() != "cancel") { + std::vector deadlines; + std::vector previews; + for (const auto& preview : batch->queued) { + previews.push_back(preview->packet.get()); + deadlines.push_back(service->lifetime()->getDeadline(service->lifetime()->findFrame(preview->sourceIds[0]))); + } + ASSERT(service->commitPreparedBatch(*batch, committed)); + ASSERT(batch->queued.empty() && committed == previews); + ASSERT(committed.size() == size_t(expected)); + for (int i = 0; i < expected; i++) { + auto frame = committed[i]; + ASSERT(frame->getOwner() == service); + ASSERT(frame->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic((start + i) % 4096)); + ASSERT(frame->peekAtFront()->getTransmitterAddress() == sender); + ASSERT(frame->getTag()->getAllocationIndex() == allocationBase + i); + ASSERT(service->lifetime()->getDeadline(frame) == deadlines[i]); + } + ASSERT(service->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic((start + expected) % 4096)); + ASSERT(queue->getNumPackets() == count - expected); + if (operation() == "nested") ASSERT(queue->getPacket(0)->peekAtFront()->getAMsduPresent()); + } + batch.reset(); + if (operation() == "cancel") checkSources(start, allocationBase); + for (size_t i = 0; i < retained.size(); i++) { + auto frame = retained[i]; + ASSERT(inProgress->getFrames(i) == frame); + auto header = frame->peekAtFront(); + ASSERT(header->getSequenceNumber() == SequenceNumberCyclic(i)); + ASSERT(header->getRetry() == (i == 1)); + ASSERT(frame->getTag()->getAllocationIndex() == int64_t(i)); + ASSERT(service->lifetime()->getDeadline(frame) == SimTime(100 + i, SIMTIME_MS)); + ASSERT(ack->getQoSDataAckStatus(header) == (i == 0 ? QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED : QosAckHandler::Status::NORMAL_ACK_NOT_ARRIVED)); + service->lifetime()->forgetFrame(frame->getId()); + } + for (auto frame : committed) dispose(frame); + while (!queue->isEmpty()) { + auto frame = queue->dequeuePacket(); + dispose(frame); + } + ASSERT(service->lifetime()->getNumFrames() == 0); + std::cout << "A-MPDU preparation passed: " << operation() << "\n"; + endSimulation(); + } +}; +Define_Module(AmpduPreparationTest); + +%file: test.ned +import inet.linklayer.ieee80211.mac.originator.OriginatorQosMacDataService; +import inet.linklayer.ieee80211.mac.originator.QosAckHandler; +import inet.linklayer.ieee80211.mac.queue.InProgressFrames; +import inet.queueing.queue.PacketQueue; +import inet.node.inet.WirelessHost; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module AmpduPreparationService extends OriginatorQosMacDataService { parameters: @class(::AmpduPreparationService); } +simple AmpduPreparationTest { parameters: string operation; @class(::AmpduPreparationTest); } +network PreparationNetwork { + submodules: + service: AmpduPreparationService; + queue: PacketQueue; + ack: QosAckHandler; + inProgress: InProgressFrames { + pendingQueueModule = "^.queue"; + originatorMacDataServiceModule = "^.service"; + ackHandlerModule = "^.ack"; + } + test: AmpduPreparationTest; + connections allowunconnected: +} +network AarfNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + host: WirelessHost; +} + +%inifile: omnetpp.ini +[General] +ned-path = .;../../../../src;../../lib +sim-time-limit = 10ms +seed-set = 0 +cmdenv-express-mode = false +record-vector-results = false +record-scalar-results = false + +[Config Preparation] +network = PreparationNetwork +*.test.operation = ${operation="cancel","commit","staleSource","staleSequence","expired","wrap","retained","bytes","window","count","nested","forwarded"} +*.service.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +*.service.msduAggregationPolicy.subframeNumThreshold = 2 +*.service.msduAggregationPolicy.maxAMsduSize = 1000 +*.service.fragmentationPolicy.typename = "" + +[Config Aarf] +network = AarfNetwork +*.host.wlan[0].opMode = "n(mixed-2.4Ghz)" +*.host.wlan[0].mac.qosStation = true +*.host.wlan[0].mac.hcf.rateControl.typename = "AarfRateControl" +*.host.wlan[0].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +*.host.wlan[0].mgmt.typename = "Ieee80211MgmtAdhoc" +*.host.wlan[0].agent.typename = "" +*.host.wlan[0].radio.receiver.bandwidth = 20MHz +*.host.mobility.initFromDisplayString = false +*.host.mobility.initialX = 0m +*.host.mobility.initialY = 0m +*.host.mobility.initialZ = 0m +*.host.mobility.constraintAreaMinX = 0m +*.host.mobility.constraintAreaMinY = 0m +*.host.mobility.constraintAreaMinZ = 0m +*.host.mobility.constraintAreaMaxX = 100m +*.host.mobility.constraintAreaMaxY = 100m +*.host.mobility.constraintAreaMaxZ = 0m + +[Config AarfFixedOverride] +extends = Aarf +*.host.wlan[0].mac.hcf.rateSelection.dataFrameBitrate = 6.5Mbps +*.host.wlan[0].mac.hcf.rateSelection.dataFrameBandwidth = 20MHz +*.host.wlan[0].mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1 + +%file: check-preparation.py +from pathlib import Path +import os +import subprocess + +text = Path("test.out").read_text() +assert "Run statistics: total 12, successful 12" in text +operations = ("cancel", "commit", "staleSource", "staleSequence", "expired", "wrap", "retained", "bytes", "window", "count", "nested", "forwarded") +for operation in operations: + assert text.count(f"A-MPDU preparation passed: {operation}\n") == 1, operation +diagnostic = "HT A-MPDU transmission requires fixed DATA rates without a rate-control submodule" +executables = [path for path in Path.cwd().glob("Ieee80211AmpduPreparation_1*") if path.is_file() and os.access(path, os.X_OK)] +assert len(executables) == 1, executables +for config in ("Aarf", "AarfFixedOverride"): + command = [str(executables[0]), "-u", "Cmdenv", "--check-signals=false", "-n", "../../../../src:.:../../lib", "omnetpp.ini", "_defaults.ini", "-c", config, "-r", "0"] + result = subprocess.run(command, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + Path(f"control-{config}.out").write_text(result.stdout) + assert result.returncode != 0, (config, result.stdout) + assert diagnostic in result.stdout, (config, result.stdout) +print("Eleven preparation cases and both AARF initialization controls passed.") + +%contains: stdout +A-MPDU preparation passed: From 75b6adbc44d49444a0b1bd658bdaab02e1a6b5b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 30/41] ieee80211: add+change: complete implicit Compressed Block Ack exchanges Before this commit, prepared aggregates lack a complete MAC exchange. Rx cannot accept independent members, and HCF cannot submit a batch or resolve its implicit response. After this commit, Rx validates each member against cached PHY outcomes and its FCS. HCF applies agreement and address checks, records receipt, and supplies physical history for mandatory reorder release. The recipient returns one Compressed Block Ack after SIFS. A failed member cannot invalidate a correct neighbor or force EIFS after correct receipt. At actual DATA submission, HCF validates the agreement, deadlines, retained mode, and complete exchange cost. Tx finalizes each member before envelope construction. RTS selection uses the complete PSDU. Cancellation preserves queued sources. Failed RTS updates contention state without a DATA attempt or member retry charge. An unsuccessful implicit response requires one BAR probe before further DATA. Actual BAR submission consumes that requirement. Probe failure returns to DATA retry without duplicate DATA feedback. A recipient without an agreement can use the existing DELBA path, so continuous arrivals do not prevent stale-agreement retirement. For example, loss of the middle member retains that member's original deadline for selective retry. The other members can complete independently. Physical fixtures cover partial loss, SIFS responses, admission, cancellation, ownership, response windows, recovery, and reachable release conditions. Protocol fixtures prove sixty application deliveries through both AP hops. The approved HT expected-failure marker removal accompanies this feature. The earlier PHY boundary fixture now checks separate members through production Rx. Valid FCS trailers permit correct members to pass. The fixture checks member drops, delimiter recovery, and standalone CTS NAV across all 16 configurations. Related Rx boundary and reorder fixtures pass their 1 and 176 runs. The aggregate step, callback contracts, receipt context, response wait, and reset handling must land together. Their consumers share one exchange lifetime. Splitting this integration further would leave incomplete contracts or require temporary implementations. Earlier commits isolate the independent arithmetic, capabilities, construction, refusal, and preparation changes. Plan: plan/pending/ieee80211-ampdu-implicit-blockack.md Change: src.ieee80211 | behavior.add+change | test expected whatsnew migration | ieee80211-implicit-blockack --- .../linklayer/ieee80211/mac/Ieee80211Mac.cc | 19 + src/inet/linklayer/ieee80211/mac/Rx.cc | 66 ++ src/inet/linklayer/ieee80211/mac/Rx.h | 1 + src/inet/linklayer/ieee80211/mac/Tx.cc | 71 +- src/inet/linklayer/ieee80211/mac/Tx.h | 7 +- .../blockack/OriginatorBlockAckAgreement.h | 3 + .../RecipientBlockAckAgreementHandler.cc | 13 +- .../RecipientBlockAckAgreementHandler.h | 1 + .../blockack/RecipientBlockAckProcedure.cc | 30 +- .../mac/blockack/RecipientBlockAckProcedure.h | 1 + .../blockackreordering/BlockAckReordering.cc | 42 +- .../blockackreordering/BlockAckReordering.h | 5 +- .../ieee80211/mac/contract/AmpduReception.h | 57 ++ .../mac/contract/FrameTransmissionDetails.msg | 1 + .../mac/contract/IFrameSequenceHandler.h | 1 + .../mac/contract/IOriginatorQoSAckPolicy.h | 2 + .../mac/contract/IQosRateSelection.h | 1 + .../IRecipientBlockAckAgreementHandler.h | 1 + .../contract/IRecipientBlockAckProcedure.h | 1 + .../contract/IRecipientQosMacDataService.h | 3 +- .../linklayer/ieee80211/mac/contract/IRx.h | 3 + .../linklayer/ieee80211/mac/contract/ITx.h | 12 + .../ieee80211/mac/coordinationfunction/Dcf.cc | 5 + .../ieee80211/mac/coordinationfunction/Dcf.h | 1 + .../ieee80211/mac/coordinationfunction/Hcf.cc | 515 ++++++++++++- .../ieee80211/mac/coordinationfunction/Hcf.h | 27 +- .../mac/framesequence/FrameSequenceContext.cc | 22 + .../mac/framesequence/FrameSequenceContext.h | 8 +- .../mac/framesequence/FrameSequenceHandler.cc | 20 +- .../mac/framesequence/FrameSequenceHandler.h | 1 + .../mac/framesequence/FrameSequenceStep.h | 13 + .../framesequence/PrimitiveFrameSequences.cc | 40 +- .../framesequence/PrimitiveFrameSequences.h | 12 + .../ieee80211/mac/framesequence/TxOpFs.cc | 9 +- .../mac/originator/OriginatorQosAckPolicy.cc | 12 + .../mac/originator/OriginatorQosAckPolicy.h | 3 + .../ieee80211/mac/originator/QosAckHandler.cc | 22 +- .../ieee80211/mac/originator/QosAckHandler.h | 2 + .../mac/originator/QosRecoveryProcedure.cc | 5 + .../mac/originator/QosRecoveryProcedure.h | 1 + .../mac/rateselection/QosRateSelection.cc | 84 ++- .../mac/rateselection/QosRateSelection.h | 1 + .../recipient/RecipientQosMacDataService.cc | 4 +- .../recipient/RecipientQosMacDataService.h | 2 +- tests/module/Ieee80211AmpduAdmission_1.test | 700 ++++++++++++++++++ tests/module/Ieee80211AmpduExchange_1.test | 373 ++++++++++ tests/module/Ieee80211AmpduMacBoundary_1.test | 117 ++- tests/module/Ieee80211AmpduRecovery_1.test | 359 +++++++++ tests/module/Ieee80211AmpduReordering_1.test | 461 ++++++++++++ .../Ieee80211AmpduResponseWindow_1.test | 349 +++++++++ tests/module/Ieee80211AmpduTxStart_1.test | 225 ++++++ .../Ieee80211CompressedBlockAckInput_1.test | 5 +- .../Ieee80211HcfMultipleProtection_1.test | 3 + .../Ieee80211HcfSingleProtection_1.test | 3 + .../Ieee80211SingleProtectionGroup_1.test | 1 + tests/module/Ieee80211Txnav_1.test | 1 + tests/module/Ieee80211VhtHtSupport_1.test | 3 + tests/protocol/wifi/11n/N_Ampdu.test | 53 +- .../protocol/wifi/11n/N_AmpduImplicitBa.test | 153 ++++ .../Ieee80211AmpduResponseValidation_1.test | 45 ++ tests/unit/Ieee80211BlockAckScheduling_1.test | 41 + tests/unit/Ieee80211ResponseTimeout_1.test | 1 + tests/unit/Ieee80211TxNavChoice_1.test | 4 + 63 files changed, 3879 insertions(+), 168 deletions(-) create mode 100644 src/inet/linklayer/ieee80211/mac/contract/AmpduReception.h create mode 100644 tests/module/Ieee80211AmpduAdmission_1.test create mode 100644 tests/module/Ieee80211AmpduExchange_1.test create mode 100644 tests/module/Ieee80211AmpduRecovery_1.test create mode 100644 tests/module/Ieee80211AmpduReordering_1.test create mode 100644 tests/module/Ieee80211AmpduResponseWindow_1.test create mode 100644 tests/module/Ieee80211AmpduTxStart_1.test create mode 100644 tests/protocol/wifi/11n/N_AmpduImplicitBa.test create mode 100644 tests/unit/Ieee80211AmpduResponseValidation_1.test diff --git a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc index a372f92a72c..3cb053c2790 100644 --- a/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc +++ b/src/inet/linklayer/ieee80211/mac/Ieee80211Mac.cc @@ -210,6 +210,25 @@ void Ieee80211Mac::handleUpperPacket(Packet *packet) void Ieee80211Mac::handleLowerPacket(Packet *packet) { + auto aggregate = packet->findTag(); + if (aggregate && aggregate->getHeaderSuccessful() && aggregate->getContentComplete() && aggregate->getAggregation()) { + auto reception = rx->lowerAggregateReceived(packet); + take(packet); + for (auto& member : reception.members) + take(member.packet.get()); + if (!reception.anyCorrect) { + delete packet; + if (mib->qos) + hcf->corruptedFrameReceived(); + else + dcf->corruptedFrameReceived(); + } + else if (mib->qos) + hcf->processLowerAggregate(packet, std::move(reception)); + else + delete packet; + return; + } if (rx->lowerFrameReceived(packet)) { auto header = packet->peekAtFront(); processLowerFrame(packet, header); diff --git a/src/inet/linklayer/ieee80211/mac/Rx.cc b/src/inet/linklayer/ieee80211/mac/Rx.cc index 48355834103..7f7ec187b3d 100644 --- a/src/inet/linklayer/ieee80211/mac/Rx.cc +++ b/src/inet/linklayer/ieee80211/mac/Rx.cc @@ -129,6 +129,72 @@ bool Rx::lowerFrameReceived(Packet *packet) } } +AmpduReception Rx::lowerAggregateReceived(Packet *packet) +{ + Enter_Method("lowerAggregateReceived"); + take(packet); + AmpduReception result; + auto indication = packet->findTag(); + auto topology = std::make_shared(); + result.topology = topology; + if (indication && indication->getHeaderSuccessful() && indication->getAggregation() && indication->getContentComplete()) { + auto successful = [indication](int kind, B offset, B length) { + for (size_t i = 0; i < indication->getRangesArraySize(); i++) { + const auto& range = indication->getRanges(i); + if (range.kind == kind && range.offset == offset && range.length == length) + return range.valid && range.successful; + } + return false; + }; + // IEEE Std 802.11-2024, 9.7.1: a failed delimiter forces four-octet resynchronization. + auto layout = inspectMpduAggregate(packet, B(0), B(packet->getDataLength()), + [&successful](B offset, B length) { return successful(0, offset, length); }); + topology->ranges = layout.ranges; + topology->length = B(packet->getDataLength()); + bool first = true; + for (const auto& range : layout.ranges) { + if (range.kind == MpduRangeKind::DELIMITER) { + if (!range.valid) + first = false; + continue; + } + topology->members.push_back({range.offset, {}, first}); + first = false; + auto member = std::make_unique(packet->getName()); + member->insertAtBack(packet->peekDataAt(range.offset, range.length)); + member->getRegionTags().copyTags(packet->getRegionTags(), packet->getFrontOffset() + range.offset, + member->getFrontOffset(), range.length); + member->copyTags(*packet); + member->removeTagIfPresent(); + // The member outcome precedes every FCS mode, including declared-correct FCS. + member->setBitError(!successful(1, range.offset, range.length)); + bool correct = range.length >= B(4) && member->hasAtBack(B(4)) && + isFcsOk(member.get()) && member->hasAtFront(); + if (!correct) { + PacketDropDetails details; + details.setReason(INCORRECTLY_RECEIVED); + emit(packetDroppedSignal, member.get(), &details); + continue; + } + result.anyCorrect = true; + const auto& header = member->peekAtFront(); + if (header->getReceiverAddress() != address) + setOrExtendNav(header->getDurationField()); + if (auto data = dynamicPtrCast(header)) { + if (data->getSequenceNumber().isSpecified()) + topology->members.back().sequence = data->getSequenceNumber(); + } + result.members.push_back({std::move(member), range.offset}); + } + } + // IEEE Std 802.11-2024, 10.3.2.3.7: any correct MPDU excludes EIFS for this PPDU. + if (!result.anyCorrect) { + for (auto contention : contentions) + contention->corruptedFrameReceived(); + } + return result; +} + void Rx::frameTransmitted(simtime_t durationField) { Enter_Method("frameTransmitted"); diff --git a/src/inet/linklayer/ieee80211/mac/Rx.h b/src/inet/linklayer/ieee80211/mac/Rx.h index e6d6e81ca08..8f079bbe1a7 100644 --- a/src/inet/linklayer/ieee80211/mac/Rx.h +++ b/src/inet/linklayer/ieee80211/mac/Rx.h @@ -60,6 +60,7 @@ class INET_API Rx : public SimpleModule, public IRx virtual void transmissionStateChanged(physicallayer::IRadio::TransmissionState transmissionState) override; virtual void receivedSignalPartChanged(physicallayer::IRadioSignal::SignalPart part) override; virtual bool lowerFrameReceived(Packet *packet) override; + virtual AmpduReception lowerAggregateReceived(Packet *packet) override; virtual void frameTransmitted(simtime_t durationField) override; virtual simtime_t getTxnavRemaining() const override; virtual void successfulFrameTransmitted(simtime_t ppduEnd, simtime_t durationField) override; diff --git a/src/inet/linklayer/ieee80211/mac/Tx.cc b/src/inet/linklayer/ieee80211/mac/Tx.cc index 52f046613c0..1a3d8def863 100644 --- a/src/inet/linklayer/ieee80211/mac/Tx.cc +++ b/src/inet/linklayer/ieee80211/mac/Tx.cc @@ -47,9 +47,21 @@ void Tx::transmitFrame(Packet *packet, const Ptr& head void Tx::transmitFrame(Packet *packet, const Ptr& header, simtime_t ifs, bool updateLocalNav, ITx::ICallback *txCallback) { Enter_Method("transmitFrame(\"%s\")", packet->getName()); - ASSERT(this->txCallback == nullptr); + ASSERT(!hasTransmission()); this->txCallback = txCallback; this->updateLocalNav = updateLocalNav; + finalizeMpdu(packet); + this->frame = packet->dup(); + ASSERT(!endIfsTimer->isScheduled() && !transmitting); + if (ifs == 0) + startTransmission(); + else + scheduleAfter(ifs, endIfsTimer); +} + +void Tx::finalizeMpdu(Packet *packet) +{ + Enter_Method("finalizeMpdu"); auto macAddressInd = packet->addTagIfAbsent(); const auto& updatedHeader = packet->removeAtFront(); if (auto oneAddressHeader = dynamicPtrCast(updatedHeader)) { @@ -72,23 +84,63 @@ void Tx::transmitFrame(Packet *packet, const Ptr& head delete[] buffer; } packet->insertAtBack(updatedTrailer); - this->frame = packet->dup(); - ASSERT(!endIfsTimer->isScheduled() && !transmitting); // we are idle - if (ifs == 0) { - // do directly what handleMessage() would do - transmitting = true; - mac->sendDownFrame(frame->dup()); - } +} + +void Tx::transmitAggregate(simtime_t ifs, IAggregateCallback *callback) +{ + Enter_Method("transmitAggregate"); + ASSERT(!hasTransmission() && !endIfsTimer->isScheduled() && !transmitting && !frame); + aggregateCallback = callback; + updateLocalNav = false; + if (ifs == 0) + startTransmission(); else scheduleAfter(ifs, endIfsTimer); } +bool Tx::cancelPendingAggregate(IAggregateCallback *callback) +{ + Enter_Method("cancelPendingAggregate"); + if (aggregateCallback != callback || transmitting) + return false; + cancelEvent(endIfsTimer); + aggregateCallback = nullptr; + return true; +} + +void Tx::startTransmission() +{ + if (aggregateCallback) { + auto packet = aggregateCallback->prepareAggregateTransmission(); + if (!packet) { + auto callback = aggregateCallback; + aggregateCallback = nullptr; + callback->aggregateTransmissionCancelled(); + return; + } + frame = packet->dup(); + } + transmitting = true; + if (txCallback) + txCallback->frameTransmissionStarted(frame); + mac->sendDownFrame(frame->dup()); +} + void Tx::radioTransmissionFinished() { Enter_Method("radioTransmissionFinished"); if (transmitting) { EV_DETAIL << "Tx: radioTransmissionFinished()\n"; transmitting = false; + if (aggregateCallback) { + auto completedFrame = frame; + auto callback = aggregateCallback; + frame = nullptr; + aggregateCallback = nullptr; + callback->transmissionComplete(completedFrame, nullptr); + delete completedFrame; + return; + } ASSERT(txCallback != nullptr); const auto& header = frame->peekAtFront(); auto duration = header->getDurationField(); @@ -109,8 +161,7 @@ void Tx::handleMessage(cMessage *msg) { if (msg == endIfsTimer) { EV_DETAIL << "Tx: endIfsTimer expired\n"; - transmitting = true; - mac->sendDownFrame(frame->dup()); + startTransmission(); } else ASSERT(false); diff --git a/src/inet/linklayer/ieee80211/mac/Tx.h b/src/inet/linklayer/ieee80211/mac/Tx.h index 7e71e6a57ea..91ff8d35555 100644 --- a/src/inet/linklayer/ieee80211/mac/Tx.h +++ b/src/inet/linklayer/ieee80211/mac/Tx.h @@ -24,6 +24,7 @@ class INET_API Tx : public SimpleModule, public ITx { protected: ITx::ICallback *txCallback = nullptr; + ITx::IAggregateCallback *aggregateCallback = nullptr; Ieee80211Mac *mac = nullptr; IRx *rx = nullptr; Packet *frame = nullptr; @@ -35,6 +36,7 @@ class INET_API Tx : public SimpleModule, public ITx virtual int numInitStages() const override { return NUM_INIT_STAGES; } virtual void initialize(int stage) override; virtual void handleMessage(cMessage *msg) override; + void startTransmission(); public: Tx() {} @@ -42,7 +44,10 @@ class INET_API Tx : public SimpleModule, public ITx virtual void transmitFrame(Packet *packet, const Ptr& header, bool updateLocalNav, ITx::ICallback *txCallback) override; virtual void transmitFrame(Packet *packet, const Ptr& header, simtime_t ifs, bool updateLocalNav, ITx::ICallback *txCallback) override; - [[nodiscard]] bool hasTransmission() const override { return txCallback != nullptr; } + void transmitAggregate(simtime_t ifs, IAggregateCallback *callback) override; + bool cancelPendingAggregate(IAggregateCallback *callback) override; + void finalizeMpdu(Packet *packet) override; + [[nodiscard]] bool hasTransmission() const override { return txCallback != nullptr || aggregateCallback != nullptr; } virtual void radioTransmissionFinished() override; }; diff --git a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h index c760205173a..a6363c5dded 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h @@ -34,8 +34,11 @@ class INET_API OriginatorBlockAckAgreement : public cObject bool isAddbaRequestSent = false; simtime_t blockAckTimeoutValue = -1; simtime_t expirationTime = -1; + bool pendingProbe = false; public: + bool hasPendingProbe() const { return pendingProbe; } + void setPendingProbe(bool value) { pendingProbe = value; } OriginatorBlockAckAgreement(MacAddress receiverAddr, Tid tid, SequenceNumberCyclic startingSequenceNumber, int bufferSize, bool isAMsduSupported, bool isDelayedBlockAckPolicySupported) : receiverAddr(receiverAddr), tid(tid), diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc index 717368a5a46..7c63aea9ec2 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.cc @@ -35,7 +35,7 @@ void RecipientBlockAckAgreementHandler::scheduleInactivityTimer(IBlockAckAgreeme void RecipientBlockAckAgreementHandler::qosFrameReceived(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) { // IEEE Std 802.11-2024, 11.5.4: matching Block Ack-policy DATA refreshes inactivity, including a duplicate. - if (qosHeader->getAckPolicy() == AckPolicy::BLOCK_ACK) { // TODO + Implicit Block Ack + if (qosHeader->getAckPolicy() == AckPolicy::BLOCK_ACK) { Tid tid = qosHeader->getTid(); MacAddress originatorAddr = qosHeader->getTransmitterAddress(); auto agreement = getAgreement(tid, originatorAddr); @@ -46,6 +46,17 @@ void RecipientBlockAckAgreementHandler::qosFrameReceived(const Ptr& qosHeader, + IBlockAckAgreementHandlerCallback *callback) +{ + // IEEE Std 802.11-2024, 11.5.4: valid Implicit BAR DATA also refreshes inactivity, including duplicates. + auto agreement = getAgreement(qosHeader->getTid(), qosHeader->getTransmitterAddress()); + if (agreement && agreement->getVariant() == BlockAckVariant::COMPRESSED && qosHeader->getAckPolicy() == NORMAL_ACK) { + agreement->calculateExpirationTime(); + scheduleInactivityTimer(callback); + } +} + void RecipientBlockAckAgreementHandler::blockAckAgreementExpired(IProcedureCallback *procedureCallback, IBlockAckAgreementHandlerCallback *agreementHandlerCallback) { // When a timeout of BlockAckTimeout is detected, the STA shall send a DELBA frame to the diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h index ac93c8366e6..21b3eabc7e5 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h @@ -49,6 +49,7 @@ class INET_API RecipientBlockAckAgreementHandler : public IRecipientBlockAckAgre virtual void processReceivedAddbaRequest(const Ptr& addbaRequest, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) override; virtual void processReceivedDelba(const Ptr& delba, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy) override; virtual void qosFrameReceived(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) override; + virtual void implicitBlockAckRequested(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) override; virtual void processTransmittedDelba(const Ptr& delba) override; virtual void blockAckAgreementExpired(IProcedureCallback *procedureCallback, IBlockAckAgreementHandlerCallback *agreementHandlerCallback) override; diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc index 61d1213020c..9771a17cc3c 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.cc @@ -74,23 +74,29 @@ const Ptr RecipientBlockAckProcedure::buildBlockAck(const Ptr return blockAck; } else if (auto compressed = dynamicPtrCast(blockAckReq)) { - ASSERT(agreement != nullptr); - auto blockAck = makeShared(); - auto record = agreement->getBlockAckRecord(); - auto start = record->getWindowStart(); - BitVector bitmap(0, 64); - for (int i = 0; i < 64; i++) - bitmap.setBit(i, record->getCompressedAckState(start + i)); - blockAck->setBlockAckBitmap(bitmap); - blockAck->setReceiverAddress(compressed->getTransmitterAddress()); - blockAck->setStartingSequenceNumber(start); - blockAck->setTidInfo(compressed->getTidInfo()); - return blockAck; + return buildCompressedBlockAck(compressed->getTransmitterAddress(), compressed->getTidInfo(), agreement); } else throw cRuntimeError("Unsupported Block Ack Request"); } +Ptr RecipientBlockAckProcedure::buildCompressedBlockAck(MacAddress peer, Tid tid, + RecipientBlockAckAgreement *agreement) +{ + ASSERT(agreement != nullptr); + auto blockAck = makeShared(); + auto record = agreement->getBlockAckRecord(); + auto start = record->getWindowStart(); + BitVector bitmap(0, 64); + for (int i = 0; i < 64; i++) + bitmap.setBit(i, record->getCompressedAckState(start + i)); + blockAck->setBlockAckBitmap(bitmap); + blockAck->setReceiverAddress(peer); + blockAck->setStartingSequenceNumber(start); + blockAck->setTidInfo(tid); + return blockAck; +} + } /* namespace ieee80211 */ } /* namespace inet */ diff --git a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h index 3d0e2899f1f..5af43038836 100644 --- a/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h +++ b/src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h @@ -26,6 +26,7 @@ class INET_API RecipientBlockAckProcedure : public IRecipientBlockAckProcedure virtual const Ptr buildBlockAck(const Ptr& blockAckReq, RecipientBlockAckAgreement *agreement); public: + Ptr buildCompressedBlockAck(MacAddress peer, Tid tid, RecipientBlockAckAgreement *agreement) override; virtual void processReceivedBlockAckReq(Packet *blockAckPacket, const Ptr& blockAckReq, IRecipientQosAckPolicy *ackPolicy, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, IProcedureCallback *callback) override; virtual void processTransmittedBlockAck(const Ptr& blockAck) override; }; diff --git a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc index 78f06a2d725..c69c60c99e7 100644 --- a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc +++ b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.cc @@ -50,7 +50,44 @@ void BlockAckReordering::clearPeer(MacAddress peer) } } -BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader, bool interframe) +bool BlockAckReordering::isMandatoryRelease(RecipientBlockAckAgreement *agreement, + const Ptr& header, bool interframe, const BlockAckReceiveContext *context) const +{ + auto record = agreement->getBlockAckRecord(); + auto priorSequence = record->getWindowStart() - 1; + if (!record->hasCompleteReceipt(priorSequence)) + return false; + if (!context) + return interframe; + auto hasDelimiterChain = [&](const std::shared_ptr& aggregate, B endpoint) { + if (!aggregate || aggregate->transmitter != header->getTransmitterAddress() || + aggregate->receiver != header->getReceiverAddress() || aggregate->tid != header->getTid()) + return false; + for (const auto& member : aggregate->members) { + if (!member.sequence || *member.sequence != priorSequence || !(member.offset < endpoint)) + continue; + bool valid = true; + for (const auto& range : aggregate->ranges) { + if (range.kind == MpduRangeKind::DELIMITER && member.offset < range.offset && range.offset < endpoint) + valid &= range.valid; + } + if (valid) + return true; + } + return false; + }; + // IEEE Std 802.11-2024, 10.25.6.6.2.1(a)(2)(i): a later member needs the complete delimiter chain. + if (context->aggregate && !context->firstMember) + return hasDelimiterChain(context->aggregate, context->memberOffset); + // Conditions (ii) and (iii) require the preceding aggregate's valid delimiter tail. + if (context->followsAggregate) + return hasDelimiterChain(context->previousAggregate, + context->previousAggregate ? context->previousAggregate->length : B(0)); + // Conditions (iv) and (v) follow an individual MPDU or a local ACK. + return context->followsIndividual; +} + +BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader, bool interframe, const BlockAckReceiveContext *context) { ReceiveBuffer *receiveBuffer = createReceiveBufferIfNecessary(agreement); auto sequenceNumber = dataHeader->getSequenceNumber(); @@ -72,10 +109,9 @@ BlockAckReordering::ReleasedFrames BlockAckReordering::processReceivedQoSFrame(R if (receiveBuffer->insertFrame(dataPacket, dataHeader)) { if (dataHeader->getAckPolicy() == BLOCK_ACK && agreement->getVariant() == BlockAckVariant::BASIC) agreement->blockAckPolicyFrameReceived(dataHeader); - auto record = agreement->getBlockAckRecord(); // IEEE Std 802.11-2024, 10.25.6.6.2.1(a)(2)(v) and 10.25.6.6.1: release the complete prefix in order. if (agreement->getVariant() == BlockAckVariant::COMPRESSED && insideWindow && windowStart < sequenceNumber && - interframe && record->hasCompleteReceipt(record->getWindowStart() - 1)) { + isMandatoryRelease(agreement, dataHeader, interframe, context)) { auto preceding = advanceReceiveBuffer(agreement, receiveBuffer, sequenceNumber); releasedFrames.insert(releasedFrames.end(), preceding.begin(), preceding.end()); } diff --git a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h index fdfbd29e226..9f090d790aa 100644 --- a/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h +++ b/src/inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h @@ -10,6 +10,7 @@ #include "inet/common/packet/Packet.h" #include "inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h" +#include "inet/linklayer/ieee80211/mac/contract/AmpduReception.h" namespace inet { namespace ieee80211 { @@ -44,6 +45,8 @@ class INET_API BlockAckReordering void releaseReceiveBuffer(RecipientBlockAckAgreement *agreement, ReceiveBuffer *receiveBuffer, const ReleasedFrames& releasedFrames); ReceiveBuffer *createReceiveBufferIfNecessary(RecipientBlockAckAgreement *agreement); bool addMsduIfComplete(ReceiveBuffer *receiveBuffer, ReleasedFrames& releasedFrames, SequenceNumberCyclic seqNum); + bool isMandatoryRelease(RecipientBlockAckAgreement *agreement, const Ptr& header, + bool interframe, const BlockAckReceiveContext *context) const; private: ReleasedFrames advanceReceiveBuffer(RecipientBlockAckAgreement *agreement, ReceiveBuffer *receiveBuffer, SequenceNumberCyclic startingSequenceNumber); @@ -54,7 +57,7 @@ class INET_API BlockAckReordering void clearPeer(MacAddress peer); void processReceivedDelba(const Ptr& delba); - ReleasedFrames processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader, bool interframe = false); + ReleasedFrames processReceivedQoSFrame(RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr& dataHeader, bool interframe = false, const BlockAckReceiveContext *context = nullptr); ReleasedFrames processReceivedBlockAckReq(RecipientBlockAckAgreement *agreement, const Ptr& blockAckReq); }; diff --git a/src/inet/linklayer/ieee80211/mac/contract/AmpduReception.h b/src/inet/linklayer/ieee80211/mac/contract/AmpduReception.h new file mode 100644 index 00000000000..0dbe31b1f6b --- /dev/null +++ b/src/inet/linklayer/ieee80211/mac/contract/AmpduReception.h @@ -0,0 +1,57 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +#ifndef __INET_AMPDURECEPTION_H +#define __INET_AMPDURECEPTION_H + +#include +#include + +#include "inet/common/packet/Packet.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" + +namespace inet { +namespace ieee80211 { + +// These facts describe one received PSDU. BlockAckRecord remains the receipt owner. +struct INET_API AmpduTopology +{ + struct Member { + B offset; + std::optional sequence; + bool first = false; + }; + std::vector ranges; + std::vector members; + B length = B(0); + MacAddress transmitter; + MacAddress receiver; + Tid tid = -1; +}; + +struct INET_API AmpduReception +{ + struct Member { + std::unique_ptr packet; + B offset; + }; + std::shared_ptr topology; + std::vector members; + bool anyCorrect = false; +}; + +// HCF supplies an immutable context for one member or one standalone MPDU. +struct INET_API BlockAckReceiveContext +{ + std::shared_ptr aggregate; + std::shared_ptr previousAggregate; + B memberOffset = B(0); + bool firstMember = false; + bool followsAggregate = false; + bool followsIndividual = false; +}; + +} // namespace ieee80211 +} // namespace inet + +#endif diff --git a/src/inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails.msg b/src/inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails.msg index 383dbba4c5b..8b8b089c93d 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails.msg +++ b/src/inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails.msg @@ -13,6 +13,7 @@ enum FrameTransmissionStatus FRAME_TRANSMISSION_STATUS_ACKNOWLEDGED = 0; FRAME_TRANSMISSION_STATUS_RETRY_LIMIT_REACHED = 1; FRAME_TRANSMISSION_STATUS_DROPPED_BEFORE_TRANSMISSION = 2; + FRAME_TRANSMISSION_STATUS_UNACKNOWLEDGED = 3; } // diff --git a/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h b/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h index d2002a5ffdc..a7c54243d39 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h @@ -46,6 +46,7 @@ class INET_API IFrameSequenceHandler virtual void startFrameSequence(IFrameSequence *frameSequence, FrameSequenceContext *context, ICallback *callback) = 0; virtual void processResponse(Packet *frame) = 0; virtual void transmissionComplete() = 0; + virtual void transmissionCancelled() = 0; virtual bool isSequenceRunning() = 0; virtual void handleStartRxTimeout() = 0; // End a response wait after recipient processing. The sequence suppresses failure for retired DATA or management frames. diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h index 641e21e8ecd..165dd477385 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h @@ -21,6 +21,8 @@ class INET_API IOriginatorQoSAckPolicy { public: virtual ~IOriginatorQoSAckPolicy() {} + virtual void setProbeEligibility(std::function predicate) = 0; + virtual simtime_t getImplicitBlockAckTimeout(const physicallayer::IIeee80211Mode *responseMode) const = 0; virtual bool isAckNeeded(const Ptr& header) const = 0; virtual AckPolicy computeAckPolicy(Packet *packet, const Ptr& header, OriginatorBlockAckAgreement *agreement) const = 0; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h b/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h index 10c35f613a0..59f75f69e7e 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h @@ -32,6 +32,7 @@ class INET_API IQosRateSelection virtual const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& rtsFrame, ResponseQueryRole role) = 0; virtual const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& dataOrMgmtHeader, ResponseQueryRole role) = 0; virtual const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& blockAckReq, ResponseQueryRole role) = 0; + virtual const physicallayer::IIeee80211Mode *computeCompressedBlockAckResponseMode(const physicallayer::IIeee80211Mode *elicitingMode) = 0; // HCF derives startsTxop from the current frame sequence before this query. virtual const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& blockAckReq, bool startsTxop) = 0; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h index 5c4beb3fe04..c2a1463709e 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h @@ -36,6 +36,7 @@ class INET_API IRecipientBlockAckAgreementHandler virtual void processReceivedDelba(const Ptr& delba, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy) = 0; virtual void processTransmittedDelba(const Ptr& delba) = 0; virtual void qosFrameReceived(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) = 0; + virtual void implicitBlockAckRequested(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) = 0; virtual void blockAckAgreementExpired(IProcedureCallback *procedureCallback, IBlockAckAgreementHandlerCallback *agreementHandlerCallback) = 0; virtual RecipientBlockAckAgreement *getAgreement(Tid tid, MacAddress originatorAddr) = 0; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h index 9669adfbf60..b347b95c622 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h @@ -23,6 +23,7 @@ class INET_API IRecipientBlockAckProcedure virtual void processReceivedBlockAckReq(Packet *packet, const Ptr& blockAckReq, IRecipientQosAckPolicy *ackPolicy, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, IProcedureCallback *callback) = 0; virtual void processTransmittedBlockAck(const Ptr& blockAck) = 0; + virtual Ptr buildCompressedBlockAck(MacAddress peer, Tid tid, RecipientBlockAckAgreement *agreement) = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h index 7aded713794..1d76ad5e13a 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h @@ -10,6 +10,7 @@ #include "inet/common/packet/Packet.h" #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mac/contract/AmpduReception.h" #include "inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h" namespace inet { @@ -27,7 +28,7 @@ class INET_API IRecipientQosMacDataService virtual void clearPeer(MacAddress peer) = 0; // HCF supplies the observed SIFS or permitted RIFS relation for this frame. - virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe = false) = 0; + virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe = false, const BlockAckReceiveContext *context = nullptr) = 0; virtual std::vector controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) = 0; virtual std::vector managementFrameReceived(Packet *mgmtPacket, const Ptr& mgmtHeader) = 0; }; diff --git a/src/inet/linklayer/ieee80211/mac/contract/IRx.h b/src/inet/linklayer/ieee80211/mac/contract/IRx.h index abfdc4dacb1..9c1a4eae650 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IRx.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IRx.h @@ -10,6 +10,7 @@ #include "inet/linklayer/common/MacAddress.h" #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mac/contract/AmpduReception.h" #include "inet/linklayer/ieee80211/mac/contract/IContention.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h" @@ -52,6 +53,8 @@ class INET_API IRx virtual void transmissionStateChanged(physicallayer::IRadio::TransmissionState state) = 0; virtual void receivedSignalPartChanged(physicallayer::IRadioSignal::SignalPart part) = 0; virtual bool lowerFrameReceived(Packet *packet) = 0; + // The caller retains the envelope. The result owns the correct, separate member Packets. + virtual AmpduReception lowerAggregateReceived(Packet *packet) = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/contract/ITx.h b/src/inet/linklayer/ieee80211/mac/contract/ITx.h index 63e16367533..06dc26851c8 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/ITx.h +++ b/src/inet/linklayer/ieee80211/mac/contract/ITx.h @@ -26,6 +26,14 @@ class INET_API ITx virtual ~ICallback() {} virtual void transmissionComplete(Packet *packet, const Ptr& header) = 0; + virtual void frameTransmissionStarted(Packet *packet) = 0; + }; + + class INET_API IAggregateCallback : public ICallback { + public: + // The caller validates and finalizes members at the actual submission boundary. + virtual Packet *prepareAggregateTransmission() = 0; + virtual void aggregateTransmissionCancelled() = 0; }; public: @@ -56,6 +64,10 @@ class INET_API ITx */ virtual void transmitFrame(Packet *packet, const Ptr& header, bool updateLocalNav, ICallback *callback) = 0; virtual void transmitFrame(Packet *packet, const Ptr& header, simtime_t ifs, bool updateLocalNav, ICallback *callback) = 0; + virtual void transmitAggregate(simtime_t ifs, IAggregateCallback *callback) = 0; + // Cancellation removes only a delayed request. It cannot cancel a submitted PPDU. + virtual bool cancelPendingAggregate(IAggregateCallback *callback) = 0; + virtual void finalizeMpdu(Packet *packet) = 0; /** * The query returns true while Tx retains an accepted frame, * including any wait before transmission and the transmission itself. diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.cc index 9e27f154969..b0b7f5edf00 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.cc @@ -264,6 +264,11 @@ FrameSequenceContext *Dcf::buildContext() return new FrameSequenceContext(mac->getAddress(), modeSet, channelAccess->getInProgressFrames(), rtsProcedure, rtsPolicy, nonQoSContext, nullptr); } +void Dcf::frameTransmissionStarted(Packet *packet) +{ + // DCF has no state transition at submission. +} + void Dcf::transmissionComplete(Packet *packet, const Ptr& header) { Enter_Method("transmissionComplete"); diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h index 7a812ffafc1..db474721363 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h @@ -113,6 +113,7 @@ class INET_API Dcf : public ICoordinationFunction, public IFrameSequenceHandler: virtual void scheduleStartRxTimer(simtime_t timeout) override; // ITx::ICallback + virtual void frameTransmissionStarted(Packet *packet) override; virtual void transmissionComplete(Packet *packet, const Ptr& header) override; // IProcedureCallback diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index 3cd1655b0fa..f2b22de216f 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -17,6 +17,7 @@ #include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" #include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" #include "inet/linklayer/ieee80211/mac/framesequence/HcfFs.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h" #include "inet/linklayer/ieee80211/mac/rateselection/RateSelection.h" #include "inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h" #include "inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h" @@ -26,6 +27,7 @@ #include "inet/queueing/contract/ISelectivePacketCollection.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" #include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/IReception.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h" @@ -72,6 +74,12 @@ void Hcf::initialize(int stage) originatorDataService = check_and_cast(getSubmodule(("originatorMacDataService"))); recipientDataService = check_and_cast(getSubmodule("recipientMacDataService")); originatorAckPolicy = check_and_cast(getSubmodule("originatorAckPolicy")); + originatorAckPolicy->setProbeEligibility([this](InProgressFrames *frames, Tid tid) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->setTid(tid); + return edca->getEdcaf(edca->classifyFrame(header))->getInProgressFrames() == frames; + }); recipientAckPolicy = check_and_cast(getSubmodule("recipientAckPolicy")); singleProtectionMechanism = check_and_cast(getSubmodule("singleProtectionMechanism")); rtsProcedure = new RtsProcedure(); @@ -170,7 +178,12 @@ std::set Hcf::getReferencedDataFrames() const auto context = frameSequenceHandler->getContext(); for (int i = 0; i < context->getNumSteps(); i++) { auto step = context->getStep(i); - if (auto transmit = dynamic_cast(step)) + if (auto aggregate = dynamic_cast(step)) { + for (auto member : aggregate->getPreparedData()->batch->members) + if (context->getInProgressFrames()->containsFrame(member)) + frames.insert(member); + } + else if (auto transmit = dynamic_cast(step)) frames.insert(transmit->getFrameToTransmit()); if (auto rts = dynamic_cast(step)) frames.insert(rts->getProtectedFrame()); @@ -354,6 +367,13 @@ void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, ++it; } PendingReception pending; + for (auto& entry : pendingReceptions) { + if (!entry.second.completed) { + pending.overlapped = true; + entry.second.overlapped = true; + entry.second.previousAggregate.reset(); + } + } auto medium = interframeRadio->getMedium(); pending.timing = medium->getTransmissionTimingSnapshot(transmission->getId()); auto wifi = dynamic_cast(transmission); @@ -361,10 +381,14 @@ void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, if (wifi) pending.extension = wifi->getSignalExtensionDuration(); auto gap = medium->computePrecedingSignalGap(transmission->getId(), interframeHistory.timing); - if (gap && (interframeHistory.mpdu || interframeHistory.ack)) { + if (!pending.overlapped && gap && (interframeHistory.mpdu || interframeHistory.ack || + interframeHistory.aggregate || interframeHistory.blockAck)) { // IEEE Std 802.11-2024, 10.3.2.3.3: this model uses coverage class zero. pending.sifs = std::abs((*gap - modeSet->getSifsTime()).raw()) <= modeSet->getSlotTime().raw() / 10; - if (interframeHistory.mpdu && interframeHistory.ht && pending.ht && interframeHistory.noSifsResponse && + pending.precedingAggregate = bool(interframeHistory.aggregate); + pending.precedingIndividual = interframeHistory.mpdu || interframeHistory.ack; + pending.previousAggregate = interframeHistory.aggregate; + if ((interframeHistory.mpdu || interframeHistory.aggregate) && interframeHistory.ht && pending.ht && interframeHistory.noSifsResponse && interframeHistory.timing.transmitterRadioId == pending.timing.transmitterRadioId && interframeHistory.extension) { auto rifs = wifi->getMode()->getRifsTime(); // IEEE Std 802.11-2024, 10.3.2.3.2 and 10.3.8: RIFS excludes the actual preceding extension. @@ -381,16 +405,39 @@ void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, if (pending != pendingReceptions.end()) pending->second.completed = true; } - else if (interframeRadio && source == dynamic_cast(interframeRadio.get()) && signalID == transmissionStartedSignal) + else if (interframeRadio && source == dynamic_cast(interframeRadio.get()) && signalID == transmissionStartedSignal) { + auto transmission = check_and_cast(obj); + auto topology = interframeHistory.aggregate; + bool compatible = false; + auto packet = transmission->getPacket(); + if (topology && packet && packet->hasAtFront()) { + auto phy = packet->peekAtFront(); + auto ht = dynamicPtrCast(phy); + if (!ht || !ht->getAggregation()) { + auto header = packet->peekDataAt(phy->getChunkLength()); + if (auto blockAck = dynamicPtrCast(header)) + compatible = blockAck->getReceiverAddress() == topology->transmitter && blockAck->getTidInfo() == topology->tid; + } + } clearInterframeHistory(); + if (compatible) + transmittedBlockAckAggregate = std::move(topology); + } else if (interframeRadio && source == dynamic_cast(interframeRadio.get()) && signalID == transmissionEndedSignal) { + auto topology = transmittedBlockAckAggregate; clearInterframeHistory(); auto transmission = check_and_cast(obj); if (completedTransmissionWasAck) { interframeHistory.timing = interframeRadio->getMedium()->getTransmissionTimingSnapshot(transmission->getId()); interframeHistory.ack = true; } + else if (completedTransmissionWasBlockAck && topology) { + interframeHistory.timing = interframeRadio->getMedium()->getTransmissionTimingSnapshot(transmission->getId()); + interframeHistory.blockAck = true; + interframeHistory.aggregate = std::move(topology); + } completedTransmissionWasAck = false; + completedTransmissionWasBlockAck = false; } else if (signalID == InProgressFrames::packetDequeuedSignal) { Enter_Method("packetDequeued"); @@ -425,7 +472,9 @@ void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, intval_t value else ++it; } - if (incomplete || value == IRadio::RECEPTION_STATE_BUSY || value == IRadio::RECEPTION_STATE_UNDEFINED) + // Tx owns a prepared response during the switch to transmitter mode. Its start identifies the actual frame. + if (incomplete || value == IRadio::RECEPTION_STATE_BUSY || + (value == IRadio::RECEPTION_STATE_UNDEFINED && !tx->hasTransmission())) interframeHistory = {}; } } @@ -434,9 +483,10 @@ void Hcf::clearInterframeHistory() { interframeHistory = {}; pendingReceptions.clear(); + transmittedBlockAckAggregate.reset(); } -bool Hcf::receiveInterframe(Packet *packet, const Ptr& header) +bool Hcf::receiveInterframe(Packet *packet, const Ptr& header, BlockAckReceiveContext *context) { auto time = packet->findTag(); if (!time) @@ -446,10 +496,17 @@ bool Hcf::receiveInterframe(Packet *packet, const Ptr& return false; auto pending = std::move(entry->second); pendingReceptions.erase(entry); + if (pending.overlapped) + return false; // IEEE Std 802.11-2024, 10.27.3.1, 10.27.3.3, and 11.38.1: the BSS controls RIFS permission. bool rifsPermitted = pending.rifs && modeSet->getPhyType() != Ieee80211ModeSet::PhyType::VHT && (mib->mode == Ieee80211Mib::INDEPENDENT || mib->mode == Ieee80211Mib::MESH || mib->getHtOperation().rifsMode); bool related = pending.sifs || (pending.rifs && rifsPermitted && pending.precedingReceiver == header->getReceiverAddress()); + if (context) { + context->followsAggregate = related && pending.precedingAggregate; + context->followsIndividual = related && pending.precedingIndividual; + context->previousAggregate = std::move(pending.previousAggregate); + } interframeHistory.timing = std::move(pending.timing); interframeHistory.mpdu = true; interframeHistory.ht = pending.ht; @@ -703,12 +760,15 @@ void Hcf::completeTransfers() void Hcf::discardAgreementData(MacAddress peer, Tid tid, bool all, int64_t highestTransmittedDataIndex) { + bool cancelledAggregate = false; if (frameSequenceHandler->isSequenceRunning()) { auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); if (prepared) { auto header = prepared->frame->peekAtFront(); - if (header->getReceiverAddress() == peer && header->getTid() == tid) + if (header->getReceiverAddress() == peer && header->getTid() == tid) { prepared->cancelled = true; + cancelledAggregate = prepared->batch && tx->cancelPendingAggregate(this); + } } } for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { @@ -765,6 +825,8 @@ void Hcf::discardAgreementData(MacAddress peer, Tid tid, bool all, int64_t highe if (!frameSequenceHandler->isSequenceRunning() || frameSequenceHandler->getContext()->getInProgressFrames() != frames) frames->clearDroppedFrames(); } + if (cancelledAggregate) + aggregateTransmissionCancelled(); } void Hcf::firstDataDiscarded(const Ptr& header) @@ -981,6 +1043,108 @@ void Hcf::receiveSignal(cComponent *source, simsignal_t signalID, bool value, cO updateContention(); } +void Hcf::processLowerAggregate(Packet *packet, AmpduReception received) +{ + Enter_Method("processLowerAggregate"); + auto reception = std::move(received); + take(packet); + std::unique_ptr envelope(packet); + for (auto& member : reception.members) + take(member.packet.get()); + if (edca->getChannelOwner() && frameSequenceHandler->isSequenceRunning() && + dynamic_cast(frameSequenceHandler->getContext()->getLastStep())) { + bool addressed = false; + for (const auto& member : reception.members) + addressed |= isForUs(member.packet->peekAtFront()); + // An aggregate cannot satisfy a control-response step. Resolve an elapsed or addressed wait first. + if (!startRxTimer->isScheduled() || addressed) { + frameSequenceHandler->handleStartRxTimeout(); + cancelEvent(startRxTimer); + } + } + if (!reception.anyCorrect || reception.members.empty() || !reception.topology) { + clearInterframeHistory(); + return; + } + Ptr common; + // IEEE Std 802.11-2024, 9.7.1 and 10.25.6.5: validate the complete supported context before state changes. + for (const auto& member : reception.members) { + auto header = dynamicPtrCast(member.packet->peekAtFront()); + if (!header || header->getType() != ST_DATA_WITH_QOS || header->getAckPolicy() != NORMAL_ACK || + header->getTid() < 0 || header->getTid() > 15 || !header->getSequenceNumber().isSpecified() || + header->getReceiverAddress().isUnspecified() || header->getReceiverAddress().isMulticast() || + header->getTransmitterAddress().isUnspecified() || header->getTransmitterAddress().isMulticast() || + header->getFragmentNumber() != 0 || header->getMoreFragments() || header->getDurationField() < SIMTIME_ZERO || + (common && (common->getReceiverAddress() != header->getReceiverAddress() || + common->getTransmitterAddress() != header->getTransmitterAddress() || common->getTid() != header->getTid() || + common->getDurationField() != header->getDurationField()))) { + clearInterframeHistory(); + return; + } + common = header; + } + if (!isForUs(common) || !recipientBlockAckAgreementHandler) { + clearInterframeHistory(); + return; + } + auto agreement = recipientBlockAckAgreementHandler->getAgreement(common->getTid(), common->getTransmitterAddress()); + // ADDBA has no variant field. An active Basic agreement cannot accept an implicit Compressed request. + if (agreement && (blockAckVariant != BlockAckVariant::COMPRESSED || agreement->getVariant() != BlockAckVariant::COMPRESSED)) + throw cRuntimeError("Block Ack profile conflict at %s: peer=%s TID=%d local=basic received=implicit-compressed; ADDBA does not negotiate the profile. Configure matching blockAckVariant values and start a new run", + getFullPath().c_str(), common->getTransmitterAddress().str().c_str(), common->getTid()); + // INET policy: implicit DATA without an agreement causes silent discard and no receive state. + if (!agreement || recipientBlockAckAgreementHandler->isTeardownPending(common->getTransmitterAddress(), common->getTid()) || + !isProfileAllowed(common->getTransmitterAddress(), false)) { + clearInterframeHistory(); + return; + } + auto topology = std::make_shared(*reception.topology); + topology->transmitter = common->getTransmitterAddress(); + topology->receiver = common->getReceiverAddress(); + topology->tid = common->getTid(); + BlockAckReceiveContext context; + if (interframeRadio) + receiveInterframe(packet, common, &context); + context.aggregate = topology; + // The PPDU consumes physical history once. Members never consume receiveInterframe separately. + if (interframeHistory.mpdu) { + interframeHistory.mpdu = false; + interframeHistory.aggregate = topology; + interframeHistory.noSifsResponse = false; + } + recipientBlockAckAgreementHandler->implicitBlockAckRequested(common, this); + for (auto& member : reception.members) { + auto header = member.packet->peekAtFront(); + context.memberOffset = member.offset; + context.firstMember = false; + for (const auto& position : topology->members) { + if (position.offset == member.offset) { + context.firstMember = position.first; + break; + } + } + take(member.packet.get()); + emit(packetReceivedFromPeerSignal, member.packet.get()); + sendUp(recipientDataService->dataFrameReceived(member.packet.release(), header, + recipientBlockAckAgreementHandler, false, &context)); + } + sendImplicitBlockAck(packet, common, agreement); +} + +void Hcf::sendImplicitBlockAck(Packet *envelope, const Ptr& header, + RecipientBlockAckAgreement *agreement) +{ + auto mode = rateSelection->computeCompressedBlockAckResponseMode(envelope->getTag()->getMode()); + auto response = recipientBlockAckProcedure->buildCompressedBlockAck(header->getTransmitterAddress(), header->getTid(), agreement); + response->setDurationField(encodeDuration(std::max(SIMTIME_ZERO, + header->getDurationField() - modeSet->getSifsTime() - mode->getDuration(LENGTH_COMPRESSED_BLOCKACK)), false)); + auto packet = new Packet("ImplicitBlockAck", response); + packet->insertAtBack(makeShared()); + setFrameMode(packet, response, mode); + tx->transmitFrame(packet, response, modeSet->getSifsTime(), false, this); + delete packet; +} + void Hcf::processLowerFrame(Packet *packet, const Ptr& header) { Enter_Method("processLowerFrame(%s)", packet->getName()); @@ -994,7 +1158,8 @@ void Hcf::processLowerFrame(Packet *packet, const Ptr& return; } } - bool interframe = interframeRadio && receiveInterframe(packet, header); + BlockAckReceiveContext receiveContext; + bool interframe = interframeRadio && receiveInterframe(packet, header, &receiveContext); EV_INFO << "Processing lower frame: " << packet->getName() << endl; auto edcaf = edca->getChannelOwner(); auto action = dynamicPtrCast(header); @@ -1040,7 +1205,7 @@ void Hcf::processLowerFrame(Packet *packet, const Ptr& else if (hcca->isOwning()) throw cRuntimeError("Hcca is unimplemented!"); else if (isForUs(header)) - recipientProcessReceivedFrame(packet, header, interframe); + recipientProcessReceivedFrame(packet, header, interframe, &receiveContext); else { EV_INFO << "This frame is not for us" << std::endl; PacketDropDetails details; @@ -1241,7 +1406,8 @@ void Hcf::frameSequenceFinished() finishingSequence = false; } -void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr& header, bool interframe) +void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr& header, bool interframe, + const BlockAckReceiveContext *context) { EV_INFO << "Processing received frame " << packet->getName() << " as recipient.\n"; emit(packetReceivedFromPeerSignal, packet); @@ -1299,7 +1465,7 @@ void Hcf::recipientProcessReceivedFrame(Packet *packet, const Ptr(header)) { if (dataHeader->getType() == ST_DATA_WITH_QOS && recipientBlockAckAgreementHandler) recipientBlockAckAgreementHandler->qosFrameReceived(dataHeader, this); - sendUp(recipientDataService->dataFrameReceived(packet, dataHeader, recipientBlockAckAgreementHandler, interframe)); + sendUp(recipientDataService->dataFrameReceived(packet, dataHeader, recipientBlockAckAgreementHandler, interframe, context)); } else if (auto mgmtHeader = dynamicPtrCast(header)) { auto accepted = recipientDataService->managementFrameReceived(packet, mgmtHeader); @@ -1417,7 +1583,18 @@ bool Hcf::dispatchAgreementAction(const Ptr& header) void Hcf::transmissionComplete(Packet *packet, const Ptr& header) { Enter_Method("transmissionComplete"); + if (!header) { + completedTransmissionWasAck = completedTransmissionWasBlockAck = false; + auto owner = edca->getChannelOwner(); + auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); + auto step = check_and_cast(frameSequenceHandler->getContext()->getLastStep()); + step->setPpduEnd(simTime()); + owner->getTxopProcedure()->recordTransmittedDuration(prepared->duration); + frameSequenceHandler->transmissionComplete(); + return; + } completedTransmissionWasAck = header->getType() == ST_ACK; + completedTransmissionWasBlockAck = bool(dynamicPtrCast(header)); auto edcaf = edca->getChannelOwner(); if (edcaf) { auto step = check_and_cast(frameSequenceHandler->getContext()->getLastStep()); @@ -1440,7 +1617,7 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) auto edcaf = edca->getChannelOwner(); auto context = frameSequenceHandler->getContext(); auto prepared = context->getQoSContext()->preparedData.get(); - if (prepared && prepared->frame == packet && prepared->preparation) { + if (prepared && prepared->frame == packet && (prepared->preparation || prepared->batch)) { // IEEE Std 802.11-2024, 10.23.2.2 and 10.23.2.12.1: BA RTS failure updates QSRC/CW. // The uncommitted sources retain their lifetimes. No provisional sequence owns an SRC entry. if (validatePreparedData(*prepared, simTime())) @@ -1497,6 +1674,18 @@ void Hcf::originatorProcessTransmittedFrame(Packet *packet) { Enter_Method("originatorProcessTransmittedFrame"); auto edcaf = edca->getChannelOwner(); + auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); + if (prepared && prepared->batch && prepared->envelope.get() == packet) { + if (prepared->cancelled) + return; + for (auto member : prepared->batch->members) { + if (!edcaf->getInProgressFrames()->containsFrame(member)) + continue; + edcaf->emit(packetSentToPeerSignal, member); + edcaf->getAckHandler()->processTransmittedImplicitBlockAckMember(member->peekAtFront()); + } + return; + } if (edcaf) edcaf->emit(packetSentToPeerSignal, packet); if (obsoleteActions.count(packet->getId()) || @@ -1593,6 +1782,11 @@ void Hcf::originatorProcessTransmittedControlFrame(const PtrgetContext()->getQoSContext()->preparedData.get(); + if (prepared && prepared->batch && prepared->envelope.get() == failedPacket) { + processAggregateOutcome(nullptr); + return; + } auto failedHeader = failedPacket->peekAtFront(); auto edcaf = edca->getChannelOwner(); if (obsoleteActions.count(failedPacket->getId()) || @@ -1663,6 +1857,11 @@ void Hcf::originatorProcessReceivedFrame(Packet *receivedPacket, Packet *lastTra { Enter_Method("originatorProcessReceivedFrame"); emit(packetReceivedFromPeerSignal, receivedPacket); + auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); + if (prepared && prepared->batch && prepared->envelope.get() == lastTransmittedPacket) { + processAggregateOutcome(receivedPacket->peekAtFront()); + return; + } if (obsoleteActions.count(lastTransmittedPacket->getId()) || (dynamicPtrCast(lastTransmittedPacket->peekAtFront()) && !edca->getChannelOwner()->getInProgressFrames()->containsFrame(lastTransmittedPacket))) @@ -1745,6 +1944,11 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const Ptrmembers.size() != 1 || !prepared.batch->queued.empty())) + return false; auto header = prepared.frame->peekAtFront(); // IEEE Std 802.11-2024, 10.23.2.9: the same-size single-MPDU retry exception also permits an A-MSDU. // Committed Compressed MPDUs retain their payload and length throughout retry; this path forms no A-MPDU. bool committedRetry = !prepared.preparation && header->getRetry(); + if (prepared.batch && !committedRetry) + return false; if (!committedRetry && (header->getAMsduPresent() || header->getRetry())) return false; for (int i = 0; i < context->getNumSteps(); i++) { auto step = dynamic_cast(context->getStep(i)); - if (step && step->getPpduEnd() >= SIMTIME_ZERO && - dynamicPtrCast(step->getFrameToTransmit()->peekAtFront())) + if (step && step->getPpduEnd() >= SIMTIME_ZERO && (dynamic_cast(step) || + dynamicPtrCast(step->getFrameToTransmit()->peekAtFront()))) return false; } return true; @@ -1904,9 +2113,9 @@ bool Hcf::isInitialDataException(const FrameSequenceContext *context, const Prep simtime_t Hcf::computePreparedDataCost(const PreparedDataTransmission& prepared, bool protect) const { auto sifs = modeSet->getSifsTime(); - auto cost = prepared.dataMode->getDuration(prepared.frame->getDataLength()); + auto cost = prepared.dataMode->getDuration(prepared.batch ? prepared.envelope->getDataLength() : prepared.frame->getDataLength()); if (prepared.ackMode) - cost += sifs + prepared.ackMode->getDuration(LENGTH_ACK); + cost += sifs + prepared.ackMode->getDuration(prepared.batch ? LENGTH_COMPRESSED_BLOCKACK : LENGTH_ACK); if (protect) cost += prepared.rtsMode->getDuration(prepared.rtsPrediction->getDataLength()) + sifs + prepared.ctsMode->getDuration(LENGTH_CTS) + sifs; @@ -1914,15 +2123,15 @@ simtime_t Hcf::computePreparedDataCost(const PreparedDataTransmission& prepared, } bool Hcf::canAdmitPreparedData(const FrameSequenceContext *context, const PreparedDataTransmission& prepared, - simtime_t ifs, bool protect) const + simtime_t ifs, bool protect, simtime_t elapsedIfs) const { auto txop = context->getQoSContext()->txopProcedure; auto cost = computePreparedDataCost(prepared, protect); int previousData = 0; for (int i = 0; i < context->getNumSteps(); i++) { auto step = dynamic_cast(context->getStep(i)); - if (step && step->getPpduEnd() >= SIMTIME_ZERO && - dynamicPtrCast(step->getFrameToTransmit()->peekAtFront())) + if (step && step->getPpduEnd() >= SIMTIME_ZERO && (dynamic_cast(step) || + dynamicPtrCast(step->getFrameToTransmit()->peekAtFront()))) previousData++; } // IEEE Std 802.11-2024, 10.23.2.9: zero permits one SU DATA PPDU, including an A-MSDU. @@ -1930,8 +2139,15 @@ bool Hcf::canAdmitPreparedData(const FrameSequenceContext *context, const Prepar if (previousData != 0) return false; } - else if (ifs + cost > txop->getRemaining() && !isInitialDataException(context, prepared)) - return false; + else { + bool initialOverrun = ifs + cost > txop->getRemaining() && isInitialDataException(context, prepared); + if (ifs + cost > txop->getRemaining() && !initialOverrun) + return false; + // IEEE Std 802.11-2024, 9.2.5.2(b)(4): a rounded reservation can exceed the TXOP deadline. + if (txop->getProtectionMechanism() == TxopProcedure::MULTIPLE_PROTECTION && + txop->getReservationEnd() > txop->getStart() + txop->getLimit() && !initialOverrun) + return false; + } bool later = context->getNumSteps() > 0; // The current TransmitStep is already present at the final submission check. if (later) { @@ -1939,7 +2155,7 @@ bool Hcf::canAdmitPreparedData(const FrameSequenceContext *context, const Prepar later = !last || last->getPpduEnd() >= SIMTIME_ZERO || context->getNumSteps() > 1; } // 10.23.2.8 samples TXNAV at exchange completion, before the leading IFS. - if (later && txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && cost >= rx->getTxnavRemaining()) + if (later && txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION && cost >= rx->getTxnavRemaining() + elapsedIfs) return false; if (later && protect && txop->getLimit() > 0 && txop->getProtectionMechanism() == TxopProcedure::MULTIPLE_PROTECTION && (simTime() + ifs - txop->getStart() - txop->getLimit()).raw() % SimTime(1, SIMTIME_US).raw() != 0) @@ -1958,6 +2174,31 @@ bool Hcf::validatePreparedData(const PreparedDataTransmission& prepared, simtime !isProfileAllowed(header->getReceiverAddress(), true)) return false; auto service = check_and_cast(originatorDataService); + if (prepared.batch) { + if (!service->isBatchValid(*prepared.batch, start)) + return false; + auto frames = edca->getChannelOwner()->getInProgressFrames(); + for (auto member : prepared.batch->members) { + bool queued = false; + for (const auto& preview : prepared.batch->queued) + queued |= preview->packet.get() == member; + if (!queued && (!frames->containsFrame(member) || !isFrameEligible(member, true) || + edca->getLifetimeHandler()->isExpired(member, start))) + return false; + if (!agreement->containsSequence(member->peekAtFront()->getSequenceNumber())) + return false; + } + auto peer = mib->findPeerHtState(header->getReceiverAddress()); + if (!peer || !isPeerCompatibleMode(modeSet, peer, prepared.dataMode) || + (prepared.rtsMode && !isPeerCompatibleMode(modeSet, peer, prepared.rtsMode)) || + (prepared.ctsMode && rateSelection->computeResponseCtsFrameMode(prepared.rtsPrediction.get(), + prepared.rtsPrediction->peekAtFront(), ResponseQueryRole::PREDICT) != prepared.ctsMode)) + return false; + const auto& caps = peer->negotiatedCapabilities.localTxPeerRx; + return caps.valid && prepared.limits.maxLength == B((1 << (13 + caps.receiverMaxAmpduLengthExponent)) - 1) && + prepared.limits.minimumMpduStartSpacing == caps.receiverMinimumMpduStartSpacing && + rateSelection->computeCompressedBlockAckResponseMode(prepared.dataMode) == prepared.ackMode; + } if (prepared.preparation) { if (!service->isPreparationValid(*prepared.preparation, start)) return false; @@ -2001,7 +2242,7 @@ DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context if (frames->containsFrame(candidate)) prepared->frame = candidate; else { - prepared->preparation = service->prepareFrame(edca->getChannelOwner()->getPendingQueue(), true); + prepared->preparation = service->prepareFrame(edca->getChannelOwner()->getPendingQueue(), !service->hasAMpduAggregation()); if (!prepared->preparation) return DataPreparationResult::DEFERRED; prepared->frame = prepared->preparation->packet.get(); @@ -2012,6 +2253,8 @@ DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context auto txop = context->getQoSContext()->txopProcedure; prepared->dataMode = rateSelection->computeMode(prepared->frame, prepared->frame->peekAtFront(), txop); + if (service->hasAMpduAggregation() && prepareAggregateData(context, *prepared)) + return DataPreparationResult::READY; const IIeee80211Mode *selectedRtsMode = nullptr; for (;;) { auto packet = prepared->frame; @@ -2058,6 +2301,217 @@ DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context } } +bool Hcf::prepareAggregateData(FrameSequenceContext *context, const PreparedDataTransmission& selected) +{ + auto ht = dynamic_cast(selected.dataMode); + if (!ht || ht->getDataMode()->getBandwidth() != MHz(20) || ht->isHtShortGuardInterval() || + ht->getPreambleMode()->getPreambleFormat() != Ieee80211HtPreambleMode::HT_PREAMBLE_MIXED) + return false; + auto header = selected.frame->peekAtFront(); + if (header->getAMsduPresent() || header->getMoreFragments() || header->getFragmentNumber() != 0) + return false; + auto peer = mib->findPeerHtState(header->getReceiverAddress()); + if (!peer || !peer->negotiatedCapabilities.localTxPeerRx.valid) + return false; + auto prepared = std::make_unique(); + prepared->modeSet = modeSet; + prepared->agreement = selected.agreement; + prepared->dataMode = selected.dataMode; + auto& limits = prepared->limits; + const auto& caps = peer->negotiatedCapabilities.localTxPeerRx; + limits.receiver = header->getReceiverAddress(); + limits.transmitter = mac->getAddress(); + limits.tid = header->getTid(); + limits.windowStart = selected.agreement->getStartingSequenceNumber(); + limits.windowSize = selected.agreement->getWindowSize(); + limits.maxLength = B((1 << (13 + caps.receiverMaxAmpduLengthExponent)) - 1); + limits.minimumMpduStartSpacing = caps.receiverMinimumMpduStartSpacing; + limits.mode = selected.dataMode; + auto owner = edca->getChannelOwner(); + std::vector retained; + for (auto packet : context->getInProgressFrames()->getEligibleFrames()) { + auto data = dynamicPtrCast(packet->peekAtFront()); + if (data && data->getReceiverAddress() == limits.receiver && data->getTid() == limits.tid && + !data->getAMsduPresent() && !data->getMoreFragments() && data->getFragmentNumber() == 0 && + selected.agreement->containsSequence(data->getSequenceNumber())) + retained.push_back(packet); + } + auto isRetry = [owner](Packet *packet) { + return owner->getAckHandler()->getQoSDataAckStatus(packet->peekAtFront()) != + QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED; + }; + std::stable_sort(retained.begin(), retained.end(), [&](Packet *left, Packet *right) { + if (isRetry(left) != isRetry(right)) + return isRetry(left); + return OriginatorBlockAckAgreement::computeSequenceDistance(limits.windowStart, + left->peekAtFront()->getSequenceNumber()) < + OriginatorBlockAckAgreement::computeSequenceDistance(limits.windowStart, + right->peekAtFront()->getSequenceNumber()); + }); + auto service = check_and_cast(originatorDataService); + prepared->batch = service->prepareBatch(owner->getPendingQueue(), retained, limits); + if (!prepared->batch) + return false; + auto& batch = *prepared->batch; + const IIeee80211Mode *rtsMode = nullptr; + while (!batch.members.empty()) { + if (batch.members.size() == 1 && (!batch.queued.empty() || !isRetry(batch.members.front()))) + break; + prepared->frame = batch.members.front(); + prepared->setEnvelope(service->buildAggregate(batch, limits)); + if (!prepared->envelope) + break; + prepared->ackMode = rateSelection->computeCompressedBlockAckResponseMode(prepared->dataMode); + auto data = prepared->frame->peekAtFront(); + bool protect = rtsPolicy->isRtsNeeded(prepared->envelope.get(), data); + prepared->setRtsPrediction(nullptr); + prepared->rtsMode = prepared->ctsMode = nullptr; + if (protect) { + prepared->setRtsPrediction(new Packet("prepared-RTS", rtsProcedure->buildRtsFrame(data))); + prepared->rtsPrediction->insertAtBack(makeShared()); + auto rts = prepared->rtsPrediction->peekAtFront(); + if (!rtsMode) + rtsMode = rateSelection->computeMode(prepared->rtsPrediction.get(), rts, context->getQoSContext()->txopProcedure); + prepared->rtsMode = rtsMode; + setFrameMode(prepared->rtsPrediction.get(), rts, rtsMode); + prepared->ctsMode = rateSelection->computeResponseCtsFrameMode(prepared->rtsPrediction.get(), rts, ResponseQueryRole::PREDICT); + auto legalControl = [](const IIeee80211Mode *mode) { + return mode->getModulationClass() == IIeee80211Mode::ModulationClass::OFDM || + mode->getModulationClass() == IIeee80211Mode::ModulationClass::ERP_OFDM; + }; + if (!legalControl(rtsMode) || !legalControl(prepared->ctsMode)) + throw cRuntimeError("HT A-MPDU protection requires non-HT OFDM or ERP-OFDM RTS and CTS modes"); + } + if (validatePreparedData(*prepared, simTime() + context->getIfs()) && + canAdmitPreparedData(context, *prepared, context->getIfs(), protect)) { + context->getQoSContext()->preparedData = std::move(prepared); + return true; + } + auto removed = batch.members.back(); + batch.members.pop_back(); + batch.queued.erase(std::remove_if(batch.queued.begin(), batch.queued.end(), + [removed](const std::unique_ptr& preview) { return preview->packet.get() == removed; }), batch.queued.end()); + } + return false; +} + +Packet *Hcf::prepareAggregateTransmission() +{ + Enter_Method("prepareAggregateTransmission"); + auto context = frameSequenceHandler->getContext(); + auto prepared = context->getQoSContext()->preparedData.get(); + if (!prepared || !prepared->batch || !validatePreparedData(*prepared, simTime()) || + !canAdmitPreparedData(context, *prepared, SIMTIME_ZERO, false, + check_and_cast(context->getLastStep())->getIfs())) + return nullptr; + auto owner = edca->getChannelOwner(); + auto service = check_and_cast(originatorDataService); + std::vector committed; + if (!service->commitPreparedBatch(*prepared->batch, committed)) + return nullptr; + for (auto packet : committed) + owner->getInProgressFrames()->adoptPreparedFrame(packet); + auto txop = owner->getTxopProcedure(); + auto response = modeSet->getSifsTime() + prepared->ackMode->getDuration(LENGTH_COMPRESSED_BLOCKACK); + if (txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION) + prepared->duration = encodeDuration(response, true); + else { + auto ppduDuration = prepared->dataMode->getDuration(prepared->envelope->getDataLength()); + auto reservation = std::max(SIMTIME_ZERO, txop->getReservationEnd() - simTime()); + auto remaining = std::max(SIMTIME_ZERO, txop->getStart() + txop->getLimit() - simTime()); + bool overrun = txop->getLimit() > 0 && ppduDuration + response > txop->getRemaining() && + isInitialDataException(context, *prepared); + prepared->duration = overrun ? computeMultipleProtectionDuration(0, 0, 0, ppduDuration, ppduDuration + response, false) : + computeMultipleProtectionDuration(txop->getLimit(), remaining, reservation, ppduDuration, + txop->getLimit() == 0 ? ppduDuration + response : SIMTIME_ZERO, txop->getReservationEnd() != 0); + } + for (auto packet : prepared->batch->members) { + auto data = packet->removeAtFront(); + auto status = owner->getAckHandler()->getQoSDataAckStatus(data); + data->setRetry(status != QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED); + data->setAckPolicy(NORMAL_ACK); + data->setDurationField(prepared->duration); + packet->insertAtFront(data); + tx->finalizeMpdu(packet); + } + prepared->setEnvelope(service->buildAggregate(*prepared->batch, prepared->limits)); + ASSERT(prepared->envelope); + prepared->envelope->addTagIfAbsent()->setMode(prepared->dataMode); + prepared->submitted = true; + for (auto packet : prepared->batch->members) { + prepared->agreement->recordTransmittedData(packet->getTag()->getAllocationIndex()); + RateSelection::emitDatarateSelected(this, packet->peekAtFront(), prepared->dataMode); + } + return prepared->envelope.get(); +} + +void Hcf::aggregateTransmissionCancelled() +{ + Enter_Method("aggregateTransmissionCancelled"); + frameSequenceHandler->transmissionCancelled(); + mac->sendDownPendingRadioConfigMsg(); +} + +void Hcf::processAggregateOutcome(const Ptr& response) +{ + auto context = frameSequenceHandler->getContext(); + auto prepared = context->getQoSContext()->preparedData.get(); + auto owner = edca->getChannelOwner(); + auto agreement = originatorBlockAckAgreementHandler->getAgreement(prepared->limits.receiver, prepared->limits.tid); + if (prepared->cancelled || !prepared->submitted || !agreement || agreement != prepared->agreement) + return; + auto frames = owner->getInProgressFrames(); + std::set>> acked; + if (response) { + owner->getRecoveryProcedure()->blockAckFrameReceived(); + acked = owner->getAckHandler()->processReceivedCompressedBlockAck(response, agreement); + originatorBlockAckAgreementHandler->processReceivedBlockAck(response, this); + auto step = check_and_cast(context->getStepBeforeLast()); + rx->successfulFrameTransmitted(step->getPpduEnd(), prepared->duration); + } + else { + owner->getRecoveryProcedure()->controlFrameTransmissionFailed(); + agreement->setPendingProbe(true); + } + for (auto packet : prepared->batch->members) { + if (!frames->containsFrame(packet)) + continue; + auto data = packet->peekAtFront(); + bool acknowledged = response && owner->getAckHandler()->getQoSDataAckStatus(data) == QosAckHandler::Status::BLOCK_ACK_ARRIVED_ACKED; + FrameTransmissionDetails details; + details.setStatus(acknowledged ? FRAME_TRANSMISSION_STATUS_ACKNOWLEDGED : FRAME_TRANSMISSION_STATUS_UNACKNOWLEDGED); + emit(Ieee80211Mac::frameTransmissionOutcomeSignal, packet, &details); + if (!acknowledged) { + owner->getRecoveryProcedure()->implicitBlockAckMemberFailed(packet, data); + if (!response) + owner->getAckHandler()->processFailedImplicitBlockAckMember(data); + auto updated = packet->removeAtFront(); + updated->setRetry(true); + packet->insertAtFront(updated); + } + } + for (int i = 0; i < frames->getLength(); i++) { + auto data = dynamicPtrCast(frames->getFrames(i)->peekAtFront()); + if (data && owner->getAckHandler()->getQoSDataAckStatus(data) == QosAckHandler::Status::BLOCK_ACK_ARRIVED_ACKED) + owner->getRecoveryProcedure()->dropFrame(data); + } + frames->dropFrames(acked); + owner->getAckHandler()->dropFrames(acked); + advanceOriginatorWindows(); + completeTransfers(); +} + +void Hcf::frameTransmissionStarted(Packet *packet) +{ + Enter_Method("frameTransmissionStarted"); + auto bar = dynamicPtrCast(packet->peekAtFront()); + if (bar && originatorBlockAckAgreementHandler) { + auto agreement = originatorBlockAckAgreementHandler->getAgreement(bar->getReceiverAddress(), bar->getTidInfo()); + if (agreement) + agreement->setPendingProbe(false); + } +} + simtime_t Hcf::forecastSingleProtectionSuccessor(Packet *packet, const Ptr& header, TxopProcedure *txop, InProgressFrames *frames, simtime_t completionTime) { @@ -2104,9 +2558,16 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) Enter_Method("transmitFrame"); auto channelOwner = edca->getChannelOwner(); if (channelOwner) { - auto header = packet->peekAtFront(); auto context = frameSequenceHandler->getContext(); auto prepared = context->getQoSContext()->preparedData.get(); + if (dynamic_cast(context->getLastStep())) { + if (!prepared || !validatePreparedData(*prepared, simTime() + ifs) || + !canAdmitPreparedData(context, *prepared, ifs, false)) + return false; + tx->transmitAggregate(ifs, this); + return true; + } + auto header = packet->peekAtFront(); auto rtsStep = dynamic_cast(context->getLastStep()); bool preparedStep = prepared && (prepared->frame == packet || (rtsStep && rtsStep->getProtectedFrame() == prepared->frame)); @@ -2114,7 +2575,7 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) !canAdmitPreparedData(context, *prepared, ifs, rtsStep != nullptr))) return false; if (dynamicPtrCast(header) && - !(preparedStep && prepared->preparation) && + !(preparedStep && (prepared->preparation || prepared->batch)) && !channelOwner->getInProgressFrames()->containsFrame(packet)) return false; if (!isFrameEligible(packet, true)) @@ -2431,6 +2892,8 @@ void Hcf::corruptedFrameReceived() Hcf::~Hcf() { + if (tx) + tx->cancelPendingAggregate(this); if (interframeRadio) { auto radioModule = check_and_cast(interframeRadio.get()); for (auto signal : {receptionStartedSignal, receptionEndedSignal, transmissionStartedSignal, transmissionEndedSignal, IRadio::receptionStateChangedSignal}) diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h index a6594025b0f..7c2dba912f5 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h @@ -41,6 +41,7 @@ #include "inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h" #include "inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h" +#include "inet/linklayer/ieee80211/mac/contract/AmpduReception.h" namespace inet { namespace ieee80211 { @@ -51,7 +52,7 @@ class Ieee80211Mib; /** * Implements IEEE 802.11 Hybrid Coordination Function. */ -class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler::ICallback, public IChannelAccess::ICallback, public ITx::ICallback, public IProcedureCallback, public IBlockAckAgreementHandlerCallback, public ModeSetListener +class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler::ICallback, public IChannelAccess::ICallback, public ITx::IAggregateCallback, public IProcedureCallback, public IBlockAckAgreementHandlerCallback, public ModeSetListener { private: BlockAckVariant blockAckVariant = BlockAckVariant::BASIC; @@ -60,15 +61,21 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: physicallayer::TransmissionTimingSnapshot timing; bool mpdu = false; bool ack = false; + bool blockAck = false; bool ht = false; bool noSifsResponse = false; MacAddress receiver; std::optional extension; + std::shared_ptr aggregate; }; struct PendingReception { bool completed = false; bool sifs = false; bool rifs = false; + bool overlapped = false; + bool precedingIndividual = false; + bool precedingAggregate = false; + std::shared_ptr previousAggregate; MacAddress precedingReceiver; physicallayer::TransmissionTimingSnapshot timing; bool ht = false; @@ -78,10 +85,16 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: InterframeHistory interframeHistory; std::map pendingReceptions; bool completedTransmissionWasAck = false; + bool completedTransmissionWasBlockAck = false; + std::shared_ptr transmittedBlockAckAggregate; void clearInterframeHistory(); - bool receiveInterframe(Packet *packet, const Ptr& header); + bool receiveInterframe(Packet *packet, const Ptr& header, + BlockAckReceiveContext *context = nullptr); public: + Packet *prepareAggregateTransmission() override; + void aggregateTransmissionCancelled() override; + void frameTransmissionStarted(Packet *packet) override; static simsignal_t edcaCollisionDetectedSignal; static simsignal_t blockAckAgreementAddedSignal; static simsignal_t blockAckAgreementDeletedSignal; @@ -171,10 +184,12 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: static simtime_t encodeDuration(simtime_t duration, bool holder); simtime_t computeImmediateResponseDuration(Packet *packet, const Ptr& header); DataPreparationResult prepareDataTransmission(FrameSequenceContext *context); + bool prepareAggregateData(FrameSequenceContext *context, const PreparedDataTransmission& selected); + void processAggregateOutcome(const Ptr& response); bool validatePreparedData(const PreparedDataTransmission& prepared, simtime_t start) const; simtime_t computePreparedDataCost(const PreparedDataTransmission& prepared, bool protect) const; bool canAdmitPreparedData(const FrameSequenceContext *context, const PreparedDataTransmission& prepared, - simtime_t ifs, bool protect) const; + simtime_t ifs, bool protect, simtime_t elapsedIfs = 0) const; bool isInitialDataException(const FrameSequenceContext *context, const PreparedDataTransmission& prepared) const; simtime_t forecastSingleProtectionSuccessor(Packet *packet, const Ptr& header, TxopProcedure *txop, InProgressFrames *frames, simtime_t completionTime); @@ -209,7 +224,10 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: bool isProfileAllowed(MacAddress peer, bool originator) const; // Recipient - virtual void recipientProcessReceivedFrame(Packet *packet, const Ptr& header, bool interframe = false); + virtual void recipientProcessReceivedFrame(Packet *packet, const Ptr& header, bool interframe = false, + const BlockAckReceiveContext *context = nullptr); + void sendImplicitBlockAck(Packet *envelope, const Ptr& header, + RecipientBlockAckAgreement *agreement); virtual void recipientProcessReceivedControlFrame(Packet *packet, const Ptr& header); virtual void recipientProcessReceivedManagementFrame(const Ptr& header); virtual void recipientProcessTransmittedControlResponseFrame(Packet *packet, const Ptr& header); @@ -259,6 +277,7 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: // ICoordinationFunction virtual void processUpperFrame(Packet *packet, const Ptr& header) override; virtual void processLowerFrame(Packet *packet, const Ptr& header) override; + virtual void processLowerAggregate(Packet *packet, AmpduReception reception); virtual void corruptedFrameReceived() override; }; diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc index f392d6fc3aa..7ab65c01b5f 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.cc @@ -6,16 +6,38 @@ #include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h" +#include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" namespace inet { namespace ieee80211 { using namespace inet::physicallayer; +AmpduTransmitStep::AmpduTransmitStep(std::shared_ptr prepared, simtime_t ifs) : + TransmitStep(nullptr, ifs), prepared(std::move(prepared)) +{ +} + +Packet *AmpduTransmitStep::getFrameToTransmit() +{ + return prepared->envelope.get(); +} + PreparedDataTransmission::~PreparedDataTransmission() { if (rtsPrediction) drop(rtsPrediction.get()); + if (envelope) + drop(envelope.get()); +} + +void PreparedDataTransmission::setEnvelope(Packet *packet) +{ + if (envelope) + drop(envelope.get()); + envelope.reset(packet); + if (envelope) + take(envelope.get()); } void PreparedDataTransmission::setRtsPrediction(Packet *packet) diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h index 85fa551c5f4..b5026782257 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h @@ -37,6 +37,11 @@ enum class DataPreparationResult { LEGACY, READY, DEFERRED }; struct INET_API PreparedDataTransmission : public cObject { std::unique_ptr preparation; + std::unique_ptr batch; + MpduAggregationLimits limits; + std::unique_ptr envelope; + simtime_t duration = 0; + bool submitted = false; Packet *frame = nullptr; // Borrowed from preparation, or from InProgressFrames after commitment. const physicallayer::Ieee80211ModeSet *modeSet = nullptr; const physicallayer::IIeee80211Mode *dataMode = nullptr; @@ -49,6 +54,7 @@ struct INET_API PreparedDataTransmission : public cObject ~PreparedDataTransmission() override; void setRtsPrediction(Packet *packet); + void setEnvelope(Packet *packet); }; class INET_API QoSContext @@ -68,7 +74,7 @@ class INET_API QoSContext TxopProcedure *txopProcedure = nullptr; const BlockAckVariant blockAckVariant; std::function prepareData; - std::unique_ptr preparedData; + std::shared_ptr preparedData; }; class INET_API NonQoSContext diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc index c01596ee2ab..84d3d9ac4b2 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.cc @@ -22,8 +22,11 @@ void FrameSequenceHandler::interruptFrameSequence() auto outgoing = check_and_cast(context->getStepBeforeLast())->getFrameToTransmit(); // Retirement removes DATA and management frames from the queue before this transition. // Control exchanges retain their ordinary failure path through the recovery callback. - bool retired = dynamicPtrCast(outgoing->peekAtFront()) && - !context->getInProgressFrames()->containsFrame(outgoing); + auto prepared = context->getQoSContext() ? context->getQoSContext()->preparedData.get() : nullptr; + bool aggregate = prepared && prepared->batch && prepared->envelope.get() == outgoing; + bool retired = aggregate ? prepared->cancelled : + dynamicPtrCast(outgoing->peekAtFront()) && + !context->getInProgressFrames()->containsFrame(outgoing); if (retired) finishFrameSequence(); else @@ -74,6 +77,13 @@ void FrameSequenceHandler::transmissionComplete() } } +void FrameSequenceHandler::transmissionCancelled() +{ + ASSERT(isSequenceRunning() && dynamic_cast(context->getLastStep())); + context->removeLastStep(); + finishFrameSequence(); +} + void FrameSequenceHandler::startFrameSequence(IFrameSequence *frameSequence, FrameSequenceContext *context, IFrameSequenceHandler::ICallback *callback) { EV_INFO << "Starting frame sequence.\n"; @@ -173,8 +183,10 @@ void FrameSequenceHandler::abortFrameSequence() auto step = context->getLastStep(); auto failedTxStep = check_and_cast(dynamic_cast(step) ? context->getStepBeforeLast() : step); auto frameToTransmit = failedTxStep->getFrameToTransmit(); - auto header = frameToTransmit->peekAtFront(); - if (auto dataOrMgmtHeader = dynamicPtrCast(header)) + auto header = dynamic_cast(failedTxStep) ? nullptr : frameToTransmit->peekAtFront(); + if (dynamic_cast(failedTxStep)) + callback->originatorProcessFailedFrame(frameToTransmit); + else if (auto dataOrMgmtHeader = dynamicPtrCast(header)) callback->originatorProcessFailedFrame(frameToTransmit); else if (auto rtsTxStep = dynamic_cast(failedTxStep)) callback->originatorProcessRtsProtectionFailed(const_cast(rtsTxStep->getProtectedFrame())); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h index a3d0d6f647b..d18fceb8528 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h @@ -29,6 +29,7 @@ class INET_API FrameSequenceHandler : public IFrameSequenceHandler virtual void abortFrameSequence(); public: + void transmissionCancelled() override; virtual const FrameSequenceContext *getContext() const override { return context; } virtual const IFrameSequence *getFrameSequence() const override { return frameSequence; } virtual void startFrameSequence(IFrameSequence *frameSequence, FrameSequenceContext *context, IFrameSequenceHandler::ICallback *callback) override; diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h index ce0b17abac6..79daa569a2b 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h @@ -8,11 +8,15 @@ #ifndef __INET_FRAMESEQUENCESTEP_H #define __INET_FRAMESEQUENCESTEP_H +#include + #include "inet/linklayer/ieee80211/mac/contract/IFrameSequence.h" namespace inet { namespace ieee80211 { +struct PreparedDataTransmission; + class INET_API TransmitStep : public ITransmitStep { protected: @@ -53,6 +57,15 @@ class INET_API RtsTransmitStep : public TransmitStep virtual const Packet *getProtectedFrame() { return protectedFrame; } }; +class INET_API AmpduTransmitStep : public TransmitStep +{ + std::shared_ptr prepared; + public: + AmpduTransmitStep(std::shared_ptr prepared, simtime_t ifs); + Packet *getFrameToTransmit() override; + const PreparedDataTransmission *getPreparedData() const { return prepared.get(); } +}; + class INET_API ReceiveStep : public IReceiveStep { protected: diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc index 66da226a753..4c5bc8b7414 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.cc @@ -10,6 +10,36 @@ namespace inet { namespace ieee80211 { +bool isValidCompressedBlockAck(Packet *packet, MacAddress local, MacAddress peer, Tid tid) +{ + auto response = dynamicPtrCast(packet->peekAtFront()); + return response && response->getReceiverAddress() == local && response->getTransmitterAddress() == peer && + response->getTidInfo() == tid && !response->getMultiTid() && response->getCompressedBitmap() && + response->getFragmentNumber() == 0 && response->getStartingSequenceNumber().isSpecified() && + response->getBlockAckBitmap().getSize() == 64 && + response->getChunkLength() == LENGTH_COMPRESSED_BLOCKACK - B(4) && packet->getDataLength() == LENGTH_COMPRESSED_BLOCKACK; +} + +IFrameSequenceStep *AmpduBlockAckFs::prepareStep(FrameSequenceContext *context) +{ + auto prepared = context->getQoSContext()->preparedData.get(); + if (step == 0) + return new AmpduTransmitStep(context->getQoSContext()->preparedData, context->getIfs()); + if (step == 1) + return new ReceiveStep(context->getQoSContext()->ackPolicy->getImplicitBlockAckTimeout(prepared->ackMode)); + return nullptr; +} + +bool AmpduBlockAckFs::completeStep(FrameSequenceContext *context) +{ + if (step++ == 0) + return true; + auto prepared = context->getQoSContext()->preparedData.get(); + auto receive = check_and_cast(context->getLastStep()); + return !prepared->cancelled && isValidCompressedBlockAck(receive->getReceivedFrame(), + prepared->limits.transmitter, prepared->limits.receiver, prepared->limits.tid); +} + // TODO remove isForUs checks it's already done in framesequencehandler void SelfCtsFs::startSequence(FrameSequenceContext *context, int firstStep) @@ -467,14 +497,8 @@ bool BlockAckReqBlockAckFs::completeStep(FrameSequenceContext *context) auto compressed = dynamicPtrCast(request); auto response = dynamicPtrCast(receivedHeader); // IEEE Std 802.11-2024, 9.3.1.8.2: this profile supports the 64-bit bitmap without dynamic fragmentation. - return context->isForUs(receivedHeader) && compressed && response && - response->getReceiverAddress() == compressed->getTransmitterAddress() && - response->getTransmitterAddress() == compressed->getReceiverAddress() && - response->getTidInfo() == compressed->getTidInfo() && - !response->getMultiTid() && response->getCompressedBitmap() && response->getFragmentNumber() == 0 && - response->getStartingSequenceNumber().isSpecified() && response->getBlockAckBitmap().getSize() == 64 && - response->getChunkLength() == LENGTH_COMPRESSED_BLOCKACK - B(4) && - receivedPacket->getDataLength() == LENGTH_COMPRESSED_BLOCKACK; + return compressed && isValidCompressedBlockAck(receivedPacket, compressed->getTransmitterAddress(), + compressed->getReceiverAddress(), compressed->getTidInfo()); } default: throw cRuntimeError("Unknown step"); diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h index 2a88d853108..70d9cc4ea0b 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h @@ -156,6 +156,18 @@ class INET_API LastFrameAckFs : public IFrameSequence virtual std::string getHistory() const override { return std::string("LAST-FRAME") + (step == 2 ? " ACK" : ""); } // TODO completeStep = true? }; +class INET_API AmpduBlockAckFs : public IFrameSequence +{ + int step = 0; + public: + void startSequence(FrameSequenceContext *context, int firstStep) override { step = 0; } + IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + bool completeStep(FrameSequenceContext *context) override; + std::string getHistory() const override { return "A-MPDU BLOCKACK"; } +}; + +INET_API bool isValidCompressedBlockAck(Packet *packet, MacAddress local, MacAddress peer, Tid tid); + class INET_API BlockAckReqBlockAckFs : public IFrameSequence { protected: diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc index d2986e6dffe..78d11e1dd0f 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc @@ -32,7 +32,9 @@ TxOpFs::TxOpFs() : new SequentialFs({new OptionalFs(new RtsCtsFs(), OPTIONALFS_PREDICATE(isRtsCtsNeeded)), new AlternativesFs({new ManagementAckFs(), /* TODO DATA + QAP*/}, - ALTERNATIVESFS_SELECTOR(selectMgmtOrDataQap))})}, + ALTERNATIVESFS_SELECTOR(selectMgmtOrDataQap))}), + new SequentialFs({new OptionalFs(new RtsCtsFs(), OPTIONALFS_PREDICATE(isRtsCtsNeeded)), + new AmpduBlockAckFs()})}, ALTERNATIVESFS_SELECTOR(selectTxOpSequence)) { } @@ -47,6 +49,8 @@ int TxOpFs::selectTxOpSequence(AlternativesFs *frameSequence, FrameSequenceConte auto qos = context->getQoSContext(); if (qos->ackPolicy->isBlockAckReqNeeded(context->getInProgressFrames(), qos->txopProcedure, qos->blockAckAgreementHandler)) return 2; + if (qos->preparedData && qos->preparedData->batch) + return 4; auto frameToTransmit = context->getDataFrameToTransmit(); const auto& macHeader = frameToTransmit->peekAtFront(); if (dynamicPtrCast(macHeader)) @@ -72,6 +76,9 @@ int TxOpFs::selectTxOpSequence(AlternativesFs *frameSequence, FrameSequenceConte bool TxOpFs::isRtsCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *context) { auto protectedFrame = context->getDataFrameToTransmit(); + auto prepared = context->getQoSContext()->preparedData.get(); + if (prepared && prepared->batch) + return prepared->rtsMode != nullptr; return context->getRtsPolicy()->isRtsNeeded(protectedFrame, protectedFrame->peekAtFront()); } diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc index dbdfdf50d0b..b1aa01db57d 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.cc @@ -39,6 +39,13 @@ bool OriginatorQosAckPolicy::isBlockAckReqNeeded(InProgressFrames *frames, TxopP std::tuple OriginatorQosAckPolicy::computeBlockAckReqParameters(InProgressFrames *frames, TxopProcedure *txop, IOriginatorBlockAckAgreementHandler *agreements) const { using Id = std::pair; + if (agreements && probeEligibility) { + for (const auto& entry : agreements->getAgreements()) { + auto agreement = entry.second; + if (agreement->getIsAddbaResponseReceived() && agreement->hasPendingProbe() && probeEligibility(frames, entry.first.second)) + return std::make_tuple(entry.first.first, agreement->getStartingSequenceNumber(), entry.first.second); + } + } std::map> groups; for (auto frame : frames->getOutstandingFrames()) { auto header = frame->peekAtFront(); @@ -127,5 +134,10 @@ simtime_t OriginatorQosAckPolicy::getBlockAckTimeout(Packet *packet, const PtrgetSifsTime() + modeSet->getSlotTime() + rateSelection->computeResponseBlockAckFrameMode(packet, blockAckReq, ResponseQueryRole::PREDICT)->getPhyRxStartDelay() : blockAckTimeout; } +simtime_t OriginatorQosAckPolicy::getImplicitBlockAckTimeout(const physicallayer::IIeee80211Mode *responseMode) const +{ + return blockAckTimeout == -1 ? modeSet->getSifsTime() + modeSet->getSlotTime() + responseMode->getPhyRxStartDelay() : blockAckTimeout; +} + } /* namespace ieee80211 */ } /* namespace inet */ diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h index cefd7008567..405d0269169 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h @@ -25,6 +25,7 @@ class INET_API OriginatorQosAckPolicy : public ModeSetListener, public IOriginat simtime_t blockAckTimeout = -1; simtime_t ackTimeout = -1; + std::function probeEligibility; protected: virtual int numInitStages() const override { return NUM_INIT_STAGES; } @@ -33,6 +34,8 @@ class INET_API OriginatorQosAckPolicy : public ModeSetListener, public IOriginat virtual bool checkAgreementPolicy(const Ptr& header, OriginatorBlockAckAgreement *agreement) const; public: + void setProbeEligibility(std::function predicate) override { probeEligibility = predicate; } + simtime_t getImplicitBlockAckTimeout(const physicallayer::IIeee80211Mode *responseMode) const override; virtual bool isAckNeeded(const Ptr& header) const override; virtual AckPolicy computeAckPolicy(Packet *packet, const Ptr& header, OriginatorBlockAckAgreement *agreement) const override; virtual bool isBlockAckPolicyEligibleFrame(Packet *packet, const Ptr& header) const override; diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc index e213b5665bb..f01e08414ca 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.cc @@ -229,6 +229,24 @@ void QosAckHandler::processTransmittedDataOrMgmtFrame(const PtrgetReceiverAddress(), SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()))] = Status::WAITING_FOR_NORMAL_ACK; } +void QosAckHandler::processTransmittedImplicitBlockAckMember(const Ptr& header) +{ + // IEEE Std 802.11-2024, 10.25.6.5: aggregate context makes policy 00 an implicit request. + QoSKey id = {header->getReceiverAddress(), {header->getTid(), + SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber())}}; + ackStatuses.at(id) = Status::WAITING_FOR_BLOCK_ACK; +} + +void QosAckHandler::processFailedImplicitBlockAckMember(const Ptr& header) +{ + // IEEE Std 802.11-2024, 10.25.6.7.1 permits DATA retry after the Block Ack response fails. + QoSKey id = {header->getReceiverAddress(), {header->getTid(), + SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber())}}; + auto found = ackStatuses.find(id); + if (found != ackStatuses.end() && found->second == Status::WAITING_FOR_BLOCK_ACK) + found->second = Status::BLOCK_ACK_NOT_ARRIVED; +} + void QosAckHandler::processTransmittedBlockAckReq(const Ptr& blockAckReq, const OriginatorBlockAckAgreement *agreement) { for (auto& ackStatus : ackStatuses) { @@ -250,7 +268,9 @@ void QosAckHandler::processTransmittedBlockAckReq(const Ptr(blockAckReq)) { if (compressedBlockAckReq->getTidInfo() == tid) { auto startingSeqNum = compressedBlockAckReq->getStartingSequenceNumber(); - if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && OriginatorBlockAckAgreement::isInBitmap(sequence, startingSeqNum) && seqCtrlField.getFragmentNumber() == 0) + bool transmitted = status == Status::BLOCK_ACK_NOT_YET_REQUESTED || status == Status::BLOCK_ACK_NOT_ARRIVED || + status == Status::BLOCK_ACK_ARRIVED_UNACKED || status == Status::NORMAL_ACK_NOT_ARRIVED; + if (transmitted && OriginatorBlockAckAgreement::isInBitmap(sequence, startingSeqNum) && seqCtrlField.getFragmentNumber() == 0) status = Status::WAITING_FOR_BLOCK_ACK; } } diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h index 69371236796..fb5c7d29e7e 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h @@ -63,6 +63,8 @@ class INET_API QosAckHandler : public SimpleModule, public IAckHandler virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) override; virtual void processTransmittedDataOrMgmtFrame(const Ptr& header); + void processTransmittedImplicitBlockAckMember(const Ptr& header); + void processFailedImplicitBlockAckMember(const Ptr& header); virtual void processTransmittedBlockAckReq(const Ptr& blockAckReq, const OriginatorBlockAckAgreement *agreement); virtual void processFailedFrame(const Ptr& dataOrMgmtHeader); virtual void dropFrame(const Ptr& dataOrMgmtHeader); diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc index e52f6b72652..75bc71ca2a1 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc @@ -126,6 +126,11 @@ void QosRecoveryProcedure::controlFrameTransmissionFailed() } } +void QosRecoveryProcedure::implicitBlockAckMemberFailed(Packet *packet, const Ptr& header) +{ + incrementCounter(header, packet->getByteLength() >= rtsThreshold ? longRetryCounter : shortRetryCounter); +} + // // This SRC and the SSRC shall be reset when a MAC frame of length less than or equal // to dot11RTSThreshold succeeds for that MPDU of type Data or MMPDU. diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h index e1804fcc323..62c9b663066 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h +++ b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h @@ -61,6 +61,7 @@ class INET_API QosRecoveryProcedure : public SimpleModule, public IRecoveryProce bool isMulticastFrame(Packet *packet, const Ptr& header); public: + void implicitBlockAckMemberFailed(Packet *packet, const Ptr& header); virtual void multicastFrameTransmitted(); virtual void ctsFrameReceived(); diff --git a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc index 5c65ba9d116..283bbe42d6b 100644 --- a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc +++ b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.cc @@ -145,51 +145,55 @@ const IIeee80211Mode *QosRateSelection::computeResponseBlockAckFrameMode(Packet return getPeerCompatibleResponseMode(blockAckReq, mode, role); } else if (dynamicPtrCast(blockAckReq)) { - auto received = getMode(packet, blockAckReq); - auto referenceRate = received->getNonHtReferenceRate(); - auto receivedClass = received->getModulationClass(); - bool highThroughput = receivedClass == IIeee80211Mode::ModulationClass::HT || receivedClass == IIeee80211Mode::ModulationClass::VHT; - if (!std::isfinite(referenceRate.get())) - throw cRuntimeError("Compressed Block Ack has no non-HT reference rate for the BAR mode"); - const Ieee80211RateSet *basic = mib ? &mib->getBssRateSet().basic : nullptr; - auto matchesClass = [received, receivedClass, highThroughput](const IIeee80211Mode *candidate) { - auto modulation = candidate->getModulationClass(); - return highThroughput ? modulation == IIeee80211Mode::ModulationClass::OFDM || modulation == IIeee80211Mode::ModulationClass::ERP_OFDM : - modulation == receivedClass && candidate->getLegacyPreambleType() == received->getLegacyPreambleType(); - }; - const IIeee80211Mode *primary = nullptr; - // IEEE Std 802.11-2024, 10.6.6.5.2: prefer a qualifying BSS basic rate, then a mandatory rate. - for (bool useBasic : {true, false}) { - if (useBasic && (!basic || !basic->known)) - continue; // INET fallback for unknown BSS state uses the mandatory rate set. - for (int i = 0; i < modeSet->getNumModes(); i++) { - auto candidate = modeSet->getMode(i); - auto rate = candidate->getDataMode()->getNetBitrate(); - bool eligible = useBasic ? basic->legacyRates.count(rate) != 0 : modeSet->isMandatory(i); - if (eligible && matchesClass(candidate) && rate <= referenceRate && - (!primary || rate > primary->getDataMode()->getNetBitrate())) - primary = candidate; - } - if (primary) - break; - } - if (!primary) - throw cRuntimeError("Compressed Block Ack has no legal non-HT response mode"); - if (!responseBlockAckFrameMode || responseBlockAckFrameMode == primary) - return primary; - auto alternate = responseBlockAckFrameMode; - auto rate = alternate->getDataMode()->getNetBitrate(); - bool basicOrMandatory = (basic && basic->known && basic->legacyRates.count(rate)) || modeSet->getIsMandatory(alternate); - // IEEE Std 802.11-2024, 10.6.6.5.4: an alternate preserves modulation and actual response duration. - if (!matchesClass(alternate) || alternate->getModulationClass() != primary->getModulationClass() || !basicOrMandatory || - alternate->getDuration(LENGTH_COMPRESSED_BLOCKACK) != primary->getDuration(LENGTH_COMPRESSED_BLOCKACK)) - throw cRuntimeError("responseBlockAckFrameBitrate is not a legal alternate Compressed Block Ack response rate"); - return alternate; + return computeCompressedBlockAckResponseMode(getMode(packet, blockAckReq)); } else throw cRuntimeError("Unknown BlockAckReq frame type"); } +const IIeee80211Mode *QosRateSelection::computeCompressedBlockAckResponseMode(const IIeee80211Mode *received) +{ + auto referenceRate = received->getNonHtReferenceRate(); + auto receivedClass = received->getModulationClass(); + bool highThroughput = receivedClass == IIeee80211Mode::ModulationClass::HT || receivedClass == IIeee80211Mode::ModulationClass::VHT; + if (!std::isfinite(referenceRate.get())) + throw cRuntimeError("Compressed Block Ack has no non-HT reference rate for the BAR mode"); + const Ieee80211RateSet *basic = mib ? &mib->getBssRateSet().basic : nullptr; + auto matchesClass = [received, receivedClass, highThroughput](const IIeee80211Mode *candidate) { + auto modulation = candidate->getModulationClass(); + return highThroughput ? modulation == IIeee80211Mode::ModulationClass::OFDM || modulation == IIeee80211Mode::ModulationClass::ERP_OFDM : + modulation == receivedClass && candidate->getLegacyPreambleType() == received->getLegacyPreambleType(); + }; + const IIeee80211Mode *primary = nullptr; + // IEEE Std 802.11-2024, 10.6.6.5.2: prefer a qualifying BSS basic rate, then a mandatory rate. + for (bool useBasic : {true, false}) { + if (useBasic && (!basic || !basic->known)) + continue; // INET fallback for unknown BSS state uses the mandatory rate set. + for (int i = 0; i < modeSet->getNumModes(); i++) { + auto candidate = modeSet->getMode(i); + auto rate = candidate->getDataMode()->getNetBitrate(); + bool eligible = useBasic ? basic->legacyRates.count(rate) != 0 : modeSet->isMandatory(i); + if (eligible && matchesClass(candidate) && rate <= referenceRate && + (!primary || rate > primary->getDataMode()->getNetBitrate())) + primary = candidate; + } + if (primary) + break; + } + if (!primary) + throw cRuntimeError("Compressed Block Ack has no legal non-HT response mode"); + if (!responseBlockAckFrameMode || responseBlockAckFrameMode == primary) + return primary; + auto alternate = responseBlockAckFrameMode; + auto rate = alternate->getDataMode()->getNetBitrate(); + bool basicOrMandatory = (basic && basic->known && basic->legacyRates.count(rate)) || modeSet->getIsMandatory(alternate); + // IEEE Std 802.11-2024, 10.6.6.5.4: an alternate preserves modulation and actual response duration. + if (!matchesClass(alternate) || alternate->getModulationClass() != primary->getModulationClass() || !basicOrMandatory || + alternate->getDuration(LENGTH_COMPRESSED_BLOCKACK) != primary->getDuration(LENGTH_COMPRESSED_BLOCKACK)) + throw cRuntimeError("responseBlockAckFrameBitrate is not a legal alternate Compressed Block Ack response rate"); + return alternate; +} + const IIeee80211Mode *QosRateSelection::computeCompressedBlockAckReqMode(Packet *packet, const Ptr& blockAckReq, bool startsTxop) { diff --git a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h index c0ecc61f8a1..ff499b97274 100644 --- a/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h +++ b/src/inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h @@ -76,6 +76,7 @@ class INET_API QosRateSelection : public IQosRateSelection, public ModeSetListen virtual bool isControlResponseFrame(const Ptr& header, TxopProcedure *txopProcedure); public: + const physicallayer::IIeee80211Mode *computeCompressedBlockAckResponseMode(const physicallayer::IIeee80211Mode *elicitingMode) override; // A control response frame is a control frame that is transmitted as a response to the reception of a frame a SIFS // time after the PPDU containing the frame that elicited the response, e.g. a CTS in response to an RTS // reception, an ACK in response to a DATA reception, a BlockAck in response to a BlockAckReq reception. In diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc index e3f9ea2151d..9d3d2edfe56 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.cc @@ -53,7 +53,7 @@ Packet *RecipientQosMacDataService::defragment(Packet *mgmtFragment) return nullptr; } -std::vector RecipientQosMacDataService::dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe) +std::vector RecipientQosMacDataService::dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe, const BlockAckReceiveContext *context) { Enter_Method("dataFrameReceived"); take(dataPacket); @@ -80,7 +80,7 @@ std::vector RecipientQosMacDataService::dataFrameReceived(Packet *data MacAddress originatorAddr = dataHeader->getTransmitterAddress(); RecipientBlockAckAgreement *agreement = blockAckAgreementHandler->getAgreement(tid, originatorAddr); if (agreement) - frames = blockAckReordering->processReceivedQoSFrame(agreement, dataPacket, dataHeader, interframe); + frames = blockAckReordering->processReceivedQoSFrame(agreement, dataPacket, dataHeader, interframe, context); } std::vector defragmentedFrames; if (basicReassembly) { // FIXME defragmentation diff --git a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h index 066359162b1..4b07f244a07 100644 --- a/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/recipient/RecipientQosMacDataService.h @@ -48,7 +48,7 @@ class INET_API RecipientQosMacDataService : public IRecipientQosMacDataService, public: virtual std::vector retireAgreement(RecipientBlockAckAgreement *agreement, bool associationReset) override; virtual void clearPeer(MacAddress peer) override; - virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe = false) override; + virtual std::vector dataFrameReceived(Packet *dataPacket, const Ptr& dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, bool interframe = false, const BlockAckReceiveContext *context = nullptr) override; virtual std::vector controlFrameReceived(Packet *controlPacket, const Ptr& controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) override; virtual std::vector managementFrameReceived(Packet *mgmtPacket, const Ptr& mgmtHeader) override; }; diff --git a/tests/module/Ieee80211AmpduAdmission_1.test b/tests/module/Ieee80211AmpduAdmission_1.test new file mode 100644 index 00000000000..fce3b8d4d82 --- /dev/null +++ b/tests/module/Ieee80211AmpduAdmission_1.test @@ -0,0 +1,700 @@ +%description: +Real HCF queues drive aggregate admission, protection, and delayed submission through two radios. +Cases 0 through 2 place the RTS threshold above, at, and below the complete PSDU length. +Case 3 adds peer spacing that crosses the RTS threshold. +Case 4 reduces three members to two across that threshold at one retained DATA mode. +Cases 5 and 6 send a retained singleton retry beyond a positive TXOP under multiple protection, without and with RTS. +Cases 7 and 8 cancel post-CTS DATA through real inactivity expiry and peer reset before SIFS ends. +Case 9 checks an ordinary positive TXOP. Threshold cases use a zero TXOP. +Cases 10 through 12 use DATA durations below, at, and above the HT mixed-format bound. +Cases 13 through 15 lose actual CTS responses for new, retained, and mixed batches. +Two RTS failures cross the contention retry boundary without member failure or disposal. +Cases 16 and 17 use nonzero propagation after RTS to test the next unprotected batch. +An encoded reservation beyond the TXOP deadline must defer that batch without source changes. +A reservation equal to the deadline must permit that batch when its exchange fits. +The selected mode supplies the boundary lengths and the reduction budget. +The fixture seeds accepted agreements and the singleton's prior failed attempt. +It checks current HCF and Tx behavior, not ADDBA negotiation or the seeded prior transmission. +The campaign uses HT20 MCS0 and MCS7, long GI, both bands, scalar reception, and seed zero. +At MCS0, case 3 proves that the selected spacing needs no extra delimiter. +At MCS7, case 3 proves that extra delimiters cross the RTS threshold. + +%extraargs: -r 0..56 + +%file: AmpduAdmission.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h" +#include "inet/linklayer/ieee80211/mac/originator/QosRtsPolicy.h" +#include "inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IReception.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +static const Ieee80211HtMode *admissionMode(int mcs, bool band5) +{ + return Ieee80211HtCompliantModes::getCompliantMode( + mcs == 0 ? &Ieee80211HtmcsTable::htMcs0BW20MHz : &Ieee80211HtmcsTable::htMcs7BW20MHz, + band5 ? Ieee80211HtMode::BAND_5GHZ : Ieee80211HtMode::BAND_2_4GHZ, + Ieee80211HtPreambleMode::HT_PREAMBLE_MIXED, Ieee80211HtModeBase::HT_GUARD_INTERVAL_LONG); +} + +static cValue admissionTxopLimit(cComponent *, cValue arguments[], int) +{ + int scenario = arguments[0].intValue(); + auto mode = admissionMode(arguments[1].intValue(), arguments[2].boolValue()); + simtime_t limit; + if (scenario == 16 || scenario == 17) limit = SimTime(1, SIMTIME_MS); + else if (scenario < 3 || scenario >= 10) limit = SIMTIME_ZERO; + else if (scenario == 5 || scenario == 6) limit = SimTime(1, SIMTIME_US); + else if (scenario == 4) { + // This setup budget lies between two and three DATA PPDUs at the selected mode. + // A 6 Mbps response supplies a conservative response duration for both supported MCS values. + auto response = Ieee80211ModeSet::getModeSet("a")->getMode(bps(6000000)); + limit = (mode->getDuration(B(2008)) + mode->getDuration(B(3012))) / 2 + + mode->getSifsTime() + response->getDuration(LENGTH_COMPRESSED_BLOCKACK); + } + else limit = SimTime(1, SIMTIME_MS); + return cValue(limit.dbl(), "s"); +} +Define_NED_Function(admissionTxopLimit, "quantity admissionTxopLimit(int scenario, int mcs, bool band5)"); + +class AdmissionHcf; +class AdmissionDriver : public cSimpleModule +{ + bool verificationScheduled = false; + public: + void verifyAfter(simtime_t interval) { + Enter_Method("verifyAfter"); + if (!verificationScheduled) { + verificationScheduled = true; + scheduleAfter(interval, new cMessage("verify")); + } + } + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("begin")); } + void handleMessage(cMessage *message) override; +}; +Define_Module(AdmissionDriver); + +class AdmissionErrorModel : public Ieee80211NistErrorModel +{ + public: + double computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart) const override { + if (!par("dropCts").boolValue()) return 0; + auto packet = snir->getReception()->getTransmission()->getPacket(); + auto phy = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(packet); + auto ht = dynamicPtrCast(phy); + if (ht && ht->getAggregation()) return 0; + return packet->peekDataAt(phy->getChunkLength())->getType() == ST_CTS ? 1 : 0; + } + double computeAmpduRangeSuccessRate(const ISnir *, const IIeee80211Mode *, B) const override { return 1; } +}; +Define_Module(AdmissionErrorModel); + +class AdmissionRtsPolicy : public QosRtsPolicy +{ + public: + mutable std::vector> aggregateQueries; + void setThreshold(B length) { rtsThreshold = length.get(); } + bool isRtsNeeded(Packet *packet, const Ptr& header) const override { + bool result = QosRtsPolicy::isRtsNeeded(packet, header); + if (dynamicPtrCast(packet->peekAtFront())) + aggregateQueries.push_back({B(packet->getDataLength()), result}); + return result; + } +}; +Define_Module(AdmissionRtsPolicy); + +class AdmissionRateSelection : public IQosRateSelection +{ + public: + IQosRateSelection *delegate = nullptr; + const IIeee80211Mode *fixedDataMode = nullptr; + int dataQueries = 0; + const IIeee80211Mode *selectedDataMode = nullptr; + const IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txop) override { + // The fixture supplies a fixed HT tuple, including HT operation through the 5 GHz ac mode set. + auto result = dynamicPtrCast(header) ? fixedDataMode : delegate->computeMode(packet, header, txop); + if (dynamicPtrCast(header)) { + dataQueries++; + selectedDataMode = result; + } + return result; + } + const IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { + return delegate->computeResponseCtsFrameMode(packet, header, role); + } + const IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { + return delegate->computeResponseAckFrameMode(packet, header, role); + } + const IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { + return delegate->computeResponseBlockAckFrameMode(packet, header, role); + } + const IIeee80211Mode *computeCompressedBlockAckResponseMode(const IIeee80211Mode *mode) override { + return delegate->computeCompressedBlockAckResponseMode(mode); + } + const IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool starts) override { + return delegate->computeCompressedBlockAckReqMode(packet, header, starts); + } +}; + +class AdmissionOriginatorAgreements : public OriginatorBlockAckAgreementHandler +{ + public: + void accept(MacAddress peer, int window = 64) { + auto agreement = new OriginatorBlockAckAgreement(peer, 0, SequenceNumberCyclic(0), window, false, false); + agreement->setIsAddbaRequestSent(true); + agreement->setIsAddbaResponseReceived(true); + agreement->setBlockAckTimeoutValue(SIMTIME_ZERO); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 0}] = agreement; + } +}; + +class AdmissionRecipientAgreements : public RecipientBlockAckAgreementHandler +{ + public: + void accept(MacAddress peer, int window = 64) { + auto agreement = new RecipientBlockAckAgreement(peer, 0, SequenceNumberCyclic(0), window, SIMTIME_ZERO); + agreement->setVariant(BlockAckVariant::COMPRESSED); + agreement->addbaResposneSent(); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 0}] = agreement; + } +}; + +class AdmissionHcf : public Hcf +{ + struct Source { int64_t id; Packet *packet; cObject *owner; simtime_t deadline; }; + struct Canonical { Packet *packet; cObject *owner; simtime_t deadline; int sequence; int64_t allocation; QosAckHandler::Status status; }; + std::vector sources; + std::vector canonical; + AdmissionRateSelection selection; + const IIeee80211Mode *expectedMode = nullptr; + B unspacedLength = B(0); + B fullLength = B(0); + B reducedLength = B(0); + MacAddress peer; + bool postCtsEvent = false; + int scenario() const { return par("scenario"); } + int mcs() const { return par("mcs"); } + bool source() const { return getFullPath().find("sender") != std::string::npos; } + bool cancellationCase() const { return scenario() == 7 || scenario() == 8; } + bool singletonCase() const { return scenario() == 5 || scenario() == 6; } + bool rtsFailureCase() const { return scenario() >= 13 && scenario() <= 15; } + bool reservationCase() const { return scenario() == 16 || scenario() == 17; } + AdmissionDriver *driver() const { + return check_and_cast(getSimulation()->getSystemModule()->getSubmodule("driver")); + } + OriginatorQosMacDataService *service() const { return check_and_cast(originatorDataService); } + void assertNoMemberRetryCount(Packet *packet) { + bool absent = false; + try { + edca->getEdcaf(AC_BE)->getRecoveryProcedure()->getRetryCount(packet, packet->peekAtFront()); + } + catch (const cRuntimeError& error) { + ASSERT(std::string(error.what()).find("The retry counter entry doesn't exist") != std::string::npos); + absent = true; + } + ASSERT(absent); + } + Packet *makeMember(int length) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(peer); + header->setTransmitterAddress(mac->getAddress()); + header->setAddress3(peer); + header->setTid(0); + header->setSequenceNumber(SequenceNumberCyclic(77)); + header->setDurationField(SIMTIME_ZERO); + auto packet = new Packet("admission-msdu", header); + packet->insertAtBack(makeShared(B(length) - header->getChunkLength() - B(4))); + packet->insertAtBack(makeShared()); + return packet; + } + public: + int rtsSent = 0; + int ctsReceived = 0; + int startCallbacks = 0; + int submissions = 0; + int aggregateCompletions = 0; + int successfulResponses = 0; + int failures = 0; + int cancellations = 0; + int implicitProbes = 0; + int delivered = 0; + int inactivityEvents = 0; + int rtsFailures = 0; + int dataOutcomes = 0; + int memberDisposals = 0; + B submittedLength = B(0); + int submittedMembers = 0; + int proposedMembers = 0; + simtime_t ctsTime; + bool checkedReservation = false; + MacAddress address() const { return mac->getAddress(); } + void seed(AdmissionHcf *other) { + Enter_Method("seed"); + peer = other->address(); + auto radio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + auto peerCapabilities = mib->localHtCapabilities; + if (source() && scenario() == 3) + peerCapabilities.minimumMpduStartSpacing = 7; + mib->setPeerHtCapabilities(peer, peerCapabilities, mib->getHtOperation()); + if (source()) { + selection.delegate = rateSelection; + rateSelection = &selection; + delete originatorBlockAckAgreementHandler; + auto accepted = new AdmissionOriginatorAgreements(); + accepted->accept(peer, reservationCase() ? 2 : 64); + originatorBlockAckAgreementHandler = accepted; + } + else { + delete recipientBlockAckAgreementHandler; + auto accepted = new AdmissionRecipientAgreements(); + accepted->accept(peer, reservationCase() ? 2 : 64); + recipientBlockAckAgreementHandler = accepted; + } + expectedMode = admissionMode(mcs(), par("band5").boolValue()); + ASSERT(modeSet->containsMode(expectedMode)); + selection.fixedDataMode = expectedMode; + } + void begin() { + Enter_Method("begin"); + ASSERT(source()); + int count = reservationCase() ? 4 : scenario() == 4 ? 3 : singletonCase() ? 1 : 2; + int length = scenario() == 4 || singletonCase() ? 1000 : 64; + std::vector frames; + if (scenario() >= 10 && scenario() <= 12) { + auto ht = check_and_cast(expectedMode); + auto target = SimTime(5480 + (scenario() - 10) * 4, SIMTIME_US); + int targetLength = 0; + for (int bytes = 30; bytes <= 65535; bytes++) { + if (ht->getDuration(B(bytes)) - ht->getSignalExtensionTime() == target) { + targetLength = bytes; + break; + } + } + ASSERT(targetLength > 0); + count = (targetLength + 2003) / 2004; + int firstLength = (targetLength - 4 * count) / count / 4 * 4; + for (int i = 0; i < count; i++) { + int memberLength = i + 1 == count ? targetLength - (count - 1) * (firstLength + 4) - 4 : firstLength; + ASSERT(memberLength >= 30 && memberLength <= 2346); + frames.push_back(makeMember(memberLength)); + } + } + else for (int i = 0; i < count; i++) frames.push_back(makeMember(reservationCase() && i < 2 ? 1000 : length)); + proposedMembers = frames.size(); + MpduAggregation builder; + unspacedLength = builder.computeAggregateLength(frames, expectedMode, 0); + fullLength = builder.computeAggregateLength(frames, expectedMode, scenario() == 3 ? 7 : 0); + if (scenario() == 4) { + auto reduced = frames; + reduced.pop_back(); + reducedLength = builder.computeAggregateLength(reduced, expectedMode, 0); + } + if (reservationCase()) { + fullLength = builder.computeAggregateLength({frames[0], frames[1]}, expectedMode, 0); + reducedLength = builder.computeAggregateLength({frames[2], frames[3]}, expectedMode, 0); + } + auto policy = check_and_cast(rtsPolicy); + B threshold = fullLength + B(1); + if (scenario() == 1) threshold = fullLength; + if (scenario() == 2) threshold = fullLength - B(1); + if (scenario() == 3) { + ASSERT((fullLength > unspacedLength) == (mcs() == 7)); + threshold = unspacedLength + B(1); + } + if (scenario() == 4) threshold = reducedLength + B(1); + if (scenario() == 6 || cancellationCase()) threshold = B(1); + if (rtsFailureCase()) threshold = fullLength - B(1); + if (reservationCase()) threshold = reducedLength + B(1); + policy->setThreshold(threshold); + if (rtsFailureCase()) { + subscribe(Ieee80211Mac::frameTransmissionOutcomeSignal, this); + subscribe(packetDroppedSignal, this); + } + for (auto packet : frames) { + processUpperFrame(packet, packet->peekAtFront()); + sources.push_back({packet->getId(), packet, packet->getOwner(), edca->getLifetimeHandler()->getDeadline(packet)}); + } + int retained = singletonCase() ? 1 : scenario() == 14 ? 2 : scenario() == 15 ? 1 : 0; + for (int i = 0; i < retained; i++) { + auto owner = edca->getEdcaf(AC_BE); + auto preview = service()->prepareFrame(owner->getPendingQueue(), false); + ASSERT(preview); + auto committed = service()->commitPreparedFrame(*preview); + ASSERT(committed); + owner->getInProgressFrames()->adoptPreparedFrame(committed); + auto header = committed->removeAtFront(); + header->setRetry(true); + header->setAckPolicy(NORMAL_ACK); + committed->insertAtFront(header); + owner->getAckHandler()->processTransmittedImplicitBlockAckMember(header); + owner->getAckHandler()->processFailedImplicitBlockAckMember(header); + auto agreement = originatorBlockAckAgreementHandler->getAgreement(peer, 0); + agreement->recordTransmittedData(committed->getTag()->getAllocationIndex()); + canonical.push_back({committed, committed->getOwner(), edca->getLifetimeHandler()->getDeadline(committed), + header->getSequenceNumber().get(), committed->getTag()->getAllocationIndex(), + owner->getAckHandler()->getQoSDataAckStatus(header)}); + sources.erase(sources.begin()); + } + } + Packet *prepareAggregateTransmission() override { + startCallbacks++; + ASSERT(!cancellationCase()); + ASSERT(selection.dataQueries == (reservationCase() ? submissions + 1 : 1)); + ASSERT(selection.selectedDataMode == expectedMode); + auto owner = edca->getChannelOwner(); + auto txop = owner->getTxopProcedure(); + if (singletonCase()) { + ASSERT(txop->getLimit() > 0 && txop->getProtectionMechanism() == TxopProcedure::MULTIPLE_PROTECTION); + ASSERT(expectedMode->getDuration(fullLength) > txop->getLimit()); + } + auto packet = Hcf::prepareAggregateTransmission(); + ASSERT(packet); + submissions++; + submittedLength = B(packet->getDataLength()); + ASSERT(packet->getTag()->getMode() == expectedMode); + auto layout = inspectMpduAggregate(packet, B(0), submittedLength); + ASSERT(layout.complete); + simtime_t duration = -1; + int currentMembers = 0; + for (const auto& range : layout.ranges) { + if (range.kind != MpduRangeKind::MPDU) continue; + auto header = packet->peekDataAt(range.offset); + ASSERT(header->getRetry() == singletonCase()); + ASSERT(header->getAckPolicy() == NORMAL_ACK); + if (currentMembers == 0) duration = header->getDurationField(); + ASSERT(header->getDurationField() == duration); + submittedMembers++; + currentMembers++; + } + ASSERT(duration > SIMTIME_ZERO); + if (reservationCase()) ASSERT(submittedLength == (submissions == 1 ? fullLength : reducedLength)); + else if (scenario() == 12) { + ASSERT(submittedLength < fullLength && submittedMembers == proposedMembers - 1); + ASSERT(check_and_cast(expectedMode)->isPpduDurationValid(submittedLength)); + } + else if (scenario() == 4) ASSERT(submittedLength == reducedLength && submittedMembers == 2); + else ASSERT(submittedLength == fullLength); + if (scenario() == 10 || scenario() == 11) { + auto ht = check_and_cast(expectedMode); + ASSERT(ht->getDuration(submittedLength) - ht->getSignalExtensionTime() == + SimTime(scenario() == 10 ? 5480 : 5484, SIMTIME_US)); + } + return packet; + } + void aggregateTransmissionCancelled() override { + cancellations++; + Hcf::aggregateTransmissionCancelled(); + } + void verify(AdmissionHcf *receiver) { + Enter_Method("verify"); + ASSERT(source()); + ASSERT(failures == 0 && implicitProbes == 0); + if (reservationCase()) { + ASSERT(checkedReservation && rtsSent == 1 && ctsReceived == 1); + ASSERT(startCallbacks == (scenario() == 16 ? 1 : 2)); + ASSERT(submissions == startCallbacks && aggregateCompletions == startCallbacks && successfulResponses == startCallbacks); + ASSERT(cancellations == 0 && receiver->delivered == (scenario() == 16 ? 2 : 4)); + auto queue = edca->getEdcaf(AC_BE)->getPendingQueue(); + ASSERT(queue->getNumPackets() == (scenario() == 16 ? 2 : 0)); + ASSERT(service()->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(scenario() == 16 ? 2 : 4)); + ASSERT(!tx->hasTransmission()); + if (scenario() == 16) { + for (size_t i = 2; i < sources.size(); i++) { + const auto& source = sources[i]; + auto retained = edca->getLifetimeHandler()->findFrame(source.id); + ASSERT(retained == source.packet && retained->getOwner() == source.owner); + ASSERT(edca->getLifetimeHandler()->getDeadline(retained) == source.deadline); + ASSERT(retained->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + ASSERT(!retained->findTag()); + } + } + } + else if (rtsFailureCase()) { + ASSERT(rtsFailures == 2 && rtsSent == 2 && ctsReceived == 0); + ASSERT(startCallbacks == 0 && submissions == 0 && aggregateCompletions == 0 && successfulResponses == 0); + ASSERT(cancellations == 0 && dataOutcomes == 0 && memberDisposals == 0 && receiver->delivered == 0); + auto agreement = originatorBlockAckAgreementHandler->getAgreement(peer, 0); + ASSERT(agreement && !agreement->hasPendingProbe()); + auto owner = edca->getEdcaf(AC_BE); + ASSERT(owner->getPendingQueue()->getNumPackets() == int(sources.size())); + ASSERT(owner->getInProgressFrames()->getLength() == int(canonical.size())); + ASSERT(service()->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(canonical.size())); + for (const auto& source : sources) { + auto packet = edca->getLifetimeHandler()->findFrame(source.id); + ASSERT(packet == source.packet && packet->getOwner() == source.owner); + ASSERT(edca->getLifetimeHandler()->getDeadline(packet) == source.deadline); + ASSERT(!packet->findTag()); + ASSERT(packet->peekAtFront()->getSequenceNumber() == SequenceNumberCyclic(77)); + } + for (const auto& retained : canonical) { + auto packet = retained.packet; + ASSERT(owner->getInProgressFrames()->containsFrame(packet) && packet->getOwner() == retained.owner); + ASSERT(edca->getLifetimeHandler()->getDeadline(packet) == retained.deadline); + auto header = packet->peekAtFront(); + ASSERT(header->getSequenceNumber() == SequenceNumberCyclic(retained.sequence) && header->getRetry()); + ASSERT(packet->getTag()->getAllocationIndex() == retained.allocation); + ASSERT(owner->getAckHandler()->getQoSDataAckStatus(header) == retained.status); + assertNoMemberRetryCount(packet); + } + } + else if (cancellationCase()) { + ASSERT(postCtsEvent && ctsReceived == 1 && rtsSent == 1); + ASSERT(startCallbacks == 0 && submissions == 0 && aggregateCompletions == 0); + ASSERT(cancellations == 1 && successfulResponses == 0 && receiver->delivered == 0); + ASSERT(service()->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(0)); + ASSERT(!frameSequenceHandler->isSequenceRunning() && !tx->hasTransmission()); + ASSERT(!originatorBlockAckAgreementHandler->getAgreement(peer, 0)); + ASSERT(inactivityEvents == (scenario() == 7 ? 1 : 0)); + for (const auto& source : sources) { + auto retained = edca->getLifetimeHandler()->findFrame(source.id); + if (scenario() == 8) ASSERT(!retained); + else { + ASSERT(retained == source.packet && retained->getOwner() == source.owner); + ASSERT(edca->getLifetimeHandler()->getDeadline(retained) == source.deadline); + ASSERT(!retained->findTag()); + } + } + } + else { + ASSERT(startCallbacks == 1 && submissions == 1 && aggregateCompletions == 1 && successfulResponses == 1); + ASSERT(cancellations == 0 && receiver->delivered == submittedMembers); + ASSERT(rtsSent == ((scenario() == 1 || scenario() == 2 || (scenario() == 3 && mcs() == 7) || scenario() == 6) ? 1 : 0)); + auto policy = check_and_cast(rtsPolicy); + if (scenario() == 4) { + bool protectedFull = false, unprotectedReduced = false; + for (auto query : policy->aggregateQueries) { + protectedFull |= query.first == fullLength && query.second; + unprotectedReduced |= query.first == reducedLength && !query.second; + } + ASSERT(protectedFull && unprotectedReduced); + ASSERT(edca->getEdcaf(AC_BE)->getPendingQueue()->getNumPackets() == 1); + ASSERT(service()->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(2)); + } + } + std::cout << "Aggregate admission assertions passed: scenario=" << scenario() << " mcs=" << mcs() + << " band5=" << par("band5").boolValue() << "\n"; + } + protected: + void originatorProcessRtsProtectionFailed(Packet *packet) override { + Hcf::originatorProcessRtsProtectionFailed(packet); + ASSERT(rtsFailureCase()); + rtsFailures++; + ASSERT(rtsFailures <= 2); + auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); + ASSERT(prepared && prepared->batch && !prepared->submitted); + auto owner = edca->getChannelOwner(); + ASSERT(owner->getRecoveryProcedure()->getShortRetryLimit() == 1); + for (auto member : prepared->batch->members) + assertNoMemberRetryCount(member); + ASSERT(!prepared->agreement->hasPendingProbe()); + if (rtsFailures == 2) driver()->verifyAfter(SimTime(1, SIMTIME_NS)); + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *details) override { + if (signal == Ieee80211Mac::frameTransmissionOutcomeSignal) { + auto packet = check_and_cast(object); + if (dynamicPtrCast(packet->peekAtFront())) dataOutcomes++; + } + else { + if (signal == packetDroppedSignal) { + auto packet = check_and_cast(object); + if (dynamicPtrCast(packet->peekAtFront())) memberDisposals++; + } + Hcf::receiveSignal(source, signal, object, details); + } + } + void originatorProcessTransmittedFrame(Packet *packet) override { + if (auto header = dynamicPtrCast(packet->peekAtFront())) { + if (header->getType() == ST_RTS) rtsSent++; + if (dynamicPtrCast(header)) implicitProbes++; + } + Hcf::originatorProcessTransmittedFrame(packet); + } + void originatorProcessReceivedFrame(Packet *packet, Packet *transmitted) override { + auto header = packet->peekAtFront(); + bool cts = header->getType() == ST_CTS; + bool blockAck = bool(dynamicPtrCast(header)); + Hcf::originatorProcessReceivedFrame(packet, transmitted); + if (cts) { + ctsReceived++; + ctsTime = simTime(); + if (cancellationCase()) { + ASSERT(service()->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(0)); + auto interval = modeSet->getSifsTime() / 2; + if (scenario() == 7) { + auto agreement = originatorBlockAckAgreementHandler->getAgreement(peer, 0); + agreement->setBlockAckTimeoutValue(interval); + agreement->calculateExpirationTime(); + scheduleInactivityTimer(); + } + else scheduleAfter(interval, new cMessage("reset-during-sifs")); + driver()->verifyAfter(modeSet->getSifsTime() + SimTime(1, SIMTIME_NS)); + } + } + if (blockAck) { + successfulResponses++; + if (reservationCase() && successfulResponses == 1) { + auto txop = edca->getChannelOwner()->getTxopProcedure(); + auto deadline = txop->getStart() + txop->getLimit(); + auto responseMode = rateSelection->computeCompressedBlockAckResponseMode(expectedMode); + ASSERT(simTime() + modeSet->getSifsTime() + expectedMode->getDuration(reducedLength) + + modeSet->getSifsTime() + responseMode->getDuration(LENGTH_COMPRESSED_BLOCKACK) < deadline); + if (scenario() == 16) ASSERT(txop->getReservationEnd() > deadline); + else ASSERT(txop->getReservationEnd() == deadline); + checkedReservation = true; + if (scenario() == 16) driver()->verifyAfter(modeSet->getSifsTime() + SimTime(1, SIMTIME_NS)); + } + else driver()->verifyAfter(SimTime(1, SIMTIME_NS)); + } + } + void handleMessage(cMessage *message) override { + if (message->isName("reset-during-sifs")) { + delete message; + ASSERT(tx->hasTransmission()); + postCtsEvent = true; + resetPeer(peer); + } + else { + bool inactivity = message == inactivityTimer; + if (inactivity) { + ASSERT(cancellationCase() && scenario() == 7 && tx->hasTransmission()); + ASSERT(ctsTime < simTime() && simTime() < ctsTime + modeSet->getSifsTime()); + postCtsEvent = true; + inactivityEvents++; + } + Hcf::handleMessage(message); + } + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (!header) aggregateCompletions++; + Hcf::transmissionComplete(packet, header); + } + void originatorProcessFailedFrame(Packet *packet) override { + failures++; + Hcf::originatorProcessFailedFrame(packet); + } + void sendUp(const std::vector& frames) override { + for (auto packet : frames) { + delivered++; + take(packet); + delete packet; + } + } +}; +Define_Module(AdmissionHcf); + +void AdmissionDriver::handleMessage(cMessage *message) +{ + auto sender = check_and_cast(getModuleByPath("^.sender.wlan[0].mac.hcf")); + auto receiver = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.hcf")); + bool begin = message->isName("begin"); + delete message; + if (begin) { + sender->seed(receiver); + receiver->seed(sender); + sender->begin(); + } + else { + sender->verify(receiver); + endSimulation(); + } +} + +%file: test.ned +import inet.node.inet.AdhocHost; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.originator.OriginatorQosMacDataService; +import inet.linklayer.ieee80211.mac.originator.QosRtsPolicy; +import inet.linklayer.ieee80211.mac.rateselection.QosRateSelection; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211RadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +module AdmissionHcf extends Hcf { parameters: int scenario; int mcs; bool band5; @class(::AdmissionHcf); } +module AdmissionRtsPolicy extends QosRtsPolicy { parameters: @class(::AdmissionRtsPolicy); } +module AdmissionErrorModel extends Ieee80211NistErrorModel { parameters: bool dropCts = default(false); @class(::AdmissionErrorModel); } +simple AdmissionDriver { parameters: @class(::AdmissionDriver); } +network Test { + submodules: + radioMedium: Ieee80211RadioMedium; + sender: AdhocHost; + receiver: AdhocHost; + driver: AdmissionDriver; +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src +sim-time-limit = 20ms +seed-set = 0 +cmdenv-express-mode = false +record-vector-results = false +record-scalar-results = false +**.wlan[0].opMode = ${band5} ? "ac" : "n(mixed-2.4Ghz)" +**.wlan[0].mac.qosStation = true +**.wlan[0].mac.hcf.typename = "AdmissionHcf" +**.wlan[0].mac.hcf.scenario = ${scenario=0..17} +**.wlan[0].mac.hcf.mcs = ${mcs=0,7} +**.wlan[0].mac.hcf.band5 = ${band5=false,true} +**.wlan[0].mac.hcf.isBlockAckSupported = true +**.wlan[0].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +**.wlan[0].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +**.wlan[0].mac.hcf.rtsPolicy.typename = "AdmissionRtsPolicy" +**.wlan[0].mac.hcf.rateSelection.dataFrameBitrate = ${mcs} == 0 ? 6.5Mbps : 65Mbps +**.wlan[0].mac.hcf.rateSelection.dataFrameBandwidth = 20MHz +**.wlan[0].mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1 +**.wlan[0].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps +**.wlan[0].mac.hcf.rateSelection.responseCtsFrameBitrate = 6Mbps +**.wlan[0].mac.hcf.edca.*.txopProcedure.txopLimit = admissionTxopLimit(${scenario}, ${mcs}, ${band5}) +**.wlan[0].mac.hcf.edca.*.txopProcedure.protectionMechanism = (${scenario} == 5 || ${scenario} == 6 || ${scenario} == 9 || ${scenario} >= 16) ? "multiple" : "single" +**.wlan[0].radio.receiver.errorModel.typename = "AdmissionErrorModel" +*.sender.wlan[0].radio.receiver.errorModel.dropCts = ${scenario} >= 13 && ${scenario} <= 15 +**.wlan[0].mac.hcf.edca.*.recoveryProcedure.shortRetryLimit = (${scenario} >= 13 && ${scenario} <= 15) ? 1 : 7 +**.wlan[0].radio.bandName = ${band5} ? "5 GHz (mapped 20 MHz)" : "2.4 GHz" +**.wlan[0].mib.htMaxAmpduLengthExponent = 3 +**.wlan[0].radio.receiver.bandwidth = 20MHz +**.wlan[0].radio.separateReceptionParts = true +*.radioMedium.backgroundNoise.power = -110dBm +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = ${scenario} == 16 ? 250ns : (${scenario} == 17 ? 500ns : 0s) +**.mobility.initFromDisplayString = false +**.mobility.initialX = 10m +**.mobility.initialY = 10m +**.mobility.initialZ = 0m +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +constraint = $scenario < 13 || ($mcs == 7 && !$band5) + +%contains: stdout +Aggregate admission assertions passed: + +%contains: stdout +Run statistics: total 57, successful 57 diff --git a/tests/module/Ieee80211AmpduExchange_1.test b/tests/module/Ieee80211AmpduExchange_1.test new file mode 100644 index 00000000000..2fc4e53dc3b --- /dev/null +++ b/tests/module/Ieee80211AmpduExchange_1.test @@ -0,0 +1,373 @@ +%description: +Production association establishes HT limits before two aggregate DATA hops. +The source sends sixty UDP payloads through an AP to a second station. +The fixture checks actual member FCS, shared addresses and Duration, policy bits, and implicit responses. +The matrix varies scalar or dimensional PHY, NIST or Yans, protection, and TXOP limit. +All cases use seed zero and fixed HT20 long-GI DATA rates. + +%extraargs: -r 0..15 + +%postrun-command: python3 check-exchange.py + +%file: Exchange.cc +#include +#include "inet/common/Simsignals.h" +#include "inet/common/checksum/Checksum.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +class AmpduExchangeLossModel : public Ieee80211NistErrorModel +{ + mutable std::map losses; + mutable int implicitResponses = 0; + mutable int probeResponses = 0; + mutable int partialTransmission = -1; + mutable int partialMembers = 0; + public: + double computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart part) const override { + auto transmission = snir->getReception()->getTransmission(); + auto packet = transmission->getPacket(); + auto phy = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(packet); + auto ht = dynamicPtrCast(phy); + if (ht && ht->getAggregation()) + return 0; + auto header = packet->peekDataAt(phy->getChunkLength()); + if (header->getType() != ST_BLOCKACK || par("lossMode").intValue() == 0) + return 0; + auto id = transmission->getId(); + auto found = losses.find(id); + if (found == losses.end()) { + bool implicit = strstr(packet->getName(), "Implicit") != nullptr; + bool lose = implicit ? implicitResponses++ == 0 : + implicitResponses > 0 && par("lossMode").intValue() == 2 && probeResponses++ == 0; + found = losses.emplace(id, lose).first; + } + return found->second ? 1 : 0; + } + double computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *, B length) const override { + if (par("lossMode").intValue() != 3 || length == B(4)) + return 1; + auto id = snir->getReception()->getTransmission()->getId(); + if (partialTransmission == -1) + partialTransmission = id; + return id == partialTransmission && partialMembers++ == 0 ? 0 : 1; + } +}; +Define_Module(AmpduExchangeLossModel); + +class AmpduExchangeHcf : public Hcf +{ + public: + int aggregates = 0; + int members = 0; + int responses = 0; + int positive = 0; + int responsesSent = 0; + int acceptedDialogs = 0; + int failedImplicit = 0; + int probes = 0; + int dataAfterProbe = 0; + int barsSinceData = 0; + bool awaitProbe = false; + int attemptOutcomes = 0; + int retryBatches = 0; + int mixedBatches = 0; + std::map deadlines; + static bool isAggregate(Packet *packet) { + return dynamicPtrCast(packet->peekAtFront()) != nullptr; + } + protected: + void initialize(int stage) override { + Hcf::initialize(stage); + if (stage == INITSTAGE_LOCAL) + subscribe(Ieee80211Mac::frameTransmissionOutcomeSignal, this); + } + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *details) override { + if (signal == Ieee80211Mac::frameTransmissionOutcomeSignal) { + auto packet = check_and_cast(object); + if (dynamicPtrCast(packet->peekAtFront())) + attemptOutcomes++; + } + else + Hcf::receiveSignal(source, signal, object, details); + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (isAggregate(packet)) { + auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); + bool newMember = false; + bool retryMember = false; + int previousRetry = -1; + int previousNew = -1; + for (auto member : prepared->batch->members) { + auto data = member->peekAtFront(); + int offset = OriginatorBlockAckAgreement::computeSequenceDistance(prepared->limits.windowStart, data->getSequenceNumber()); + if (data->getRetry()) { + ASSERT(!newMember && offset > previousRetry); + previousRetry = offset; + retryMember = true; + } + else { + ASSERT(offset > previousNew); + previousNew = offset; + newMember = true; + } + auto index = member->getTag()->getAllocationIndex(); + auto deadline = edca->getLifetimeHandler()->getDeadline(member); + auto previous = deadlines.find(index); + if (previous != deadlines.end()) + ASSERT(previous->second == deadline); + else + deadlines.emplace(index, deadline); + } + retryBatches += retryMember; + mixedBatches += retryMember && newMember; + if (probes > 0) + dataAfterProbe++; + barsSinceData = 0; + auto mode = packet->getTag()->getMode(); + ASSERT(mode->getHtMcsIndex() >= 0 && !mode->isHtShortGuardInterval()); + ASSERT(mode->getDataMode()->getBandwidth() == MHz(20)); + auto layout = inspectMpduAggregate(packet, B(0), B(packet->getDataLength())); + ASSERT(layout.complete); + MacAddress receiver, transmitter; + Tid tid = -1; + simtime_t duration = -1; + int count = 0; + for (const auto& range : layout.ranges) { + ASSERT(range.valid); + if (range.kind != MpduRangeKind::MPDU) + continue; + Packet member("observed-member", packet->peekDataAt(range.offset, range.length)); + auto data = member.peekAtFront(); + ASSERT(data->getType() == ST_DATA_WITH_QOS && data->getAckPolicy() == NORMAL_ACK); + ASSERT(!data->getAMsduPresent() && !data->getMoreFragments() && data->getFragmentNumber() == 0); + if (count == 0) { + receiver = data->getReceiverAddress(); + transmitter = data->getTransmitterAddress(); + tid = data->getTid(); + duration = data->getDurationField(); + } + ASSERT(data->getReceiverAddress() == receiver && data->getTransmitterAddress() == transmitter); + ASSERT(data->getTid() == tid && data->getDurationField() == duration); + auto trailer = member.removeAtBack(B(4)); + ASSERT(trailer->getFcsMode() == FCS_COMPUTED); + auto bytes = member.peekAllAsBytes()->getBytes(); + ASSERT(ethernetFcs(bytes.data(), bytes.size()) == trailer->getFcs()); + count++; + } + ASSERT(count > 0 && count <= 64); + ASSERT(mib->findPeerHtState(receiver) && mib->findPeerHtState(receiver)->valid); + aggregates++; + members += count; + } + else if (header && dynamicPtrCast(header) && awaitProbe) { + ASSERT(++barsSinceData == 1); + if (par("requireFreshProbe").boolValue()) + ASSERT(!edca->getChannelOwner()->getPendingQueue()->isEmpty()); + probes++; + awaitProbe = false; + } + Hcf::transmissionComplete(packet, header); + } + void originatorProcessFailedFrame(Packet *packet) override { + if (isAggregate(packet)) { + failedImplicit++; + awaitProbe = true; + } + Hcf::originatorProcessFailedFrame(packet); + } + void originatorProcessReceivedFrame(Packet *received, Packet *transmitted) override { + if (isAggregate(transmitted)) { + auto blockAck = received->peekAtFront(); + ASSERT(received->getDataLength() == LENGTH_COMPRESSED_BLOCKACK); + ASSERT(blockAck->getReceiverAddress() == mib->address); + responses++; + positive += blockAck->getBlockAckBitmap() != BitVector(0, 64); + } + Hcf::originatorProcessReceivedFrame(received, transmitted); + } + void recipientProcessTransmittedControlResponseFrame(Packet *packet, + const Ptr& header) override { + if (dynamicPtrCast(header)) { + auto mode = packet->getTag()->getMode(); + ASSERT(mode->getHtMcsIndex() < 0); + responsesSent++; + } + Hcf::recipientProcessTransmittedControlResponseFrame(packet, header); + } +}; +Define_Module(AmpduExchangeHcf); + +class AmpduExchangeTest : public cSimpleModule, public cListener +{ + int delivered = 0; + int bytes = 0; + protected: + void initialize() override { scheduleAt(SimTime(10, SIMTIME_MS), new cMessage("subscribe")); } + void receiveSignal(cComponent *, simsignal_t, cObject *object, cObject *) override { + auto packet = check_and_cast(object); + delivered++; + bytes += packet->getByteLength(); + } + void handleMessage(cMessage *message) override { + if (message->isName("subscribe")) { + delete message; + getModuleByPath("^.sta2.app[0]")->subscribe(packetReceivedSignal, this); + scheduleAt(SimTime(1400, SIMTIME_MS), new cMessage("verify")); + return; + } + delete message; + ASSERT(delivered == 60 && bytes == 72000); + for (const char *path : {"^.sta1.wlan[0].mac.hcf", "^.ap.wlan[0].mac.hcf"}) { + auto hcf = check_and_cast(getModuleByPath(path)); + std::cout << "Aggregate exchange: node=" << path << " aggregates=" << hcf->aggregates + << " members=" << hcf->members << " responses=" << hcf->responses + << " positive=" << hcf->positive << " probes=" << hcf->probes + << " failures=" << hcf->failedImplicit << " dataAfterProbe=" << hcf->dataAfterProbe + << " outcomes=" << hcf->attemptOutcomes << " retries=" << hcf->retryBatches + << " mixed=" << hcf->mixedBatches << "\n"; + ASSERT(hcf->aggregates > 0 && hcf->members > hcf->aggregates); + ASSERT(hcf->responses > 0 && hcf->positive > 0); + ASSERT(hcf->attemptOutcomes == hcf->members); + if (par("recovery").boolValue()) { + ASSERT(hcf->failedImplicit > 0 && hcf->probes > 0 && hcf->dataAfterProbe > 0); + } + } + if (par("recovery").boolValue()) { + auto mode = getModuleByPath("^.sta1.wlan[0].radio.receiver.errorModel")->par("lossMode").intValue(); + auto source = check_and_cast(getModuleByPath("^.sta1.wlan[0].mac.hcf")); + if (mode == 2 || mode == 3) + ASSERT(source->retryBatches > 0); + if (mode == 3) + ASSERT(source->mixedBatches > 0); + } + std::cout << "Implicit aggregate exchange assertions passed.\n"; + endSimulation(); + } +}; +Define_Module(AmpduExchangeTest); + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.common.contract.packetlevel.IRadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +module AmpduExchangeHcf extends Hcf { parameters: bool requireFreshProbe = default(false); @class(::AmpduExchangeHcf); } +module AmpduExchangeLossModel extends Ieee80211NistErrorModel { parameters: int lossMode = default(0); @class(::AmpduExchangeLossModel); } +simple AmpduExchangeTest { parameters: bool recovery = default(false); @class(::AmpduExchangeTest); } +network AmpduExchangeNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: like IRadioMedium; + ap: AccessPoint; + sta1: WirelessHost; + sta2: WirelessHost; + test: AmpduExchangeTest; +} + +%inifile: omnetpp.ini +[General] +network = AmpduExchangeNetwork +ned-path = .;../../../../src +sim-time-limit = 1.5s +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.radioMedium.typename = ${medium="Ieee80211ScalarRadioMedium","Ieee80211DimensionalRadioMedium"} +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" +*.sta1.numApps = 1 +*.sta1.app[0].typename = "UdpBasicApp" +*.sta1.app[0].destAddresses = "sta2" +*.sta1.app[0].destPort = 1000 +*.sta1.app[0].messageLength = 1200B +*.sta1.app[0].startTime = 1s +*.sta1.app[0].stopTime = 1.00119s +*.sta1.app[0].sendInterval = 20us +*.sta2.numApps = 1 +*.sta2.app[0].typename = "UdpSink" +*.sta2.app[0].localPort = 1000 +*.sta*.ipv4.arp.typename = "GlobalArp" +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].radio.typename = ${radio="Ieee80211ScalarRadio","Ieee80211DimensionalRadio" ! medium} +**.wlan[*].radio.receiver.errorModel.typename = ${model="Ieee80211NistErrorModel","Ieee80211YansErrorModel"} +**.wlan[*].bitrate = 6Mbps +**.wlan[*].mac.fcsMode = "computed" +**.checksumMode = "computed" +**.wlan[*].classifier.typename = "QosClassifier" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "AmpduExchangeHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 65Mbps +**.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps +**.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +**.originatorMacDataService.msduAggregationPolicy.typename = "" +**.originatorAckPolicy.blockAckReqThreshold = 5 +**.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +**.rtsPolicy.rtsThreshold = 2346B +**.txopProcedure.protectionMechanism = ${protection="single","multiple"} +**.txopProcedure.txopLimit = ${limit=0s,4ms} +**.bandName = "2.4 GHz" +**.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.sta1.mobility.initialX = 0m +*.ap.mobility.initialX = 5m +*.sta2.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +[Config Recovery] +constraint = $medium == "Ieee80211ScalarRadioMedium" && $model == "Ieee80211NistErrorModel" && $protection == "multiple" && $limit == 0s +*.test.recovery = true +*.sta1.wlan[0].mac.hcf.requireFreshProbe = true +*.radioMedium.typename = "Ieee80211ScalarRadioMedium" +**.wlan[*].radio.typename = "Ieee80211ScalarRadio" +**.wlan[*].radio.receiver.errorModel.typename = "AmpduExchangeLossModel" +**.wlan[*].radio.receiver.errorModel.lossMode = ${loss=1,2,3} +**.txopProcedure.txopLimit = 0s +**.txopProcedure.protectionMechanism = "multiple" + +%file: check-exchange.py +from pathlib import Path +import os +import subprocess + +text = Path("test.out").read_text() +assert "Run statistics: total 16, successful 16" in text +assert "Warning:" not in text +executables = [path for path in Path.cwd().glob("Ieee80211AmpduExchange_1*") if path.is_file() and os.access(path, os.X_OK)] +assert len(executables) == 1, executables +command = [str(executables[0]), "-u", "Cmdenv", "--check-signals=false", "-n", "../../../../src:.:../../lib", "omnetpp.ini", "_defaults.ini", "-c", "Recovery", "-r", "0..2"] +result = subprocess.run(command, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) +Path("recovery.out").write_text(result.stdout) +assert result.returncode == 0, result.stdout +assert "Run statistics: total 3, successful 3" in result.stdout +assert "Warning:" not in result.stdout +print("Sixteen infrastructure cases and three response-loss recovery cases passed.") + +%contains: stdout +Implicit aggregate exchange assertions passed. diff --git a/tests/module/Ieee80211AmpduMacBoundary_1.test b/tests/module/Ieee80211AmpduMacBoundary_1.test index 8312c02d7cd..d8949740108 100644 --- a/tests/module/Ieee80211AmpduMacBoundary_1.test +++ b/tests/module/Ieee80211AmpduMacBoundary_1.test @@ -1,7 +1,8 @@ %description: The production radio sends aggregate containers to the production MAC and Rx. -Rx rejects successful, partially failed, and entirely failed aggregates before standalone FCS or header checks. -The drop signal retains the PHY range outcomes and the clear container bit-error flag. +Rx accepts correct members with valid FCS trailers and drops failed members. +The aggregate retains the PHY range outcomes and the clear container bit-error flag. +Separate members retain their own outcomes and omit the aggregate indication. A standalone CTS still sets NAV through the normal acceptance path. Scalar and dimensional radios cover whole-signal and separate-part reception with DCF and HCF. Malformed delimiters before typed MPDUs permit bounded recovery without a radio exception. @@ -38,27 +39,17 @@ class BoundaryErrorModel : public Ieee80211NistErrorModel }; Define_Module(BoundaryErrorModel); -class BoundaryDriver : public cSimpleModule, public cListener +class BoundaryRx : public Rx { - int sent = 0; - int dropped = 0; - int navSet = 0; - protected: - void initialize() override { - auto rx = getModuleByPath("^.receiver.wlan[0].mac.rx"); - rx->subscribe(packetDroppedSignal, this); - rx->subscribe(Rx::navChangedSignal, this); - scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("send")); - } - void receiveSignal(cComponent *, simsignal_t signal, cObject *object, cObject *) override { - ASSERT(signal == packetDroppedSignal); - auto packet = check_and_cast(object); - ASSERT(dropped < 4); - ASSERT(packet->isName(dropped == 0 ? "good" : dropped == 1 ? "partial" : dropped == 2 ? "failed" : "malformed")); + public: + int received = 0; + AmpduReception lowerAggregateReceived(Packet *packet) override { + ASSERT(received < 4); + ASSERT(packet->isName(received == 0 ? "good" : received == 1 ? "partial" : received == 2 ? "failed" : "malformed")); ASSERT(!packet->hasBitError()); auto indication = packet->getTag(); ASSERT(indication->getAggregation() && indication->getHeaderSuccessful() && indication->getContentComplete()); - if (dropped == 3) { + if (received == 3) { ASSERT(indication->getRangesArraySize() == 30); ASSERT(!indication->getRanges(0).valid && indication->getRanges(0).offset == B(0)); int members = 0; @@ -74,23 +65,68 @@ class BoundaryDriver : public cSimpleModule, public cListener } } ASSERT(members == 2); - dropped++; - return; } - ASSERT(indication->getRangesArraySize() == 6); - int failed = 0; - for (size_t i = 0; i < indication->getRangesArraySize(); i++) { - auto& range = indication->getRanges(i); - ASSERT(range.valid); - failed += !range.successful; + else { + ASSERT(indication->getRangesArraySize() == 6); + int failed = 0; + for (size_t i = 0; i < indication->getRangesArraySize(); i++) { + const auto& range = indication->getRanges(i); + ASSERT(range.valid); + failed += !range.successful; + } + ASSERT(failed == (received == 0 ? 0 : received == 1 ? 1 : 3)); + } + auto reception = Rx::lowerAggregateReceived(packet); + std::vector expected = received == 0 ? std::vector{0, 1, 2} : + received == 1 ? std::vector{0, 2} : received == 2 ? std::vector{} : std::vector{1, 2}; + ASSERT(reception.anyCorrect == !expected.empty()); + ASSERT(reception.members.size() == expected.size()); + ASSERT(reception.topology && reception.topology->length == B(318)); + ASSERT(reception.topology->members.size() == (received == 3 ? 2 : 3)); + for (size_t i = 0; i < expected.size(); i++) { + const auto& member = reception.members[i]; + ASSERT(member.offset == (expected[i] == 0 ? B(4) : B(108 * expected[i]))); + ASSERT(member.packet->getDataLength() == B(100 + expected[i])); + ASSERT(member.packet->peekAtFront()->getSequenceNumber().get() == expected[i]); + ASSERT(!member.packet->hasBitError()); + ASSERT(!member.packet->findTag()); } - ASSERT(failed == (dropped == 0 ? 0 : dropped == 1 ? 1 : 3)); + received++; + return reception; + } +}; +Define_Module(BoundaryRx); + +class BoundaryDriver : public cSimpleModule, public cListener +{ + BoundaryRx *rx = nullptr; + int sent = 0; + int dropped = 0; + int navSet = 0; + protected: + void initialize() override { + rx = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.rx")); + rx->subscribe(packetDroppedSignal, this); + rx->subscribe(Rx::navChangedSignal, this); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("send")); + } + void receiveSignal(cComponent *, simsignal_t signal, cObject *object, cObject *details) override { + ASSERT(signal == packetDroppedSignal); + auto packet = check_and_cast(object); + ASSERT(dropped < 4); + ASSERT(packet->isName(dropped == 0 ? "partial" : "failed")); + int sequence = dropped == 0 ? 1 : dropped - 1; + ASSERT(packet->getDataLength() == B(100 + sequence)); + ASSERT(packet->peekAtFront()->getSequenceNumber().get() == sequence); + ASSERT(packet->hasBitError()); + ASSERT(!packet->findTag()); + ASSERT(check_and_cast(details)->getReason() == INCORRECTLY_RECEIVED); dropped++; } void receiveSignal(cComponent *, simsignal_t signal, const SimTime& value, cObject *) override { ASSERT(signal == Rx::navChangedSignal); if (value > SIMTIME_ZERO) { - ASSERT(sent == 5 && dropped == 4); + ASSERT(sent == 5 && rx->received == 4 && dropped == 4); ASSERT(value == SimTime(50, SIMTIME_US)); navSet++; } @@ -103,10 +139,18 @@ class BoundaryDriver : public cSimpleModule, public cListener auto delimiter = makeShared(); delimiter->setLength(sent == 3 && length == 100 ? 2000 : length); packet->insertAtBack(delimiter); + Packet mpdu("member"); auto member = makeShared(); - member->setSequenceNumber(SequenceNumberCyclic(0)); - packet->insertAtBack(member); - packet->insertAtBack(makeShared(std::vector(length - member->getChunkLength().get(), 0))); + member->setDurationField(SIMTIME_ZERO); + member->setSequenceNumber(SequenceNumberCyclic(length - 100)); + mpdu.insertAtBack(member); + mpdu.insertAtBack(makeShared(std::vector(length - member->getChunkLength().get() - 4, 0))); + auto bytes = mpdu.peekAllAsBytes()->getBytes(); + auto trailer = makeShared(); + trailer->setFcsMode(FCS_COMPUTED); + trailer->setFcs(ethernetFcs(bytes.data(), bytes.size())); + mpdu.insertAtBack(trailer); + packet->insertAtBack(mpdu.peekData()); if (length != 102 && length % 4) packet->insertAtBack(makeShared(std::vector(4 - length % 4, 0))); } @@ -139,13 +183,14 @@ class BoundaryDriver : public cSimpleModule, public cListener } using cListener::finish; void finish() override { - ASSERT(sent == 5 && dropped == 4 && navSet == 1); + ASSERT(sent == 5 && rx->received == 4 && dropped == 4 && navSet == 1); EV << "MAC aggregate boundary checks passed\n"; } }; Define_Module(BoundaryDriver); %file: test.ned +import inet.linklayer.ieee80211.mac.Rx; import inet.mobility.static.StationaryMobility; import inet.node.inet.AdhocHost; import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Radio; @@ -157,6 +202,11 @@ module BoundaryErrorModel extends Ieee80211NistErrorModel parameters: @class(::BoundaryErrorModel); } +simple BoundaryRx extends Rx +{ + parameters: + @class(::BoundaryRx); +} simple BoundaryDriver { parameters: @@ -200,6 +250,7 @@ cmdenv-express-mode = false *.receiver.numWlanInterfaces = 1 *.receiver.wlan[0].opMode = "n(mixed-2.4Ghz)" *.receiver.wlan[0].mac.qosStation = ${qos=false,true} +*.receiver.wlan[0].mac.rx.typename = "BoundaryRx" *.receiver.wlan[0].radio.receiver.errorModel.typename = "BoundaryErrorModel" *.receiver.wlan[0].radio.separateReceptionParts = ${parts=false,true} *.sender.radio.separateReceptionParts = ${parts} diff --git a/tests/module/Ieee80211AmpduRecovery_1.test b/tests/module/Ieee80211AmpduRecovery_1.test new file mode 100644 index 00000000000..30be19018a3 --- /dev/null +++ b/tests/module/Ieee80211AmpduRecovery_1.test @@ -0,0 +1,359 @@ +%description: +Real infrastructure association establishes HT state before the production HCF accepts test DATA. +The AP silently loses its recipient agreement at the first aggregate. The originator retains its agreement. +Continuous arrivals must permit an actual Compressed BAR, recipient DELBA, originator retirement, later ADDBA, and later aggregate DATA. +The pending DATA queue must remain nonempty from recipient state loss through the first BAR transmission. +Finite traffic loses every actual BAR at the AP PHY. MSDU expiry must close the originator agreement before inactivity expiry. +Four runs combine finite or continuous arrivals with zero or 200 ms inactivity timeout. Seed zero fixes contention. +The fixture injects complete QoS DATA at the HCF upper boundary. It does not test an application or the IP path. + +%extraargs: -r 0..3 + +%file: AmpduRecovery.cc +#include +#include "inet/common/Simsignals.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IReception.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +class RecoveryPhysicalModel : public Ieee80211NistErrorModel +{ + public: + mutable int barLosses = 0; + double computePacketErrorRate(const ISnir *snir, IRadioSignal::SignalPart) const override { + auto packet = snir->getReception()->getTransmission()->getPacket(); + auto phy = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(packet); + auto ht = dynamicPtrCast(phy); + if ((!ht || !ht->getAggregation()) && par("dropBars").boolValue()) { + auto header = packet->peekDataAt(phy->getChunkLength()); + if (dynamicPtrCast(header)) { + barLosses++; + return 1; + } + } + return 0; + } + double computeAmpduRangeSuccessRate(const ISnir *, const IIeee80211Mode *, B) const override { return 1; } +}; +Define_Module(RecoveryPhysicalModel); + +class RecoveryHcf : public Hcf +{ + public: + bool recipientStateLost = false; + simtime_t lossTime; + int aggregateReceptions = 0; + int receivedDelbas = 0; + int deliveredData = 0; + MacAddress address() const { return mac->getAddress(); } + queueing::IPacketQueue *dataQueue() const { return edca->getEdcaf(AC_BE)->getPendingQueue(); } + int queuedData() const { return dataQueue()->getNumPackets(); } + int retainedData() const { return edca->getEdcaf(AC_BE)->getInProgressFrames()->getLength(); } + size_t trackedData() const { return edca->getLifetimeHandler()->getNumFrames(); } + OriginatorBlockAckAgreement *originatorAgreement(MacAddress peer) const { + return originatorBlockAckAgreementHandler->getAgreement(peer, 0); + } + void injectData(MacAddress receiver, int count) { + Enter_Method("injectData"); + for (int i = 0; i < count; i++) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(receiver); + header->setTransmitterAddress(mac->getAddress()); + header->setAddress3(receiver); + header->setToDS(true); + header->setTid(0); + auto frame = new Packet("recovery-data", header); + frame->insertAtBack(makeShared(B(200))); + frame->insertAtBack(makeShared()); + processUpperFrame(frame, header); + } + } + void processLowerAggregate(Packet *packet, AmpduReception reception) override { + aggregateReceptions++; + if (par("loseRecipientState").boolValue() && !recipientStateLost && !reception.members.empty()) { + const auto& header = reception.members.front().packet->peekAtFront(); + auto peer = header->getTransmitterAddress(); + auto tid = header->getTid(); + ASSERT(recipientBlockAckAgreementHandler->getAgreement(tid, peer)); + recipientStateLost = true; + lossTime = simTime(); + // Model lost recipient state without a local DELBA or a peer reset. + retireAgreement(peer, tid, false, true); + ASSERT(!recipientBlockAckAgreementHandler->getAgreement(tid, peer)); + } + Hcf::processLowerAggregate(packet, std::move(reception)); + } + protected: + void recipientProcessReceivedManagementFrame(const Ptr& header) override { + if (auto delba = dynamicPtrCast(header)) { + if (!delba->getInitiator()) receivedDelbas++; + } + Hcf::recipientProcessReceivedManagementFrame(header); + } + void sendUp(const std::vector& frames) override { + for (auto frame : frames) { + if (dynamicPtrCast(frame->peekAtFront())) { + deliveredData++; + take(frame); + delete frame; + } + else + Hcf::sendUp({frame}); + } + } +}; +Define_Module(RecoveryHcf); + +class RecoveryDriver : public cSimpleModule, public cListener +{ + RecoveryHcf *originator = nullptr; + RecoveryHcf *recipient = nullptr; + cModule *originatorRadio = nullptr; + cModule *recipientRadio = nullptr; + int originatorAdditions = 0; + int originatorDeletions = 0; + int addbaTransmissions = 0; + int barTransmissions = 0; + int recipientDelbaTransmissions = 0; + int aggregateTransmissions = 0; + int laterAggregateTransmissions = 0; + int lifetimeDrops = 0; + int queuedAtProbe = -1; + bool drainedBeforeProbe = false; + bool retirementAtInactivity = false; + simtime_t firstProbeTime; + simtime_t firstRetirementTime; + simtime_t laterSetupTime; + simtime_t firstRecipientDelbaTime; + bool continuous() const { return par("continuous"); } + void checkBacklog() { + if (continuous() && recipient->recipientStateLost && barTransmissions == 0 && originator->queuedData() == 0) + drainedBeforeProbe = true; + } + void observeTransmission(cComponent *source, const Ieee80211Transmission *transmission) { + auto packet = transmission->getPacket(); + auto phy = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(packet); + auto ht = dynamicPtrCast(phy); + if (source == originatorRadio && ht && ht->getAggregation()) { + ASSERT(transmission->getMode()->getHtMcsIndex() == 7); + ASSERT(transmission->getMode()->getDataMode()->getBandwidth() == MHz(20)); + ASSERT(!transmission->getMode()->isHtShortGuardInterval()); + aggregateTransmissions++; + if (originatorDeletions > 0 && originatorAdditions >= 2) + laterAggregateTransmissions++; + return; + } + if (ht && ht->getAggregation()) return; + auto header = packet->peekDataAt(phy->getChunkLength()); + if (source == originatorRadio) { + if (dynamicPtrCast(header)) { + addbaTransmissions++; + if (originatorDeletions > 0) laterSetupTime = simTime(); + } + if (auto bar = dynamicPtrCast(header)) { + if (recipient->recipientStateLost) { + ASSERT(bar->getTidInfo() == 0); + checkBacklog(); + if (barTransmissions == 0) { + firstProbeTime = simTime(); + queuedAtProbe = originator->queuedData(); + } + barTransmissions++; + } + } + } + if (source == recipientRadio) { + if (auto delba = dynamicPtrCast(header)) { + if (!delba->getInitiator() && recipient->recipientStateLost) { + if (recipientDelbaTransmissions == 0) firstRecipientDelbaTime = simTime(); + recipientDelbaTransmissions++; + } + } + } + } + public: + RecoveryDriver() : cSimpleModule(65536) {} + protected: + void receiveSignal(cComponent *source, simsignal_t signal, cObject *object, cObject *details) override { + if (signal == transmissionStartedSignal) { + observeTransmission(source, check_and_cast(object)); + return; + } + if (source == originator && signal == Hcf::blockAckAgreementAddedSignal && dynamic_cast(object)) + originatorAdditions++; + if (source == originator && signal == Hcf::blockAckAgreementDeletedSignal) { + if (auto agreement = dynamic_cast(object)) { + if (recipient->recipientStateLost) { + if (originatorDeletions == 0) firstRetirementTime = simTime(); + originatorDeletions++; + retirementAtInactivity |= agreement->getExpirationTime() <= simTime(); + } + } + } + if (source == originator && signal == packetDroppedSignal) { + auto drop = dynamic_cast(details); + if (drop && drop->getReason() == LIFETIME_EXPIRED) lifetimeDrops++; + } + checkBacklog(); + } + void activity() override { + originator = check_and_cast(getModuleByPath("^.sta.wlan[0].mac.hcf")); + recipient = check_and_cast(getModuleByPath("^.ap.wlan[0].mac.hcf")); + originatorRadio = getModuleByPath("^.sta.wlan[0].radio"); + recipientRadio = getModuleByPath("^.ap.wlan[0].radio"); + originatorRadio->subscribe(transmissionStartedSignal, this); + recipientRadio->subscribe(transmissionStartedSignal, this); + originator->subscribe(Hcf::blockAckAgreementAddedSignal, this); + originator->subscribe(Hcf::blockAckAgreementDeletedSignal, this); + originator->subscribe(packetDroppedSignal, this); + auto queue = check_and_cast(originator->dataQueue()); + for (auto signal : {packetPushedSignal, packetPulledSignal, packetRemovedSignal}) queue->subscribe(signal, this); + wait(SimTime(30, SIMTIME_MS)); + auto staMib = check_and_cast(getModuleByPath("^.sta.wlan[0].mib")); + auto apMib = check_and_cast(getModuleByPath("^.ap.wlan[0].mib")); + ASSERT(staMib->bssStationData.isAssociated); + ASSERT(staMib->bssData.bssid == apMib->address); + auto peer = staMib->findPeerHtState(apMib->address); + ASSERT(peer && peer->valid && peer->negotiatedCapabilities.localTxPeerRx.valid); + ASSERT(apMib->findPeerHtState(staMib->address)); + ASSERT(peer->negotiatedCapabilities.localTxPeerRx.receiverMaxAmpduLengthExponent == 1); + ASSERT(peer->negotiatedCapabilities.localTxPeerRx.receiverMinimumMpduStartSpacing == 2); + originator->injectData(recipient->address(), continuous() ? 256 : 32); + if (continuous()) { + while (simTime() < SimTime(110, SIMTIME_MS)) { + wait(SimTime(100, SIMTIME_US)); + checkBacklog(); + originator->injectData(recipient->address(), 4); + } + } + wait(SimTime(120, SIMTIME_MS) - simTime()); + ASSERT(recipient->recipientStateLost && recipient->aggregateReceptions > 0); + ASSERT(aggregateTransmissions > 0 && barTransmissions > 0); + ASSERT(firstProbeTime > recipient->lossTime); + ASSERT(originatorDeletions > 0 && !retirementAtInactivity); + if (continuous()) { + ASSERT(!drainedBeforeProbe && queuedAtProbe > 0); + ASSERT(recipientDelbaTransmissions > 0 && originator->receivedDelbas > 0); + ASSERT(firstRecipientDelbaTime > firstProbeTime); + ASSERT(firstRetirementTime >= firstRecipientDelbaTime); + ASSERT(originatorAdditions >= 2 && addbaTransmissions >= 2); + ASSERT(laterSetupTime > firstRetirementTime && laterAggregateTransmissions > 0); + } + else { + auto model = check_and_cast(recipientRadio->getSubmodule("receiver")->getSubmodule("errorModel")); + ASSERT(model->barLosses > 0); + ASSERT(recipientDelbaTransmissions == 0 && originator->receivedDelbas == 0); + ASSERT(lifetimeDrops > 0 && firstRetirementTime >= SimTime(60, SIMTIME_MS)); + ASSERT(originatorAdditions == 1); + ASSERT(!originator->originatorAgreement(recipient->address())); + ASSERT(originator->queuedData() == 0 && originator->retainedData() == 0 && originator->trackedData() == 0); + } + std::cout << "Absent-agreement recovery passed: continuous=" << continuous() + << " probes=" << barTransmissions << " delbas=" << recipientDelbaTransmissions + << " retirements=" << originatorDeletions << " setups=" << addbaTransmissions + << " laterAggregates=" << laterAggregateTransmissions << " lifetimeDrops=" << lifetimeDrops << "\n"; + endSimulation(); + } +}; +Define_Module(RecoveryDriver); + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +module RecoveryPhysicalModel extends Ieee80211NistErrorModel { parameters: bool dropBars = default(false); @class(::RecoveryPhysicalModel); } +module RecoveryHcf extends Hcf { parameters: bool loseRecipientState = default(false); @class(::RecoveryHcf); } +simple RecoveryDriver { parameters: bool continuous; @class(::RecoveryDriver); } +network RecoveryNetwork { + submodules: + radioMedium: Ieee80211ScalarRadioMedium; + sta: WirelessHost; + ap: AccessPoint; + test: RecoveryDriver; +} + +%inifile: omnetpp.ini +[General] +network = RecoveryNetwork +ned-path = .;../../../../src;../../lib +sim-time-limit = 125ms +seed-set = 0 +cmdenv-express-mode = false +record-vector-results = false +record-scalar-results = false +*.test.continuous = ${continuous=false,true} +*.ap.wlan[0].mgmt.typename = "Ieee80211MgmtAp" +*.sta.wlan[0].mgmt.typename = "Ieee80211MgmtSta" +*.sta.wlan[0].agent.typename = "Ieee80211AgentSta" +*.sta.wlan[0].agent.startingTime = 0s +*.sta.wlan[0].agent.channelsToScan = "6" +*.sta.wlan[0].agent.probeDelay = 1ms +*.sta.wlan[0].agent.minChannelTime = 5ms +*.sta.wlan[0].agent.maxChannelTime = 5ms +*.sta.wlan[0].agent.authenticationTimeout = 20ms +*.sta.wlan[0].agent.associationTimeout = 20ms +**.mgmt.numChannels = 1 +*.ap.wlan[0].address = "02:00:00:00:00:01" +*.sta.wlan[0].address = "02:00:00:00:00:02" +**.wlan[0].opMode = "n(mixed-2.4Ghz)" +**.wlan[0].bitrate = 65Mbps +**.wlan[0].radio.bandName = "2.4 GHz" +**.wlan[0].radio.channelNumber = 6 +**.wlan[0].radio.receiver.bandwidth = 20MHz +**.wlan[0].radio.receiver.errorModel.typename = "RecoveryPhysicalModel" +*.ap.wlan[0].radio.receiver.errorModel.dropBars = !${continuous} +*.ap.wlan[0].mib.htMaxAmpduLengthExponent = 1 +*.ap.wlan[0].mib.htMinimumMpduStartSpacing = 2 +*.sta.wlan[0].mib.htMaxAmpduLengthExponent = 0 +*.sta.wlan[0].mib.htMinimumMpduStartSpacing = 1 +**.wlan[0].mac.qosStation = true +**.wlan[0].mac.hcf.typename = "RecoveryHcf" +*.ap.wlan[0].mac.hcf.loseRecipientState = true +**.wlan[0].mac.hcf.isBlockAckSupported = true +**.wlan[0].mac.hcf.blockAckVariant = "compressed" +**.wlan[0].mac.hcf.rateControl.typename = "" +**.wlan[0].mac.hcf.rateSelection.dataFrameBitrate = 65Mbps +**.wlan[0].mac.hcf.rateSelection.dataFrameBandwidth = 20MHz +**.wlan[0].mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1 +**.wlan[0].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps +**.wlan[0].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +**.wlan[0].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +**.wlan[0].mac.hcf.originatorAckPolicy.blockAckReqThreshold = 2 +**.wlan[0].mac.hcf.originatorBlockAckAgreementPolicy.blockAckTimeoutValue = ${inactivity=0s,200ms} +**.wlan[0].mac.hcf.recipientBlockAckAgreementPolicy.blockAckTimeoutValue = ${inactivity} +**.wlan[0].mac.hcf.edca.edcaf[*].msduLifetime = 30ms +**.wlan[0].mac.hcf.edca.edcaf[*].recoveryProcedure.shortRetryLimit = 1024 +**.wlan[0].mac.hcf.edca.edcaf[*].recoveryProcedure.longRetryLimit = 1024 +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.sta.mobility.initialX = 10m +*.ap.mobility.initialX = 20m +**.mobility.initialY = 10m +**.mobility.initialZ = 0m +*.radioMedium.backgroundNoise.power = -110dBm + +%contains: stdout +Absent-agreement recovery passed: + +%contains: stdout +Run statistics: total 4, successful 4 diff --git a/tests/module/Ieee80211AmpduReordering_1.test b/tests/module/Ieee80211AmpduReordering_1.test new file mode 100644 index 00000000000..a8be9aa524c --- /dev/null +++ b/tests/module/Ieee80211AmpduReordering_1.test @@ -0,0 +1,461 @@ +%description: +Real radios send HT aggregates through the production MAC, Rx, HCF, and recipient data service. +Twenty-two scenarios check partial reception, all-member failure, absent agreements, duplicates, delimiter gaps, invalid FCS, and overheard DATA. +Physical SIFS intervals exercise aggregate and individual history for release conditions (i) through (v). +Negative history cases use a long interval, a failed delimiter tail, or an absent prior receipt. +The fixture supplies peer HT capabilities and accepted agreements. It does not test ADDBA negotiation. +A response probe suppresses Block Ack transmission in the first seventeen scenarios. +Three additional scenarios use actual Block Ack transmission and physical SIFS intervals to check retained or cleared aggregate history. +Two negative RIFS scenarios send standalone HT DATA with Block Ack policy before an aggregate or another standalone frame. +A 2 us gap after the 6 us signal extension does not meet the production RIFS condition. +HCF adds the preceding signal extension to the measured gap before it compares that sum with the RIFS duration. +Both scenarios keep the frame after the missing sequence number in the recipient buffer. +Scalar and dimensional radios use long and short GI, whole and separate reception parts, and seed zero. + +%extraargs: -r 0..175 +%postrun-command: python3 check-reordering.py + +%file: AmpduReordering.cc +#include +#include "inet/common/ProtocolTag_m.h" +#include "inet/common/Simsignals.h" +#include "inet/common/checksum/Checksum.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/linklayer/ieee80211/mac/Tx.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/contract/IContention.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mib/Ieee80211Mib.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h" +#include "inet/physicallayer/wireless/common/contract/packetlevel/IReception.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +class ReorderPhysicalModel : public Ieee80211NistErrorModel +{ + mutable std::map delimiterCalls; + public: + double computePacketErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeAmpduRangeSuccessRate(const ISnir *snir, const IIeee80211Mode *, B length) const override { + auto transmission = snir->getReception()->getTransmission(); + auto packet = transmission->getPacket(); + if (length == B(4)) { + int index = delimiterCalls[transmission->getId()]++; + return (packet->isName("delimiter-gap") || packet->isName("delimiter-tail")) && index == 1 ? 0 : 1; + } + return packet->isName("all-failed") || (packet->isName("partial") && length == B(101)) ? 0 : 1; + } +}; +Define_Module(ReorderPhysicalModel); + +class ReorderAcceptedAgreements : public RecipientBlockAckAgreementHandler +{ + public: + void accept(MacAddress peer, int start) { + auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(start), 2, SIMTIME_ZERO); + agreement->setVariant(BlockAckVariant::COMPRESSED); + agreement->addbaResposneSent(); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + } +}; + +class ReorderPhysicalHcf : public Hcf +{ + public: + std::vector delivered; + int aggregateCalls = 0; + int acceptedMembers = 0; + int normalResponses = 0; + int blockResponses = 0; + int corruptions = 0; + int delbas = 0; + bool actualResponses = false; + MacAddress address() const { return mac->getAddress(); } + RecipientBlockAckAgreement *agreement() { return recipientBlockAckAgreementHandler->getAgreement(5, MacAddress("02:00:00:00:00:02")); } + void seed(int scenario) { + Enter_Method("seed"); + actualResponses = scenario >= 17 && scenario < 20; + auto radio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto transmitter = check_and_cast(radio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + mib->setPeerHtCapabilities(MacAddress("02:00:00:00:00:02"), mib->localHtCapabilities, mib->getHtOperation()); + delete recipientBlockAckAgreementHandler; + auto accepted = new ReorderAcceptedAgreements(); + recipientBlockAckAgreementHandler = accepted; + if (scenario != 3) + accepted->accept(MacAddress("02:00:00:00:00:02"), actualResponses ? 0 : (scenario == 14 ? 4095 : (scenario == 16 ? 4094 : 100))); + } + void processLowerAggregate(Packet *packet, AmpduReception reception) override { + aggregateCalls++; + acceptedMembers += reception.members.size(); + Hcf::processLowerAggregate(packet, std::move(reception)); + } + void corruptedFrameReceived() override { + corruptions++; + Hcf::corruptedFrameReceived(); + } + protected: + void sendUp(const std::vector& frames) override { + for (auto frame : frames) { + delivered.push_back(frame->peekAtFront()->getSequenceNumber().get()); + take(frame); + delete frame; + } + } + void transmitControlResponseFrame(Packet *packet, const Ptr& header, + Packet *, const Ptr&) override { + if (header->getType() == ST_ACK) normalResponses++; + if (dynamicPtrCast(header)) blockResponses++; + delete packet; + } + void processMgmtFrame(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) delbas++; + Hcf::processMgmtFrame(packet, header); + } +}; +Define_Module(ReorderPhysicalHcf); + +class ReorderResponseTx : public Tx +{ + public: + void transmitFrame(Packet *packet, const Ptr& header, + simtime_t ifs, bool updateLocalNav, ITx::ICallback *callback) override { + auto hcf = check_and_cast(getModuleByPath("^.hcf")); + if (!hcf->actualResponses && dynamicPtrCast(header)) { + hcf->blockResponses++; + return; + } + Tx::transmitFrame(packet, header, ifs, updateLocalNav, callback); + } +}; +Define_Module(ReorderResponseTx); + +class ReorderContentionProbe : public IContention +{ + public: + int corruptions = 0; + void startContention(int, simtime_t, simtime_t, simtime_t, ICallback *) override { ASSERT(false); } + bool isContentionInProgress() override { return false; } + void mediumStateChanged(bool) override {} + void corruptedFrameReceived() override { corruptions++; } +}; + +class ReorderPhysicalDriver : public cSimpleModule, public cListener, public ITx::ICallback +{ + ReorderPhysicalHcf *hcf = nullptr; + ReorderContentionProbe contention; + int sent = 0; + int actualBlockAckTransmissions = 0; + int unrelatedTransmissions = 0; + int unrelatedCompletions = 0; + simtime_t expectedSecondStart; + const IIeee80211Mode *mode = nullptr; + int scenario() const { return par("scenario"); } + bool actualResponses() const { return scenario() >= 17 && scenario() < 20; } + bool rifsScenario() const { return scenario() >= 20; } + bool twoTransmissions() const { return scenario() == 5 || (scenario() >= 8 && scenario() <= 13) || scenario() >= 17; } + bool individual(bool second) const { + return second ? scenario() == 9 || scenario() == 11 || scenario() == 18 || scenario() == 21 : + scenario() == 10 || scenario() == 11 || rifsScenario(); + } + Packet *member(int sequence, int length, bool standalone) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(scenario() == 7 ? MacAddress("02:00:00:00:00:09") : hcf->address()); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); + header->setAddress3(MacAddress("02:00:00:00:00:02")); + header->setTid(5); + header->setAckPolicy(standalone ? BLOCK_ACK : NORMAL_ACK); + header->setSequenceNumber(SequenceNumberCyclic(sequence)); + header->setDurationField(SIMTIME_ZERO); + auto frame = new Packet("member", header); + frame->insertAtBack(makeShared(B(length) - header->getChunkLength() - B(4))); + auto trailer = makeShared(); + auto bytes = frame->peekAllAsBytes()->getBytes(); + auto fcs = ethernetFcs(bytes.data(), bytes.size()); + trailer->setFcsMode(FCS_COMPUTED); + trailer->setFcs(scenario() == 6 && length == 101 ? fcs ^ 1 : fcs); + frame->insertAtBack(trailer); + return frame; + } + void transmit() { + bool second = sent != 0; + std::vector sequences; + if (actualResponses()) + sequences = {second ? 2 : 0}; + else if ((scenario() >= 8 && scenario() <= 13) || rifsScenario()) + sequences = {second ? 102 : 100}; + else if (scenario() == 14) + sequences = {4095, 1}; + else if (scenario() == 16) + sequences = {4094, 0}; + else if (scenario() == 15) + sequences = {102}; + else + sequences = {100, 101, 102}; + const char *name = scenario() == 1 ? "partial" : scenario() == 2 ? "all-failed" : scenario() == 4 ? "delimiter-gap" : + scenario() == 13 && !second ? "delimiter-tail" : "aggregate"; + Packet *packet = nullptr; + if (individual(second)) + packet = member(sequences.front(), 100, true); + else { + packet = new Packet(name); + for (size_t i = 0; i < sequences.size(); i++) { + int length = 100 + i; + auto delimiter = makeShared(); + delimiter->setLength(length); + packet->insertAtBack(delimiter); + auto frame = member(sequences[i], length, false); + packet->insertAtBack(frame->peekData()); + delete frame; + if (i + 1 < sequences.size() && length % 4) + packet->insertAtBack(makeShared(B(4 - length % 4))); + } + if (scenario() == 13 && !second) { + auto delimiter = makeShared(); + delimiter->setLength(0); + packet->insertAtBack(delimiter); + } + } + packet->addTag()->setProtocol(&Protocol::ieee80211Mac); + packet->addTag()->setMode(mode); + sent++; + send(packet, "out"); + } + void transmitUnrelatedControl() { + auto header = makeShared(); + header->setReceiverAddress(MacAddress("02:00:00:00:00:09")); + header->setDurationField(SIMTIME_ZERO); + auto packet = new Packet("unrelated-local-control", header); + packet->insertAtBack(makeShared()); + packet->addTag()->setMode(Ieee80211ModeSet::getModeSet("g(mixed)")->getMode(Mbps(6))); + auto tx = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.tx")); + ASSERT(!tx->hasTransmission()); + tx->transmitFrame(packet, header, false, this); + delete packet; + } + public: + void frameTransmissionStarted(Packet *) override {} + void transmissionComplete(Packet *, const Ptr& header) override { + ASSERT(header && header->getType() == ST_CTS); + unrelatedCompletions++; + } + protected: + void initialize() override { + hcf = check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.hcf")); + check_and_cast(getModuleByPath("^.receiver.wlan[0].mac.rx"))->registerContention(&contention); + getModuleByPath("^.sender.radio")->subscribe(transmissionStartedSignal, this); + getModuleByPath("^.receiver.wlan[0].radio")->subscribe(transmissionEndedSignal, this); + auto modes = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + for (int i = 0; i < modes->getNumModes(); i++) { + auto candidate = modes->getMode(i); + if (candidate->getHtMcsIndex() == 0 && candidate->getDataMode()->getBandwidth() == MHz(20) && + candidate->isHtShortGuardInterval() == par("shortGi").boolValue()) + mode = candidate; + } + ASSERT(mode); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("first")); + } + void receiveSignal(cComponent *, simsignal_t signal, cObject *object, cObject *) override { + Enter_Method_Silent(); + auto transmission = check_and_cast(object); + if (signal == transmissionEndedSignal) { + if (!actualResponses()) return; + auto packet = transmission->getPacket(); + auto phy = Ieee80211Radio::peekIeee80211PhyHeaderAtFront(packet); + auto header = packet->peekDataAt(phy->getChunkLength()); + if (dynamicPtrCast(header)) { + actualBlockAckTransmissions++; + if (sent == 1) { + expectedSecondStart = transmission->getEndTime() + mode->getSifsTime(); + scheduleAt(expectedSecondStart, new cMessage(scenario() == 19 ? "unrelated" : "second")); + } + } + else if (header->getType() == ST_CTS) { + ASSERT(scenario() == 19 && sent == 1); + unrelatedTransmissions++; + expectedSecondStart = transmission->getEndTime() + mode->getSifsTime(); + scheduleAt(expectedSecondStart, new cMessage("second")); + } + return; + } + if (actualResponses()) { + if (sent == 2) ASSERT(transmission->getStartTime() == expectedSecondStart); + return; + } + if (sent == 1 && twoTransmissions()) { + auto interval = scenario() == 5 || scenario() == 12 ? SimTime(1, SIMTIME_MS) : mode->getSifsTime(); + if (rifsScenario()) { + ASSERT(mode->getRifsTime() == SimTime(2, SIMTIME_US)); + ASSERT(transmission->getSignalExtensionDuration() == SimTime(6, SIMTIME_US)); + interval = mode->getRifsTime(); + } + expectedSecondStart = transmission->getEndTime() + interval; + scheduleAt(expectedSecondStart, new cMessage("second")); + } + if (rifsScenario() && sent == 2) ASSERT(transmission->getStartTime() == expectedSecondStart); + } + void handleMessage(cMessage *message) override { + if (message->isName("unrelated")) { + delete message; + transmitUnrelatedControl(); + return; + } + if (message->isName("first")) hcf->seed(scenario()); + delete message; + transmit(); + } + using cListener::finish; + void finish() override { + std::vector expected; + if (scenario() == 0 || scenario() == 5) expected = {100, 101, 102}; + else if (scenario() == 1 || scenario() == 6 || (scenario() >= 8 && scenario() <= 11)) expected = {100, 102}; + else if (scenario() == 4 || scenario() == 12 || scenario() == 13) expected = {100}; + else if (scenario() == 14) expected = {4095, 1}; + else if (scenario() == 16) expected = {4094, 0}; + else if (scenario() == 17 || scenario() == 18) expected = {0, 2}; + else if (scenario() == 19) expected = {0}; + else if (rifsScenario()) expected = {100}; + ASSERT(hcf->delivered == expected); + ASSERT(sent == (twoTransmissions() ? 2 : 1)); + ASSERT(hcf->normalResponses == 0 && hcf->delbas == 0); + ASSERT(contention.corruptions == (scenario() == 2 ? 1 : 0)); + ASSERT(hcf->corruptions == (scenario() == 2 ? 1 : 0)); + if (actualResponses()) { + ASSERT(actualBlockAckTransmissions == (scenario() == 18 ? 1 : 2)); + ASSERT(unrelatedTransmissions == (scenario() == 19 ? 1 : 0)); + ASSERT(unrelatedCompletions == unrelatedTransmissions); + } + if (scenario() == 3) { + ASSERT(!hcf->agreement()); + ASSERT(hcf->blockResponses == 0); + } + else { + auto record = hcf->agreement()->getBlockAckRecord(); + if (rifsScenario()) { + ASSERT(record->hasCompleteReceipt(SequenceNumberCyclic(100))); + ASSERT(record->hasCompleteReceipt(SequenceNumberCyclic(102))); + ASSERT(hcf->aggregateCalls == (individual(true) ? 0 : 1)); + } + if (scenario() == 2 || scenario() == 7) { + ASSERT(!record->hasCompleteReceipt(SequenceNumberCyclic(100))); + ASSERT(!record->hasCompleteReceipt(SequenceNumberCyclic(101))); + ASSERT(!record->hasCompleteReceipt(SequenceNumberCyclic(102))); + ASSERT(hcf->blockResponses == 0); + } + if (scenario() == 1 || scenario() == 4 || scenario() == 6) { + ASSERT(record->hasCompleteReceipt(SequenceNumberCyclic(100))); + ASSERT(!record->hasCompleteReceipt(SequenceNumberCyclic(101))); + ASSERT(record->hasCompleteReceipt(SequenceNumberCyclic(102))); + } + } + std::cout << "Physical aggregate reordering passed: scenario=" << scenario() << " delivered="; + for (int sequence : hcf->delivered) std::cout << sequence << ","; + std::cout << "\n"; + } +}; +Define_Module(ReorderPhysicalDriver); + +%file: test.ned +import inet.mobility.static.StationaryMobility; +import inet.node.inet.AdhocHost; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.Tx; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Radio; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211RadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +module ReorderPhysicalModel extends Ieee80211NistErrorModel { parameters: @class(::ReorderPhysicalModel); } +module ReorderPhysicalHcf extends Hcf { parameters: @class(::ReorderPhysicalHcf); } +module ReorderResponseTx extends Tx { parameters: @class(::ReorderResponseTx); } +simple ReorderPhysicalDriver { parameters: int scenario; bool shortGi; @class(::ReorderPhysicalDriver); gates: output out; } +module ReorderPhysicalSender { + parameters: @networkNode; + gates: input in; input radioIn @directIn; + submodules: + mobility: StationaryMobility; + radio: Ieee80211Radio; + connections allowunconnected: + in --> radio.upperLayerIn; + radioIn --> radio.radioIn; +} +network Test { + submodules: + radioMedium: Ieee80211RadioMedium; + driver: ReorderPhysicalDriver; + sender: ReorderPhysicalSender; + receiver: AdhocHost; + connections: + driver.out --> sender.in; +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src +sim-time-limit = 7ms +seed-set = 0 +cmdenv-express-mode = false +record-vector-results = false +record-scalar-results = false +*.driver.scenario = ${scenario=0..21} +*.driver.shortGi = ${shortGi=false,true} +*.receiver.wlan[0].opMode = "n(mixed-2.4Ghz)" +*.receiver.wlan[0].mac.qosStation = true +*.receiver.wlan[0].mac.hcf.typename = "ReorderPhysicalHcf" +*.receiver.wlan[0].mac.hcf.isBlockAckSupported = true +*.receiver.wlan[0].mac.tx.typename = "ReorderResponseTx" +*.receiver.wlan[0].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +*.receiver.wlan[0].radio.receiver.errorModel.typename = "ReorderPhysicalModel" +*.receiver.wlan[0].radio.separateReceptionParts = ${parts=false,true} +*.sender.radio.separateReceptionParts = ${parts} +*.sender.radio.opMode = "n(mixed-2.4Ghz)" +*.sender.radio.initialRadioMode = "transmitter" +*.sender.radio.antenna.mobilityModule = "^.^.mobility" +*.radioMedium.signalAnalogRepresentation = ${analog="scalar","dimensional"} +**.radio.signalAnalogRepresentation = ${analog} +**.radio.receiver.bandwidth = 20MHz +*.radioMedium.backgroundNoise.power = -110dBm +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +**.mobility.initFromDisplayString = false +**.mobility.initialX = 10m +**.mobility.initialY = 10m +**.mobility.initialZ = 0m +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m + +%contains: stdout +Physical aggregate reordering passed: + +%file: check-reordering.py +from collections import Counter +from pathlib import Path +import re + +text = Path("test.out").read_text() +errors = Path("test.err").read_text() +assert "Warning:" not in text + errors +assert "Error:" not in text + errors +assert re.findall(r"Run statistics: total (\d+), successful (\d+)([^\n]*)", text) == [("176", "176", "")] +scenarios = re.findall(r"^Physical aggregate reordering passed: scenario=(\d+) delivered=", text, re.MULTILINE) +assert Counter(map(int, scenarios)) == Counter({scenario: 8 for scenario in range(22)}) +print("All 176 physical reordering cases passed without warnings or errors.") + +%contains: stdout +Run statistics: total 176, successful 176 diff --git a/tests/module/Ieee80211AmpduResponseWindow_1.test b/tests/module/Ieee80211AmpduResponseWindow_1.test new file mode 100644 index 00000000000..63e2764edd8 --- /dev/null +++ b/tests/module/Ieee80211AmpduResponseWindow_1.test @@ -0,0 +1,349 @@ +%description: +A real HCF waits for an ACK after ordinary QoS DATA transmission. +A second radio starts an HT aggregate before the response timer expires. +The aggregate HEADER ends before expiry. Its DATA remains active at expiry. +The timer consumes its event while the production ReceiveStep remains active. +Overheard aggregate reception must end that wait with one originator failure. +Addressed aggregate reception must end that wait before one real Block Ack transmission. +The fixture supplies recipient agreement and peer HT state. It does not test ADDBA negotiation. +Both cases use long and short GI, separate reception parts, deterministic reception, and seed zero. +The addressed cases complete one non-HT Compressed Block Ack at 6 Mbps after SIFS. + +%extraargs: -r 0..3 + +%file: AmpduResponseWindow.cc +#include +#include "inet/common/ProtocolTag_m.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmitter.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" + +using namespace inet; +using namespace inet::ieee80211; +using namespace inet::physicallayer; + +class ResponseWindowHcf; + +class ResponseWindowDriver : public cSimpleModule, public cListener +{ + ResponseWindowHcf *hcf = nullptr; + const IIeee80211Mode *mode = nullptr; + simtime_t responseDeadline; + bool armed = false; + bool transmitted = false; + public: + void arm(simtime_t deadline); + protected: + void initialize() override; + void handleMessage(cMessage *message) override; + void receiveSignal(cComponent *, simsignal_t, cObject *object, cObject *) override; + Packet *createAggregate(); +}; +Define_Module(ResponseWindowDriver); + +class ResponseWindowErrorModel : public Ieee80211NistErrorModel +{ + public: + double computePacketErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeAmpduRangeSuccessRate(const ISnir *, const IIeee80211Mode *, B) const override { return 1; } +}; +Define_Module(ResponseWindowErrorModel); + +class ResponseWindowAgreements : public RecipientBlockAckAgreementHandler +{ + public: + void accept(MacAddress peer) { + auto agreement = new RecipientBlockAckAgreement(peer, 5, SequenceNumberCyclic(100), 64, SIMTIME_ZERO); + agreement->setVariant(BlockAckVariant::COMPRESSED); + agreement->addbaResposneSent(); + agreement->calculateExpirationTime(); + blockAckAgreements[{peer, 5}] = agreement; + } +}; + +class ResponseWindowHcf : public Hcf +{ + IRadio *physicalRadio = nullptr; + simtime_t aggregateEnd; + public: + int waitTimers = 0; + int consumedTimers = 0; + int failedFrames = 0; + int finishedSequences = 0; + int receivedAggregates = 0; + int transmittedBlockAcks = 0; + int delivered = 0; + bool observedDataAtExpiry = false; + MacAddress address() const { return mac->getAddress(); } + void begin() { + Enter_Method("begin"); + physicalRadio = check_and_cast(mac->gate("lowerLayerOut")->getNextGate()->getOwnerModule()); + auto transmitter = check_and_cast(physicalRadio->getTransmitter()); + auto channel = transmitter->getChannel(); + mib->setPrimaryChannel(channel->getChannelNumber(), channel->getBand()); + auto incomingPeer = MacAddress("02:00:00:00:00:02"); + mib->setPeerHtCapabilities(incomingPeer, mib->localHtCapabilities, mib->getHtOperation()); + delete recipientBlockAckAgreementHandler; + auto accepted = new ResponseWindowAgreements(); + accepted->accept(incomingPeer); + recipientBlockAckAgreementHandler = accepted; + + // The absent outgoing peer supplies no ACK. Its absent HT state retains Normal Ack DATA. + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(MacAddress("02:00:00:00:00:09")); + header->setTransmitterAddress(address()); + header->setAddress3(header->getReceiverAddress()); + header->setTid(0); + auto packet = new Packet("outgoing-normal-data", header); + packet->insertAtBack(makeShared(B(100))); + packet->insertAtBack(makeShared()); + processUpperFrame(packet, header); + } + void verify(bool addressed) { + Enter_Method("verify"); + ASSERT(waitTimers == 1 && consumedTimers == 1 && observedDataAtExpiry); + ASSERT(receivedAggregates == 1); + ASSERT(failedFrames == 1 && finishedSequences == 1); + ASSERT(!frameSequenceHandler->isSequenceRunning()); + ASSERT(edca->getChannelOwner() == nullptr); + ASSERT(!startRxTimer->isScheduled()); + ASSERT(transmittedBlockAcks == (addressed ? 1 : 0)); + ASSERT(delivered == (addressed ? 2 : 0)); + ASSERT(!tx->hasTransmission()); + std::cout << "Aggregate response-window assertions passed: addressed=" << addressed << "\n"; + } + void processLowerAggregate(Packet *packet, AmpduReception reception) override { + auto mode = packet->getTag()->getMode(); + ASSERT(mode->getHtMcsIndex() == 0 && mode->getDataMode()->getBandwidth() == MHz(20)); + ASSERT(mode->isHtShortGuardInterval() == par("shortGi").boolValue()); + ASSERT(!mode->isHtShortGuardInterval() || mib->localHtCapabilities.shortGi20); + ASSERT(!mib->getBssRateSet().basic.known); + aggregateEnd = simTime(); + ASSERT(consumedTimers == 1); + ASSERT(frameSequenceHandler->isSequenceRunning()); + ASSERT(frameSequenceHandler->getContext()->getLastStep()->getType() == IFrameSequenceStep::Type::RECEIVE); + ASSERT(!startRxTimer->isScheduled()); + receivedAggregates++; + Hcf::processLowerAggregate(packet, std::move(reception)); + ASSERT(!frameSequenceHandler->isSequenceRunning()); + ASSERT(edca->getChannelOwner() == nullptr); + } + protected: + void scheduleStartRxTimer(simtime_t timeout) override { + Hcf::scheduleStartRxTimer(timeout); + waitTimers++; + ASSERT(waitTimers == 1); + check_and_cast(getSimulation()->getSystemModule()->getSubmodule("driver"))->arm(startRxTimer->getArrivalTime()); + } + void handleMessage(cMessage *message) override { + if (message == startRxTimer) { + ASSERT(physicalRadio->getReceivedSignalPart() == IRadioSignal::SIGNAL_PART_DATA); + ASSERT(isReceptionInProgress()); + ASSERT(frameSequenceHandler->isSequenceRunning()); + ASSERT(frameSequenceHandler->getContext()->getLastStep()->getType() == IFrameSequenceStep::Type::RECEIVE); + observedDataAtExpiry = true; + Hcf::handleMessage(message); + consumedTimers++; + ASSERT(!startRxTimer->isScheduled()); + ASSERT(frameSequenceHandler->isSequenceRunning()); + } + else + Hcf::handleMessage(message); + } + void originatorProcessFailedFrame(Packet *packet) override { + ASSERT(packet->peekAtFront()->getReceiverAddress() == MacAddress("02:00:00:00:00:09")); + failedFrames++; + Hcf::originatorProcessFailedFrame(packet); + } + void frameSequenceFinished() override { + finishedSequences++; + Hcf::frameSequenceFinished(); + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) { + auto mode = packet->getTag()->getMode(); + ASSERT(mode->getHtMcsIndex() < 0 && mode->getDataMode()->getNetBitrate() == bps(6000000)); + ASSERT(simTime() - mode->getDuration(packet->getDataLength()) == aggregateEnd + modeSet->getSifsTime()); + ASSERT(!frameSequenceHandler->isSequenceRunning()); + ASSERT(edca->getChannelOwner() == nullptr); + transmittedBlockAcks++; + } + Hcf::transmissionComplete(packet, header); + } + void sendUp(const std::vector& frames) override { + for (auto frame : frames) { + delivered++; + take(frame); + delete frame; + } + } +}; +Define_Module(ResponseWindowHcf); + +void ResponseWindowDriver::initialize() +{ + hcf = check_and_cast(getModuleByPath("^.host.wlan[0].mac.hcf")); + getModuleByPath("^.sender.radio")->subscribe(transmissionStartedSignal, this); + auto modes = Ieee80211ModeSet::getModeSet("n(mixed-2.4Ghz)"); + for (int i = 0; i < modes->getNumModes(); i++) { + auto candidate = modes->getMode(i); + if (candidate->getHtMcsIndex() == 0 && candidate->getDataMode()->getBandwidth() == MHz(20) && + candidate->isHtShortGuardInterval() == par("shortGi").boolValue()) + mode = candidate; + } + ASSERT(mode); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("begin")); +} + +void ResponseWindowDriver::arm(simtime_t deadline) +{ + Enter_Method("arm"); + ASSERT(!armed); + armed = true; + responseDeadline = deadline; + ASSERT(simTime() + SimTime(20, SIMTIME_US) < deadline); + scheduleAfter(SimTime(20, SIMTIME_US), new cMessage("aggregate")); +} + +Packet *ResponseWindowDriver::createAggregate() +{ + auto packet = new Packet("incoming-aggregate"); + for (int sequence : {100, 101}) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(par("addressed").boolValue() ? hcf->address() : MacAddress("02:00:00:00:00:08")); + header->setTransmitterAddress(MacAddress("02:00:00:00:00:02")); + header->setAddress3(header->getTransmitterAddress()); + header->setTid(5); + header->setAckPolicy(NORMAL_ACK); + header->setSequenceNumber(SequenceNumberCyclic(sequence)); + header->setDurationField(SIMTIME_ZERO); + auto delimiter = makeShared(); + delimiter->setLength(1000); + packet->insertAtBack(delimiter); + packet->insertAtBack(header); + packet->insertAtBack(makeShared(B(1000) - header->getChunkLength() - B(4))); + auto trailer = makeShared(); + trailer->setFcsMode(FCS_DECLARED_CORRECT); + packet->insertAtBack(trailer); + } + packet->addTag()->setProtocol(&Protocol::ieee80211Mac); + packet->addTag()->setMode(mode); + return packet; +} + +void ResponseWindowDriver::receiveSignal(cComponent *, simsignal_t, cObject *object, cObject *) +{ + Enter_Method_Silent(); + auto transmission = check_and_cast(object); + ASSERT(armed && !transmitted); + transmitted = true; + // The real radio must reach DATA before expiry and remain there until after expiry. + ASSERT(transmission->getStartTime(IRadioSignal::SIGNAL_PART_DATA) < responseDeadline); + ASSERT(responseDeadline < transmission->getEndTime(IRadioSignal::SIGNAL_PART_DATA)); + scheduleAt(transmission->getEndTime() + SimTime(1, SIMTIME_MS), new cMessage("verify")); +} + +void ResponseWindowDriver::handleMessage(cMessage *message) +{ + if (message->isName("begin")) { + delete message; + hcf->begin(); + } + else if (message->isName("aggregate")) { + delete message; + send(createAggregate(), "out"); + } + else { + delete message; + ASSERT(transmitted); + hcf->verify(par("addressed").boolValue()); + endSimulation(); + } +} + +%file: test.ned +import inet.mobility.static.StationaryMobility; +import inet.node.inet.AdhocHost; +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211Radio; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211RadioMedium; +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +module ResponseWindowHcf extends Hcf { parameters: bool shortGi; @class(::ResponseWindowHcf); } +module ResponseWindowErrorModel extends Ieee80211NistErrorModel { parameters: @class(::ResponseWindowErrorModel); } +simple ResponseWindowDriver { parameters: bool addressed; bool shortGi; @class(::ResponseWindowDriver); gates: output out; } +module ResponseWindowSender { + parameters: @networkNode; + gates: input in; input radioIn @directIn; + submodules: + mobility: StationaryMobility; + radio: Ieee80211Radio; + connections allowunconnected: + in --> radio.upperLayerIn; + radioIn --> radio.radioIn; +} +network Test { + submodules: + radioMedium: Ieee80211RadioMedium; + driver: ResponseWindowDriver; + sender: ResponseWindowSender; + host: AdhocHost; + connections: + driver.out --> sender.in; +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src +sim-time-limit = 10ms +seed-set = 0 +cmdenv-express-mode = false +record-vector-results = false +record-scalar-results = false +*.driver.addressed = ${addressed=false,true} +*.driver.shortGi = ${shortGi=false,true} +*.host.wlan[0].mac.hcf.shortGi = ${shortGi} +*.host.wlan[0].opMode = "n(mixed-2.4Ghz)" +*.host.wlan[0].mac.qosStation = true +*.host.wlan[0].mac.hcf.typename = "ResponseWindowHcf" +*.host.wlan[0].mac.hcf.isBlockAckSupported = true +*.host.wlan[0].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +*.host.wlan[0].mac.hcf.originatorAckPolicy.ackTimeout = 200us +*.host.wlan[0].radio.receiver.errorModel.typename = "ResponseWindowErrorModel" +*.host.wlan[0].radio.separateReceptionParts = true +*.sender.radio.separateReceptionParts = true +*.sender.radio.opMode = "n(mixed-2.4Ghz)" +*.sender.radio.initialRadioMode = "transmitter" +*.sender.radio.antenna.mobilityModule = "^.^.mobility" +**.recoveryProcedure.shortRetryLimit = 1 +**.recoveryProcedure.longRetryLimit = 1 +**.radio.receiver.bandwidth = 20MHz +*.radioMedium.backgroundNoise.power = -110dBm +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +**.mobility.initFromDisplayString = false +**.mobility.initialX = 10m +**.mobility.initialY = 10m +**.mobility.initialZ = 0m +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m + +%contains: stdout +Aggregate response-window assertions passed: + +%contains: stdout +Run statistics: total 4, successful 4 diff --git a/tests/module/Ieee80211AmpduTxStart_1.test b/tests/module/Ieee80211AmpduTxStart_1.test new file mode 100644 index 00000000000..d3c151b1e50 --- /dev/null +++ b/tests/module/Ieee80211AmpduTxStart_1.test @@ -0,0 +1,225 @@ +%description: +Production Tx calls aggregate preparation at the exact submission time after IFS, or immediately for zero IFS. +Cancellation before IFS expiry prevents preparation and submission. Refusal clears the request before its cancellation callback. +Completion accepts a one-byte envelope without a MAC header or trailer and supplies a null header to the callback. +The completion callback can submit a replacement before the earlier completion returns. +A minimal MAC subclass captures submissions. The fixture calls the production radio-completion entry directly. +This module evidence does not establish production HCF cancellation or real radio completion. + +%file: AggregateTxStart.cc +#include +#include "inet/common/packet/chunk/BytesChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" +#include "inet/linklayer/ieee80211/mac/Tx.h" +#include "inet/linklayer/ieee80211/mac/contract/IRx.h" + +using namespace inet; +using namespace inet::ieee80211; + +class AggregateTxNavProbe : public IRx +{ + public: + int updates = 0; + bool isReceptionInProgress() const override { return false; } + bool isMediumFree() const override { return true; } + simtime_t getTxnavRemaining() const override { return SIMTIME_ZERO; } + void successfulFrameTransmitted(simtime_t, simtime_t) override {} + void setContentionBlocked(bool) override {} + void frameTransmitted(simtime_t) override { updates++; } + void registerContention(IContention *) override {} + void receptionStateChanged(physicallayer::IRadio::ReceptionState) override {} + void transmissionStateChanged(physicallayer::IRadio::TransmissionState) override {} + void receivedSignalPartChanged(physicallayer::IRadioSignal::SignalPart) override {} + bool lowerFrameReceived(Packet *) override { throw cRuntimeError("Unexpected receive operation"); } + AmpduReception lowerAggregateReceived(Packet *) override { throw cRuntimeError("Unexpected aggregate receive operation"); } +}; + +class AggregateCaptureMac : public Ieee80211Mac +{ + protected: + int numInitStages() const override { return 1; } + void initialize(int) override {} + public: + std::vector submissions; + std::vector submittedIds; + void sendDownFrame(Packet *packet) override { + Enter_Method("sendDownFrame"); + take(packet); + ASSERT(packet->getDataLength() == B(1)); + ASSERT(packet->peekAllAsBytes()->getBytes() == std::vector{0x5a}); + submissions.push_back(simTime()); + submittedIds.push_back(packet->getId()); + delete packet; + } +}; +Define_Module(AggregateCaptureMac); + +class AggregateBoundaryTx : public Tx +{ + protected: + int numInitStages() const override { return 1; } + void initialize(int) override { + mac = check_and_cast(getModuleByPath("^.mac")); + rx = &navProbe; + endIfsTimer = new cMessage("endIFS"); + } + public: + AggregateTxNavProbe navProbe; +}; +Define_Module(AggregateBoundaryTx); + +class AggregateUnusedCallback : public ITx::IAggregateCallback +{ + public: + void frameTransmissionStarted(Packet *) override { throw cRuntimeError("Unexpected callback"); } + Packet *prepareAggregateTransmission() override { throw cRuntimeError("Unexpected callback"); } + void aggregateTransmissionCancelled() override { throw cRuntimeError("Unexpected callback"); } + void transmissionComplete(Packet *, const Ptr&) override { throw cRuntimeError("Unexpected callback"); } +}; + +class AggregateTxStartTest : public cSimpleModule, public ITx::IAggregateCallback +{ + AggregateBoundaryTx *tx = nullptr; + AggregateCaptureMac *capture = nullptr; + AggregateUnusedCallback unrelated; + std::unique_ptr source; + int prepared = 0; + int cancelled = 0; + int completed = 0; + int ordinaryStarted = 0; + bool refuse = false; + bool replaceAtCompletion = false; + simtime_t expectedSubmission; + std::vector preparationTimes; + + public: + AggregateTxStartTest() : cSimpleModule(65536) {} + Packet *prepareAggregateTransmission() override { + ASSERT(tx->hasTransmission()); + ASSERT(simTime() == expectedSubmission); + prepared++; + preparationTimes.push_back(simTime()); + ASSERT(source->getOwner() == this); + return refuse ? nullptr : source.get(); + } + void aggregateTransmissionCancelled() override { + ASSERT(!tx->hasTransmission()); + ASSERT(simTime() == expectedSubmission); + cancelled++; + } + void frameTransmissionStarted(Packet *) override { ordinaryStarted++; } + void transmissionComplete(Packet *packet, const Ptr& header) override { + ASSERT(!tx->hasTransmission()); + ASSERT(header == nullptr); + ASSERT(packet != source.get() && packet->getId() != source->getId()); + ASSERT(packet->getDataLength() == B(1)); + ASSERT(packet->peekAllAsBytes()->getBytes() == std::vector{0x5a}); + ASSERT(source->getOwner() == this); + completed++; + if (replaceAtCompletion) { + replaceAtCompletion = false; + expectedSubmission = simTime(); + tx->transmitAggregate(SIMTIME_ZERO, this); + ASSERT(tx->hasTransmission()); + } + } + protected: + void activity() override { + tx = check_and_cast(getModuleByPath("^.tx")); + capture = check_and_cast(getModuleByPath("^.mac")); + wait(SimTime(1, SIMTIME_MS)); + int passed = 0; + for (const std::string operation : {"delayed", "zero", "cancel", "refuse", "zeroRefuse", "replace"}) { + ASSERT(!tx->hasTransmission()); + prepared = cancelled = completed = ordinaryStarted = 0; + refuse = operation == "refuse" || operation == "zeroRefuse"; + replaceAtCompletion = operation == "replace"; + source = std::make_unique("one-byte-envelope", makeShared(std::vector{0x5a})); + auto originalId = source->getId(); + auto before = capture->submissions.size(); + auto delay = operation == "zero" || operation == "zeroRefuse" ? SIMTIME_ZERO : SimTime(16, SIMTIME_US); + expectedSubmission = simTime() + delay; + tx->transmitAggregate(delay, this); + ASSERT(!tx->cancelPendingAggregate(&unrelated)); + if (operation == "cancel") { + ASSERT(tx->hasTransmission() && prepared == 0); + wait(delay / 2); + ASSERT(tx->cancelPendingAggregate(this)); + ASSERT(!tx->hasTransmission()); + ASSERT(!tx->cancelPendingAggregate(this)); + wait(delay); + ASSERT(prepared == 0 && cancelled == 0 && completed == 0); + ASSERT(capture->submissions.size() == before); + } + else { + if (delay > SIMTIME_ZERO) { + ASSERT(tx->hasTransmission() && prepared == 0); + ASSERT(capture->submissions.size() == before); + wait(delay / 2); + ASSERT(prepared == 0 && tx->hasTransmission()); + wait(delay / 2 + SimTime(1, SIMTIME_NS)); + } + ASSERT(prepared == 1); + if (refuse) { + ASSERT(cancelled == 1 && completed == 0 && !tx->hasTransmission()); + ASSERT(capture->submissions.size() == before); + ASSERT(!tx->cancelPendingAggregate(this)); + } + else { + ASSERT(cancelled == 0 && completed == 0 && tx->hasTransmission()); + ASSERT(capture->submissions.size() == before + 1); + ASSERT(capture->submissions.back() == preparationTimes.back()); + ASSERT(capture->submittedIds.back() != originalId); + ASSERT(!tx->cancelPendingAggregate(this)); + tx->radioTransmissionFinished(); + if (operation == "replace") { + ASSERT(completed == 1 && prepared == 2 && tx->hasTransmission()); + ASSERT(capture->submissions.size() == before + 2); + tx->radioTransmissionFinished(); + ASSERT(completed == 2); + } + else + ASSERT(completed == 1); + ASSERT(!tx->hasTransmission()); + tx->radioTransmissionFinished(); + ASSERT(completed == (operation == "replace" ? 2 : 1)); + } + } + ASSERT(ordinaryStarted == 0 && tx->navProbe.updates == 0); + ASSERT(source->getId() == originalId && source->getOwner() == this); + ASSERT(source->getDataLength() == B(1)); + source.reset(); + passed++; + std::cout << "Aggregate Tx boundary passed: " << operation << "\n"; + } + ASSERT(passed == 6); + std::cout << "All six aggregate Tx boundary cases passed.\n"; + endSimulation(); + } +}; +Define_Module(AggregateTxStartTest); + +%file: test.ned +import inet.common.SimpleModule; +simple AggregateCaptureMac extends SimpleModule { parameters: @class(::AggregateCaptureMac); } +simple AggregateBoundaryTx extends SimpleModule { parameters: @class(::AggregateBoundaryTx); } +simple AggregateTxStartTest extends SimpleModule { parameters: @class(::AggregateTxStartTest); } +network Test { + submodules: + mac: AggregateCaptureMac; + tx: AggregateBoundaryTx; + test: AggregateTxStartTest; +} + +%inifile: omnetpp.ini +[General] +network = Test +ned-path = .;../../../../src;../../lib +sim-time-limit = 10ms +seed-set = 0 +cmdenv-express-mode = false +record-vector-results = false +record-scalar-results = false + +%contains: stdout +All six aggregate Tx boundary cases passed. diff --git a/tests/module/Ieee80211CompressedBlockAckInput_1.test b/tests/module/Ieee80211CompressedBlockAckInput_1.test index 0775fc9b4a7..39a6506ce2d 100644 --- a/tests/module/Ieee80211CompressedBlockAckInput_1.test +++ b/tests/module/Ieee80211CompressedBlockAckInput_1.test @@ -70,9 +70,10 @@ class InputDataSpy : public IRecipientQosMacDataService { } void clearPeer(MacAddress peer) override { delegate->clearPeer(peer); } std::vector dataFrameReceived(Packet *packet, const Ptr& header, - IRecipientBlockAckAgreementHandler *agreements, bool interframe = false) override { + IRecipientBlockAckAgreementHandler *agreements, bool interframe = false, + const BlockAckReceiveContext *context = nullptr) override { dataCalls++; - return delegate->dataFrameReceived(packet, header, agreements, interframe); + return delegate->dataFrameReceived(packet, header, agreements, interframe, context); } std::vector controlFrameReceived(Packet *packet, const Ptr& header, IRecipientBlockAckAgreementHandler *agreements) override { diff --git a/tests/module/Ieee80211HcfMultipleProtection_1.test b/tests/module/Ieee80211HcfMultipleProtection_1.test index 852333eb985..a2ea0cc1346 100644 --- a/tests/module/Ieee80211HcfMultipleProtection_1.test +++ b/tests/module/Ieee80211HcfMultipleProtection_1.test @@ -112,6 +112,9 @@ class ProtectionRateSelection : public IQosRateSelection { const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckResponseMode(const physicallayer::IIeee80211Mode *mode) override { + return delegate->computeCompressedBlockAckResponseMode(mode); + } }; class ProtectionHcf : public Hcf { diff --git a/tests/module/Ieee80211HcfSingleProtection_1.test b/tests/module/Ieee80211HcfSingleProtection_1.test index 1ef31e67f3d..fe64ee85701 100644 --- a/tests/module/Ieee80211HcfSingleProtection_1.test +++ b/tests/module/Ieee80211HcfSingleProtection_1.test @@ -94,6 +94,9 @@ class SingleRateSelection : public IQosRateSelection { const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckResponseMode(const physicallayer::IIeee80211Mode *mode) override { + return delegate->computeCompressedBlockAckResponseMode(mode); + } }; class SingleRateControl : public IRateControl { public: diff --git a/tests/module/Ieee80211SingleProtectionGroup_1.test b/tests/module/Ieee80211SingleProtectionGroup_1.test index 0bb495f62cf..76d8e3e744e 100644 --- a/tests/module/Ieee80211SingleProtectionGroup_1.test +++ b/tests/module/Ieee80211SingleProtectionGroup_1.test @@ -29,6 +29,7 @@ class GroupRateSelection : public IQosRateSelection { const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseCtsFrameMode(packet, header, role); } const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseBlockAckFrameMode(packet, header, role); } const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckResponseMode(const physicallayer::IIeee80211Mode *mode) override { return delegate->computeCompressedBlockAckResponseMode(mode); } }; class GroupMechanism : public SingleProtectionMechanism { public: diff --git a/tests/module/Ieee80211Txnav_1.test b/tests/module/Ieee80211Txnav_1.test index 0e23937594f..5a740809038 100644 --- a/tests/module/Ieee80211Txnav_1.test +++ b/tests/module/Ieee80211Txnav_1.test @@ -33,6 +33,7 @@ class TxnavSelection : public IQosRateSelection { const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseAckFrameMode(packet, header, role); } const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { return delegate->computeResponseBlockAckFrameMode(packet, header, role); } const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckResponseMode(const physicallayer::IIeee80211Mode *mode) override { return delegate->computeCompressedBlockAckResponseMode(mode); } }; class TxnavRx : public Rx { public: diff --git a/tests/module/Ieee80211VhtHtSupport_1.test b/tests/module/Ieee80211VhtHtSupport_1.test index f9b9501aada..72d90237935 100644 --- a/tests/module/Ieee80211VhtHtSupport_1.test +++ b/tests/module/Ieee80211VhtHtSupport_1.test @@ -71,6 +71,9 @@ class VhtHtSelection : public IQosRateSelection { const IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, const Ptr& header, bool startsTxop) override { return delegate->computeCompressedBlockAckReqMode(packet, header, startsTxop); } + const IIeee80211Mode *computeCompressedBlockAckResponseMode(const IIeee80211Mode *mode) override { + return delegate->computeCompressedBlockAckResponseMode(mode); + } }; class VhtHtRx : public Rx { public: diff --git a/tests/protocol/wifi/11n/N_Ampdu.test b/tests/protocol/wifi/11n/N_Ampdu.test index dc5492f03e0..412399fd28b 100644 --- a/tests/protocol/wifi/11n/N_Ampdu.test +++ b/tests/protocol/wifi/11n/N_Ampdu.test @@ -1,16 +1,11 @@ -%# expected-result: FAIL %description: -Expected failure by explicit maintainer decision: defer this nontrivial repair to future work. -Repair requires production QoS aggregation selection, transmission, receive integration, and Block Ack progress. -Evidence and deferred-repair decision: doc/project/evidence/model/wifi/results.md#deferred-repair-expectations. -This declaration records unresolved work, not supported behavior. - -Observe an HT A-MPDU subframe. Aggregation construction exists, but the production -originator invocation is commented out and the default policy never aggregates. +Observe an HT A-MPDU through production association and fixed-rate Compressed Block Ack. +Require an implicit response and exactly sixty upper deliveries through the AP. %file: N_Ampdu.cc #include "ProtocolTest.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" namespace inet { namespace protocoltest { @@ -18,8 +13,18 @@ namespace protocoltest { Define_ProtocolTest(wifi_11n_ampdu) { return ProtocolTest("wifi_11n_ampdu") + .meanwhile(exactlyTimes(60, on("sta2.udp").signal("packetSentToUpper").within(1.5))) + .meanwhile(atLeastTimes(1, on("sta1.wlan[0].mac").signal("packetReceivedFromLower") + .filterEvent([](const MatchContext& c) { + return c.event.packet && dynamicPtrCast( + c.event.packet->peekAtFront()) != nullptr; + }) + .describe("an implicit Compressed Block Ack response").within(1.5))) .once(on("sta1.wlan[0].mac").signal("packetSentToLower") - .filterPacket("Ieee80211MpduSubframeHeader.length >= 0") + .filterEvent([](const MatchContext& c) { + return c.event.packet && dynamicPtrCast( + c.event.packet->peekAtFront()) != nullptr; + }) .describe("a frame containing an A-MPDU subframe header").within(2.0)); } @@ -30,16 +35,32 @@ Define_ProtocolTest(wifi_11n_ampdu) [General] *.tester.testName = "wifi_11n_ampdu" -*.sta*.wlan[*].mac.hcf.isBlockAckSupported = true -**.wlan[*].mac.hcf.blockAckVariant = "basic" -*.ap.wlan[*].mac.hcf.isBlockAckSupported = true -*.sta1.app[0].sendInterval = 0.1ms -include ../../ini/_n.ini +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "compressed" +**.wlan[*].mac.hcf.rateControl.typename = "" +**.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 65Mbps +**.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps +**.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +**.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +**.hcf.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +**.wlan[*].mac.fcsMode = "computed" +**.checksumMode = "computed" +**.txopProcedure.txopLimit = 0s +*.sta1.app[0].messageLength = 1200B +*.sta1.app[0].sendInterval = 20us +*.sta1.app[0].stopTime = 1.00119s +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" **.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB **.hcf.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 10000B -**.hcf.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 -**.hcf.originatorMacDataService.msduAggregationPolicy.aggregationLengthThreshold = 100 +include ../../ini/_n.ini include ../../ini/_base.ini %contains: stdout PROTOCOLTEST wifi_11n_ampdu: PASS + +%contains: stdout +WifiInfraNetwork.sta2.app[0]: received 60 packets diff --git a/tests/protocol/wifi/11n/N_AmpduImplicitBa.test b/tests/protocol/wifi/11n/N_AmpduImplicitBa.test new file mode 100644 index 00000000000..2cc0843219b --- /dev/null +++ b/tests/protocol/wifi/11n/N_AmpduImplicitBa.test @@ -0,0 +1,153 @@ +%description: +Real association and application traffic use HT aggregates on both AP hops. +Computed member FCS and a matched implicit response permit exactly sixty upper deliveries. +A deterministic partial-loss case requires an aggregate member with Retry set. +Both cases use seed zero. This fixture does not claim performance validation. + +%extraargs: -r 0..1 + +%postrun-command: python3 check-implicit.py + +%file: check-implicit.py +from pathlib import Path + +output = Path("test.out").read_text() +for name in ("wifi_11n_implicit_ba", "wifi_11n_implicit_ba_partial"): + assert output.count(f"PROTOCOLTEST {name}: PASS") == 1 +assert output.count("WifiInfraNetwork.sta2.app[0]: received 60 packets") == 2 +assert " Warning:" not in output +assert " Error:" not in output +assert ": FAIL" not in output + +%file: N_AmpduImplicitBa.cc +#include +#include "ProtocolTest.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +#include "inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h" +#include "inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/errormodel/Ieee80211NistErrorModel.h" + +namespace inet::protocoltest { +using namespace ieee80211; +using namespace physicallayer; + +class ImplicitProtocolErrorModel : public Ieee80211NistErrorModel +{ + mutable bool firstMember = true; + public: + double computePacketErrorRate(const ISnir *, IRadioSignal::SignalPart) const override { return 0; } + double computeAmpduRangeSuccessRate(const ISnir *, const IIeee80211Mode *, B length) const override { + if (length == B(4)) + return 1; + bool fail = par("partialLoss").boolValue() && firstMember; + firstMember = false; + return fail ? 0 : 1; + } +}; +Define_Module(ImplicitProtocolErrorModel); + +static bool hasAggregate(const MatchContext& context, bool requireRetry) +{ + auto packet = context.event.packet; + if (!packet || !dynamicPtrCast(packet->peekAtFront())) + return false; + auto mode = packet->getTag()->getMode(); + if (mode->getHtMcsIndex() < 0 || mode->isHtShortGuardInterval()) + return false; + auto layout = inspectMpduAggregate(packet, B(0), B(packet->getDataLength())); + bool retry = false; + int members = 0; + for (const auto& range : layout.ranges) { + if (range.kind != MpduRangeKind::MPDU) + continue; + auto data = packet->peekDataAt(range.offset); + ASSERT(data->getAckPolicy() == NORMAL_ACK && data->getFragmentNumber() == 0 && !data->getMoreFragments()); + retry |= data->getRetry(); + members++; + } + return layout.complete && members > 0 && (!requireRetry || retry); +} + +static ProtocolTest implicitProgram(const char *name, bool partialLoss) +{ + auto program = ProtocolTest(name) + .meanwhile(exactlyTimes(60, on("sta2.udp").signal("packetSentToUpper").within(1.5))); + if (partialLoss) + program.meanwhile(atLeastTimes(1, on("sta1.wlan[0].mac").signal("packetSentToLower") + .filterEvent([](const MatchContext& c) { return hasAggregate(c, true); }) + .describe("selective DATA retry after partial receipt").within(1.5))); + program.once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto header = c.event.packet->peekAtFront(); + auto response = dynamicPtrCast(header); + return response && response->getStatusCode() == SC_SUCCESSFUL && response->getBlockAckPolicy(); + }).describe("accepted immediate agreement after infrastructure association").within(1.2)) + .once(on("sta1.wlan[0].mac").signal("packetSentToLower") + .filterEvent([](const MatchContext& c) { return hasAggregate(c, false); }) + .describe("production HT aggregate from the source").within(0.1)) + .once(on("sta1.wlan[0].mac").signal("packetReceivedFromLower") + .filterEvent([](const MatchContext& c) { + if (!c.event.packet) return false; + auto response = dynamicPtrCast(c.event.packet->peekAtFront()); + return response && response->getBlockAckBitmap().getSize() == 64; + }).describe("implicit Compressed Block Ack").within(0.02)) + .once(on("ap.wlan[0].mac").signal("packetSentToLower") + .filterEvent([](const MatchContext& c) { return hasAggregate(c, false); }) + .describe("production HT aggregate from the AP").within(0.1)); + return program; +} + +Define_ProtocolTest(wifi_11n_implicit_ba) +{ + return implicitProgram("wifi_11n_implicit_ba", false); +} + +Define_ProtocolTest(wifi_11n_implicit_ba_partial) +{ + return implicitProgram("wifi_11n_implicit_ba_partial", true); +} +} + +%file: ImplicitProtocolErrorModel.ned +import inet.physicallayer.wireless.ieee80211.packetlevel.errormodel.Ieee80211NistErrorModel; +module ImplicitProtocolErrorModel extends Ieee80211NistErrorModel { + parameters: + bool partialLoss = default(false); + @class(::inet::protocoltest::ImplicitProtocolErrorModel); +} + +%inifile: test.ini +[General] +*.tester.testName = ${test="wifi_11n_implicit_ba","wifi_11n_implicit_ba_partial"} +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "compressed" +**.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 65Mbps +**.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps +**.wlan[*].mac.hcf.rateControl.typename = "" +**.wlan[*].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +**.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.typename = "" +**.wlan[*].mac.hcf.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +**.wlan[*].mac.fcsMode = "computed" +**.checksumMode = "computed" +**.wlan[*].radio.receiver.errorModel.typename = "ImplicitProtocolErrorModel" +**.wlan[*].radio.receiver.errorModel.partialLoss = ${test} == "wifi_11n_implicit_ba_partial" +**.txopProcedure.txopLimit = 0s +*.sta1.app[0].messageLength = 1200B +*.sta1.app[0].sendInterval = 20us +*.sta1.app[0].stopTime = 1.00119s +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" +**.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB +include ../../ini/_n.ini +include ../../ini/_base.ini + +%contains: stdout +PROTOCOLTEST wifi_11n_implicit_ba: PASS + +%contains: stdout +PROTOCOLTEST wifi_11n_implicit_ba_partial: PASS diff --git a/tests/unit/Ieee80211AmpduResponseValidation_1.test b/tests/unit/Ieee80211AmpduResponseValidation_1.test new file mode 100644 index 00000000000..f7888b5d34a --- /dev/null +++ b/tests/unit/Ieee80211AmpduResponseValidation_1.test @@ -0,0 +1,45 @@ +%description: +The shared Compressed response validator accepts a zero bitmap at sequence wrap. +It rejects mismatched addresses, TID, profile, fragment fields, bitmap width, and wire length. +The aggregate frame sequence supplies its actual peer and TID to this validator. +These helper checks supplement the real receive-window fixture. + +%includes: +#include "inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +using namespace inet; +using namespace inet::ieee80211; + +%activity: +const MacAddress local("02:00:00:00:00:01"); +const MacAddress peer("02:00:00:00:00:02"); +const MacAddress other("02:00:00:00:00:03"); +for (int scenario = 0; scenario < 12; scenario++) { + auto header = makeShared(); + header->setReceiverAddress(scenario == 1 ? other : local); + header->setTransmitterAddress(scenario == 2 ? other : peer); + header->setTidInfo(scenario == 3 ? 2 : 5); + header->setStartingSequenceNumber(SequenceNumberCyclic(4095)); + header->setBlockAckBitmap(BitVector(0, scenario == 7 ? 63 : scenario == 8 ? 65 : 64)); + if (scenario == 4) header->setMultiTid(true); + if (scenario == 5) header->setCompressedBitmap(false); + if (scenario == 6) header->setFragmentNumber(1); + if (scenario == 9) header->setChunkLength(B(27)); + Packet packet("response", header); + if (scenario != 10) + packet.insertAtBack(makeShared()); + if (scenario == 11) + packet.insertAtBack(makeShared(B(1))); + ASSERT(isValidCompressedBlockAck(&packet, local, peer, 5) == (scenario == 0)); +} +auto basic = makeShared(); +basic->setReceiverAddress(local); +basic->setTransmitterAddress(peer); +basic->setTidInfo(5); +Packet wrongProfile("basic", basic); +wrongProfile.insertAtBack(makeShared()); +ASSERT(!isValidCompressedBlockAck(&wrongProfile, local, peer, 5)); +EV << "Compressed response validation boundaries passed.\n"; + +%contains: stdout +Compressed response validation boundaries passed. diff --git a/tests/unit/Ieee80211BlockAckScheduling_1.test b/tests/unit/Ieee80211BlockAckScheduling_1.test index ce6049d666d..f82be88e6cd 100644 --- a/tests/unit/Ieee80211BlockAckScheduling_1.test +++ b/tests/unit/Ieee80211BlockAckScheduling_1.test @@ -200,6 +200,47 @@ ASSERT(policy.isBlockAckReqNeeded(&frames, nullptr, &agreements)); wait(duration); ASSERT(!policy.isBlockAckReqNeeded(&frames, nullptr, &agreements)); ASSERT(ack.getQoSDataAckStatus(unrelated.front()) == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED); +// A pending probe survives complete member expiry. The caller's EDCA predicate limits its owner. +agreements.getAgreement(peer, 2)->setPendingProbe(true); +selectedAgreement->setPendingProbe(true); +otherAgreement->setPendingProbe(true); +policy.setProbeEligibility([](InProgressFrames *, Tid) { return false; }); +ASSERT(!policy.isBlockAckReqNeeded(&frames, nullptr, &agreements)); +policy.setProbeEligibility([&frames](InProgressFrames *candidate, Tid tid) { return candidate == &frames && tid == 5; }); +choice = policy.computeBlockAckReqParameters(&frames, nullptr, &agreements); +ASSERT(std::get<0>(choice) == peer && std::get<2>(choice) == 5); +ASSERT(std::get<1>(choice) == selectedAgreement->getStartingSequenceNumber()); +selectedAgreement->setPendingProbe(false); +choice = policy.computeBlockAckReqParameters(&frames, nullptr, &agreements); +ASSERT(std::get<0>(choice) == other && std::get<2>(choice) == 5); +otherAgreement->setPendingProbe(false); +ASSERT(!policy.isBlockAckReqNeeded(&frames, nullptr, &agreements)); +// A probe wait includes failed transmitted members, but excludes a numbered unsent member. +QosAckHandler implicitAck; +SchedulingFrames implicitFrames; +implicitFrames.configure(&implicitAck); +OriginatorBlockAckAgreement implicitAgreement(peer, 5, SequenceNumberCyclic(4095), 2, false, false); +auto attempted = implicitFrames.add(peer, 5, 4095, false); +auto numberedUnsent = implicitFrames.add(peer, 5, 0, false); +implicitAck.processTransmittedImplicitBlockAckMember(attempted); +implicitAck.processFailedImplicitBlockAckMember(attempted); +ASSERT(implicitAck.getQoSDataAckStatus(attempted) == QosAckHandler::Status::BLOCK_ACK_NOT_ARRIVED); +auto probe = makeShared(); +probe->setReceiverAddress(peer); +probe->setTidInfo(5); +probe->setStartingSequenceNumber(SequenceNumberCyclic(4095)); +implicitAck.processTransmittedBlockAckReq(probe, &implicitAgreement); +ASSERT(implicitAck.getQoSDataAckStatus(attempted) == QosAckHandler::Status::WAITING_FOR_BLOCK_ACK); +ASSERT(implicitAck.getQoSDataAckStatus(numberedUnsent) == QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED); +auto zeroResponse = makeShared(); +zeroResponse->setTransmitterAddress(peer); +zeroResponse->setTidInfo(5); +zeroResponse->setStartingSequenceNumber(SequenceNumberCyclic(4095)); +zeroResponse->setBlockAckBitmap(BitVector(0, 64)); +ASSERT(implicitAck.processReceivedCompressedBlockAck(zeroResponse, &implicitAgreement).empty()); +ASSERT(implicitAck.getQoSDataAckStatus(attempted) == QosAckHandler::Status::BLOCK_ACK_ARRIVED_UNACKED); +ASSERT(implicitAck.isEligibleToTransmit(attempted)); +ASSERT(implicitAck.getQoSDataAckStatus(numberedUnsent) == QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED); std::cout << "Block Ack scheduling isolation assertions passed.\n"; %contains: stdout diff --git a/tests/unit/Ieee80211ResponseTimeout_1.test b/tests/unit/Ieee80211ResponseTimeout_1.test index c55f286bb21..c486ec99abd 100644 --- a/tests/unit/Ieee80211ResponseTimeout_1.test +++ b/tests/unit/Ieee80211ResponseTimeout_1.test @@ -50,6 +50,7 @@ class TestRateSelection : public SimpleModule, public IRateSelection, public IQo virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txopProcedure) override { return responseMode; } const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *, const Ptr&, bool) override { return responseMode; } + const physicallayer::IIeee80211Mode *computeCompressedBlockAckResponseMode(const physicallayer::IIeee80211Mode *) override { return responseMode; } }; Define_Module(TestRateSelection); diff --git a/tests/unit/Ieee80211TxNavChoice_1.test b/tests/unit/Ieee80211TxNavChoice_1.test index 168f85cd213..4d2816e2b0e 100644 --- a/tests/unit/Ieee80211TxNavChoice_1.test +++ b/tests/unit/Ieee80211TxNavChoice_1.test @@ -23,6 +23,9 @@ class NavRx : public IRx { void transmissionStateChanged(physicallayer::IRadio::TransmissionState) override {} void receivedSignalPartChanged(physicallayer::IRadioSignal::SignalPart) override {} bool lowerFrameReceived(Packet *) override { return false; } + AmpduReception lowerAggregateReceived(Packet *) override { + throw cRuntimeError("NavRx does not receive aggregate frames in this fixture"); + } }; class ForwardingTx : public Tx { @@ -60,6 +63,7 @@ class CompletionCallback : public ITx::ICallback { CompletionTx *tx; bool replacementChoice; CompletionCallback(CompletionTx *tx, bool choice) : tx(tx), replacementChoice(choice) {} + void frameTransmissionStarted(Packet *) override {} void transmissionComplete(Packet *, const Ptr&) override { ASSERT(!tx->hasTransmission()); tx->replaceChoice(replacementChoice); From 185f9acaec4903238bcc975055836675a25b3966 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 31/41] examples: add: demonstrate HT implicit Block Ack through an AP Before this commit, users lack a complete configuration for the new HT aggregate profile. Selecting an HT mode alone does not establish peer capabilities or an accepted agreement. After this commit, one example uses production management and fixed HT20 long-GI DATA rates. Scalar, dimensional, and zero-TXOP configurations send UDP traffic through an AP. The README explains opt-in, selective retry, probe recovery, and profile limits. These demonstrations establish no throughput result. Plan: plan/pending/ieee80211-ampdu-implicit-blockack.md Change: examples | behavior.add | - | ieee80211-implicit-blockack --- examples/wireless/htampdu/HtAmpdu.ned | 18 ++++++++ examples/wireless/htampdu/README | 13 ++++++ examples/wireless/htampdu/omnetpp.ini | 61 +++++++++++++++++++++++++++ 3 files changed, 92 insertions(+) create mode 100644 examples/wireless/htampdu/HtAmpdu.ned create mode 100644 examples/wireless/htampdu/README create mode 100644 examples/wireless/htampdu/omnetpp.ini diff --git a/examples/wireless/htampdu/HtAmpdu.ned b/examples/wireless/htampdu/HtAmpdu.ned new file mode 100644 index 00000000000..25678277f6f --- /dev/null +++ b/examples/wireless/htampdu/HtAmpdu.ned @@ -0,0 +1,18 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later + +package inet.examples.wireless.htampdu; + +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.physicallayer.wireless.common.contract.packetlevel.IRadioMedium; + +network HtAmpdu +{ + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: like IRadioMedium; + ap: AccessPoint; + source: WirelessHost; + destination: WirelessHost; +} diff --git a/examples/wireless/htampdu/README b/examples/wireless/htampdu/README new file mode 100644 index 00000000000..8fb89a50b1d --- /dev/null +++ b/examples/wireless/htampdu/README @@ -0,0 +1,13 @@ +This example selects HT A-MPDU transmission with implicit Compressed Block Ack. + +The source sends UDP traffic through an AP to the destination. Production management establishes peer HT capabilities and Block Ack agreements. HCF selects independent MPDUs from the queue after agreement acceptance. Each aggregate receives one Compressed Block Ack response. The originator retains unacknowledged members for selective retry with their original deadlines. + +Run the default configuration from this directory: + + inet -u Cmdenv -c General + +The ZeroTxop configuration permits one aggregate DATA PPDU per channel grant. The Dimensional configuration selects the dimensional PHY. The default configuration uses the scalar PHY. These runs demonstrate the configured mechanism; they do not supply throughput validation. + +HtMpduAggregationPolicy requires fixed DATA rates without a rate-control submodule. This example selects HT mixed format, 20 MHz, one spatial stream, and long GI. The receiver also accepts advertised HT20 short-GI aggregates. A-MSDU nesting, adaptive aggregate rates, HT40 aggregate transmission, VHT aggregates, Multi-TID Block Ack, and correlated FEC errors remain outside this profile. + +NIST and Yans use cached delimiter and MPDU outcomes. A failed member does not invalidate every other member. The MAC still validates delimiters, FCS, addresses, and agreement state before receipt. After an absent or invalid implicit response, the originator submits at most one explicit BAR probe before its next DATA attempt. This probe is an INET recovery policy. diff --git a/examples/wireless/htampdu/omnetpp.ini b/examples/wireless/htampdu/omnetpp.ini new file mode 100644 index 00000000000..28f5f459cb4 --- /dev/null +++ b/examples/wireless/htampdu/omnetpp.ini @@ -0,0 +1,61 @@ +[General] +network = HtAmpdu +sim-time-limit = 1.5s +seed-set = 0 + +*.source.numApps = 1 +*.source.app[0].typename = "UdpBasicApp" +*.source.app[0].destAddresses = "destination" +*.source.app[0].destPort = 1000 +*.source.app[0].messageLength = 1200B +*.source.app[0].startTime = 1s +*.source.app[0].stopTime = 1.03s +*.source.app[0].sendInterval = 30us +*.destination.numApps = 1 +*.destination.app[0].typename = "UdpSink" +*.destination.app[0].localPort = 1000 +*.source.ipv4.arp.typename = "GlobalArp" +*.destination.ipv4.arp.typename = "GlobalArp" + +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].bitrate = 6Mbps +**.wlan[*].classifier.typename = "QosClassifier" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.fcsMode = "computed" +**.checksumMode = "computed" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "compressed" +**.wlan[*].mac.hcf.rateControl.typename = "" +**.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 65Mbps +**.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps +**.wlan[*].mac.hcf.rateSelection.dataFrameBandwidth = 20MHz +**.wlan[*].mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1 +**.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" +**.originatorMacDataService.msduAggregationPolicy.typename = "" +**.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +**.txopProcedure.txopLimit = 4ms +**.txopProcedure.protectionMechanism = "multiple" +**.rtsPolicy.rtsThreshold = 2346B +**.bandName = "2.4 GHz" + +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.source.mobility.initialX = 0m +*.ap.mobility.initialX = 5m +*.destination.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +[Config ZeroTxop] +description = "One aggregate DATA PPDU per channel grant" +**.txopProcedure.txopLimit = 0s + +[Config Dimensional] +description = "HT aggregates through the dimensional PHY" +*.radioMedium.typename = "Ieee80211DimensionalRadioMedium" +**.wlan[*].radio.typename = "Ieee80211DimensionalRadio" From 08bb4a150bb472548f849bc923c0c901b6f67ec3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 32/41] doc: comment: explain HT implicit Block Ack operation and migration Before this commit, user documentation describes A-MPDU transmission as unavailable. Extension authors also lack the aggregate preparation, submission, reception, and response contracts. After this commit, the user guide explains configuration, independent member state, complete-PSDU RTS selection, implicit responses, and probe recovery. The migration guide names each changed extension role. WHATSNEW describes the supported profile and its limits. The Wi-Fi evidence report records the approved HT marker removal while it preserves the historical audit. Change: doc | comment | - | ieee80211-implicit-blockack --- WHATSNEW | 12 +++++- doc/project/evidence/model/wifi/results.md | 8 +++- doc/src/migration-guide/index.rst | 28 +++++++++++++- doc/src/users-guide/ch-80211.rst | 44 ++++++++++++++++++---- 4 files changed, 81 insertions(+), 11 deletions(-) diff --git a/WHATSNEW b/WHATSNEW index e76e4d1eeb1..e9fabaa0469 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -468,7 +468,7 @@ Notable backward incompatible changes are the following: Before DATA commitment, failed RTS updates access-category retry state without a provisional sequence counter. Original DATA lifetimes bound repeated attempts. This changes the scoped path's former discard after a fixed number of RTS failures. - Existing demonstrations retain explicit Basic settings, configurations, and result rows. IEEE Std 802.11e-2005 introduced Basic; IEEE Std 802.11-2024 reserves its Type 0 value. Retention does not establish complete historical conformance. A-MPDU requirements for n and ac remain deferred. Multi-TID Block Ack and the existing delayed Basic requirement also remain deferred. Compressed support does not establish complete VHT transfer support or MAC stop/start recovery. + Existing demonstrations retain explicit Basic settings, configurations, and result rows. IEEE Std 802.11e-2005 introduced Basic; IEEE Std 802.11-2024 reserves its Type 0 value. Retention does not establish complete historical conformance. VHT A-MPDU, Multi-TID Block Ack, and the existing delayed Basic requirement remain deferred. Compressed support does not establish complete VHT transfer support or MAC stop/start recovery. Custom QoS rate selectors, recipient ACK policies, recipient data services, and frame sequences require the interface changes in the migration guide. Custom radio media, communication caches, and IEEE 802.11 modes also require the new timing queries. Basic classes and methods remain available. @@ -506,6 +506,16 @@ Notable backward incompatible changes are the following: Delimiter recovery now scans across typed MPDU headers. An invalid delimiter no longer causes a chunk conversion error at those headers. Bounded recovery retains later complete MPDU ranges. +60. IEEE 802.11 HT A-MPDU and implicit Compressed Block Ack + + HtMpduAggregationPolicy enables HT20 mixed-format A-MPDU transmission after an accepted Compressed agreement. The default policy leaves aggregation disabled. The first transmit profile requires long GI and fixed DATA rates without rate control. The receiver also accepts advertised HT20 short-GI aggregates. The htampdu example supplies scalar, dimensional, and zero-TXOP configurations. + + Each member retains its sequence number, retry state, and independent deadline. HCF commits new members after the IFS interval at actual DATA submission. The complete PSDU length controls RTS protection and exchange admission. Partial PHY loss permits separate member acceptance and one implicit response after SIFS. One correct member prevents EIFS, including overheard DATA and DATA without an agreement. + + Missing or invalid implicit responses cause one contention failure and one pending explicit BAR probe. Probe submission consumes that flag. Probe failure permits DATA retry without another probe until a later DATA attempt. This INET policy exposes lost recipient agreement state under continuous traffic. It adds probe airtime and channel access delay. Valid zero-bit responses do not arm a probe. + + Custom aggregation policies, QoS data services, Rx, Tx, recipient services, ACK policies, and response procedures require the migration changes. NIST and Yans use cached range outcomes. Adaptive aggregate rates, HT40 transmit aggregation, VHT aggregates, nested A-MSDUs, and correlated FEC errors remain outside this profile. These changes can alter affected exchange order, delivery times, and simulation results. + Notable backward compatible changes are the following: 1. IEEE 802.11 per-station rate statistics diff --git a/doc/project/evidence/model/wifi/results.md b/doc/project/evidence/model/wifi/results.md index 59555af44de..91f58ed65d2 100644 --- a/doc/project/evidence/model/wifi/results.md +++ b/doc/project/evidence/model/wifi/results.md @@ -1,9 +1,15 @@ # Wi-Fi protocol tests — expectation audit -> **Kind:** report · **Status:** snapshot 2026-09-17 · **Seal:** none · **Owns:** — · **Stands on:** [failure classification](../../../guide/derive-tests-from-a-standard.md#the-class-of-a-failure-and-when-to-declare-it-expected), [testing rules](../../../rule/testing.md) +> **Kind:** report · **Status:** snapshot 2026-10-18 with September history · **Seal:** none · **Owns:** — · **Stands on:** [failure classification](../../../guide/derive-tests-from-a-standard.md#the-class-of-a-failure-and-when-to-declare-it-expected), [testing rules](../../../rule/testing.md) Raw artifacts linked under `audit/` are local, Git-ignored evidence and are not included in the branch. The observations, classifications, and follow-up work are recorded below. +## HT aggregate update, 2026-10-18 + +`N_Ampdu` now uses the supported HT20 aggregate profile with fixed rates and Compressed Block Ack. Its production exchange observes an aggregate and an implicit response. It requires exactly 60 UDP deliveries and independently checks 60 application receipts. The maintainer explicitly approves removal of this test's expected-failure marker after the focused pass. The [Implicit Block Ack execution record](../../../../../plan/pending/ieee80211-ampdu-implicit-blockack-execution.md) supplies the source identity, commands, and final evidence. + +`Ac_Ampdu` retains its expected failure because VHT aggregates remain outside this profile. HT transmission from an `ac` interface does not establish VHT aggregate support. All other deferred declarations retain their existing scope. The sections below retain the September snapshot and its historical counts. + ## Deferred-repair expectations After the audit and rebase, the maintainer explicitly requested that the 12 failures from the 18-test focused run be declared expected: their repairs are nontrivial and deferred to future contributions. This later decision supersedes the removal decision for those 12 tests only. The six repaired passing tests retain their PASS expectations. The maintainer subsequently extended the same decision to the separately added `Ac_Ldpc` test. The total deferred-repair scope is now 13 tests. diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 1bc0127f048..cfdb577ca14 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -14,6 +14,30 @@ retransmissions do (``synRetries``). When they run out, the connection raises th ``TCP_E_TIMEOUT_CONN_ESTAB``, as the timer did before, so a subclass that handles this event needs no change. +IEEE 802.11 implicit Block Ack extension points +--------------------------------------------- + +The default MPDU policy remains disabled. ``HtMpduAggregationPolicy`` enables independent HT20 long-GI members with fixed DATA rates. Custom MPDU policies implement ``isEnabled()`` and ``selectFrames()``. The caller supplies negotiated receiver limits and one retained DATA mode. A policy returns borrowed member references without queue extraction or state changes. + +Custom QoS data services implement batch preparation, validation, commitment, and construction through ``IOriginatorQosMacDataService``. Each new member owns one reversible preview. The batch borrows canonical members from the in-progress queue. Commitment validates every queued source before the first extraction. Failed preparation preserves sequence state and independent deadlines. + +``IRx::lowerAggregateReceived()`` returns separately owned correct members and immutable delimiter topology. The caller retains the envelope. Custom recipient services pass ``BlockAckReceiveContext`` to the reorder owner. This context supplies physical interval and delimiter facts; it does not replace receipt state. Custom agreement handlers implement ``implicitBlockAckRequested()`` to refresh inactivity for valid implicit DATA. + +Custom Tx implementations support ``transmitAggregate()``, ``cancelPendingAggregate()``, and ``finalizeMpdu()``. The aggregate callback validates and commits members at actual submission after the existing IFS timer. Cancellation removes a delayed request before exchange-context disposal. Aggregate completion supplies a null MAC header because the envelope has no outer MAC header or FCS. Every Tx callback implements ``frameTransmissionStarted()`` for an actual-submission notification. A concrete callback can use an empty override when submission requires no state change. + +Custom QoS ACK policies accept probe eligibility through existing EDCA classification. They also supply the implicit Block Ack receive-start timeout from the actual response mode. Every custom rate selector implements ``computeCompressedBlockAckResponseMode()`` for implicit callers. A selector without this capability must throw a diagnostic from its concrete override. Explicit Compressed BAR and implicit DATA share this rate calculation without a fabricated BAR. + +Custom recipient procedures construct a Compressed response directly from peer, TID, and current agreement state. ``FrameTransmissionDetails`` adds ``FRAME_TRANSMISSION_STATUS_UNACKNOWLEDGED`` for unsuccessful aggregate member attempts. A probe supplies no second DATA attempt outcome. Existing packet-drop signals retain terminal disposal observations. + +IEEE 802.11 HT aggregate construction +------------------------------------ + +The MIB parameter ``htMinimumMpduStartSpacing`` supplies the encoded receiver limit from zero through seven. Zero preserves the default with no spacing restriction. The remaining values represent 0.25, 0.5, 1, 2, 4, 8, and 16 microseconds. Full and simplified management preserve the receiver's value in each negotiated direction. The negotiated transmit direction stores the peer receiver's value. + +Custom ``IMpduAggregation`` implementations must supply two HT operations. ``computeAggregateLength()`` previews the PSDU length at the supplied mode and spacing. Zero means an empty batch, unsupported mode, invalid member length, or excessive HT PSDU length. The new ``aggregateFrames()`` overload accepts source references, the mode, encoded spacing, and the peer byte limit. It returns ``nullptr`` when construction exceeds a limit, including either HT duration limit. These operations retain all source Packets and their state. + +The existing pointer overload retains its consuming contract. The supplied builder copies region tags from each source's data range to the member's position. It inserts alignment padding and zero-length delimiters between members as necessary. The final member has no padding. A singleton retains its delimiter, so HT-SIG byte conversion preserves its aggregate identity. These construction operations do not enable aggregate selection or implicit Block Ack responses. + IEEE 802.11 HT A-MPDU PHY reception --------------------------------- @@ -33,9 +57,9 @@ Separate-part reception retains its current abort; whole-signal reception suppli ``Ieee80211AmpduInd`` carries copied PHY facts without reception or transmission pointers. Each range identifies a delimiter or complete MPDU by PSDU-relative byte offset, byte length, validity, and physical success. Spacing delimiters have four-byte ranges. Alignment padding has no range outcome or separate draw. MAC delimiter and FCS checks still control acceptance; the PHY indication alone grants no delivery or response permission. -The default ``Rx`` rejects containers whose PHY indication identifies an aggregate before standalone FCS or MAC header checks. This applies even when every range succeeds. The drop signal retains the PHY outcomes. Custom receive modules must keep aggregate containers separate from standalone frame parsing until they implement member acceptance. MPDU deaggregation can extract bounded recovered members from an incomplete layout. Extraction alone grants no MAC acceptance. +The default ``Rx`` sends aggregate containers through a separate member-validation path before standalone FCS or MAC header checks. A failed common header or incomplete content prevents member acceptance. Custom receive modules must keep aggregate containers separate from standalone frame parsing until they implement member acceptance. MPDU deaggregation can extract bounded recovered members from an incomplete layout. Extraction alone grants no MAC acceptance. -The medium cache retains each aggregate decision. PREAMBLE calculates no HEADER or DATA outcome. HEADER, DATA, WHOLE, and direct success queries reuse retained prerequisites and samples. WHOLE summarizes all ranges. Partial DATA failure preserves the aggregate bytes for the later MAC receive integration. This change alone does not enable MAC A-MPDU receipt or implicit Block Ack responses. +The medium cache retains each aggregate decision. PREAMBLE calculates no HEADER or DATA outcome. HEADER, DATA, WHOLE, and direct success queries reuse retained prerequisites and samples. WHOLE summarizes all ranges. Partial DATA failure preserves the aggregate bytes for MAC member validation. The PHY indication alone does not authorize MAC receipt or an implicit Block Ack response. With a present model, aggregate ``ErrorRateInd`` fields contain ``NaN`` for unknown probabilities. The receiver does not calculate the former whole-PSDU estimate for these fields. Member outcomes are separate from probability estimates. Without a model, the receiver preserves the common base's tag presence and values. Ordinary MPDUs retain their current metadata. Custom readers of aggregate error-rate fields must accept unknown values. diff --git a/doc/src/users-guide/ch-80211.rst b/doc/src/users-guide/ch-80211.rst index fa35d64e63b..01b9dd836f9 100644 --- a/doc/src/users-guide/ch-80211.rst +++ b/doc/src/users-guide/ch-80211.rst @@ -609,7 +609,7 @@ minimum. Outside active Compressed agreements, multiple protection does not check complete exchange cost against the remaining budget. For example, that retained policy can start a 120 us exchange with only 100 us left. Active Compressed agreements use their separate complete-cost admission. The reference scope assumes whole-microsecond positive limits, integral initial PPDU airtime, and integral legacy RTS airtime. -Multiple protection adds no A-MPDU, new fragmentation, CTS-to-self, dual CTS, PIFS recovery, or TXOP sharing. Reverse direction, beamforming, S1G, multi-user operation, and general MAC lifecycle support remain outside this implementation. General rate selection and recipient response timing retain their separate limits. +Multiple protection supports the HT aggregate profile below. New fragmentation, CTS-to-self, dual CTS, PIFS recovery, and TXOP sharing remain outside this implementation. Reverse direction, beamforming, S1G, multi-user operation, and general MAC lifecycle support also remain outside this implementation. General rate selection and recipient response timing retain their separate limits. .. _ug:sec:80211:fragmentation: @@ -642,17 +642,47 @@ default policy is :ned:`BasicMsduAggregationPolicy` with these parameters: - :par:`aggregationLengthThreshold`: the smallest aggregated payload that makes an A-MSDU. The default, ``-1``, means no check. -Set ``msduAggregationPolicy.typename = ""`` to turn aggregation off. A-MSDU -aggregation needs packets in the queue; it has an effect only when the -traffic source is faster than the channel. A-MPDU aggregation is not -available: the ``mpduAggregationPolicy`` slot exists, but the default policy -never aggregates, and the MAC does not build A-MPDU frames. +Set ``msduAggregationPolicy.typename = ""`` to turn A-MSDU aggregation off. A-MSDU aggregation needs packets in the queue. The default MPDU policy also leaves A-MPDU transmission disabled. The HT policy below enables A-MPDU transmission with implicit Compressed Block Ack. .. code-block:: ini **.wlan[*].mac.qosStation = true **.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.maxAMsduSize = 3000 +.. _ug:sec:80211:htampdu: + +HT A-MPDU and implicit Block Ack +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Select ``HtMpduAggregationPolicy`` to combine independent MPDUs after an accepted Compressed Block Ack agreement. The first transmit profile uses HT mixed format, 20 MHz, and long GI. Configure a fixed DATA rate without a rate-control submodule. HCF rejects aggregate opt-in with rate control at initialization. The receiver also accepts advertised HT20 short-GI aggregates. + +.. code-block:: ini + + **.wlan[*].opMode = "n(mixed-2.4Ghz)" + **.wlan[*].mac.qosStation = true + **.wlan[*].mac.hcf.isBlockAckSupported = true + **.wlan[*].mac.hcf.blockAckVariant = "compressed" + **.wlan[*].mac.hcf.rateControl.typename = "" + **.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 65Mbps + **.wlan[*].mac.hcf.rateSelection.dataFrameBandwidth = 20MHz + **.wlan[*].mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1 + **.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps + **.wlan[*].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" + +Production infrastructure management supplies peer capabilities and receiver limits. An HT mode alone does not supply this state. Each aggregate contains unfragmented QoS DATA for one receiver and TID. HCF applies the peer's byte limit, minimum MPDU start spacing, transmit window, and both HT duration limits. A-MSDU members remain outside this aggregate profile. + +HCF selects transmitted retries first, followed by numbered unsent members and new queued members. New members retain separate sequence numbers and deadlines. HCF commits queued members at actual DATA submission after the IFS interval. Expiry or agreement loss before submission cancels the batch without a DATA attempt. RTS protection uses the complete PSDU length, including delimiters and spacing. + +Every member carries ACK policy bits ``00`` and the same Duration value. Aggregate context makes those bits an implicit Block Ack request. The recipient validates each member against its copied PHY outcome and FCS. A valid member can arrive despite another member's failure. One correct member prevents EIFS, including an overheard member or DATA without an agreement. + +The recipient sends one Compressed Block Ack after SIFS for accepted aggregate DATA. Positive bits release only transmitted members. Missing bits retain the affected members for selective retry. A valid zero-bit response completes the response exchange without a probe. An absent or invalid response arms one explicit BAR probe before further DATA for that agreement. + +The probe is an INET recovery policy. It can expose lost recipient agreement state while fresh DATA remains queued. Probe submission consumes the pending flag. Probe failure returns to DATA retry without another probe until a later DATA attempt. Each probe adds airtime and channel access delay. + +A zero TXOP limit permits one aggregate DATA PPDU with its protection and response. Multiple-member aggregates must fit a positive limit. A singleton retry can use the applicable single-MPDU exception. The example at ``examples/wireless/htampdu`` provides scalar, dimensional, and zero-limit configurations. + +NIST and Yans supply cached per-range outcomes under scalar SNIR reduction. This abstraction does not model correlated FEC errors or interference changes within a member. Adaptive aggregate rates, HT40 transmit aggregation, VHT aggregates, and Multi-TID Block Ack remain outside this profile. These capabilities do not establish complete amendment conformance or throughput validation. + .. _ug:sec:80211:ack: Acknowledgement and retries @@ -1041,7 +1071,7 @@ The model does not contain: - PCF and HCCA, the polled channel access methods. The module :ned:`Hcca` exists as a placeholder. -- A-MPDU aggregation and self-CTS protection. +- HT40 transmit aggregation, VHT aggregates, and self-CTS protection. - Multi-TID block acknowledgement and delayed Compressed Block Ack. From d841dc77db7d0b141bf31e5e215a0de9bb281957 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Sun, 18 Oct 2026 02:29:59 +0200 Subject: [PATCH 33/41] plan: comment: record implicit Block Ack completion and evidence Before this commit, the plan records the proposed exchange and A1 status. It lacks the completed MAC evidence and the final verification boundaries. After this commit, the execution record maps A1 through A7 to their fixtures and results. It preserves failed attempts, disk-space recovery, the approved base exception, and the separate HT marker approval. Ordinary fingerprints pass. Graphical controls match the parent despite pre-existing baseline differences. The record states the interface, link, C++ analysis, and positive-RIFS limits. The user separately authorizes commit, push, and PR creation. A0 remains open, so the plan stays under pending. This publication does not change the validated source base or approve a merge. Change: plan | comment | - | ieee80211-implicit-blockack --- ...80211-ampdu-implicit-blockack-execution.md | 307 ++++++++++++++++++ ...ee80211-ampdu-implicit-blockack-summary.md | 14 +- .../ieee80211-ampdu-implicit-blockack.md | 16 +- 3 files changed, 329 insertions(+), 8 deletions(-) create mode 100644 plan/pending/ieee80211-ampdu-implicit-blockack-execution.md diff --git a/plan/pending/ieee80211-ampdu-implicit-blockack-execution.md b/plan/pending/ieee80211-ampdu-implicit-blockack-execution.md new file mode 100644 index 00000000000..740deb09c25 --- /dev/null +++ b/plan/pending/ieee80211-ampdu-implicit-blockack-execution.md @@ -0,0 +1,307 @@ +# Implicit Block Ack execution record + +Execution date: 2026-10-18. A1 through A7 are complete on the approved base, within the profile and verification limits below. The implementation evidence describes the source tree before commit. The user subsequently authorizes commit, push, and PR creation. A0 remains open because prerequisite merge confirmation is absent. + +## A2–A7 authorization and scope + +The user's request `Execute stages A2-A7` authorizes the remaining stages on this worktree after A1. This request extends implementation beyond the earlier A1-only exception. The base remains `56b75c959af104b5db931bef022bdfe5578eead9`, with the recorded A1 changes. The prerequisite merge status remains unverified. This execution preserves the separate `AGENTS.md` change. Commits, publication, and baseline changes require their own authority. + +The root agent owns production source changes. Separate read-only investigations trace transmit contracts and mandatory receive release. A test specialist owns the new A2 boundary fixture. The existing plan defines each stage's behavior and acceptance conditions. Stage completion requires the corresponding direct evidence. + +### A2 implementation contract + +Rx must reject a delivered PHY failure container before a standalone MAC header or trailer peek. The current guard checks only the decoded Aggregation property. A failed common header supplies no accepted Aggregation property. Rx will also check common header success and complete content from the typed PHY indication. This guard requires no range draw, shared chunk change, or new event. + +The existing real-radio fixture supplies copied long-GI and short-GI outcomes, all four decision parts, actual failure paths, and receive metadata. The new boundary fixture will prove refusal before the FCS predicate, including short malformed containers. Ordinary standalone reception retains its current path. A4 will add the separate aggregate entry and member validation. Source inspection and the seal registry validate this bounded contract before the edit. + +### A3 implementation contract + +The data service will prepare independent queued previews beside borrowed canonical members. The new HT policy will select one peer, transmitter, and TID within supplied window, byte, mode, and spacing limits. The existing Basic policy will retain its disabled behavior. HCF will reject aggregate opt-in with a rate-control submodule before DATA attempts. The new policy requires HT mixed format, 20 MHz, and long GI. + +Preparation will assign consecutive provisional numbers without a counter update. Batch validation will check every queued source before the first extraction. Commitment will reuse the existing extraction, region-tag, lifetime, and allocation owners for each new member. Canonical members retain their numbers and deadlines. The in-progress queue will expose eligible canonical members without extraction. HCF will supply retries before numbered unsent members, followed by queued candidates. + +Batch refusal will retain sources and sequence state. The preparation fixture will check this boundary through production queues and commitment. It will also check sequence wrap, independent deadlines, count and byte limits, and numbered unsent members. Existing collision recovery remains a single-frame path. A5 will connect this preparation to actual aggregate submission. The inspected owners, interface implementations, and unsealed paths validate this contract before source edits. + +### A5 implementation contract + +HCF will retain one prepared batch beside the canonical members in the in-progress queue. The frame sequence will use a distinct aggregate transmit step and an implicit Block Ack receive step. This distinction prevents an envelope from entry into ordinary MAC-header paths. Each batch will retain one actual DATA mode through size reduction, RTS prediction, admission, and submission. HCF will supply transmitted retries first, followed by numbered unsent members, each in cyclic sequence order. + +Tx will use its existing IFS timer for aggregate requests. At expiry, HCF will validate current agreement identity, member eligibility, deadlines, mode compatibility, and complete exchange cost. HCF will commit queued previews only after those checks. Tx will finalize each member before envelope construction. Actual submission will record every member's allocation index with the agreement owner. + +Cancellation will clear the Tx request before HCF deletes its exchange context. Refusal will produce no DATA attempt, DATA outcome, probe, or queue extraction. Zero IFS will use the same submission callback. Ordinary Tx callers will retain their current contract. No new timer or simulation event is necessary. + +The shared response selector will accept an actual eliciting mode instead of a fabricated BAR. Explicit and implicit Compressed responses will use the same legal non-HT rate rule. The recipient procedure will construct the bitmap directly from current receipt state. The implicit response will follow SIFS and use the aggregate's common Duration value. HCF will retain the existing receive-start timer and reception-completion mechanism. + +The acknowledgment owner will attach all submitted members to the implicit wait. A valid matched bitmap will complete one successful response exchange. Positive bits will acknowledge only transmitted members. Missing bits will retain retry eligibility and independent deadlines. A missing or invalid response will produce one contention failure and arm one pending probe on the current agreement. + +The BAR policy will select pending probes through existing EDCA classification. Submission will consume the probe flag. Refusal and member expiry will retain the flag until transfer completion or agreement retirement. Probe outcomes will produce no second DATA attempt or member outcome. Aggregate RTS failure will update contention once without member retry increments or disposal. + +The proposed exchange fixture uses production association, queues, radios, and both DATA hops through an AP. It will assert member FCS, shared wire fields, actual aggregate modes, matched responses, and upper-layer delivery. Its bounded matrix varies PHY representation, NIST/Yans, protection, and TXOP limit at seed zero. Separate focused cases must prove cancellation, partial receipt, failed responses, probe transitions, and recovery under continuous traffic. A build or healthy exchange cannot establish those failure paths. + +Current source inspection identifies each owner and its terminal paths. The WLAN sources remain outside the packet subsystem seal. The new exchange fixture exists but remains unrun. These facts validate the contract before the A5 production edit. A4 retains sole production write ownership until its stable handoff. + +### Required A5 scope correction + +The infrastructure fixture initially showed source aggregates but individual AP frames. DS forwarding copies the incoming transmitter address into its outgoing header. Tx replaces that address only at submission. The HT policy therefore refused the AP's queued candidates before that replacement. + +An initial correction assigned the local transmitter address in DS. Fingerprint comparison exposed an ordinary A-MSDU effect: its builder derives Address3 from that transmitter field. The correction therefore changed ordinary wire bytes. The final implementation removes the DS edit. + +Aggregate preparation now assigns the local transmitter address only to its independent queued preview. HCF supplies that address through the existing batch limits. Tx assigns the same address before FCS calculation. + +The queued source retains its identity, owner, header, sequence state, and deadline until commitment. Retained canonical members still face the existing transmitter check. This correction does not normalize a pre-existing numbered, unsent AP member with another transmitter address. Such a member can use standalone service. + +The preparation fixture adds a forwarded-source case. The infrastructure exchange checks aggregate transmission across both hops. Fresh fingerprint checks verify ordinary behavior after the DS edit disappears. + +### Required cyclic arithmetic correction + +The physical reorder fixture reaches sequence wrap with a two-slot window. The shared cyclic helper rejects an intermediate arithmetic value of minus one. Its operators already reject an unspecified source before that calculation. Thus, valid arithmetic such as `0 - 1` cannot return sequence 4095. Window advancement can fail through the same helper. + +The unsealed target is `mac/common/Ieee80211Defs.h`. The correction removes only the internal rejection of a valid arithmetic intermediate. Constructors and operators retain their checks for an unspecified sequence object. A new unit fixture will check every sequence against bounded positive and negative offsets. The real-radio wrap cases will verify receipt and reorder advancement. These facts validate the expanded contract before the edit. + +## A2–A7 result and verification scope + +HCF now transmits independent HT MPDUs in one PPDU after acceptance of a Compressed Block Ack agreement. Each member retains its sequence number, FCS, allocation index, lifetime, and retry state. The recipient validates correct members, updates receipt state, applies mandatory release, and returns one Compressed response after SIFS. The originator retries only unacknowledged members. + +For example, an aggregate can contain three members with sequence numbers 10, 11, and 12. If member 11 fails, the recipient records 10 and 12. The originator retains 11 with its original deadline. A later aggregate can combine that retry with new members. This example describes the implemented mechanism; the physical loss fixtures supply direct checks. + +The transmit policy supports HT mixed format, 20 MHz, one retained long-GI DATA mode, and fixed rates. The receiver also accepts advertised HT20 short-GI aggregates. Basic and disabled MPDU policies retain their historical behavior. Adaptive aggregate rates, HT40 transmit aggregation, VHT aggregates, Multi-TID Block Ack, and correlated FEC errors remain outside this profile. + +The originator marks one probe requirement after an unsuccessful implicit response. BAR selection checks that requirement before further DATA, subject to access-category ownership and legal admission. Actual BAR submission consumes the requirement. Probe failure returns to DATA retry without a second DATA outcome. A BAR received without an agreement uses the existing DELBA path. Continuous traffic can therefore retire a stale agreement without queue drain. + +### Required admission correction + +The example exposed a reservation endpoint beyond the positive TXOP deadline. At event 2845, the remaining reservation was 2.831966644 ms. The remaining TXOP was 2.831933288 ms. Fractional propagation delay and Duration encoding produced the 33.356 ns difference. The new preparation path bypassed the legacy admission guard against that condition. + +HCF now refuses the next prepared exchange when the reservation endpoint exceeds the deadline. The explicit initial singleton-overrun exception remains valid. Refusal occurs before queue commitment or a DATA attempt. The admission fixture adds a fractional-propagation case and an equal-endpoint control. The example retains its physical propagation delay. + +### Interface contracts + +The response-rate method and actual-submission callback are pure virtual interface declarations. Every in-tree implementation supplies a concrete override. DCF requires no submission transition, so its concrete callback does nothing. Custom rate selectors must implement implicit response selection or throw an explicit capability diagnostic. The migration guide lists these obligations. + +### Final campaign + +The final campaign uses the unchanged base and uncommitted source described above. Its artifacts reside in `out/verification/ampdu-a2-a7/`. This ignored directory retains logs across tool-session replacement. Earlier `/tmp/ampdu-*` logs became unavailable after such a replacement. Earlier results remain historical observations; the final campaign repeats the affected checks against the fresh library. + +Each runner first executes `source ./setenv -q`. Each runner uses `MAKEFLAGS=--jobserver-style=pipe MPLCONFIGDIR=/tmp/ampdu-matplotlib`. Debug compilation precedes all behavioral checks. The unit, module, and protocol commands below use serial fixture execution. Independent categories use separate generated directories. + +```sh +make MODE=debug -j8 +make MODE=release -j8 + +inet_run_unit_tests -m debug -f 'Ieee80211(Ampdu.*|SequenceNumberCyclic|BlockAck.*|CompressedBlockAck.*|ResponseTimeout|TxNavChoice|TxopProcedure|HtCapabilities|HtMgmtElements|HtModeSet|HtModeCache)_1\.test$' --no-concurrent + +inet_run_module_tests -m debug -f 'Ieee80211(Ampdu(Admission|Capabilities|Exchange|Preparation|Recovery|ResponseWindow|RxBoundary|TxStart|PhyReception)|CompressedBlockAck.*|BlockAck.*|Edca.*Lifetime.*|HtAssociation|MgmtStaSimplifiedInitialization|VhtHtSupport|HcfMultipleProtection|HcfSingleProtection|SingleProtectionGroup|Txnav)_1\.test$' --no-concurrent + +inet_run_module_tests -m debug -f 'Ieee80211AmpduReordering_1\.test$' --no-concurrent + +inet_run_protocol_tests -m debug -w '^tests/protocol/wifi$' -f '/(N_AmpduImplicitBa|N_Ampdu|N_BlockAck|Ac_BlockAck|Ac_BlockAckFallback)\.test$' --no-concurrent +``` + +The unit selection checks response validation, sequence wrap, batch construction, probe selection, and ordinary timing controls. The module selection checks production negotiation, physical reception, actual submission, admission, retry, stale-agreement recovery, and historical compatibility. The separate reorder campaign preserves its original 160 physical cases and adds 16 negative RIFS cases. Seed zero controls the feature fixtures except the PHY matrix, which defines seeds zero, one, and two. + +The real infrastructure exchange varies scalar and dimensional reception, NIST and Yans, single and multiple protection, and zero or positive TXOP limits. Its 16 main configurations require exactly 60 upper deliveries across both AP hops. Three additional cases force full, partial, or failed probe recovery with a healthy agreement. Fresh DATA remains queued at the probe. The fixture checks later DATA progress, original deadlines, retry order, mixed batches, and one outcome per submitted member. + +The admission matrix covers both bands, MCS 0/7, complete-PSDU RTS thresholds, spacing, fixed-mode reduction, and HT duration boundaries. It also checks positive-limit singleton overrun, zero-limit behavior, post-CTS cancellation, and new, retained, or mixed-batch RTS failure. RTS failures preserve member state without a DATA attempt. The final two cases check reservation overshoot and equality with actual propagation delay. + +The response-window fixture uses a real outstanding receive timer. A new aggregate overlaps the timeout. An addressed aggregate receives one response after SIFS; an overheard aggregate resolves the previous wait without a local response. Long and short GI cases use actual reception. The response uses non-HT 6 Mbps when BSS basic-rate state is unknown. + +The recovery fixture separately checks absent-agreement behavior. Continuous cases retain fresh queued DATA with inactivity values zero and 200 ms. They require BAR, recipient DELBA, agreement retirement, later ADDBA, and further aggregates. Finite cases lose the probes and require lifetime completion. These fixtures distinguish seeded agreements from the infrastructure fixture's production management exchange. + +The example provides scalar, dimensional, and zero-TXOP configurations. The user guide explains opt-in and recovery. The migration guide lists each changed extension role. WHATSNEW states the supported profile and its limits. These artifacts establish no throughput or complete-amendment conformance claim. + +The user separately approves removal of the historical `N_Ampdu.test` expected-failure marker on 2026-10-18. The final focused campaign proves aggregate observation, implicit response, and exactly 60 application deliveries before that removal. The VHT marker and stored fingerprints remain unchanged. No commit or publication forms part of this execution. + +### Corrected evidence boundaries + +The first protocol output check matched a test name without its verdict. Raw output showed a failed protocol assertion despite the runner's PASS. Shared INI defaults also preceded the intended traffic overrides. The corrected fixtures place their overrides first and require complete PASS records. + +UDP supplies the supported upper-delivery signal. The sink's actual finish counter independently proves application receipt. The deterministic zero-propagation fixture disables only the diagnostic for simultaneous transmission starts; the medium still models interference. + +An all-failed aggregate exposed an ownership warning. Rx retained ownership of the envelope after its method returned. MAC now takes the envelope and returned members before local disposal or HCF handoff. The strict reorder checker requires all 176 successful runs without warnings or errors. + +The first ownership build failed inside Clang with invalid-UTF-8 diagnostics for built-in definitions. The compiler failure's cause remains unknown. A retry with `CCACHE_DISABLE=1` compiled the same source successfully. Subsequent final source builds retain that setting. `debug-ownership-build.log` and `debug-ownership-build-retry.log` preserve both results. + +Positive RIFS remains unverified because a consistent supported configuration cannot reach it. HCF compares the physical gap plus the preceding signal extension with 2 microseconds. HT at 2.4 GHz adds a 6 microsecond extension. The `ac` mode admits HT at 5 GHz, but HCF excludes RIFS for that VHT mode set. The fixture preserves all reachable SIFS cases and adds 16 negative RIFS cases. It does not introduce a mixed, inconsistent mode configuration. + +### Mechanical checks and review + +Both scoped WLAN architecture checks pass. The changed-file NED/MSG naming check passes. The source-seal check passes without a sealed source edit. The document-seal index remains consistent. The separate `AGENTS.md` change remains outside this feature work. The final preservation check uses its recorded SHA-256. + +The interface checker exits 1 for two unchanged bodies in `IFrameSequence.h`. `AV-CONTRACT-02` records these as open deviations in `doc/project/audit/architecture-exceptions.md`. The new interface methods contain no default bodies. Independent review confirms that each in-tree implementation supplies its required override. These facts do not imply a clean project-wide interface gate. + +The complete document-link check reports 163 broken links to absent standards files in unchanged documents. The scoped check uses the canonical checker with an explicit inventory of four changed Markdown documents. It reports zero broken links. The C++ checker cannot run because this build supplies no `compile_commands.json`; it exits 2. Independent source review and debug/release compilation remain separate evidence. No C++ checker pass follows from them. + +The final narrow source review resolves the preview address, ownership, interface, and protocol-observation defects. The earlier integrated review covers response windows, singleton overrun, probe counters, and cyclic sequence arithmetic. Neither review supplies runtime evidence by itself. No new production-source finding remains open in those review scopes. + +The artifacts use these names: + +| Check | Result | Artifact under `out/verification/ampdu-a2-a7/` | +| --- | --- | --- | +| Final debug compilation. | Exit 0. | `debug-preview-build.log` | +| Final release compilation. | Exit 0. | `release-final-build.log` | +| Unit campaign. | 17 fixtures pass. | `units.log` | +| Module campaign. | 45 fixtures pass. | `modules.log` | +| Final preview and infrastructure exchange. | Both fixtures pass; preparation includes 12 cases and two AARF rejection controls. | `preview-integration.log` | +| Physical reorder and history. | 176 runs pass without warnings or errors. | `reordering-final176.log`, `.out`, and `.err` | +| Focused Wi-Fi protocol campaign. | All five fixtures pass before marker removal. | `protocol-final-focused.log` | +| Complete Wi-Fi inventory after setup recovery. | 77 distinct fixtures: 48 passes and 29 expected failures. No unresolved error or unexpected runtime failure remains. | `protocol-combined-results.json`, `protocol-full.log`, `protocol-space-retry.log`, `protocol-matcher-retry.log` | +| Ordinary fingerprints. | All 23 configurations pass; exit 0. | `fingerprints-final.log`, `fingerprints-final-raw.log` | +| Graphical fingerprints. | All 20 match the parent; 18 stored expectations differ on both revisions. The runner exits 1. | `fingerprints-final-tyf.log`, `final-tyf-parent-comparison.json` | +| Three example configurations. | All reach the simulation limit without error. | `example-final-General.log`, `example-final-ZeroTxop.log`, `example-final-Dimensional.log` | +| MAC and PHY architecture. | Both pass. | `architecture-mac.log`, `architecture-phy.log` | +| Changed-file names and source seals. | Both pass. | `naming-diff.log`, `source-seals.log` | +| Document seals and scoped links. | Both pass. | `document-seals.log`, `document-links-scoped.log` | +| Interface checker. | Two known, unchanged deviations; exit 1. | `interfaces.log` | +| Complete document links. | 163 pre-existing missing standards links; exit 1. | `document-links.log` | +| C++ checker. | No compilation database; no analysis; exit 2. | `cpp.log` | + +The module campaign spans the final corrections. The final preview and exchange rerun replaces its earlier evidence for the changed preparation path. The strict reorder run replaces the earlier run with an ownership warning. Other affected fixtures use the fresh library after their relevant source correction. The final protocol and fingerprint campaigns start after the last production edit. + +### Final regression campaigns + +The focused protocol campaign passes all five fixtures. The corrected implicit fixture runs both normal receipt and deterministic partial loss. Each run requires 60 UDP deliveries, 60 sink receipts, and its complete protocol PASS record. The historical HT fixture retains aggregate observation and adds receipt completion. The approved marker removal applies only to that HT fixture. The complete Wi-Fi campaign uses this command: + +```sh +inet_run_protocol_tests -m debug -w '^tests/protocol/wifi$' --no-concurrent +``` + +The full campaign selects 77 test files. Its log is `protocol-full.log`. Existing expected failures remain explicit. The runner's preview mode previously raised a selection error before any simulation. That preview supplies no executed-test evidence. The actual campaign supplies the executed inventory. + +The full invocation reports 40 passes, 22 expected failures, and 15 setup errors after filesystem exhaustion. Its log also shows a matcher write error for `Ac_MultiTidBa`. Thus only 61 fixtures supply complete observations before recovery: 40 passes and 21 expected failures. The invocation exits 1. No unexpected runtime failure precedes that setup failure. The HT marker metadata still reflects its earlier declaration in that invocation; its observed PASS remains valid. + +The recovery removes duplicate generated matcher output and compresses raw simulation logs without source changes. Compressed logs remain beside their original paths as `test.out.gz`. This action restores 4.7 GiB of free space. A filtered retry selects the 15 setup failures and the approved HT marker control. It reports nine passes and seven expected failures, with exit 0. Its log is `protocol-space-retry.log`. + +A separate `Ac_MultiTidBa` retry resolves the matcher write error. Its log is `protocol-matcher-retry.log`. The original full-invocation errors remain visible in the record. These filtered retries replace incomplete evidence; they do not change source or expectations. + +The matcher retry reports its expected failure and exits 1 under the runner's all-failure aggregation rule. The final combined inventory contains all 77 distinct fixtures: 48 passes and 29 expected failures. Every final observation matches its current declared expectation. `protocol-combined-results.json` identifies the authoritative artifact for each fixture. No unresolved setup error or unexpected runtime failure remains. This result combines the full invocation with the bounded retries; it is not a single successful full-suite invocation. + +```sh +inet_run_protocol_tests -m debug -w '^tests/protocol/wifi$' -f '/(Ac_LdpcStbcCap|Ac_Ldpc|Ac_4ss|Ac_OpModeNotification|Ac_PhyMode|Ac_MuMimo|Ac_VhtIe|Ac_Ampdu|Ac_256qam|Legacy_RtsCts|Legacy_PhyMode|Legacy_DataAck|Legacy_Pcf|Legacy_Fragmentation|Legacy_Nav|N_Ampdu)\.test$' --no-concurrent +inet_run_protocol_tests -m debug -w '^tests/protocol/wifi$' -f '/Ac_MultiTidBa\.test$' --no-concurrent +``` + +The ordinary fingerprint campaign passes all 23 selected configurations without an expectation change. It uses the final debug library and these exact commands from the repository root: + +```sh +cd tests/fingerprint +PYTHONUNBUFFERED=1 ./fingerprinttest -d -t 4 -m '(showcases/wireless/(blockack|aggregation|fragmentation|qos|txop)|examples/(wireless/qos|adhoc/qos))' -f 'tplx' -f '~tNl' -f '~tND' +``` + +`fingerprints-final.log` records the 23 passes and exit 0. `fingerprints-final-raw.log` preserves the exact simulator commands and output. The CSV rows define configurations and limits. The scalar attributes record seed sets zero and one. The passing byte fingerprints replace the earlier four differences from the removed DS edit. + +Graphical fingerprints use a separate campaign with the same selector and `-f 'tyf'`. The legacy wrapper supplies fake-GUI probability 0.001. Parent controls use that same value. The newer Python API's probability 0.1 would define different inputs. These checks do not establish visual rendering correctness. + +The parent control uses revision `56b75c959af104b5db931bef022bdfe5578eead9` and its existing debug library. No parent production source is newer than that library. The control uses the same current NED inputs, commands, configurations, and seeds as the feature. It changes no parent file. `fingerprint-control/README.md` states the library hashes and input identities. The control covers all 20 graphical configurations separately. + +The final graphical campaign records two baseline passes and 18 baseline mismatches; its runner exits 1. Every final actual value equals its corresponding parent value. `compare-final-tyf.py` verifies all 20 rows against the isolated parent results. Its output is `final-tyf-parent-comparison.log`; its detailed rows are `final-tyf-parent-comparison.json`. This comparison establishes no new graphical fingerprint change under the recorded inputs. It does not repair the pre-existing baseline differences. + +### Stage closure + +| Stage | Closure evidence | +| --- | --- | +| A2. | PHY refusal stops before standalone MAC/FCS peeks. The physical matrix retains all 468 runs and copied outcome checks. | +| A3. | Twelve preparation cases and two AARF rejection controls prove refusal, commitment, retained members, limits, and forwarded previews. | +| A4. | All 176 physical reorder/history cases pass without warnings or errors. They cover reachable mandatory release and the recorded negative RIFS boundary. | +| A5. | Admission passes 57 runs. Actual-start and response-window fixtures pass. Infrastructure exchanges verify computed member FCS, implicit responses, selective retry, and probe policy. | +| A6. | Production management establishes both AP hops. Healthy and absent-agreement recovery pass. Historical module controls and the complete protocol inventory retain their declared outcomes. | +| A7. | The example, user guide, migration guide, release note, and execution records exist. Debug/release compilation, ordinary fingerprints, and parent graphical comparisons complete the declared verification. | + +The known interface deviations, absent C++ compilation database, missing standards links, and positive-RIFS coverage limit remain explicit above. No publication gate receives an inferred pass. The plan remains under `pending` because A0 is open. The approved execution exception closes A1–A7 on this base. The later publication request authorizes commit, push, and PR creation. Merge approval remains separate. + +## A1 scope and authorization + +The user authorizes A1 on base `56b75c959af104b5db931bef022bdfe5578eead9` before the prerequisite PRs merge. This exception applies to A1 only. The active branch is `work/ieee80211-ampdu-implicit-blockack-a1-a7`. The [feature plan](ieee80211-ampdu-implicit-blockack.md) defines A1. The [PHY execution record](ieee80211-ampdu-phy-execution.md) supplies the prerequisite evidence. + +GitHub queries failed, so this execution does not confirm merge status. No commit, push, or baseline change forms part of this task. + +## Validated implementation contract + +The MIB owns local HT capabilities and negotiated receiver limits. Before A1, management conversion omitted minimum MPDU start spacing. The serializer already preserved its encoded bits. A1 adds the encoded value to both capability directions and management conversion. Existing peer removal removes the complete capability state. The default remains zero. + +The aggregate builder owns delimiter insertion, alignment, and content references. Before A1, its region-tag destination preceded the member content. A1 corrects that offset and uses the source Packet's front offset. A new construction API retains the source Packets on success and refusal. The existing consuming API retains its ownership contract. No queue, sequence, lifetime, retry, or acknowledgment state changes through construction. + +The HT mode owns the conversion from receiver spacing to octet distance. It also owns the L-SIG length and PPDU duration checks. The builder uses these calculations with the supplied peer byte limit. It adds zero-length delimiters between members when alignment alone cannot satisfy spacing. The final member has no alignment padding or extra delimiter. + +Empty batches and size-limit violations produce refusal before allocation or source disposal. Invalid API parameters produce an error. + +For example, two 30-octet members at 65 Mbps with encoded spacing 7 require 130 octets between their starts. Alignment and zero-length delimiters increase that distance to 132 octets. The builder retains both source Packets. The resulting aggregate ends immediately after the second member. + +The focused checks cover all spacing encodings and exponents, asymmetric negotiation, management bytes, and cleanup. Existing full and simplified association fixtures verify their production paths. New construction checks cover alignment, zero-length delimiters, byte limits, source retention, region tags, and singleton identity. The existing PHY wire fixture owns HT-SIG golden bytes and independent decode. The PHY reception fixture owns error-model compatibility. These checks do not establish aggregate selection or implicit responses, which belong to later stages. + +Source inspection confirms one implementation of the aggregate interface. No target falls under the packet subsystem seal. The contract passes the pre-write checks. The implementation adds no event, timer, callback, retained protocol state, or lifecycle operation. + +## Result and limits + +The MIB and management preserve the receiver spacing value in both directions. The new aggregate API retains source Packets and refuses excessive member, PSDU, peer, or duration values. The builder copies region tags to member content positions. HT modes supply octet distance, L-SIG length, and separate duration predicates. No HT-SIG field, serializer, or bounded parser required a change; A1 consumes the implemented P1 representation. + +The new construction fixture checks MCS 0 and 7, four alignment residues, and all eight spacing encodings. It checks the 65535-octet PSDU boundary at MCS 15, where airtime permits that length. This calculation test does not expand the feature's transmit profile. It separately checks the 4095-octet member boundary and source retention after refusal. Deaggregation restores each member's region-tag offsets. Fresh bytes preserve singleton HT-SIG identity. + +The capability fixture checks all 32 combinations of length exponent and spacing through production simplified management. It passes the negotiated transmit limits to the builder. Existing fixtures check asymmetric values through full association and simplified restart, shutdown, and crash. Peer cleanup removes the complete old state. The PHY reception fixture retains its absent-role, incomplete-coverage, absent-model, and compatible-model checks. + +A1 adds no aggregate selection, DATA commitment, implicit response, or selective retry. The existing disabled invocation and default aggregate policy remain in place. A3 owns the production selection of members. Later stages retain their MAC reception and exchange requirements. No fingerprint, performance, or complete feature claim follows from these checks. Release compilation and publication gates remain outside this task. + +## Verification + +All commands ran from the active checkout. Builds use debug mode. Each test command first uses `source ./setenv -q`. This selects the active checkout instead of the inherited parent environment. Each runner also uses the environment assignments below: + +```sh +MAKEFLAGS=--jobserver-style=pipe MPLCONFIGDIR=/tmp/a1-matplotlib +``` + +The assignments precede each runner command on the same shell line. They select pipe-based make coordination and a writable Matplotlib directory. The initial inherited environment caused a read-only filesystem error before any test ran. The corrected environment resolved that setup error. + +| Check | Exact command after the environment setup | Result and artifact | +| --- | --- | --- | +| Base library before source edits. | `make MODE=debug -j8` | Exit 0; `/tmp/a1-build-base.log`. | +| Base unit controls. | `inet_run_unit_tests -m debug -f 'Ieee80211(HtCapabilities\|HtMgmtElements\|AmpduWire\|CompressedBlockAckRecord)_1\.test$' --no-concurrent` | Four fixtures pass, exit 0; `/tmp/a1-base-unit.log`. | +| Base ordinary PHY and Normal Ack controls. | `inet_run_module_tests -m debug -f 'Ieee80211(VhtHtSupport\|CompressedBlockAckMigration)_1\.test$' --no-concurrent` | Two fixtures pass across 13 runs, exit 0; `/tmp/a1-base-module.log`. | +| A1 library. | `make MODE=debug -j8` | Exit 0; `/tmp/a1-build.log`. | +| Unit selection. | `inet_run_unit_tests -m debug -f 'Ieee80211(AmpduCapabilityEncoding\|AmpduConstruction\|AmpduWire\|MpduDelimiterWire\|MpduSubframeHeaderSerializer\|HtCapabilities\|HtMgmtElements\|HtModeSet\|HtModeCache\|CompressedBlockAckRecord)_1\.test$' --no-concurrent` | Eight existing fixtures pass. Two new fixtures require test corrections; exit 1. `/tmp/a1-unit.log`. | +| Corrected new unit fixtures. | `inet_run_unit_tests -m debug -f 'Ieee80211Ampdu(CapabilityEncoding\|Construction)_1\.test$' --no-concurrent` | Both fixtures pass, exit 0; `/tmp/a1-new-unit.log`. | +| Module selection. | `inet_run_module_tests -m debug -f 'Ieee80211(AmpduCapabilities\|HtAssociation\|MgmtStaSimplifiedInitialization\|VhtHtSupport\|CompressedBlockAckMigration\|BlockAckAssociationReset\|CompressedBlockAckExchange)_1\.test$' --no-concurrent` | Six existing fixtures pass across 47 runs. The new fixture requires a test correction; exit 1. `/tmp/a1-module.log`. | +| Corrected capability fixture and PHY controls. | `inet_run_module_tests -m debug -f 'Ieee80211Ampdu(Capabilities\|PhyReception)_1\.test$' --no-concurrent` | Both fixtures pass, exit 0; `/tmp/a1-capabilities-phy.log`. Capability coverage uses 32 runs with seed 0. PHY coverage uses 468 defined configurations with its seeds 0, 1, and 2. | + +The new unit fixtures required an explicit Packet include and a valid HT factory call. The new module fixture required an explicit global class name. Its first corrected run completed all 32 simulations but lacked the required output marker. A direct completion message resolved that fixture failure. `/tmp/a1-capabilities-module.log` records the intermediate marker failure. Production source remained unchanged through these test corrections. + +The final evidence covers ten distinct unit fixtures and eight distinct module fixtures. No final fixture retains an unexpected failure. The table preserves earlier runner failures rather than treating their aggregate exit status as success. The source base has no production diff before the base build; `/tmp/a1-base-source-diff.log` records that check. + +Module fixtures use configuration `General`. All module runs use seed 0 except the PHY fixture, which explicitly varies seeds 0, 1, and 2. The exact run ranges are: + +| Fixture | Runs | +| --- | --- | +| `Ieee80211VhtHtSupport_1.test` | 0–6 | +| `Ieee80211CompressedBlockAckMigration_1.test` | 0–5 | +| `Ieee80211CompressedBlockAckExchange_1.test` | 0–15 | +| `Ieee80211BlockAckAssociationReset_1.test` | 0–15 | +| `Ieee80211HtAssociation_1.test` | 0 | +| `Ieee80211MgmtStaSimplifiedInitialization_1.test` | 0 | +| `Ieee80211AmpduCapabilities_1.test` | 0–31 | +| `Ieee80211AmpduPhyReception_1.test` | 0–467 | + +Both scoped architecture commands pass with exit 0: + +```sh +doc/project/enforcement/check-architecture.sh src/inet/linklayer/ieee80211 +doc/project/enforcement/check-architecture.sh src/inet/physicallayer/wireless/ieee80211 +``` + +Their logs are `/tmp/a1-architecture-mac.log` and `/tmp/a1-architecture-phy.log`. `doc/project/enforcement/check-source-seals.sh --diff` passes with exit 0. Its log is `/tmp/a1-source-seals.log`. `python3 doc/project/enforcement/check-ned-msg-naming.py --diff --scope src/inet/linklayer/ieee80211` passes with exit 0. Its log is `/tmp/a1-naming-diff.log`. + +The complete WLAN naming scan uses `doc/project/enforcement/check-naming.sh src/inet/linklayer/ieee80211`. It exits 1 with 32 candidates, all in unchanged source files. `/tmp/a1-naming.log` preserves that result. This task introduces no candidate in that scan. The execution does not claim that the complete subtree satisfies every naming rule. + +The self-audit confirms the interface implementation, ownership paths, source offsets, byte limits, and mode calculations against the validated contract. No implementation scope expansion occurred. `git diff --check` passes. A byte comparison confirms preservation of the separate `AGENTS.md` change. + +## Standard evidence + +The implementation uses normative IEEE Std 802.11-2024 requirements. The corpus supplies these canonical nodes: + +| Requirement | Canonical node | Physical PDF pages | +| --- | --- | --- | +| Receiver length and spacing encodings. | `ieee80211-2024:table:9-225` | 1126 | +| Octet distance and zero-length delimiters. | `ieee80211-2024:clause:10.12.3` | 1977–1979 | +| Mixed-format L-SIG length calculation. | `ieee80211-2024:clause:10.27.4` | 2091–2092 | +| HT PSDU limit, PPDU time limit, and signal extension. | `ieee80211-2024:table:19-25` | 3493–3494 | + +The corpus required a rebuild for its current format. Its linter reports 76 ambiguous headings and 425 unresolved references across the corpus. Exact node retrieval identifies the requirements above. The spacing clause resolves its reference to Table 9-225 through exact table retrieval. + +PDF inspection confirms the ceiling operators in Equation (10-17) on physical page 2091. The image is `/tmp/a1-duration-standard.png`. The raw retrieval and lint artifacts use the `/tmp/a1-` prefix. diff --git a/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md b/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md index 39d36d79585..fac32f5f6fc 100644 --- a/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md +++ b/plan/pending/ieee80211-ampdu-implicit-blockack-summary.md @@ -4,13 +4,17 @@ This plan proposes several independently acknowledged MPDUs in one HT transmission. The recipient sends one Compressed Block Ack after the transmission ends. The aggregate requests that response without a separate BAR. The originator retries only the MPDUs that remain unacknowledged. -This summary describes revision 12 of the [feature plan](ieee80211-ampdu-implicit-blockack.md) and revision 11 of the [PHY plan](ieee80211-ampdu-phy-reception.md), dated 2026-10-17. Their source reference is branch `work/compressed-blockack-s5` at `4fa5cc0de15ee57388bcb3f20e866cab5972a670`. The feature remains proposed. The diagrams describe the design, not executed simulation traces. +This summary describes revision 12 of the [feature plan](ieee80211-ampdu-implicit-blockack.md) and revision 11 of the [PHY plan](ieee80211-ampdu-phy-reception.md), dated 2026-10-17. Their design reference is branch `work/compressed-blockack-s5` at `4fa5cc0de15ee57388bcb3f20e866cab5972a670`. The diagrams describe the design, not executed simulation traces. + +Execution status, 2026-10-18: the user authorizes A1 through A7 on base `56b75c959af104b5db931bef022bdfe5578eead9` before prerequisite merge confirmation. Those stages are complete within the declared profile and verification limits. The user subsequently authorizes commit, push, and PR creation. The [execution record](ieee80211-ampdu-implicit-blockack-execution.md) supplies current evidence and limits. + +A0 remains open. Expected-result changes, commits, and publication require separate authority. The user separately approves removal of the historical HT aggregate test marker after its focused pass. The PHY plan supplies aggregate reception before the MAC feature uses it. Its first gate proves deterministic member outcomes and includes the shared NIST/Yans implementation. It also preserves default HT operation and reception without an error model. Its second gate extends the NIST/Yans and compatibility evidence. The MAC feature can reach deterministic integration between those gates. -Execution status, 2026-10-17: PHY P0 through P4 and gates D1 and D2 are complete under the user's approved merge exception. The [execution record](ieee80211-ampdu-phy-execution.md) states the checks and limits. P3 verifies NIST/Yans range probabilities and seeded outcomes. P4 compares 576 ordinary reception records with the pinned parent. All records match exactly. MAC aggregate receipt and implicit Block Ack remain pending. +Execution status, 2026-10-17: PHY P0 through P4 and gates D1 and D2 are complete under the user's approved merge exception. The [PHY execution record](ieee80211-ampdu-phy-execution.md) states the checks and limits. P3 verifies NIST/Yans range probabilities and seeded outcomes. P4 compares 576 ordinary reception records with the pinned parent. All records match exactly. The MAC execution above adds aggregate receipt and implicit Block Ack. -Implementation waits for merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). Read-only source checks can occur now. Both plans require a refreshed merged base before source implementation. This is the agreed delivery policy for one shared S5 baseline. +Without the recorded exception, implementation waits for merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). Both plans normally require a refreshed merged base before source implementation. The exception above permits this execution on the approved S5 base. ## What changes after S5 @@ -335,7 +339,9 @@ flowchart TD D2 --> A7 ``` -The two plans now contain ten fixtures across unit, module, and protocol tests. The PHY plan owns three implemented fixtures; the feature plan owns seven proposed fixtures. P4 adds the parent-compatible ordinary reception fixture. The complete feature still needs source ownership, reorder release, exchanges, recovery, timing, and production negotiation checks. Current Basic, explicit Compressed, lifetime, reset, and disabled-feature checks provide regression coverage. Compatible configurations with disabled transmit aggregation must preserve current frame sequences and random draws. [Verification methods](ieee80211-ampdu-implicit-blockack.md#7-verification-methods-and-expected-results). +The implementation supplies the planned module and protocol fixtures. Additional fixtures isolate PHY refusal, actual submission, response-window recovery, response validation, capability encoding, construction, and cyclic sequence arithmetic. The [execution record](ieee80211-ampdu-implicit-blockack-execution.md) maps these checks to their boundaries. The PHY plan also retains its ordinary reception comparison with the parent. + +Basic, explicit Compressed, lifetime, reset, and disabled-feature checks provide regression controls. Physical fixtures check reorder release, exchanges, recovery, timing, and production negotiation. Compatible configurations with disabled transmit aggregation must preserve current frame sequences and random draws. [Verification methods](ieee80211-ampdu-implicit-blockack.md#7-verification-methods-and-expected-results). Direct exchange assertions must prove one DATA PPDU, one response after SIFS, correct receipt bits, selective retry, and exactly-once upper delivery. Physical reception tests must produce the partial results through the real receiver. An injected bitmap cannot prove that PHY integration. Fingerprints can detect a changed trajectory; they cannot replace these assertions. diff --git a/plan/pending/ieee80211-ampdu-implicit-blockack.md b/plan/pending/ieee80211-ampdu-implicit-blockack.md index 2a95af3b58f..fac347ce63f 100644 --- a/plan/pending/ieee80211-ampdu-implicit-blockack.md +++ b/plan/pending/ieee80211-ampdu-implicit-blockack.md @@ -8,9 +8,13 @@ Plan revision: 12, 2026-10-17. The user's `proceed, including the optional simpl The project plan procedure remains a draft; this document uses its structure without an additional approval requirement. +A1 is complete on the separately approved base `56b75c959af104b5db931bef022bdfe5578eead9`. The user authorizes A1 before the prerequisite merges on 2026-10-18. The later request `Execute stages A2-A7` extends that authority on the same base. A2 through A7 are complete within the recorded profile and verification limits. The user subsequently authorizes commit, push, and PR creation. + +The [execution record](ieee80211-ampdu-implicit-blockack-execution.md) states the changes, evidence, and limits. This exception does not close A0. Expected-result changes, commits, and publication retain their separate authority requirements. + This feature plan consumes the [PHY prerequisite plan](ieee80211-ampdu-phy-reception.md). That plan owns aggregate representation, bounded delimiter parsing, cached partial reception, and error-model integration. This plan owns member selection, MAC reception, mandatory release, implicit responses, and recovery. -Implementation waits for merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). The assessment on 2026-10-16 confirmed all three as open. Read-only A0 checks can occur before merge. A0 cannot close until the merged dependency chain and refreshed implementation base exist. +Implementation normally waits for merged PRs [#1343](https://github.com/inet-framework/inet/pull/1343), [#1344](https://github.com/inet-framework/inet/pull/1344), and [#1345](https://github.com/inet-framework/inet/pull/1345). The assessment on 2026-10-16 confirmed all three as open. The exception above permits A1 through A7 on the approved base. Read-only A0 checks can occur before merge. A0 cannot close until the merged dependency chain and refreshed implementation base exist. The [delivery table](#6-implementation-steps-and-dependencies) identifies the stages and their prerequisites. The [fixture table](#7-verification-methods-and-expected-results) identifies acceptance evidence. Detailed standards and execution commands remain in the appendices. @@ -391,7 +395,7 @@ The proposed transmit configuration is: **.mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy" ``` -`HtMpduAggregationPolicy` does not exist yet. The fixed rate above selects HT MCS 0 with one spatial stream under the required HT20 long-GI configuration. These settings also require compatible modes, usable peer HT state, and accepted agreements. The example must configure those conditions explicitly. The initial policy adds no local count or byte cap. It derives those limits from the agreement, peer, and PHY. +`HtMpduAggregationPolicy` implements this opt-in profile. The fixed rate above selects HT MCS 0 with one spatial stream under the required HT20 long-GI configuration. These settings also require compatible modes, usable peer HT state, and accepted agreements. The example configures those conditions explicitly. The initial policy adds no local count or byte cap. It derives those limits from the agreement, peer, and PHY. Custom data services, MPDU policies, Tx/Rx modules, response policies, and response-rate selectors can need interface updates. The migration guide must list each changed method and distinguish unsupported capability from an empty valid result. It must cover aggregate start, cancellation, member finalization, and the complete receive outcome. The DATA rate-control API remains unchanged; aggregate transmit opt-in requires its HCF submodule to be absent. Current `BasicMpduAggregationPolicy` configurations retain their rate-control behavior. The PHY plan owns error-model migration and preserves operation without an error model. @@ -424,11 +428,13 @@ A1 and A3 can supply reviewed preparation changes before the complete feature ex ### Proposed direct checks -The seven fixtures below belong to this feature plan and remain proposed. The [PHY plan](ieee80211-ampdu-phy-reception.md#7-verification-methods-and-expected-results) owns three implemented fixtures: `Ieee80211AmpduWire_1.test`, `Ieee80211AmpduPhyReception_1.test`, and `Ieee80211AmpduPhyCompatibility_1.test`. P4 adds the third fixture for parent-compatible ordinary reception comparisons. The combined inventory is ten. The [PHY execution record](ieee80211-ampdu-phy-execution.md) states the completed PHY evidence and its limits. That evidence does not establish MAC feature completion. +The seven fixtures below belong to this feature plan. A1 implements `Ieee80211AmpduCapabilities_1.test` with the existing association and PHY controls. The other six fixtures remain proposed. A1 also adds the unit fixtures `Ieee80211AmpduCapabilityEncoding_1.test` and `Ieee80211AmpduConstruction_1.test`. The [A1 execution record](ieee80211-ampdu-implicit-blockack-execution.md) states their coverage and limits. + +The [PHY plan](ieee80211-ampdu-phy-reception.md#7-verification-methods-and-expected-results) owns three implemented fixtures: `Ieee80211AmpduWire_1.test`, `Ieee80211AmpduPhyReception_1.test`, and `Ieee80211AmpduPhyCompatibility_1.test`. P4 adds the third fixture for parent-compatible ordinary reception comparisons. The combined inventory is twelve. The [PHY execution record](ieee80211-ampdu-phy-execution.md) states the completed PHY evidence and its limits. That evidence does not establish MAC feature completion. Fixed causal cases use seed 0. Injected agreements or deterministic error models establish only the stated boundary. Infrastructure cases separately prove production negotiation. [Appendix B](#appendix-b-verification-commands-and-campaigns) contains commands, campaign bounds, and evidence requirements. -| Proposed fixture and category | Trigger and production boundary | Required observation | +| Fixture and category | Trigger and production boundary | Required observation | | --- | --- | --- | | `Ieee80211AmpduCapabilities_1.test`, module. | Full and simplified management with asymmetric receive limits. Include an absent aggregate role, a role without advertised short-GI support, and an absent error model. Use exact MAC inputs with a one-antenna limit and catalog modes outside that limit. | Exponents 0–3 and spacing values 0–7 reach the correct directional consumer; reset removes old peer limits. Absent roles fail before advertisement; incomplete coverage fails before the MIB changes local HT capability. Unsupported unadvertised modes do not cause rejection. An absent model retains valid HT initialization and negotiation. Compatible models retain advertised HT20 short-GI support. | | `Ieee80211AmpduPreparation_1.test`, module. | Production queues, HT policy, fixed DATA rates, batch preparation, and commitment. Include internal collision survivors and aggregate transmit opt-in with AARF. | Source identities, sequence wrap, independent deadlines, count/window/byte limits, and refusal before extraction. Numbered, unsent members keep their allocation and first-DATA Retry value. Internal collision terminal disposal still affects its selected frame only. Batch reduction retains one rate decision. AARF fails initialization with and without fixed-rate overrides. | @@ -464,6 +470,8 @@ A6 must also prove DATA progress for a healthy agreement under deterministic res ### Evidence status +The paragraphs below record the plan review on 2026-10-17. The [A1 execution record](ieee80211-ampdu-implicit-blockack-execution.md) supplies the later implementation and test evidence on its approved base. A1 completion does not establish the later MAC stages. + The source assessment checked the commented invocation, error-model APIs, mandatory release text, HT duration table, and prerequisite PR state. These are source and standards observations. No INET build, module test, protocol test, or simulation ran for this revision. Document checks cannot establish PHY or MAC behavior. All 144 local links resolve across the three documents. Changed prose passed sentence-length and paragraph checks. Hash checks confirmed preservation of the seven unrelated local files. These checks establish document properties only. From f4d63d184087c904d745d9fe6a15305fdcec41ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 09:15:16 +0000 Subject: [PATCH 34/41] tests: change: match graphical baselines to the dependency build Before this commit, twenty graphical expectations differ from the unchanged dependency build under OMNeT++ 6.4.0aipre2. Each corresponding event, communication, and packet-data fingerprint still matches. After this commit, only those tyf expectations match the measured dependency values. The twenty-five selected rows retain their original non-graphical expectations. The dependency and C3 produce identical values for every selected row. The graphical drift predates this topic; its earlier cause is unknown. This commit changes no simulation source. The user explicitly authorized fingerprint updates on 2026-10-19. Each line below names one inherited graphical update: - /showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0: f985-34fb/tyf -> 74c3-9ba0/tyf. - /showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0: 27f2-4a52/tyf -> cb71-81f8/tyf. - /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0: 335d-6687/tyf -> e394-4985/tyf. - /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0: 6f6e-b101/tyf -> 77f4-58c1/tyf. - /showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0: 95cc-1859/tyf -> 6cdd-e65e/tyf. - /examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation: 33b7-00f9/tyf -> 97f7-655d/tyf. - /showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0: bd88-5ba6/tyf -> c99f-3188/tyf. - /examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0: dfcf-4644/tyf -> 24e0-2e48/tyf. - /examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0: f37f-cd48/tyf -> 3edc-eb8d/tyf. - /showcases/wireless/txop/ -f omnetpp.ini -c General -r 0: c87d-3f3a/tyf -> 6175-eb06/tyf. - /showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0: 093e-1ca4/tyf -> 34ac-bc95/tyf. - /showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0: bda9-15d1/tyf -> 64d2-47e3/tyf. - /examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation: df04-18f7/tyf -> 734c-15d1/tyf. - /examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0: 6097-a429/tyf -> b802-9992/tyf. - /examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0: 9f3c-4512/tyf -> b06a-f098/tyf. - /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0: 2c1e-66e5/tyf -> f74f-a0c0/tyf. - /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1: a587-3a4d/tyf -> 57c2-84bd/tyf. - /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0: a4c3-19bf/tyf -> 57cd-2e76/tyf. - /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0: b2d6-1329/tyf -> 8cb9-109e/tyf. - /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0: 08b5-d005/tyf -> 0db4-29ea/tyf. The debug wrapper selects the aggregation, Block Ack, fragmentation, QoS, TXOP, and MAC control directories. The publication record contains its exact filter and results. Later source commits own their additional trajectory changes. Change: tests.fingerprint | behavior.change | - | txop-admission-remaining --- tests/fingerprint/examples.csv | 22 +++++++++++----------- tests/fingerprint/showcases.csv | 18 +++++++++--------- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/tests/fingerprint/examples.csv b/tests/fingerprint/examples.csv index 175356337e3..611e703a853 100644 --- a/tests/fingerprint/examples.csv +++ b/tests/fingerprint/examples.csv @@ -6,10 +6,10 @@ /examples/adhoc/ieee80211/, -f omnetpp.ini -c Ping1 -r 0, 1000s, 8668-d4e7/tplx;e2b1-205b/~tNl;4083-075c/~tND;e1f1-f93c/tyf, PASS, wireless adhoc Ipv4 # /examples/adhoc/ieee80211/, -f omnetpp.ini -c Ping2 -r 0, 100s, 0000-0000/tplx;0000-0000/~tNl;0000-0000/~tND, ERROR, wireless adhoc # [Config Ping2] # interactive config, needed a *.numHosts parameter /examples/adhoc/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 5749-0281/tplx;f38a-cb93/~tNl;c2ed-b352/~tND;0eb8-3e3b/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;2c1e-66e5/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;a587-3a4d/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;33b7-00f9/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, 2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;df04-18f7/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;f74f-a0c0/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;57c2-84bd/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;97f7-655d/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, 2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;734c-15d1/tyf, PASS, wireless adhoc Ipv4 /examples/aodv/, -f omnetpp.ini -c IPv4SlowMobility -r 0, 50s, 77fe-0daf/tplx;1d8d-30ff/~tNl;6467-0c74/~tND;ac08-940e/tyf, PASS, wireless adhoc AckingWirelessInterface Ipv4 /examples/aodv/, -f omnetpp.ini -c IPv4ModerateFastMobility -r 0, 50s, ed5e-39c4/tplx;3f90-6604/~tNl;b754-ceda/~tND, PASS, wireless adhoc AckingWirelessInterface Ipv4 @@ -605,8 +605,8 @@ /examples/wireless/layeredapsk/, -f omnetpp.ini -c General -r 0, 100s, 1d44-454e/tplx;a4c8-b076/~tNl;21b2-88a0/~tND;49fc-2324/tyf, PASS, wireless Ipv4 # /examples/wireless/mactest/, -f omnetpp.ini -c MacBase -r 0 # abstract-config -/examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, 5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;dfcf-4644/tyf, PASS, wireless -/examples/wireless/mactest/, -f omnetpp.ini -c MacDcf -r 0, 100s, 031d-548a/tplx;4db6-9460/~tNl;4c1d-35a0/~tND;f37f-cd48/tyf, PASS, wireless +/examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, 5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;24e0-2e48/tyf, PASS, wireless +/examples/wireless/mactest/, -f omnetpp.ini -c MacDcf -r 0, 100s, 031d-548a/tplx;4db6-9460/~tNl;4c1d-35a0/~tND;3edc-eb8d/tyf, PASS, wireless # /examples/wireless/multiradio/, -f .qtenv.ini -c General -r 0 /examples/wireless/multiradio/, -f omnetpp.ini -c IndependentWlans -r 0, 100s, 1998-e0e1/tplx;bcf2-7eef/~tNl;e212-9ab0/~tND;552a-1fd5/tyf, PASS, wireless Ipv4 @@ -654,11 +654,11 @@ /examples/wireless/power/, -f omnetpp.ini -c General -r 0, 100s, 6fae-d558/tplx;b8ea-b2fc/~tNl;7a95-cf35/~tND, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 0be7-a22e/tplx;5eb9-6cea/~tNl;87a5-11a1/~tND;6097-a429/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, d929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;9f3c-4512/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;317d-aa4f/~tND;a4c3-19bf/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;b2d6-1329/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;08b5-d005/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 0be7-a22e/tplx;5eb9-6cea/~tNl;87a5-11a1/~tND;b802-9992/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, d929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;b06a-f098/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;317d-aa4f/~tND;57cd-2e76/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;8cb9-109e/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;0db4-29ea/tyf, PASS, wireless Ipv4 /examples/wireless/ratecontrol/, -f omnetpp.ini -c Mac -r 0, 100s, bf30-2f13/tplx;7b2f-653d/~tNl;6f09-d8eb/~tND;19fe-8b0e/tyf, PASS, wireless diff --git a/tests/fingerprint/showcases.csv b/tests/fingerprint/showcases.csv index 9baf2771fb6..94ae085def2 100644 --- a/tests/fingerprint/showcases.csv +++ b/tests/fingerprint/showcases.csv @@ -191,9 +191,9 @@ /showcases/visualizer/canvas/transportpathactivity/, -f omnetpp.ini -c EnablingPathVisualizationWireless -r 0, 500s, 691e-0e35/tplx;5dfc-9178/~tNl;0fa0-c15f/~tND;9224-5dd7/tyf, PASS, wireless Ipv4 /showcases/visualizer/canvas/transportpathactivity/, -f omnetpp.ini -c Filtering -r 0, 100s, 8bcf-d426/tplx;8f09-7a80/~tNl;92a4-c3ec/~tND;0694-d5be/tyf, PASS, wireless EthernetMac Ipv4 -/showcases/wireless/aggregation/, -f omnetpp.ini -c NoAggregation -r 0, 1s, 21a4-c882/tplx;ecf2-6e33/~tNl;5d9e-8fdf/~tND;27f2-4a52/tyf, PASS, wireless Ipv4 -/showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, 0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf, PASS, wireless Ipv4 -/showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;bd88-5ba6/tyf, PASS, wireless Ipv4 +/showcases/wireless/aggregation/, -f omnetpp.ini -c NoAggregation -r 0, 1s, 21a4-c882/tplx;ecf2-6e33/~tNl;5d9e-8fdf/~tND;cb71-81f8/tyf, PASS, wireless Ipv4 +/showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, 0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;6cdd-e65e/tyf, PASS, wireless Ipv4 +/showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;c99f-3188/tyf, PASS, wireless Ipv4 /showcases/wireless/analogmodel/, -f omnetpp.ini -c Routing -r 0, 5s, 56b0-3510/tplx;baeb-0d2c/~tNl;3d4b-65fc/~tND;00a2-e4ee/tyf, PASS, wireless Ipv4 /showcases/wireless/analogmodel/, -f omnetpp.ini -c Distance -r 0, 2.5s, 1e75-270e/tplx;6d7a-d84c/~tNl;7b7c-2bfb/~tND;5575-fd8f/tyf, PASS, wireless Ipv4 @@ -265,9 +265,9 @@ /showcases/wireless/errorrate/, -f omnetpp.ini -c General -r '$bitrate==54 && $distance==350', 500s, 7a69-d427/tplx;3aa8-584d/~tNl;e972-9ec9/~tND;6be5-e4ba/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFnofrag -r 0, 1s, 52b9-628f/tplx;3fec-74a2/~tNl;dbb5-67b0/~tND;8871-1dd1/tyf, PASS, wireless Ipv4 -/showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;f985-34fb/tyf, PASS, wireless Ipv4 -/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;335d-6687/tyf, PASS, wireless Ipv4 -/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;6f6e-b101/tyf, PASS, wireless Ipv4 +/showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;74c3-9ba0/tyf, PASS, wireless Ipv4 +/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;e394-4985/tyf, PASS, wireless Ipv4 +/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;77f4-58c1/tyf, PASS, wireless Ipv4 /showcases/wireless/handover/, -f omnetpp.ini -c General -r 0, 250s, 6150-7a8b/tplx;bcc9-11d2/~tNl;99fd-923d/~tND;02e9-9ad3/tyf, PASS, wireless @@ -313,8 +313,8 @@ /showcases/wireless/power/, -f omnetpp.ini -c General -r 0, 100s, 498f-b665/tplx;6f50-5caf/~tNl;1403-6fb2/~tND, PASS, wireless Ipv4 -/showcases/wireless/qos/, -f omnetpp.ini -c NonQos -r 0, 10s, 5734-43a3/tplx;9c39-00a3/~tNl;03a9-2f02/~tND;093e-1ca4/tyf, PASS, wireless Ipv4 -/showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, 2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;bda9-15d1/tyf, PASS, wireless Ipv4 +/showcases/wireless/qos/, -f omnetpp.ini -c NonQos -r 0, 10s, 5734-43a3/tplx;9c39-00a3/~tNl;03a9-2f02/~tND;34ac-bc95/tyf, PASS, wireless Ipv4 +/showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, 2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;64d2-47e3/tyf, PASS, wireless Ipv4 /showcases/wireless/ratecontrol/, -f omnetpp.ini -c NoRateControl -r 0, 14s, 7ee9-503a/tplx;0816-e58f/~tNl;ec30-e32d/~tND;dad3-7f89/tyf, PASS, wireless Ipv4 /showcases/wireless/ratecontrol/, -f omnetpp.ini -c AarfRateControl -r 0, 12s, a7bc-05bb/tplx;9de0-4dd3/~tNl;de90-6575/~tND;7539-d32d/tyf, PASS, wireless Ipv4 @@ -341,5 +341,5 @@ /showcases/wireless/throughput/, -f omnetpp.ini -c General -r 0, 1s, 030e-c416/tplx;66e6-0bca/~tNl;3cb5-d354/~tND;e6a5-bde0/tyf, PASS, wireless Ipv4 -/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, ab91-87f3/tplx;f30c-6aa4/~tNl;c87d-3f3a/tyf, PASS, wireless Ipv4 +/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, ab91-87f3/tplx;f30c-6aa4/~tNl;6175-eb06/tyf, PASS, wireless Ipv4 From ac7109fb42df21c0fc33ea01b9b34e7d1c4dd4a5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 10:03:04 +0200 Subject: [PATCH 35/41] ieee80211: add: bound fragment partitions by MPDU length Before this commit, the fragmentation policy uses only its configured threshold. HCF needs a complete MPDU bound to prepare legal fragments before it consumes queued sources. After this commit, the bounded operation combines that threshold with the supplied MPDU length. It reports an unfragmented frame, a legal partition, or an impossible partition. Nonfinal fragments retain equal even lengths, and the partition contains at most sixteen fragments. The existing unbounded caller retains its behavior. This implements the policy part of C1 in plan/pending/ieee80211-txop-admission-remaining-paths.md. The later admission commits supply the bound from the selected exchange mode. The migration entry describes the required operation for external policies. Change: src.ieee80211 | behavior.add | test migration | txop-admission-remaining --- doc/src/migration-guide/index.rst | 5 ++ .../mac/contract/IFragmentationPolicy.h | 10 +++ .../fragmentation/BasicFragmentationPolicy.cc | 26 ++++++++ .../fragmentation/BasicFragmentationPolicy.h | 1 + .../unit/Ieee80211BoundedFragmentation_1.test | 63 +++++++++++++++++++ 5 files changed, 105 insertions(+) create mode 100644 tests/unit/Ieee80211BoundedFragmentation_1.test diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index cfdb577ca14..3b5d2fe9d04 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -89,6 +89,11 @@ The serializer decodes the complete four-bit Type field. Type 0 retains Basic co Compressed producers must supply Fragment Number zero and a 64-bit bitmap. A Compressed Block Ack header chunk contains 28 bytes before FCS. Both BAR profiles occupy 24 bytes with FCS. Keep the corresponding header chunk and trailer lengths consistent. The serializer rejects malformed wire fields before runtime processing. +IEEE 802.11 bounded fragment preparation +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Custom ``IFragmentationPolicy`` implementations must implement ``computeBoundedFragmentSizes(frame, maxMpduBytes)``. The bound includes the MAC header and FCS. The result distinguishes an unfragmented frame, a legal fragment partition, and an impossible partition. Each nonfinal fragment must have the same even length. A partition must contain at most sixteen fragments. The existing unbounded operation remains available to non-QoS callers. + IEEE 802.11 reversible DATA preparation ------------------------------------- diff --git a/src/inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h b/src/inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h index d11293e3769..312359e955c 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h @@ -15,12 +15,22 @@ namespace ieee80211 { class Ieee80211DataOrMgmtHeader; +enum class FragmentPartitionStatus { UNFRAGMENTED, FRAGMENTED, IMPOSSIBLE }; + +struct INET_API FragmentPartition +{ + FragmentPartitionStatus status = FragmentPartitionStatus::IMPOSSIBLE; + std::vector payloadSizes; +}; + class INET_API IFragmentationPolicy { public: virtual ~IFragmentationPolicy() {} virtual std::vector computeFragmentSizes(Packet *frame) = 0; + // The bound includes the MAC header and FCS. An impossible partition consumes no source. + virtual FragmentPartition computeBoundedFragmentSizes(Packet *frame, int maxMpduBytes) = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc b/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc index e47ce922aab..7a4a8ea937f 100644 --- a/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc +++ b/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc @@ -7,6 +7,8 @@ #include "inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h" +#include + #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" namespace inet { @@ -21,6 +23,30 @@ void BasicFragmentationPolicy::initialize() WATCH(fragmentationThreshold); } +FragmentPartition BasicFragmentationPolicy::computeBoundedFragmentSizes(Packet *frame, int maxMpduBytes) +{ + Enter_Method("computeBoundedFragmentSizes"); + const int limit = std::min(fragmentationThreshold, maxMpduBytes); + if (frame->getByteLength() <= limit) + return {FragmentPartitionStatus::UNFRAGMENTED, {}}; + auto header = dynamicPtrCast(frame->peekAtFront()); + if (!header || header->getAMsduPresent() || header->getMoreFragments() || header->getFragmentNumber() != 0) + return {}; + const int overhead = B(header->getChunkLength()).get() + B(frame->peekAtBack(B(4))->getChunkLength()).get(); + // IEEE Std 802.11-2024, 10.4: nonfinal fragments have equal, even lengths. + const int capacity = (limit - overhead) / 2 * 2; + int remaining = frame->getByteLength() - overhead; + if (capacity <= 0 || remaining <= 0 || int64_t(remaining) > int64_t(capacity) * MAX_NUM_FRAGMENTS) + return {}; + FragmentPartition result{FragmentPartitionStatus::FRAGMENTED, {}}; + while (remaining > capacity) { + result.payloadSizes.push_back(capacity); + remaining -= capacity; + } + result.payloadSizes.push_back(remaining); + return result; +} + std::vector BasicFragmentationPolicy::computeFragmentSizes(Packet *frame) { Enter_Method("computeFragmentSizes"); diff --git a/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h b/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h index 0b8f0b6ac77..4033e932df4 100644 --- a/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h +++ b/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h @@ -25,6 +25,7 @@ class INET_API BasicFragmentationPolicy : public IFragmentationPolicy, public Si public: virtual std::vector computeFragmentSizes(Packet *frame) override; + virtual FragmentPartition computeBoundedFragmentSizes(Packet *frame, int maxMpduBytes) override; }; } // namespace ieee80211 diff --git a/tests/unit/Ieee80211BoundedFragmentation_1.test b/tests/unit/Ieee80211BoundedFragmentation_1.test new file mode 100644 index 00000000000..93b3a8822f9 --- /dev/null +++ b/tests/unit/Ieee80211BoundedFragmentation_1.test @@ -0,0 +1,63 @@ +%description: +Check bounded nondynamic partition sizes against IEEE Std 802.11-2024, Clause 10.4. +The production policy must combine both bounds, preserve even nonfinal lengths, and enforce sixteen fragments. + +%includes: +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" +using namespace inet; +using namespace inet::ieee80211; + +%file: TestNetwork.ned +import inet.linklayer.ieee80211.mac.fragmentation.BasicFragmentationPolicy; +network TestNetwork { + submodules: + test: Test; + policy: BasicFragmentationPolicy { fragmentationThreshold = 101B; } +} + +%inifile: omnetpp.ini +[General] +network = TestNetwork +ned-path = .;../../../../src;../../lib +seed-set = 0 + +%activity: +auto policy = check_and_cast(getModuleByPath("^.policy")); +auto header = makeShared(); +header->setType(ST_DATA_WITH_QOS); +header->addChunkLength(QOSCONTROL_PART_LENGTH); +auto overhead = B(header->getChunkLength()).get() + 4; +auto makeFrame = [&](int payload) { + auto packet = new Packet("msdu", header); + packet->insertAtBack(makeShared(B(payload))); + packet->insertAtBack(makeShared()); + return std::unique_ptr(packet); +}; +auto frame = makeFrame(100); +for (int bound : {overhead - 1, overhead, overhead + 1}) + ASSERT(policy->computeBoundedFragmentSizes(frame.get(), bound).status == FragmentPartitionStatus::IMPOSSIBLE); +auto partition = policy->computeBoundedFragmentSizes(frame.get(), overhead + 21); +ASSERT(partition.status == FragmentPartitionStatus::FRAGMENTED); +ASSERT(partition.payloadSizes == std::vector({20, 20, 20, 20, 20})); +auto odd = makeFrame(101); +ASSERT(policy->computeBoundedFragmentSizes(odd.get(), overhead + 21).payloadSizes == std::vector({20, 20, 20, 20, 20, 1})); +auto sixteen = makeFrame(320); +ASSERT(policy->computeBoundedFragmentSizes(sixteen.get(), overhead + 20).payloadSizes.size() == 16); +auto seventeen = makeFrame(321); +ASSERT(policy->computeBoundedFragmentSizes(seventeen.get(), overhead + 20).status == FragmentPartitionStatus::IMPOSSIBLE); +auto small = makeFrame(20); +ASSERT(policy->computeBoundedFragmentSizes(small.get(), overhead + 20).status == FragmentPartitionStatus::UNFRAGMENTED); +ASSERT(policy->computeBoundedFragmentSizes(small.get(), overhead + 19).payloadSizes == std::vector({18, 2})); +auto configured = policy->computeBoundedFragmentSizes(frame.get(), 1000); +ASSERT(configured.status == FragmentPartitionStatus::FRAGMENTED); +ASSERT(configured.payloadSizes.front() == (101 - overhead) / 2 * 2); +auto aggregate = frame->removeAtFront(); +aggregate->setAMsduPresent(true); +frame->insertAtFront(aggregate); +ASSERT(policy->computeBoundedFragmentSizes(frame.get(), 60).status == FragmentPartitionStatus::IMPOSSIBLE); +EV << "Bounded fragmentation assertions passed.\n"; + +%contains: stdout +Bounded fragmentation assertions passed. From 01d95368a6dd08daa314aae1eedd7bcada87db6d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 10:04:26 +0200 Subject: [PATCH 36/41] ieee80211: add: prepare reversible QoS fragment groups Before this commit, QoS fragmentation consumes the source before HCF can admit the resulting exchange. A rejected candidate cannot preserve the queue's source identity and service observations. After this commit, the data service owns duplicate fragment previews until commitment. Commitment transfers those same packets under one sequence, allocation, and absolute deadline. A numbered source can become fragments before its first local DATA transmission. The committed-frame owner replaces that source and removes its old ACK entry. Existing transmission dispatch remains unchanged. This implements the service and ownership parts of C1 in plan/pending/ieee80211-txop-admission-remaining-paths.md. Direct preparation tests cover cancellation, commitment, expiry, stale sources, and permission changes. The migration entry describes the service and ACK interface changes. Change: src.ieee80211 | behavior.add | test migration | txop-admission-remaining --- doc/src/migration-guide/index.rst | 6 + .../ieee80211/mac/contract/IAckHandler.h | 1 + .../contract/IOriginatorQosMacDataService.h | 22 ++ .../ieee80211/mac/originator/AckHandler.h | 2 +- .../originator/OriginatorQosMacDataService.cc | 138 ++++++++++++ .../originator/OriginatorQosMacDataService.h | 8 + .../ieee80211/mac/originator/QosAckHandler.h | 2 +- .../ieee80211/mac/queue/InProgressFrames.cc | 96 ++++++++ .../ieee80211/mac/queue/InProgressFrames.h | 15 ++ .../Ieee80211PreparedQosFragments_1.test | 207 ++++++++++++++++++ 10 files changed, 495 insertions(+), 2 deletions(-) create mode 100644 tests/module/Ieee80211PreparedQosFragments_1.test diff --git a/doc/src/migration-guide/index.rst b/doc/src/migration-guide/index.rst index 3b5d2fe9d04..d2f7898848b 100644 --- a/doc/src/migration-guide/index.rst +++ b/doc/src/migration-guide/index.rst @@ -94,6 +94,12 @@ IEEE 802.11 bounded fragment preparation Custom ``IFragmentationPolicy`` implementations must implement ``computeBoundedFragmentSizes(frame, maxMpduBytes)``. The bound includes the MAC header and FCS. The result distinguishes an unfragmented frame, a legal fragment partition, and an impossible partition. Each nonfinal fragment must have the same even length. A partition must contain at most sixteen fragments. The existing unbounded operation remains available to non-QoS callers. +Custom ``IOriginatorQosMacDataService`` implementations must implement the fragment preparation, validation, and commitment operations. Preparation retains queued sources and owns all fragment previews. Commitment transfers those exact previews with one sequence identity, one allocation identity, and the source's absolute deadline. For a numbered source, the caller supplies a live source with no local DATA transmission. The caller replaces that source through ``InProgressFrames::replaceWithPreparedFragments()`` after commitment succeeds. + +A fragment preparation can report an unfragmented or impossible partition without fragment previews. The caller must check its status before commitment. + +Custom ``IAckHandler`` implementations must expose ``dropFrame()`` through the interface. Both built-in handlers already supply this operation. The committed-frame owner uses it to remove the old ACK entry before fragment replacement. + IEEE 802.11 reversible DATA preparation ------------------------------------- diff --git a/src/inet/linklayer/ieee80211/mac/contract/IAckHandler.h b/src/inet/linklayer/ieee80211/mac/contract/IAckHandler.h index 26b9bda3326..d80e0bd0d09 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IAckHandler.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IAckHandler.h @@ -21,6 +21,7 @@ class INET_API IAckHandler virtual bool isEligibleToTransmit(const Ptr& header) = 0; virtual bool isOutstandingFrame(const Ptr& header) = 0; virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) = 0; + virtual void dropFrame(const Ptr& dataOrMgmtHeader) = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h index dd6019cc3dd..954d6790650 100644 --- a/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h @@ -11,6 +11,7 @@ #include "inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h" +#include "inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h" #include "inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h" namespace inet { @@ -36,6 +37,19 @@ struct INET_API PreparedQosBatch std::vector members; }; +/** Owns fragment previews. A nonnegative retainedId identifies a numbered source supplied by the caller. */ +struct INET_API PreparedQosFragments : public cObject +{ + std::unique_ptr source; + int64_t retainedId = -1; + FragmentPartitionStatus status = FragmentPartitionStatus::IMPOSSIBLE; + std::vector fragments; + + ~PreparedQosFragments() override; + void addFragment(Packet *packet); + std::vector releaseFragments(); +}; + class INET_API IOriginatorQosMacDataService : public IOriginatorMacDataService { public: @@ -55,6 +69,14 @@ class INET_API IOriginatorQosMacDataService : public IOriginatorMacDataService virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const = 0; // Success transfers the preview to the caller. Failure retains the preview and all queued sources. virtual Packet *commitPreparedFrame(PreparedQosData& preparation) = 0; + // A null numberedSource selects a queued source. Otherwise the caller supplies a live, never-transmitted source. + virtual std::unique_ptr prepareFragments(queueing::IPacketQueue *queue, + Packet *numberedSource, int maxMpduBytes) = 0; + virtual bool isFragmentPreparationValid(const PreparedQosFragments& preparation, + Packet *numberedSource, simtime_t start) const = 0; + // Success transfers previews. The caller replaces a numbered source through InProgressFrames. + virtual bool commitPreparedFragments(PreparedQosFragments& preparation, + Packet *numberedSource, std::vector& committed) = 0; }; } // namespace ieee80211 diff --git a/src/inet/linklayer/ieee80211/mac/originator/AckHandler.h b/src/inet/linklayer/ieee80211/mac/originator/AckHandler.h index 19f404d3e5d..0c8683ddfc7 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/AckHandler.h +++ b/src/inet/linklayer/ieee80211/mac/originator/AckHandler.h @@ -48,7 +48,7 @@ class INET_API AckHandler : public SimpleModule, public IAckHandler virtual bool isEligibleToTransmit(const Ptr& header) override; virtual bool isOutstandingFrame(const Ptr& header) override; virtual void processFailedFrame(const Ptr& dataOrMgmtHeader); - virtual void dropFrame(const Ptr& dataOrMgmtHeader); + virtual void dropFrame(const Ptr& dataOrMgmtHeader) override; static std::string getStatusString(Status status); }; diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc index 4d4404e20e1..6c8fe5a827c 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc @@ -44,6 +44,144 @@ Packet *PreparedQosData::releasePacket() return packet.release(); } +PreparedQosFragments::~PreparedQosFragments() +{ + for (auto packet : fragments) { + drop(packet); + delete packet; + } +} + +void PreparedQosFragments::addFragment(Packet *packet) +{ + take(packet); + fragments.push_back(packet); +} + +std::vector PreparedQosFragments::releaseFragments() +{ + for (auto packet : fragments) + drop(packet); + auto result = std::move(fragments); + fragments.clear(); + return result; +} + +std::unique_ptr OriginatorQosMacDataService::prepareFragments( + queueing::IPacketQueue *queue, Packet *numberedSource, int maxMpduBytes) +{ + Enter_Method("prepareFragments"); + if (!fragmentationPolicy) + return nullptr; + auto result = std::make_unique(); + if (numberedSource) { + if (!numberedSource->findTag()) + return nullptr; + result->retainedId = numberedSource->getId(); + result->source = std::make_unique(); + result->source->setPacket(numberedSource->dup()); + } + else + result->source = prepareFrame(queue, false); + if (!result->source) + return nullptr; + auto source = result->source->packet.get(); + if (fragmentationPermitted && !fragmentationPermitted(source)) + return nullptr; + auto partition = fragmentationPolicy->computeBoundedFragmentSizes(source, maxMpduBytes); + result->status = partition.status; + if (partition.status != FragmentPartitionStatus::FRAGMENTED) + return result; + // The builder consumes only this duplicate. All previews exist before any source extraction. + std::unique_ptr> fragments(fragmentation->fragmentFrame(source->dup(), partition.payloadSizes)); + for (auto packet : *fragments) + result->addFragment(packet); + return result; +} + +bool OriginatorQosMacDataService::isFragmentPreparationValid(const PreparedQosFragments& preparation, + Packet *numberedSource, simtime_t start) const +{ + if (!preparation.source || preparation.fragments.empty()) + return false; + if (preparation.retainedId < 0) { + if (numberedSource || !isPreparationValid(*preparation.source, start)) + return false; + } + else { + if (!numberedSource || numberedSource->getId() != preparation.retainedId || + (lifetimeHandler && lifetimeHandler->isExpired(numberedSource, start))) + return false; + auto expected = preparation.source->packet->getTag(); + auto actual = numberedSource->findTag(); + if (!actual || expected->getAllocationIndex() != actual->getAllocationIndex() || + numberedSource->peekAtFront()->getSequenceNumber() != + preparation.source->packet->peekAtFront()->getSequenceNumber()) + return false; + } + auto source = numberedSource ? numberedSource : preparation.source->packet.get(); + return !fragmentationPermitted || fragmentationPermitted(source); +} + +void OriginatorQosMacDataService::transferFragmentMetadata(PreparedQosFragments& preparation, Packet *source, + SequenceNumberCyclic sequence, int64_t allocation, simtime_t deadline) +{ + auto sourceHeader = source->peekAtFront(); + auto offset = source->getFrontOffset() + sourceHeader->getChunkLength(); + for (auto packet : preparation.fragments) { + auto header = packet->removeAtFront(); + header->setSequenceNumber(sequence); + packet->insertAtFront(header); + packet->addTagIfAbsent()->setAllocationIndex(allocation); + auto length = packet->getDataLength() - header->getChunkLength() - B(4); + packet->copyRegionTags(*source, offset, packet->getFrontOffset() + header->getChunkLength(), length); + offset += length; + } + if (lifetimeHandler) { + lifetimeHandler->prepareFrameReplacement({source->getId()}); + if (deadline != SIMTIME_MAX) + lifetimeHandler->registerFragments(preparation.fragments, deadline); + } +} + +bool OriginatorQosMacDataService::commitPreparedFragments(PreparedQosFragments& preparation, + Packet *numberedSource, std::vector& committed) +{ + Enter_Method("commitPreparedFragments"); + if (!isFragmentPreparationValid(preparation, numberedSource, simTime())) + return false; + Packet *source = numberedSource; + if (!source) { + auto queue = preparation.source->queue; + for (int i = 0; i < queue->getNumPackets(); i++) + if (queue->getPacket(i)->getId() == preparation.source->sourceIds.front()) + source = queue->getPacket(i); + auto module = dynamic_cast(queue); + auto next = queue->canPullPacket(module ? module->gate("out") : nullptr); + auto extracted = source == next ? queue->dequeuePacket() : + check_and_cast(queue)->extractPacket(source); + ASSERT(extracted == source); + take(source); + } + auto deadline = lifetimeHandler ? lifetimeHandler->getDeadline(source) : SIMTIME_MAX; + auto header = preparation.source->packet->removeAtFront(); + if (!numberedSource) + assignSequenceNumber(header); + auto sequence = header->getSequenceNumber(); + preparation.source->packet->insertAtFront(header); + auto allocation = numberedSource ? source->getTag()->getAllocationIndex() : nextDataAllocationIndex++; + transferFragmentMetadata(preparation, source, sequence, allocation, deadline); + emit(packetFragmentedSignal, source); + auto fragments = preparation.releaseFragments(); + for (auto packet : fragments) { + take(packet); + committed.push_back(packet); + } + if (!numberedSource) + delete source; + return true; +} + void OriginatorQosMacDataService::initialize() { aMsduAggregationPolicy = dynamic_cast(getSubmodule("msduAggregationPolicy")); diff --git a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h index 4b6941521ee..3e7d00ff8df 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h +++ b/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h @@ -55,8 +55,16 @@ class INET_API OriginatorQosMacDataService : public IOriginatorQosMacDataService virtual Packet *aMpduAggregateIfNeeded(std::vector *fragments); bool isPreparationValidForSequence(const PreparedQosData& preparation, simtime_t start, SequenceNumberCyclic sequence) const; Packet *commitValidatedFrame(PreparedQosData& preparation); + void transferFragmentMetadata(PreparedQosFragments& preparation, Packet *source, + SequenceNumberCyclic sequence, int64_t allocation, simtime_t deadline); public: + virtual std::unique_ptr prepareFragments(queueing::IPacketQueue *queue, + Packet *numberedSource, int maxMpduBytes) override; + virtual bool isFragmentPreparationValid(const PreparedQosFragments& preparation, + Packet *numberedSource, simtime_t start) const override; + virtual bool commitPreparedFragments(PreparedQosFragments& preparation, + Packet *numberedSource, std::vector& committed) override; void setFragmentationPermission(std::function permission) { fragmentationPermitted = permission; } void setEligibility(std::function eligible, std::function permission) { extractionEligible = eligible; diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h index fb5c7d29e7e..f5c7b577ec3 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h +++ b/src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h @@ -67,7 +67,7 @@ class INET_API QosAckHandler : public SimpleModule, public IAckHandler void processFailedImplicitBlockAckMember(const Ptr& header); virtual void processTransmittedBlockAckReq(const Ptr& blockAckReq, const OriginatorBlockAckAgreement *agreement); virtual void processFailedFrame(const Ptr& dataOrMgmtHeader); - virtual void dropFrame(const Ptr& dataOrMgmtHeader); + virtual void dropFrame(const Ptr& dataOrMgmtHeader) override; virtual void dropFrames(std::set>> seqAndFragNums); virtual Status getQoSDataAckStatus(const Ptr& header); diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc index dd63aa884cb..13fa0c007b1 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc @@ -9,6 +9,7 @@ #include +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" #include "inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h" namespace inet { @@ -106,6 +107,98 @@ void InProgressFrames::adoptPreparedFrame(Packet *packet) emit(packetEnqueuedSignal, packet); } +void InProgressFrames::adoptPreparedFragments(const std::vector& fragments) +{ + Enter_Method("adoptPreparedFragments"); + ASSERT(!fragments.empty()); + fragmentHistory[fragments.front()->getTag()->getAllocationIndex()].count = fragments.size(); + for (auto packet : fragments) + adoptPreparedFrame(packet); +} + +void InProgressFrames::replaceWithPreparedFragments(Packet *source, const std::vector& fragments) +{ + Enter_Method("replaceWithPreparedFragments"); + auto position = std::find(inProgressFrames.begin(), inProgressFrames.end(), source); + ASSERT(position != inProgressFrames.end() && !fragments.empty()); + auto index = position - inProgressFrames.begin(); + auto allocation = source->getTag()->getAllocationIndex(); + for (auto packet : fragments) + ASSERT(packet->getTag()->getAllocationIndex() == allocation); + ackHandler->dropFrame(source->peekAtFront()); + dropFrame(source); + fragmentHistory[allocation].count = fragments.size(); + for (auto packet : fragments) { + take(packet); + ackHandler->frameGotInProgress(packet->peekAtFront()); + inProgressFrames.insert(inProgressFrames.begin() + index++, packet); + packet->setArrivalTime(simTime()); + emit(packetEnqueuedSignal, packet); + } +} + +std::vector InProgressFrames::getAllocationFrames(Packet *packet) const +{ + std::vector result; + auto tag = packet->findTag(); + if (tag) { + for (auto candidate : inProgressFrames) { + auto other = candidate->findTag(); + if (other && other->getAllocationIndex() == tag->getAllocationIndex()) + result.push_back(candidate); + } + } + return result; +} + +void InProgressFrames::recordDataTransmission(Packet *packet) +{ + auto allocation = packet->getTag()->getAllocationIndex(); + auto fragment = packet->peekAtFront()->getFragmentNumber(); + auto& history = fragmentHistory[allocation]; + auto result = history.transmittedLengths.emplace(fragment, packet->getDataLength()); + if (!result.second) { + ASSERT(result.first->second == packet->getDataLength()); + history.retransmitted.insert(fragment); + } +} + +bool InProgressFrames::isSameSizeDataRetry(Packet *packet) const +{ + auto tag = packet->findTag(); + auto it = tag ? fragmentHistory.find(tag->getAllocationIndex()) : fragmentHistory.end(); + if (it == fragmentHistory.end()) + return false; + auto length = it->second.transmittedLengths.find(packet->peekAtFront()->getFragmentNumber()); + return length != it->second.transmittedLengths.end() && length->second == packet->getDataLength(); +} + +bool InProgressFrames::hasRetriedPreviousFragment(Packet *packet) const +{ + auto tag = packet->findTag(); + auto it = tag ? fragmentHistory.find(tag->getAllocationIndex()) : fragmentHistory.end(); + return it != fragmentHistory.end() && !it->second.retransmitted.empty() && + *it->second.retransmitted.begin() < packet->peekAtFront()->getFragmentNumber(); +} + +int InProgressFrames::getFragmentCount(Packet *packet) const +{ + auto tag = packet->findTag(); + auto it = tag ? fragmentHistory.find(tag->getAllocationIndex()) : fragmentHistory.end(); + return it == fragmentHistory.end() ? 1 : it->second.count; +} + +void InProgressFrames::dropAllocation(Packet *packet) +{ + Enter_Method("dropAllocation"); + for (auto member : getAllocationFrames(packet)) { + ackHandler->dropFrame(member->peekAtFront()); + if (lifetimeHandler) + lifetimeHandler->forgetFrame(member->getId()); + dropFrame(member); + } +} + Packet *InProgressFrames::getFrameToTransmit() { ensureHasFrameToTransmit(); @@ -169,6 +262,9 @@ void InProgressFrames::dropFrame(Packet *packet) { EV_DEBUG << "Dropping frame " << packet->getName() << ".\n"; inProgressFrames.erase(std::remove(inProgressFrames.begin(), inProgressFrames.end(), packet), inProgressFrames.end()); + if (auto tag = packet->findTag()) + if (getAllocationFrames(packet).empty()) + fragmentHistory.erase(tag->getAllocationIndex()); droppedFrames.push_back(packet); emit(packetDequeuedSignal, packet); } diff --git a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h index bd7264fffd3..f9ec9bc11be 100644 --- a/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h +++ b/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.h @@ -33,6 +33,12 @@ class INET_API InProgressFrames : public SimpleModule std::vector inProgressFrames; std::vector droppedFrames; std::function transmissionEligible; + struct FragmentHistory { + int count = 1; + std::map transmittedLengths; + std::set retransmitted; + }; + std::map fragmentHistory; protected: virtual void initialize(int stage) override; @@ -54,6 +60,15 @@ class INET_API InProgressFrames : public SimpleModule bool containsFrame(const Packet *packet) const; // Takes ownership after the data service commits a reversible preparation. void adoptPreparedFrame(Packet *packet); + void adoptPreparedFragments(const std::vector& fragments); + // The caller establishes that source has no local DATA transmission. + void replaceWithPreparedFragments(Packet *source, const std::vector& fragments); + std::vector getAllocationFrames(Packet *packet) const; + void recordDataTransmission(Packet *packet); + bool isSameSizeDataRetry(Packet *packet) const; + bool hasRetriedPreviousFragment(Packet *packet) const; + int getFragmentCount(Packet *packet) const; + void dropAllocation(Packet *packet); virtual Packet *getFrameToTransmit(); virtual Packet *peekFrameToTransmit(); SequenceNumberCyclic getCandidateSequenceNumber(Packet *packet) const; diff --git a/tests/module/Ieee80211PreparedQosFragments_1.test b/tests/module/Ieee80211PreparedQosFragments_1.test new file mode 100644 index 00000000000..fd8fd5a2fe3 --- /dev/null +++ b/tests/module/Ieee80211PreparedQosFragments_1.test @@ -0,0 +1,207 @@ +%description: +Check fragment preparation through the production QoS data service, queue, ACK handler, and committed-frame owner. +Cancellation and stale inputs preserve queued sources and sequence allocation. +Commitment transfers the preview pointers and preserves group identity, deadlines, and queue service metadata. +Numbered replacement retains its allocation without a second sequence assignment. +This fixture does not exercise HCF admission or real transmission. + +%extraargs: -r 0..7 + +%file: PreparedFragments.cc +#include +#include "inet/common/TimeTag_m.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h" +#include "inet/linklayer/ieee80211/mac/originator/QosAckHandler.h" +#include "inet/linklayer/ieee80211/mac/queue/InProgressFrames.h" +#include "inet/queueing/queue/PacketQueue.h" +using namespace inet; +using namespace inet::ieee80211; + +class FragmentService : public OriginatorQosMacDataService { + std::unique_ptr lifetime; + protected: + void initialize() override { + OriginatorQosMacDataService::initialize(); + lifetime = std::make_unique(1, 1, 1, 1); + setLifetimeHandler(lifetime.get(), {}); + } + public: + EdcaTransmitLifetimeHandler *getLifetime() { return lifetime.get(); } + int64_t allocations() const { return nextDataAllocationIndex; } +}; +Define_Module(FragmentService); + +class FragmentTest : public cSimpleModule { + const MacAddress peer{"02:00:00:00:00:02"}; + FragmentService *service = nullptr; + queueing::PacketQueue *queue = nullptr; + InProgressFrames *frames = nullptr; + QosAckHandler *ack = nullptr; + Packet *source = nullptr; + Packet *numbered = nullptr; + int64_t sourceId = -1; + simtime_t deadline; + std::unique_ptr preparation; + + std::string operation() { return par("operation").stdstringValue(); } + Packet *enqueue(const char *name) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(peer); + header->setTid(0); + auto packet = new Packet(name, header); + packet->insertAtBack(makeShared(B(100))); + packet->insertAtBack(makeShared()); + auto time = packet->addRegionTag(header->getChunkLength(), B(100)); + time->setPacketTotalTimesArraySize(1); + time->setPacketTotalTimes(0, SIMTIME_ZERO); + packet->setArrivalTime(simTime()); + queue->enqueuePacket(packet); + service->getLifetime()->registerFrame(packet, AC_BE); + return packet; + } + void prepare() { + source = enqueue("first"); + sourceId = source->getId(); + deadline = service->getLifetime()->getDeadline(source); + enqueue("unrelated"); + if (operation() == "numbered") { + auto ordinary = service->prepareFrame(queue, false); + numbered = service->commitPreparedFrame(*ordinary); + frames->adoptPreparedFrame(numbered); + } + if (operation() == "prohibited") + service->setFragmentationPermission([](Packet *) { return false; }); + preparation = service->prepareFragments(queue, numbered, operation() == "impossible" ? 31 : 62); + if (operation() == "prohibited" || operation() == "impossible") { + ASSERT(queue->getNumPackets() == 2 && service->allocations() == 0); + ASSERT(operation() == "prohibited" ? !preparation : + preparation && preparation->status == FragmentPartitionStatus::IMPOSSIBLE); + preparation.reset(); + } + else { + ASSERT(preparation && preparation->fragments.size() == 4); + ASSERT(queue->getNumPackets() == (numbered ? 1 : 2)); + ASSERT(service->allocations() == (numbered ? 1 : 0)); + ASSERT(service->isFragmentPreparationValid(*preparation, numbered, simTime())); + for (auto packet : preparation->fragments) + ASSERT(packet->getOwner() == preparation.get()); + } + scheduleAt(SimTime(3, SIMTIME_MS), new cMessage("check")); + } + void check() { + if (preparation) { + if (operation() == "stale") { + queue->removePacket(source); + service->getLifetime()->forgetFrame(sourceId); + take(source); + delete source; + } + if (operation() == "expired") + ASSERT(!service->isFragmentPreparationValid(*preparation, numbered, deadline)); + if (operation() == "permissionChange") + service->setFragmentationPermission([](Packet *) { return false; }); + if (operation() == "stale" || operation() == "permissionChange") { + std::vector result; + ASSERT(!service->commitPreparedFragments(*preparation, numbered, result) && result.empty()); + ASSERT(service->allocations() == 0); + } + if (operation() == "commit" || operation() == "numbered") { + auto pointers = preparation->fragments; + std::vector result; + ASSERT(service->commitPreparedFragments(*preparation, numbered, result)); + ASSERT(result == pointers && preparation->fragments.empty()); + ASSERT(service->allocations() == 1 && service->getNextSequenceNumber(peer, 0) == SequenceNumberCyclic(1)); + if (numbered) + frames->replaceWithPreparedFragments(numbered, result); + else + frames->adoptPreparedFragments(result); + ASSERT(frames->getLength() == 4 && queue->getNumPackets() == 1); + ASSERT(service->getLifetime()->findFrame(sourceId) == nullptr); + ASSERT(!service->isFragmentPreparationValid(*preparation, numbered, simTime())); + for (int i = 0; i < 4; i++) { + auto packet = result[i]; + auto header = packet->peekAtFront(); + ASSERT(packet->getOwner() == frames && frames->getFrames(0) == packet); + ASSERT(header->getSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(header->getFragmentNumber() == i && header->getMoreFragments() == (i < 3)); + ASSERT(packet->getTag()->getAllocationIndex() == 0); + ASSERT(service->getLifetime()->getDeadline(packet) == deadline); + auto length = packet->getDataLength() - header->getChunkLength() - B(4); + ASSERT(length == B(i == 3 ? 4 : 32)); + auto time = packet->findRegionTag(header->getChunkLength(), length); + ASSERT(time && time->getPacketTotalTimes(0) == (numbered ? SIMTIME_ZERO : SimTime(2, SIMTIME_MS))); + ack->dropFrame(header); + service->getLifetime()->forgetFrame(packet->getId()); + frames->dropFrame(packet); + } + frames->clearDroppedFrames(); + } + preparation.reset(); + } + while (!queue->isEmpty()) { + auto packet = queue->getPacket(0); + queue->removePacket(packet); + service->getLifetime()->forgetFrame(packet->getId()); + take(packet); + delete packet; + } + ASSERT(service->getLifetime()->getNumFrames() == 0); + std::cout << "Prepared fragment assertions passed: " << operation() << ".\n"; + endSimulation(); + } + protected: + void initialize() override { + service = check_and_cast(getModuleByPath("^.service")); + queue = check_and_cast(getModuleByPath("^.queue")); + frames = check_and_cast(getModuleByPath("^.frames")); + ack = check_and_cast(getModuleByPath("^.ack")); + scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("prepare")); + } + void handleMessage(cMessage *message) override { + bool first = message->isName("prepare"); + delete message; + if (first) prepare(); else check(); + } +}; +Define_Module(FragmentTest); + +%file: test.ned +import inet.linklayer.ieee80211.mac.originator.OriginatorQosMacDataService; +import inet.linklayer.ieee80211.mac.originator.QosAckHandler; +import inet.linklayer.ieee80211.mac.queue.InProgressFrames; +import inet.queueing.queue.PacketQueue; +module FragmentService extends OriginatorQosMacDataService { parameters: @class(::FragmentService); } +simple FragmentTest { parameters: string operation; @class(::FragmentTest); } +network FragmentNetwork { + submodules: + service: FragmentService; + queue: PacketQueue; + ack: QosAckHandler; + frames: InProgressFrames { + pendingQueueModule = "^.queue"; + originatorMacDataServiceModule = "^.service"; + ackHandlerModule = "^.ack"; + } + test: FragmentTest; + connections allowunconnected: +} + +%inifile: omnetpp.ini +[General] +network = FragmentNetwork +ned-path = .;../../../../src;../../lib +seed-set = 0 +cmdenv-express-mode = true +record-scalar-results = false +record-vector-results = false +*.test.operation = ${"cancel","commit","numbered","stale","expired","prohibited","impossible","permissionChange"} +*.service.msduAggregationPolicy.typename = "" +*.service.mpduAggregationPolicy.typename = "" +*.service.fragmentationPolicy.fragmentationThreshold = 2346B + +%contains: stdout +Prepared fragment assertions passed: From 57f454d86a9b93a7ab7b8c4276e48460d229f903 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 10:06:04 +0200 Subject: [PATCH 37/41] ieee80211: add: retain retry state for each MSDU allocation Before this commit, recovery selects retry state through each MPDU header. That state cannot carry a complete MSDU count across fragment replacement and fragment ACKs. After this commit, explicit allocation registration selects the applicable retry contract. The modern contract retains one count across associated RTS failures, DATA failures, and fragment ACKs. Basic retains separate 2016 short and long counts. An accepted Basic agreement can select lifetime retention while counters still increase. Existing callers retain their current recovery until the later activation commits register allocations. This implements C2 in plan/pending/ieee80211-txop-admission-remaining-paths.md. Direct recovery tests distinguish the limits, ACK resets, lifetime exemption, and disposal of an unrelated allocation. Change: src.ieee80211 | behavior.add | test | txop-admission-remaining --- .../mac/originator/QosRecoveryProcedure.cc | 102 +++++++++++ .../mac/originator/QosRecoveryProcedure.h | 18 ++ tests/module/Ieee80211TxopMsduRecovery_1.test | 159 ++++++++++++++++++ 3 files changed, 279 insertions(+) create mode 100644 tests/module/Ieee80211TxopMsduRecovery_1.test diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc index 75bc71ca2a1..860094bec78 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc +++ b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc @@ -8,6 +8,7 @@ #include "inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h" #include "inet/common/stlutils.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" #include "inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h" namespace inet { @@ -15,6 +16,91 @@ namespace ieee80211 { Define_Module(QosRecoveryProcedure); +QosRecoveryProcedure::MsduRetryRecord *QosRecoveryProcedure::findMsduRetryRecord(Packet *packet) +{ + auto tag = packet->findTag(); + if (!tag) + return nullptr; + auto it = msduRetryRecords.find(tag->getAllocationIndex()); + return it == msduRetryRecords.end() ? nullptr : &it->second; +} + +void QosRecoveryProcedure::registerMsdu(Packet *packet, MsduRetryContract contract, bool lifetimeOnly) +{ + Enter_Method("registerMsdu"); + auto allocation = packet->getTag()->getAllocationIndex(); + auto result = msduRetryRecords.emplace(allocation, MsduRetryRecord{contract}); + ASSERT(result.second || result.first->second.contract == contract); + result.first->second.lifetimeOnly = lifetimeOnly; +} + +bool QosRecoveryProcedure::hasMsduRetryRecord(Packet *packet) +{ + return findMsduRetryRecord(packet) != nullptr; +} + +void QosRecoveryProcedure::msduTransmissionFailed(Packet *packet, bool rts) +{ + Enter_Method("msduTransmissionFailed"); + auto record = findMsduRetryRecord(packet); + ASSERT(record); + if (record->contract == MsduRetryContract::IEEE80211_2024) { + // IEEE Std 802.11-2024, 10.23.2.12.1: one count includes associated RTS and internal collisions. + record->frameCount++; + controlFrameTransmissionFailed(); + } + else if (rts || packet->getByteLength() <= rtsThreshold) { + // IEEE Std 802.11-2016, 10.22.2.11.1: the MSDU retains both counts across fragment changes. + record->shortCount++; + incrementStationSrc(); + } + else { + record->longCount++; + incrementStationLrc(); + } +} + +void QosRecoveryProcedure::msduAckReceived(Packet *packet, bool finalMember) +{ + Enter_Method("msduAckReceived"); + auto record = findMsduRetryRecord(packet); + ASSERT(record); + if (record->contract == MsduRetryContract::BASIC_2016) { + if (packet->getByteLength() <= rtsThreshold) { + record->shortCount = 0; + resetStationSrc(); + } + else { + record->longCount = 0; + resetStationLrc(); + } + } + else + resetStationSrc(); + resetContentionWindow(); + if (finalMember) + retireMsdu(packet); +} + +bool QosRecoveryProcedure::isMsduRetryLimitReached(Packet *packet) +{ + auto record = findMsduRetryRecord(packet); + ASSERT(record); + // IEEE Std 802.11-2016, 10.24.3: the accepted Basic agreement limits the MSDU by lifetime. + if (record->lifetimeOnly) + return false; + return record->contract == MsduRetryContract::IEEE80211_2024 ? record->frameCount >= shortRetryLimit : + record->shortCount >= shortRetryLimit || record->longCount >= longRetryLimit; +} + +void QosRecoveryProcedure::retireMsdu(Packet *packet) +{ + Enter_Method("retireMsdu"); + auto tag = packet->findTag(); + if (tag) + msduRetryRecords.erase(tag->getAllocationIndex()); +} + inline std::ostream& operator<<(std::ostream& os, const std::pair& p) { return os << p.first << "#" << p.second; } // @@ -140,6 +226,10 @@ void QosRecoveryProcedure::implicitBlockAckMemberFailed(Packet *packet, const Pt // void QosRecoveryProcedure::ackFrameReceived(Packet *packet, const Ptr& ackedHeader) { + if (findMsduRetryRecord(packet)) { + msduAckReceived(packet, !ackedHeader->getMoreFragments()); + return; + } auto id = getRetryKey(ackedHeader); if (packet->getByteLength() >= rtsThreshold) { resetStationLrc(); @@ -168,6 +258,7 @@ void QosRecoveryProcedure::retryLimitReached(Packet *packet, const Ptr& heade // void QosRecoveryProcedure::dataFrameTransmissionFailed(Packet *packet, const Ptr& failedHeader) { + if (findMsduRetryRecord(packet)) { + msduTransmissionFailed(packet, false); + return; + } if (packet->getByteLength() >= rtsThreshold) { incrementStationLrc(); incrementCounter(failedHeader, longRetryCounter); @@ -217,6 +312,8 @@ void QosRecoveryProcedure::rtsFrameTransmissionFailed(const Ptr& failedHeader) { + if (findMsduRetryRecord(packet)) + return isMsduRetryLimitReached(packet); if (packet->getByteLength() >= rtsThreshold) return getRc(packet, failedHeader, longRetryCounter) >= longRetryLimit; else @@ -225,6 +322,9 @@ bool QosRecoveryProcedure::isRetryLimitReached(Packet *packet, const Ptr& header) { + if (auto record = findMsduRetryRecord(packet)) + return record->contract == MsduRetryContract::IEEE80211_2024 ? record->frameCount : + packet->getByteLength() > rtsThreshold ? record->longCount : record->shortCount; if (packet->getByteLength() >= rtsThreshold) return getRc(packet, header, longRetryCounter); else @@ -251,6 +351,8 @@ void QosRecoveryProcedure::resetContentionWindow() bool QosRecoveryProcedure::isRtsFrameRetryLimitReached(Packet *packet, const Ptr& protectedHeader) { + if (findMsduRetryRecord(packet)) + return isMsduRetryLimitReached(packet); return getRc(packet, protectedHeader, shortRetryCounter) >= shortRetryLimit; } diff --git a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h index 62c9b663066..e093ac7776b 100644 --- a/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h +++ b/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h @@ -28,8 +28,19 @@ namespace ieee80211 { */ class INET_API QosRecoveryProcedure : public SimpleModule, public IRecoveryProcedure { + public: + enum class MsduRetryContract { IEEE80211_2024, BASIC_2016 }; protected: + struct MsduRetryRecord { + MsduRetryContract contract; + int frameCount = 0; + int shortCount = 0; + int longCount = 0; + bool lifetimeOnly = false; + }; + std::map msduRetryRecords; + MsduRetryRecord *findMsduRetryRecord(Packet *packet); ICwCalculator *cwCalculator = nullptr; using RetryKey = std::pair>; @@ -61,6 +72,13 @@ class INET_API QosRecoveryProcedure : public SimpleModule, public IRecoveryProce bool isMulticastFrame(Packet *packet, const Ptr& header); public: + // These operations apply only to allocations that the caller explicitly registers. + void registerMsdu(Packet *packet, MsduRetryContract contract, bool lifetimeOnly = false); + void msduTransmissionFailed(Packet *packet, bool rts); + void msduAckReceived(Packet *packet, bool finalMember); + bool isMsduRetryLimitReached(Packet *packet); + void retireMsdu(Packet *packet); + bool hasMsduRetryRecord(Packet *packet); void implicitBlockAckMemberFailed(Packet *packet, const Ptr& header); virtual void multicastFrameTransmitted(); diff --git a/tests/module/Ieee80211TxopMsduRecovery_1.test b/tests/module/Ieee80211TxopMsduRecovery_1.test new file mode 100644 index 00000000000..763e85f522c --- /dev/null +++ b/tests/module/Ieee80211TxopMsduRecovery_1.test @@ -0,0 +1,159 @@ +%description: +Check allocation-scoped recovery with the production recovery procedure and committed-frame owner. +The fixture supplies only contention-window state and module references. +Modern counts persist across fragment ACKs and size changes. Basic uses distinct short and long counts. +Group disposal removes ACK and lifetime entries without removal of an unrelated allocation. +Accepted Basic agreements retain the MSDU beyond both retry limits. These direct calls do not activate HCF dispatch. + +%file: MsduRecovery.cc +#include +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/originator/QosAckHandler.h" +#include "inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h" +#include "inet/linklayer/ieee80211/mac/queue/InProgressFrames.h" +using namespace inet; +using namespace inet::ieee80211; + +class MsduRecovery : public QosRecoveryProcedure, public IRecoveryProcedure::ICwCalculator { + int cw = 15; + protected: + void initialize(int) override { + cwCalculator = this; + rtsThreshold = 100; + shortRetryLimit = 3; + longRetryLimit = 2; + } + public: + void incrementCw() override { cw = 2 * cw + 1; } + void resetCw() override { cw = 15; } + int getCw() override { return cw; } + int src() const { return stationShortRetryCounter; } + int lrc() const { return stationLongRetryCounter; } + bool legacyEmpty() const { return shortRetryCounter.empty() && longRetryCounter.empty(); } +}; +Define_Module(MsduRecovery); + +class MsduFrames : public InProgressFrames { + std::unique_ptr lifetime; + protected: + void initialize(int stage) override { + if (stage == INITSTAGE_LOCAL) { + ackHandler = check_and_cast(getModuleByPath("^.ack")); + lifetime = std::make_unique(1, 1, 1, 1); + lifetimeHandler = lifetime.get(); + } + } + public: + EdcaTransmitLifetimeHandler *getLifetime() { return lifetime.get(); } +}; +Define_Module(MsduFrames); + +class MsduTest : public cSimpleModule { + Packet *frame(int64_t allocation, int number, int length, bool more) { + auto header = makeShared(); + header->setType(ST_DATA_WITH_QOS); + header->addChunkLength(QOSCONTROL_PART_LENGTH); + header->setReceiverAddress(MacAddress("02:00:00:00:00:02")); + header->setSequenceNumber(SequenceNumberCyclic(allocation)); + header->setFragmentNumber(number); + header->setMoreFragments(more); + auto packet = new Packet("member", header); + packet->insertAtBack(makeShared(B(length) - header->getChunkLength() - B(4))); + packet->insertAtBack(makeShared()); + packet->addTag()->setAllocationIndex(allocation); + return packet; + } + void handleMessage(cMessage *message) override { + delete message; + auto recovery = check_and_cast(getModuleByPath("^.recovery")); + auto frames = check_and_cast(getModuleByPath("^.frames")); + auto first = frame(7, 0, 200, true); + auto second = frame(7, 1, 100, false); + auto other = frame(8, 0, 99, false); + frames->adoptPreparedFragments({first, second}); + frames->adoptPreparedFrame(other); + frames->getLifetime()->registerFragments({first, second, other}, SimTime(1)); + recovery->registerMsdu(first, QosRecoveryProcedure::MsduRetryContract::IEEE80211_2024); + recovery->registerMsdu(other, QosRecoveryProcedure::MsduRetryContract::BASIC_2016); + recovery->msduTransmissionFailed(first, true); + ASSERT(recovery->getRetryCount(second, second->peekAtFront()) == 1); + ASSERT(recovery->src() == 1 && recovery->lrc() == 0 && recovery->getCw() == 31); + ASSERT(!frames->isSameSizeDataRetry(first)); + frames->recordDataTransmission(first); + frames->recordDataTransmission(first); + recovery->msduTransmissionFailed(first, false); + recovery->msduAckReceived(first, false); + ASSERT(recovery->getRetryCount(second, second->peekAtFront()) == 2); + ASSERT(recovery->src() == 0 && recovery->getCw() == 15); + frames->getLifetime()->forgetFrame(first->getId()); + frames->dropFrame(first); + ASSERT(frames->hasRetriedPreviousFragment(second) && frames->getFragmentCount(second) == 2); + recovery->msduTransmissionFailed(second, false); + ASSERT(recovery->isMsduRetryLimitReached(second)); + recovery->retireMsdu(second); + frames->dropAllocation(second); + ASSERT(!recovery->hasMsduRetryRecord(second)); + ASSERT(frames->getLength() == 1 && frames->getFrames(0) == other); + ASSERT(frames->getLifetime()->getNumFrames() == 1 && !frames->hasRetriedPreviousFragment(second)); + recovery->msduTransmissionFailed(other, false); + ASSERT(recovery->getRetryCount(other, other->peekAtFront()) == 1); + recovery->msduAckReceived(other, false); + ASSERT(recovery->getRetryCount(other, other->peekAtFront()) == 0); + recovery->msduTransmissionFailed(other, true); + recovery->msduTransmissionFailed(other, true); + recovery->msduTransmissionFailed(other, true); + ASSERT(recovery->isMsduRetryLimitReached(other) && recovery->legacyEmpty()); + recovery->registerMsdu(other, QosRecoveryProcedure::MsduRetryContract::BASIC_2016, true); + ASSERT(!recovery->isMsduRetryLimitReached(other)); + recovery->msduTransmissionFailed(other, true); + recovery->msduTransmissionFailed(other, false); + ASSERT(recovery->getRetryCount(other, other->peekAtFront()) == 5); + ASSERT(!recovery->isRtsFrameRetryLimitReached(other, other->peekAtFront())); + auto large = frame(9, 0, 101, false); + frames->adoptPreparedFrame(large); + recovery->registerMsdu(large, QosRecoveryProcedure::MsduRetryContract::BASIC_2016, true); + recovery->msduTransmissionFailed(large, false); + recovery->msduTransmissionFailed(large, false); + ASSERT(!recovery->isMsduRetryLimitReached(large) && recovery->lrc() == 2); + ASSERT(recovery->getRetryCount(large, large->peekAtFront()) == 2); + recovery->registerMsdu(large, QosRecoveryProcedure::MsduRetryContract::BASIC_2016, false); + ASSERT(recovery->isMsduRetryLimitReached(large)); + recovery->retireMsdu(large); + frames->dropAllocation(large); + recovery->retireMsdu(other); + frames->dropAllocation(other); + frames->clearDroppedFrames(); + std::cout << "MSDU recovery assertions passed.\n"; + endSimulation(); + } + void initialize() override { scheduleAt(SIMTIME_ZERO, new cMessage()); } +}; +Define_Module(MsduTest); + +%file: test.ned +import inet.linklayer.ieee80211.mac.originator.QosAckHandler; +import inet.linklayer.ieee80211.mac.originator.QosRecoveryProcedure; +import inet.linklayer.ieee80211.mac.queue.InProgressFrames; +simple MsduRecovery extends QosRecoveryProcedure { parameters: @class(::MsduRecovery); cwCalculatorModule = ""; rtsPolicyModule = ""; } +simple MsduFrames extends InProgressFrames { parameters: @class(::MsduFrames); pendingQueueModule = ""; originatorMacDataServiceModule = ""; ackHandlerModule = ""; } +simple MsduTest { parameters: @class(::MsduTest); } +network MsduNetwork { + submodules: + recovery: MsduRecovery; + ack: QosAckHandler; + frames: MsduFrames; + test: MsduTest; +} + +%inifile: omnetpp.ini +[General] +network = MsduNetwork +ned-path = .;../../../../src;../../lib +seed-set = 0 +cmdenv-express-mode = true +record-scalar-results = false +record-vector-results = false + +%contains: stdout +MSDU recovery assertions passed. From f9ac9ed3a901b6099448b6fa3a1ccd32aa163673 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 10:06:57 +0200 Subject: [PATCH 38/41] ieee80211: add: prepare common QoS exchange admission Before this commit, prepared exchange checks require an accepted Compressed agreement. The later Basic and Normal Ack activations need the same cost, mode, validation, and ownership operations. After this commit, HCF can represent an ordinary frame or a reversible fragment group in the prepared exchange. Shared operations retain selected modes, calculate complete protection and response cost, validate sources, and commit the admitted form. Dispatch still selects the existing accepted Compressed path. Modern MSDU recovery and Basic activation remain disabled in this preparation commit. The source change exceeds 400 lines because every consumer of the prepared exchange must use its cost and ownership state consistently. Cost, validation, commitment, submission, and Duration calculation cannot use different representations in an intermediate commit. This implements C3 in plan/pending/ieee80211-txop-admission-remaining-paths.md. Existing Compressed and A-MPDU fixtures provide the dispatch controls. Change: src.ieee80211 | behavior.add | test | txop-admission-remaining --- .../ieee80211/mac/coordinationfunction/Hcf.cc | 401 +++++++++++++++--- .../ieee80211/mac/coordinationfunction/Hcf.h | 12 + .../mac/framesequence/FrameSequenceContext.h | 1 + .../ieee80211/mac/framesequence/TxOpFs.cc | 2 +- 4 files changed, 361 insertions(+), 55 deletions(-) diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index f2b22de216f..923196397c8 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -9,6 +9,7 @@ #include "inet/common/ModuleAccess.h" #include "inet/common/Simsignals.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" #include "inet/linklayer/ieee80211/mac/Ieee80211Mac.h" #include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" #include "inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h" @@ -225,7 +226,10 @@ void Hcf::expireDataFrames(bool preserveSequence) if (inProgress) { edcaf->getAckHandler()->dropFrame(header); edcaf->getRecoveryProcedure()->dropFrame(header); - frames->dropFrame(packet); + if (edcaf->getRecoveryProcedure()->hasMsduRetryRecord(packet)) + disposeMsdu(edcaf, packet); + else + frames->dropFrame(packet); } else { edcaf->getPendingQueue()->removePacket(packet); @@ -795,13 +799,21 @@ void Hcf::discardAgreementData(MacAddress peer, Tid tid, bool all, int64_t highe discard.push_back(packet); } for (auto packet : discard) { - auto data = packet->peekAtFront(); - edcaf->getAckHandler()->dropFrame(data); - edcaf->getRecoveryProcedure()->dropFrame(data); - frames->dropFrame(packet); - PacketDropDetails details; - details.setReason(OTHER_PACKET_DROP); - emit(packetDroppedSignal, packet, &details); + if (!frames->containsFrame(packet)) + continue; + bool msdu = edcaf->getRecoveryProcedure()->hasMsduRetryRecord(packet); + auto members = msdu ? frames->getAllocationFrames(packet) : std::vector{packet}; + if (msdu) + edcaf->getRecoveryProcedure()->retireMsdu(packet); + for (auto member : members) { + auto data = member->peekAtFront(); + edcaf->getAckHandler()->dropFrame(data); + edcaf->getRecoveryProcedure()->dropFrame(data); + frames->dropFrame(member); + PacketDropDetails details; + details.setReason(OTHER_PACKET_DROP); + emit(packetDroppedSignal, member, &details); + } } if (all) { auto queue = edcaf->getPendingQueue(); @@ -1306,9 +1318,10 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) if (blockAckVariant == BlockAckVariant::COMPRESSED && originatorBlockAckAgreementHandler) { auto candidate = frames->peekFrameToTransmit(); auto data = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; - auto agreement = data ? originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()) : nullptr; + auto agreement = data && originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()) : nullptr; if (data && data->getType() == ST_DATA_WITH_QOS && !data->getReceiverAddress().isMulticast() && - agreement && agreement->getIsAddbaResponseReceived() && !frames->containsFrame(candidate)) { + (usesMsduRecovery(candidate) || (agreement && agreement->getIsAddbaResponseReceived())) && !frames->containsFrame(candidate)) { scopedQueuedData = true; // Collision recovery needs a numbered frame, but it must not form an unadmitted aggregate. auto service = check_and_cast(originatorDataService); @@ -1330,6 +1343,7 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) EV_INFO << printAccessCategory(ac) << " (" << internallyCollidedFrame->getName() << ")" << endl; bool retryLimitReached = false; if (auto dataHeader = dynamicPtrCast(internallyCollidedHeader)) { // TODO QoSDataFrame + registerMsduRecovery(edcaf, internallyCollidedFrame); dataRecoveryProcedure->dataFrameTransmissionFailed(internallyCollidedFrame, dataHeader); retryLimitReached = dataRecoveryProcedure->isRetryLimitReached(internallyCollidedFrame, dataHeader); } @@ -1346,7 +1360,10 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) else if (auto mgmtHeader = dynamicPtrCast(internallyCollidedHeader)) edcaf->getMgmtAndNonQoSRecoveryProcedure()->retryLimitReached(internallyCollidedFrame, mgmtHeader); else ; // TODO + NonQoSDataFrame - edcaf->getInProgressFrames()->dropFrame(internallyCollidedFrame); + if (usesMsduRecovery(internallyCollidedFrame)) + disposeMsdu(edcaf, internallyCollidedFrame); + else + edcaf->getInProgressFrames()->dropFrame(internallyCollidedFrame); edcaf->getAckHandler()->dropFrame(internallyCollidedHeader); PacketDropDetails details; details.setReason(RETRY_LIMIT_REACHED); @@ -1630,7 +1647,10 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) EV_INFO << "RTS frame transmission failed\n"; bool retryLimitReached = false; if (auto dataHeader = dynamicPtrCast(protectedHeader)) { - edcaf->getRecoveryProcedure()->rtsFrameTransmissionFailed(dataHeader); + if (edcaf->getRecoveryProcedure()->hasMsduRetryRecord(packet)) + edcaf->getRecoveryProcedure()->msduTransmissionFailed(packet, true); + else + edcaf->getRecoveryProcedure()->rtsFrameTransmissionFailed(dataHeader); retryLimitReached = edcaf->getRecoveryProcedure()->isRtsFrameRetryLimitReached(packet, dataHeader); } else if (auto mgmtHeader = dynamicPtrCast(protectedHeader)) { @@ -1648,7 +1668,10 @@ void Hcf::originatorProcessRtsProtectionFailed(Packet *packet) else if (auto mgmtHeader = dynamicPtrCast(protectedHeader)) edcaf->getMgmtAndNonQoSRecoveryProcedure()->retryLimitReached(packet, mgmtHeader); else ; // TODO nonqos data - edcaf->getInProgressFrames()->dropFrame(packet); + if (usesMsduRecovery(packet)) + disposeMsdu(edcaf, packet); + else + edcaf->getInProgressFrames()->dropFrame(packet); edcaf->getAckHandler()->dropFrame(protectedHeader); EV_INFO << "Dropping RTS/CTS protected frame " << packet->getName() << ", because retry limit is reached.\n"; PacketDropDetails details; @@ -1827,7 +1850,10 @@ void Hcf::originatorProcessFailedFrame(Packet *failedPacket) edcaf->getRecoveryProcedure()->retryLimitReached(failedPacket, dataHeader); else if (auto mgmtHeader = dynamicPtrCast(failedHeader)) edcaf->getMgmtAndNonQoSRecoveryProcedure()->retryLimitReached(failedPacket, mgmtHeader); - edcaf->getInProgressFrames()->dropFrame(failedPacket); + if (usesMsduRecovery(failedPacket)) + disposeMsdu(edcaf, failedPacket); + else + edcaf->getInProgressFrames()->dropFrame(failedPacket); edcaf->getAckHandler()->dropFrame(dynamicPtrCast(failedHeader)); EV_INFO << "Dropping frame " << failedPacket->getName() << ", because retry limit is reached.\n"; PacketDropDetails details; @@ -1945,9 +1971,18 @@ void Hcf::originatorProcessReceivedControlFrame(Packet *packet, const PtrbuildRtsFrame(header))); + prepared.rtsPrediction->insertAtBack(makeShared()); + auto rts = prepared.rtsPrediction->peekAtFront(); + if (!selectedRtsMode) + selectedRtsMode = rateSelection->computeMode(prepared.rtsPrediction.get(), rts, txop); + prepared.rtsMode = selectedRtsMode; + setFrameMode(prepared.rtsPrediction.get(), rts, selectedRtsMode); + prepared.ctsMode = rateSelection->computeResponseCtsFrameMode(prepared.rtsPrediction.get(), rts, ResponseQueryRole::PREDICT); + } +} + +int Hcf::computeFreshMpduBound(PreparedDataTransmission& prepared, TxopProcedure *txop, + const IIeee80211Mode *&selectedRtsMode) +{ + auto original = prepared.frame; + auto header = original->peekAtFront(); + int overhead = B(header->getChunkLength()).get() + 4; + int low = overhead; + int high = original->getByteLength(); + if (txop->getLimit() == 0) + return high; + // The policy still owns the partition. This search supplies only the complete-exchange airtime bound. + while (low < high) { + int size = low + (high - low + 1) / 2; + Packet candidate("bounded-DATA", header); + candidate.insertAtBack(makeShared(B(size - overhead))); + candidate.insertAtBack(makeShared()); + prepared.frame = &candidate; + prepareDataModes(prepared, txop, selectedRtsMode); + if (computePreparedDataCost(prepared, prepared.rtsMode != nullptr) <= txop->getLimit()) + low = size; + else + high = size - 1; + } + prepared.frame = original; + prepareDataModes(prepared, txop, selectedRtsMode); + return low; +} + +bool Hcf::commitPreparedData(const FrameSequenceContext *context, PreparedDataTransmission& prepared) +{ + auto service = check_and_cast(originatorDataService); + auto owner = edca->getChannelOwner(); + auto frames = context->getInProgressFrames(); + if (prepared.fragments) { + auto source = findFragmentSource(*prepared.fragments); + std::vector fragments; + if (!service->commitPreparedFragments(*prepared.fragments, source, fragments)) + return false; + ASSERT(fragments.front() == prepared.frame); + if (source) + frames->replaceWithPreparedFragments(source, fragments); + else + frames->adoptPreparedFragments(fragments); + prepared.fragments.reset(); + } + else if (prepared.preparation) { + auto committed = service->commitPreparedFrame(*prepared.preparation); + if (!committed) + return false; + ASSERT(committed == prepared.frame); + frames->adoptPreparedFrame(committed); + prepared.preparation.reset(); + } + registerMsduRecovery(owner, prepared.frame); + return true; +} + +void Hcf::disposeMsdu(Edcaf *edcaf, Packet *packet) +{ + auto recovery = edcaf->getRecoveryProcedure(); + recovery->retireMsdu(packet); + edcaf->getInProgressFrames()->dropAllocation(packet); +} + +simtime_t Hcf::forecastPreparedSuccessor(const FrameSequenceContext *context, + const PreparedDataTransmission& prepared, simtime_t ifs) +{ + auto txop = context->getQoSContext()->txopProcedure; + if (txop->getLimit() == 0) + return SIMTIME_ZERO; + Packet *candidate = nullptr; + for (auto frame : context->getInProgressFrames()->getEligibleFrames()) + if (frame != prepared.frame) { + candidate = frame; + break; + } + auto queue = edca->getChannelOwner()->getPendingQueue(); + if (!candidate) { + for (int i = 0; i < queue->getNumPackets(); i++) { + auto frame = queue->getPacket(i); + if (prepared.preparation && std::find(prepared.preparation->sourceIds.begin(), + prepared.preparation->sourceIds.end(), frame->getId()) != prepared.preparation->sourceIds.end()) + continue; + if (isFrameEligible(frame, false)) { + candidate = frame; + break; + } + } + } + if (!candidate || candidate->peekAtFront()->getReceiverAddress().isMulticast()) + return SIMTIME_ZERO; + std::unique_ptr forecast(candidate->dup()); + auto header = forecast->peekAtFront(); + if (!isPeerCompatibleMode(modeSet, mib->findPeerHtState(header->getReceiverAddress()), prepared.dataMode)) + return SIMTIME_ZERO; + if (auto data = dynamicPtrCast(header)) { + auto policy = originatorAckPolicy->computeAckPolicy(forecast.get(), data, nullptr); + auto updated = forecast->removeAtFront(); + updated->setAckPolicy(policy); + forecast->insertAtFront(updated); + header = updated; + } + // Duration is an estimate. The next exchange selects its actual mode once at its own admission boundary. + setFrameMode(forecast.get(), header, prepared.dataMode); + auto sifs = modeSet->getSifsTime(); + auto cost = prepared.dataMode->getDuration(forecast->getDataLength()); + if (recipientAckPolicy->isAckNeeded(header)) + cost += sifs + rateSelection->computeResponseAckFrameMode(forecast.get(), header, + ResponseQueryRole::PREDICT)->getDuration(LENGTH_ACK); + auto reservation = cost; + if (rtsPolicy->isRtsNeeded(forecast.get(), header)) { + Packet rts("forecast-RTS", rtsProcedure->buildRtsFrame(header)); + rts.insertAtBack(makeShared()); + auto rtsHeader = rts.peekAtFront(); + auto mode = prepared.rtsMode ? prepared.rtsMode : rateSelection->computeMode(&rts, rtsHeader, txop); + setFrameMode(&rts, rtsHeader, mode); + reservation = mode->getDuration(rts.getDataLength()) + sifs + + rateSelection->computeResponseCtsFrameMode(&rts, rtsHeader, ResponseQueryRole::PREDICT)->getDuration(LENGTH_CTS); + cost += reservation + sifs; + } + return ifs + computePreparedDataCost(prepared, false) + sifs + cost <= txop->getRemaining() ? reservation : SIMTIME_ZERO; +} + DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context) { Enter_Method("prepareDataTransmission"); @@ -2232,17 +2480,26 @@ DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context auto header = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; if (!header || header->getType() != ST_DATA_WITH_QOS || header->getReceiverAddress().isMulticast()) return DataPreparationResult::LEGACY; - auto agreement = originatorBlockAckAgreementHandler->getAgreement(header->getReceiverAddress(), header->getTid()); - if (!agreement || !agreement->getIsAddbaResponseReceived()) + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(header->getReceiverAddress(), header->getTid()) : nullptr; + if (agreement && !agreement->getIsAddbaResponseReceived()) + agreement = nullptr; + if (!agreement) return DataPreparationResult::LEGACY; auto prepared = std::make_unique(); prepared->modeSet = modeSet; prepared->agreement = agreement; + if (agreement && blockAckVariant == BlockAckVariant::COMPRESSED && frames->containsFrame(candidate)) + edca->getChannelOwner()->getRecoveryProcedure()->retireMsdu(candidate); auto service = check_and_cast(originatorDataService); if (frames->containsFrame(candidate)) prepared->frame = candidate; else { - prepared->preparation = service->prepareFrame(edca->getChannelOwner()->getPendingQueue(), !service->hasAMpduAggregation()); + auto peer = mib->findPeerHtState(header->getReceiverAddress()); + // IEEE Std 802.11-2024, 10.11: Normal Ack preparation still requires peer HT capabilities for A-MSDU. + bool aggregate = mib->isHtOperationSupported() && peer && peer->valid && + (!agreement || !service->hasAMpduAggregation()); + prepared->preparation = service->prepareFrame(edca->getChannelOwner()->getPendingQueue(), aggregate); if (!prepared->preparation) return DataPreparationResult::DEFERRED; prepared->frame = prepared->preparation->packet.get(); @@ -2253,15 +2510,16 @@ DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context auto txop = context->getQoSContext()->txopProcedure; prepared->dataMode = rateSelection->computeMode(prepared->frame, prepared->frame->peekAtFront(), txop); - if (service->hasAMpduAggregation() && prepareAggregateData(context, *prepared)) + if (agreement && blockAckVariant == BlockAckVariant::COMPRESSED && service->hasAMpduAggregation() && prepareAggregateData(context, *prepared)) return DataPreparationResult::READY; const IIeee80211Mode *selectedRtsMode = nullptr; + bool fragmentsChecked = false; for (;;) { auto packet = prepared->frame; auto policy = originatorAckPolicy->computeAckPolicy(packet, packet->peekAtFront(), agreement); auto updated = packet->removeAtFront(); bool retry = false; - if (!prepared->preparation) { + if (!prepared->preparation && !prepared->fragments) { auto status = edca->getChannelOwner()->getAckHandler()->getQoSDataAckStatus(updated); retry = status == QosAckHandler::Status::NORMAL_ACK_NOT_ARRIVED || status == QosAckHandler::Status::BLOCK_ACK_NOT_ARRIVED || status == QosAckHandler::Status::BLOCK_ACK_ARRIVED_UNACKED; @@ -2270,22 +2528,33 @@ DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context updated->setRetry(retry); updated->setAckPolicy(policy); packet->insertAtFront(updated); - setFrameMode(packet, updated, prepared->dataMode); - prepared->ackMode = recipientAckPolicy->isAckNeeded(updated) ? - rateSelection->computeResponseAckFrameMode(packet, updated, ResponseQueryRole::PREDICT) : nullptr; - bool protect = rtsPolicy->isRtsNeeded(packet, updated); - prepared->setRtsPrediction(nullptr); - prepared->rtsMode = nullptr; - prepared->ctsMode = nullptr; - if (protect) { - prepared->setRtsPrediction(new Packet("prepared-RTS", rtsProcedure->buildRtsFrame(updated))); - prepared->rtsPrediction->insertAtBack(makeShared()); - auto rts = prepared->rtsPrediction->peekAtFront(); - if (!selectedRtsMode) - selectedRtsMode = rateSelection->computeMode(prepared->rtsPrediction.get(), rts, txop); - prepared->rtsMode = selectedRtsMode; - setFrameMode(prepared->rtsPrediction.get(), rts, selectedRtsMode); - prepared->ctsMode = rateSelection->computeResponseCtsFrameMode(prepared->rtsPrediction.get(), rts, ResponseQueryRole::PREDICT); + prepareDataModes(*prepared, txop, selectedRtsMode); + bool protect = prepared->rtsMode != nullptr; + if ((!agreement || blockAckVariant == BlockAckVariant::BASIC) && !fragmentsChecked && !updated->getAMsduPresent() && + !frames->isSameSizeDataRetry(packet) && !updated->getMoreFragments() && updated->getFragmentNumber() == 0) { + fragmentsChecked = true; + int bound = agreement ? + packet->getByteLength() : computeFreshMpduBound(*prepared, txop, selectedRtsMode); + auto fragments = service->prepareFragments(edca->getChannelOwner()->getPendingQueue(), + frames->containsFrame(candidate) ? candidate : nullptr, bound); + if (fragments && fragments->status == FragmentPartitionStatus::IMPOSSIBLE) { + auto configured = service->prepareFragments(edca->getChannelOwner()->getPendingQueue(), + frames->containsFrame(candidate) ? candidate : nullptr, packet->getByteLength()); + // IEEE Std 802.11-2024, 10.23.2.9: the sixteen-fragment exception can permit this partition. + if (configured && configured->status == FragmentPartitionStatus::FRAGMENTED && configured->fragments.size() == 16) + fragments = std::move(configured); + } + if (fragments && fragments->status == FragmentPartitionStatus::FRAGMENTED) { + prepared->fragments = std::move(fragments); + prepared->preparation.reset(); + prepared->frame = prepared->fragments->fragments.front(); + continue; + } + if ((fragments && fragments->status == FragmentPartitionStatus::IMPOSSIBLE) || + (!agreement && txop->getLimit() > 0 && computePreparedDataCost(*prepared, protect) > txop->getLimit())) + throw cRuntimeError("TXOP admission: no permitted form fits peer %s TID %d mode %s limit %s (MPDU bound %d bytes)", + updated->getReceiverAddress().str().c_str(), int(updated->getTid()), prepared->dataMode->getName(), + txop->getLimit().str().c_str(), bound); } if (validatePreparedData(*prepared, simTime() + context->getIfs()) && canAdmitPreparedData(context, *prepared, context->getIfs(), protect)) { @@ -2575,7 +2844,7 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) !canAdmitPreparedData(context, *prepared, ifs, rtsStep != nullptr))) return false; if (dynamicPtrCast(header) && - !(preparedStep && (prepared->preparation || prepared->batch)) && + !(preparedStep && (prepared->preparation || prepared->fragments || prepared->batch)) && !channelOwner->getInProgressFrames()->containsFrame(packet)) return false; if (!isFrameEligible(packet, true)) @@ -2636,11 +2905,30 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) if (preparedStep) { auto response = rtsStep ? prepared->ctsMode->getDuration(LENGTH_CTS) : prepared->ackMode ? prepared->ackMode->getDuration(LENGTH_ACK) : SIMTIME_ZERO; + simtime_t successor = SIMTIME_ZERO; + if (!rtsStep && (!prepared->agreement || blockAckVariant == BlockAckVariant::BASIC)) { + auto dataHeader = prepared->frame->peekAtFront(); + std::vector members = prepared->fragments ? prepared->fragments->fragments : + channelOwner->getInProgressFrames()->getAllocationFrames(prepared->frame); + for (auto member : members) { + auto next = member->peekAtFront(); + if (next->getFragmentNumber() == dataHeader->getFragmentNumber() + 1) { + auto nextCost = prepared->dataMode->getDuration(member->getDataLength()); + if (prepared->ackMode) + nextCost += modeSet->getSifsTime() + response; + if (txop->getLimit() == 0 || ifs + computePreparedDataCost(*prepared, false) + + modeSet->getSifsTime() + nextCost <= txop->getRemaining()) + successor = nextCost; + } + } + if (successor == 0 && !dataHeader->getMoreFragments() && dataHeader->getFragmentNumber() == 0) + successor = forecastPreparedSuccessor(context, *prepared, ifs); + } simtime_t duration; if (txop->getProtectionMechanism() == TxopProcedure::SINGLE_PROTECTION) { // Reserve this exchange only. A later BAR obtains contention through the existing arbitration path. duration = encodeDuration(singleProtectionMechanism->computeDurationField(header, response, - rtsStep ? computePreparedDataCost(*prepared, false) : SIMTIME_ZERO, true), true); + rtsStep ? computePreparedDataCost(*prepared, false) : successor, rtsStep || successor == 0), true); } else { auto ppduDuration = mode->getDuration(packet->getDataLength()); @@ -2648,10 +2936,13 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) auto reservation = std::max(SIMTIME_ZERO, txop->getReservationEnd() - projectedStart); auto remaining = std::max(SIMTIME_ZERO, txop->getStart() + txop->getLimit() - projectedStart); auto cost = computePreparedDataCost(*prepared, rtsStep != nullptr); + if (successor > 0) + cost += modeSet->getSifsTime() + successor; bool singleDataOverrun = txop->getLimit() > 0 && ifs + cost > txop->getRemaining() && isInitialDataException(context, *prepared); // An allowed single-DATA overrun protects its actual exchange beyond the nominal limit. - duration = singleDataOverrun ? computeMultipleProtectionDuration(0, 0, 0, ppduDuration, cost, false) : + duration = (singleDataOverrun || (txop->getLimit() == 0 && successor > 0)) ? + computeMultipleProtectionDuration(0, 0, 0, ppduDuration, cost, false) : computeMultipleProtectionDuration(txop->getLimit(), remaining, reservation, ppduDuration, txop->getLimit() == 0 ? cost : SIMTIME_ZERO, txop->getReservationEnd() != 0); } @@ -2744,20 +3035,22 @@ bool Hcf::transmitFrame(Packet *packet, simtime_t ifs) } else throw cRuntimeError("Undefined protection mechanism"); - if (preparedStep && packet == prepared->frame && prepared->preparation) { - auto service = check_and_cast(originatorDataService); - auto committed = service->commitPreparedFrame(*prepared->preparation); - if (!committed) + if (preparedStep && (packet == prepared->frame || (rtsStep && (!prepared->agreement || blockAckVariant == BlockAckVariant::BASIC))) && + (prepared->preparation || prepared->fragments)) { + if (!commitPreparedData(context, *prepared)) return false; - ASSERT(committed == packet); - prepared->preparation.reset(); - channelOwner->getInProgressFrames()->adoptPreparedFrame(committed); - header = committed->peekAtFront(); + header = packet->peekAtFront(); } + if (preparedStep && rtsStep) + registerMsduRecovery(channelOwner, prepared->frame); RateSelection::emitDatarateSelected(this, header, mode); EV_DEBUG << "Datarate for " << packet->getName() << " is set to " << mode->getDataMode()->getNetBitrate() << ".\n"; tx->transmitFrame(packet, packet->peekAtFront(), ifs, false, this); if (auto dataHeader = dynamicPtrCast(header)) { + if (usesMsduRecovery(packet)) { + registerMsduRecovery(channelOwner, packet); + channelOwner->getInProgressFrames()->recordDataTransmission(packet); + } if (originatorBlockAckAgreementHandler) { auto agreement = originatorBlockAckAgreementHandler->getAgreement(dataHeader->getReceiverAddress(), dataHeader->getTid()); if (agreement && agreement->getIsAddbaResponseReceived()) diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h index 7c2dba912f5..91ffa5e5b96 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h @@ -184,6 +184,18 @@ class INET_API Hcf : public ICoordinationFunction, public IFrameSequenceHandler: static simtime_t encodeDuration(simtime_t duration, bool holder); simtime_t computeImmediateResponseDuration(Packet *packet, const Ptr& header); DataPreparationResult prepareDataTransmission(FrameSequenceContext *context); + bool usesModernMsduRecovery(Packet *packet) const; + bool usesMsduRecovery(Packet *packet) const; + void registerMsduRecovery(Edcaf *edcaf, Packet *packet); + Packet *findFragmentSource(const PreparedQosFragments& preparation) const; + void prepareDataModes(PreparedDataTransmission& prepared, TxopProcedure *txop, + const physicallayer::IIeee80211Mode *&selectedRtsMode); + int computeFreshMpduBound(PreparedDataTransmission& prepared, TxopProcedure *txop, + const physicallayer::IIeee80211Mode *&selectedRtsMode); + bool commitPreparedData(const FrameSequenceContext *context, PreparedDataTransmission& prepared); + void disposeMsdu(Edcaf *edcaf, Packet *packet); + simtime_t forecastPreparedSuccessor(const FrameSequenceContext *context, + const PreparedDataTransmission& prepared, simtime_t ifs); bool prepareAggregateData(FrameSequenceContext *context, const PreparedDataTransmission& selected); void processAggregateOutcome(const Ptr& response); bool validatePreparedData(const PreparedDataTransmission& prepared, simtime_t start) const; diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h index b5026782257..ecbbe9d98a5 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h +++ b/src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h @@ -37,6 +37,7 @@ enum class DataPreparationResult { LEGACY, READY, DEFERRED }; struct INET_API PreparedDataTransmission : public cObject { std::unique_ptr preparation; + std::unique_ptr fragments; std::unique_ptr batch; MpduAggregationLimits limits; std::unique_ptr envelope; diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc index 78d11e1dd0f..58a87f8bba9 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc @@ -77,7 +77,7 @@ bool TxOpFs::isRtsCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *con { auto protectedFrame = context->getDataFrameToTransmit(); auto prepared = context->getQoSContext()->preparedData.get(); - if (prepared && prepared->batch) + if (prepared) return prepared->rtsMode != nullptr; return context->getRtsPolicy()->isRtsNeeded(protectedFrame, protectedFrame->peekAtFront()); } From 25d9c94ddacc53fd7cba4544d7b79523039ccc6a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 10:08:10 +0200 Subject: [PATCH 39/41] ieee80211: fix: admit Normal Ack DATA before queue extraction Before this commit, disabled Block Ack can consume queued QoS DATA before complete exchange admission. Normal Ack outside an agreement has the same gap. The retained one-millisecond reproduction sends a second A-MSDU beyond the TXOP deadline. After this commit, HCF prepares each candidate at one selected DATA mode. A short tail preserves queued sources. A fresh positive TXOP can select legal fragments. An impossible form stops before extraction. Admission commits before RTS, so a CTS failure updates the same MSDU record. A zero limit permits one complete fragment burst. Prepared admission checks local and peer HT capabilities before A-MSDU preparation. It also derives Retry from this hop's ACK state. An MSDU from another hop cannot force Retry on its first local transmission. These choices explain all ten fingerprint rows in this commit: - showcases/wireless/aggregation, Aggregation: the non-HT path sends ordinary MPDUs instead of A-MSDUs. - showcases/wireless/aggregation, VoicePriorityAggregation: the non-HT path sends ordinary MPDUs instead of A-MSDUs. - showcases/wireless/fragmentation, HCFfrag: complete admission defers the next MSDU after the current fragment group. - showcases/wireless/qos, Qos: the non-HT path sends ordinary MPDUs instead of A-MSDUs. - examples/adhoc/qos, MacQos run 0: disabled Block Ack uses prepared admission and excludes non-HT A-MSDUs. - examples/adhoc/qos, MsduAggregation: the non-HT path sends ordinary MPDUs instead of A-MSDUs. - examples/wireless/mactest, MacEdca: a zero-limit TXOP sends the next fragment after SIFS instead of new contention. - examples/wireless/qos, MacQos: the non-HT path sends ordinary MPDUs instead of A-MSDUs. - examples/wireless/qos, MacQosWithoutAggregation: local ACK state clears the previous hop's Retry bit on the first local transmission. - examples/wireless/qos, MacQosWithRtsCts: the protected non-HT path sends ordinary MPDUs instead of A-MSDUs. The user explicitly authorized these baseline updates on 2026-10-19. Each row records the measured C4 values, with graphical values where present. The preceding baseline commit owns inherited graphical drift. C5 owns the later Basic changes. This implements C4 in plan/pending/ieee80211-txop-admission-remaining-paths.md. The debug build and eight selected module fixtures pass. They cover admission, protection, cancellation, collisions, and management traffic. The twenty-five-row comparison separates C3, C4, and C5 effects. The publication evidence records its exact commands and values. Change: src.ieee80211 | behavior.change.fix | test fingerprint whatsnew | txop-admission-remaining --- .../ieee80211/mac/coordinationfunction/Hcf.cc | 18 +- .../ieee80211/mac/framesequence/HcfFs.cc | 3 +- tests/fingerprint/examples.csv | 12 +- tests/fingerprint/showcases.csv | 8 +- ...eee80211CompressedBlockAckAdmission_1.test | 4 +- .../Ieee80211HcfMultipleProtection_1.test | 21 +- .../Ieee80211HcfMultipleProtection_2.test | 13 +- .../Ieee80211HcfSingleProtection_1.test | 56 ++- tests/module/Ieee80211TxopAdmission_1.test | 458 ++++++++++++++++++ 9 files changed, 543 insertions(+), 50 deletions(-) create mode 100644 tests/module/Ieee80211TxopAdmission_1.test diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index 923196397c8..aeb5478d175 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -1315,7 +1315,8 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) auto frames = edcaf->getInProgressFrames(); Packet *internallyCollidedFrame = nullptr; bool scopedQueuedData = false; - if (blockAckVariant == BlockAckVariant::COMPRESSED && originatorBlockAckAgreementHandler) { + if ((blockAckVariant == BlockAckVariant::COMPRESSED && originatorBlockAckAgreementHandler) || + !originatorBlockAckAgreementHandler) { auto candidate = frames->peekFrameToTransmit(); auto data = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; auto agreement = data && originatorBlockAckAgreementHandler ? @@ -2285,12 +2286,19 @@ bool Hcf::validatePreparedData(const PreparedDataTransmission& prepared, simtime bool Hcf::usesModernMsduRecovery(Packet *packet) const { - return false; + if (originatorBlockAckAgreementHandler && blockAckVariant == BlockAckVariant::BASIC) + return false; + auto header = dynamicPtrCast(packet->peekAtFront()); + if (!header || header->getType() != ST_DATA_WITH_QOS || header->getReceiverAddress().isMulticast()) + return false; + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(header->getReceiverAddress(), header->getTid()) : nullptr; + return !agreement || !agreement->getIsAddbaResponseReceived(); } bool Hcf::usesMsduRecovery(Packet *packet) const { - return false; + return usesModernMsduRecovery(packet); } void Hcf::registerMsduRecovery(Edcaf *edcaf, Packet *packet) @@ -2473,7 +2481,7 @@ simtime_t Hcf::forecastPreparedSuccessor(const FrameSequenceContext *context, DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context) { Enter_Method("prepareDataTransmission"); - if (blockAckVariant != BlockAckVariant::COMPRESSED || !originatorBlockAckAgreementHandler) + if (blockAckVariant == BlockAckVariant::BASIC && originatorBlockAckAgreementHandler) return DataPreparationResult::LEGACY; auto frames = context->getInProgressFrames(); auto candidate = frames->peekFrameToTransmit(); @@ -2484,8 +2492,6 @@ DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context originatorBlockAckAgreementHandler->getAgreement(header->getReceiverAddress(), header->getTid()) : nullptr; if (agreement && !agreement->getIsAddbaResponseReceived()) agreement = nullptr; - if (!agreement) - return DataPreparationResult::LEGACY; auto prepared = std::make_unique(); prepared->modeSet = modeSet; prepared->agreement = agreement; diff --git a/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc b/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc index 7bcd7d3be5c..1f1f952f5c9 100644 --- a/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc +++ b/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc @@ -35,8 +35,7 @@ HcfFs::HcfFs() : int HcfFs::selectHcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context) { auto qos = context->getQoSContext(); - auto frameToTransmit = qos->blockAckAgreementHandler ? context->getInProgressFrames()->peekFrameToTransmit() : - context->getInProgressFrames()->getFrameToTransmit(); + auto frameToTransmit = context->getInProgressFrames()->peekFrameToTransmit(); if (qos->ackPolicy->isBlockAckReqNeeded(context->getInProgressFrames(), qos->txopProcedure, qos->blockAckAgreementHandler)) return 1; return frameToTransmit && frameToTransmit->peekAtFront()->getReceiverAddress().isMulticast() ? 0 : 1; diff --git a/tests/fingerprint/examples.csv b/tests/fingerprint/examples.csv index 611e703a853..4cdf3bcf574 100644 --- a/tests/fingerprint/examples.csv +++ b/tests/fingerprint/examples.csv @@ -6,10 +6,10 @@ /examples/adhoc/ieee80211/, -f omnetpp.ini -c Ping1 -r 0, 1000s, 8668-d4e7/tplx;e2b1-205b/~tNl;4083-075c/~tND;e1f1-f93c/tyf, PASS, wireless adhoc Ipv4 # /examples/adhoc/ieee80211/, -f omnetpp.ini -c Ping2 -r 0, 100s, 0000-0000/tplx;0000-0000/~tNl;0000-0000/~tND, ERROR, wireless adhoc # [Config Ping2] # interactive config, needed a *.numHosts parameter /examples/adhoc/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 5749-0281/tplx;f38a-cb93/~tNl;c2ed-b352/~tND;0eb8-3e3b/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;f74f-a0c0/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;57c2-84bd/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;97f7-655d/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, 2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;734c-15d1/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf, PASS, wireless adhoc Ipv4 /examples/aodv/, -f omnetpp.ini -c IPv4SlowMobility -r 0, 50s, 77fe-0daf/tplx;1d8d-30ff/~tNl;6467-0c74/~tND;ac08-940e/tyf, PASS, wireless adhoc AckingWirelessInterface Ipv4 /examples/aodv/, -f omnetpp.ini -c IPv4ModerateFastMobility -r 0, 50s, ed5e-39c4/tplx;3f90-6604/~tNl;b754-ceda/~tND, PASS, wireless adhoc AckingWirelessInterface Ipv4 @@ -605,7 +605,7 @@ /examples/wireless/layeredapsk/, -f omnetpp.ini -c General -r 0, 100s, 1d44-454e/tplx;a4c8-b076/~tNl;21b2-88a0/~tND;49fc-2324/tyf, PASS, wireless Ipv4 # /examples/wireless/mactest/, -f omnetpp.ini -c MacBase -r 0 # abstract-config -/examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, 5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;24e0-2e48/tyf, PASS, wireless +/examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf, PASS, wireless /examples/wireless/mactest/, -f omnetpp.ini -c MacDcf -r 0, 100s, 031d-548a/tplx;4db6-9460/~tNl;4c1d-35a0/~tND;3edc-eb8d/tyf, PASS, wireless # /examples/wireless/multiradio/, -f .qtenv.ini -c General -r 0 @@ -655,9 +655,9 @@ /examples/wireless/power/, -f omnetpp.ini -c General -r 0, 100s, 6fae-d558/tplx;b8ea-b2fc/~tNl;7a95-cf35/~tND, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 0be7-a22e/tplx;5eb9-6cea/~tNl;87a5-11a1/~tND;b802-9992/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, d929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;b06a-f098/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;317d-aa4f/~tND;57cd-2e76/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;8cb9-109e/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;761d-e145/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, 5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;0db4-29ea/tyf, PASS, wireless Ipv4 /examples/wireless/ratecontrol/, -f omnetpp.ini -c Mac -r 0, 100s, bf30-2f13/tplx;7b2f-653d/~tNl;6f09-d8eb/~tND;19fe-8b0e/tyf, PASS, wireless diff --git a/tests/fingerprint/showcases.csv b/tests/fingerprint/showcases.csv index 94ae085def2..57eb474d4d0 100644 --- a/tests/fingerprint/showcases.csv +++ b/tests/fingerprint/showcases.csv @@ -192,8 +192,8 @@ /showcases/visualizer/canvas/transportpathactivity/, -f omnetpp.ini -c Filtering -r 0, 100s, 8bcf-d426/tplx;8f09-7a80/~tNl;92a4-c3ec/~tND;0694-d5be/tyf, PASS, wireless EthernetMac Ipv4 /showcases/wireless/aggregation/, -f omnetpp.ini -c NoAggregation -r 0, 1s, 21a4-c882/tplx;ecf2-6e33/~tNl;5d9e-8fdf/~tND;cb71-81f8/tyf, PASS, wireless Ipv4 -/showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, 0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;6cdd-e65e/tyf, PASS, wireless Ipv4 -/showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;c99f-3188/tyf, PASS, wireless Ipv4 +/showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf, PASS, wireless Ipv4 +/showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf, PASS, wireless Ipv4 /showcases/wireless/analogmodel/, -f omnetpp.ini -c Routing -r 0, 5s, 56b0-3510/tplx;baeb-0d2c/~tNl;3d4b-65fc/~tND;00a2-e4ee/tyf, PASS, wireless Ipv4 /showcases/wireless/analogmodel/, -f omnetpp.ini -c Distance -r 0, 2.5s, 1e75-270e/tplx;6d7a-d84c/~tNl;7b7c-2bfb/~tND;5575-fd8f/tyf, PASS, wireless Ipv4 @@ -266,7 +266,7 @@ /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFnofrag -r 0, 1s, 52b9-628f/tplx;3fec-74a2/~tNl;dbb5-67b0/~tND;8871-1dd1/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;74c3-9ba0/tyf, PASS, wireless Ipv4 -/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;e394-4985/tyf, PASS, wireless Ipv4 +/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, d7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;77f4-58c1/tyf, PASS, wireless Ipv4 /showcases/wireless/handover/, -f omnetpp.ini -c General -r 0, 250s, 6150-7a8b/tplx;bcc9-11d2/~tNl;99fd-923d/~tND;02e9-9ad3/tyf, PASS, wireless @@ -314,7 +314,7 @@ /showcases/wireless/power/, -f omnetpp.ini -c General -r 0, 100s, 498f-b665/tplx;6f50-5caf/~tNl;1403-6fb2/~tND, PASS, wireless Ipv4 /showcases/wireless/qos/, -f omnetpp.ini -c NonQos -r 0, 10s, 5734-43a3/tplx;9c39-00a3/~tNl;03a9-2f02/~tND;34ac-bc95/tyf, PASS, wireless Ipv4 -/showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, 2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;64d2-47e3/tyf, PASS, wireless Ipv4 +/showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf, PASS, wireless Ipv4 /showcases/wireless/ratecontrol/, -f omnetpp.ini -c NoRateControl -r 0, 14s, 7ee9-503a/tplx;0816-e58f/~tNl;ec30-e32d/~tND;dad3-7f89/tyf, PASS, wireless Ipv4 /showcases/wireless/ratecontrol/, -f omnetpp.ini -c AarfRateControl -r 0, 12s, a7bc-05bb/tplx;9de0-4dd3/~tNl;de90-6575/~tND;7539-d32d/tyf, PASS, wireless Ipv4 diff --git a/tests/module/Ieee80211CompressedBlockAckAdmission_1.test b/tests/module/Ieee80211CompressedBlockAckAdmission_1.test index d3c46e46cb0..30510077389 100644 --- a/tests/module/Ieee80211CompressedBlockAckAdmission_1.test +++ b/tests/module/Ieee80211CompressedBlockAckAdmission_1.test @@ -569,8 +569,10 @@ class AdmissionTest : public cSimpleModule { } if (scenario == 14) ASSERT(hcf->data == 1 && hcf->aggregates == 1 && hcf->queriesAtData.front() == 1); - if (scenario == 15 || scenario == 16) + if (scenario == 15) ASSERT(hcf->service()->preparations == 0); + if (scenario == 16) + ASSERT(hcf->service()->preparations > 0 && hcf->service()->commits == 1); if (scenario == 17) { ASSERT(hcf->data == 2 && hcf->aggregates == 0); ASSERT(hcf->queriesAtData[0] == 1 && hcf->queriesAtData[1] == 2); diff --git a/tests/module/Ieee80211HcfMultipleProtection_1.test b/tests/module/Ieee80211HcfMultipleProtection_1.test index a2ea0cc1346..fd0c8de6557 100644 --- a/tests/module/Ieee80211HcfMultipleProtection_1.test +++ b/tests/module/Ieee80211HcfMultipleProtection_1.test @@ -95,9 +95,12 @@ class ProtectionRateSelection : public IQosRateSelection { public: IQosRateSelection *delegate = nullptr; int modeQueries = 0; + std::map, int> dataQueries; const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txop) override { modeQueries++; + if (dynamicPtrCast(header) && !header->getReceiverAddress().isMulticast()) + ASSERT(++dataQueries[std::make_pair(packet->getId(), txop->getStart())] == 1); return delegate->computeMode(packet, header, txop); } const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& header, ResponseQueryRole role) override { @@ -332,7 +335,8 @@ class ProtectionTest : public cSimpleModule { if (scenario != 8) ASSERT(!senderRx->successfulEndpoints.empty()); if (scenario != 6 && scenario != 7 && scenario != 11 && scenario != 12) { - ASSERT(sender->tracedSelection.modeQueries == (int)senderMac->transmissions.size()); + // A refused preview can add a query. Each DATA candidate still has one decision per TXOP. + ASSERT(sender->tracedSelection.modeQueries >= (int)senderMac->transmissions.size()); } auto propagation = scenario == 1 || scenario == 3 || scenario == 16 ? SimTime(0.2e-6) : scenario == 4 ? SimTime(0.48e-6) : SIMTIME_ZERO; @@ -420,24 +424,19 @@ class ProtectionTest : public cSimpleModule { ASSERT(senderMac->transmissions[1].start > ackEnd + SimTime(16, SIMTIME_US)); } if (scenario == 17) { - ASSERT(sender->burstData.size() == 1 && sender->burstData[0] == 2); + ASSERT(sender->burstData.size() == 2 && sender->burstData[0] == 1 && sender->burstData[1] == 1); ASSERT(senderMac->transmissions.size() == 4); ASSERT(receiverMac->transmissions.size() == 4); auto first = senderMac->transmissions[0]; auto rts = senderMac->transmissions[2]; auto data = senderMac->transmissions[3]; - auto deadline = first.start + SimTime(384, SIMTIME_US); ASSERT(first.type == ST_RTS && rts.type == ST_RTS); - ASSERT(rts.start - first.start == SimTime(304, SIMTIME_US)); - ASSERT(rts.start + rts.airtime + rts.duration == deadline); + ASSERT(rts.start > receiverMac->transmissions[1].start + receiverMac->transmissions[1].airtime + SimTime(16, SIMTIME_US)); + ASSERT(rts.start + rts.airtime + rts.duration == rts.start + SimTime(384, SIMTIME_US)); ASSERT(receiverMac->transmissions[2].type == ST_CTS); - ASSERT(receiverMac->transmissions[2].duration == 0); ASSERT(data.type == ST_DATA_WITH_QOS); - ASSERT(data.start - first.start == SimTime(432, SIMTIME_US)); - ASSERT(data.start > deadline); - ASSERT(data.duration == 0); - ASSERT(sender->completedEndpoints.back() == data.start + data.airtime); - ASSERT(receiverMac->transmissions[3].duration == 0); + ASSERT(data.start - rts.start == SimTime(128, SIMTIME_US)); + ASSERT(receiverMac->transmissions[3].start + receiverMac->transmissions[3].airtime <= rts.start + SimTime(384, SIMTIME_US)); } ASSERT(receiver->failures == 0); std::cout << "HCF multiple protection exchange assertions passed.\n"; diff --git a/tests/module/Ieee80211HcfMultipleProtection_2.test b/tests/module/Ieee80211HcfMultipleProtection_2.test index bd2ef75b3d2..86665f59823 100644 --- a/tests/module/Ieee80211HcfMultipleProtection_2.test +++ b/tests/module/Ieee80211HcfMultipleProtection_2.test @@ -301,9 +301,8 @@ class RateProtectionTest : public cSimpleModule { } if (scenario == 2) { auto rate = check_and_cast(getModuleByPath("^.sender.wlan[0].mac.hcf.rateControl")); - ASSERT(rate->rates.size() == 2); - ASSERT(rate->rates[0] == bps(9000000) && rate->rates[1] == bps(12000000)); - ASSERT(rate->queries[1] - rate->queries[0] == SimTime(112, SIMTIME_US)); + ASSERT(rate->rates.size() == 1); + ASSERT(rate->rates[0] == bps(9000000)); ASSERT(senderMac->starts[1] - senderMac->starts[0] == SimTime(128, SIMTIME_US)); ASSERT(senderMac->ends[0] + senderMac->durations[0] - senderMac->starts[0] == SimTime(296, SIMTIME_US)); ASSERT(sender->acknowledgments == 1); @@ -313,7 +312,7 @@ class RateProtectionTest : public cSimpleModule { ASSERT(receiverMac->suppressed); ASSERT(sender->failures == 1); ASSERT(rate->rates[0] == bps(9000000)); - ASSERT(rate->queries.size() >= 3); + ASSERT(rate->queries.size() == 2); ASSERT(senderMac->types[0] == ST_RTS && senderMac->types[1] == ST_RTS); ASSERT(sender->acknowledgments == 1); for (size_t i = 0; i < rate->rates.size(); i++) @@ -325,10 +324,10 @@ class RateProtectionTest : public cSimpleModule { std::cout << "Recipient transmitted NAV duration: " << duration << "\n"; } if (scenario == 4) { - ASSERT(senderMac->rates[1] == bps(6000000)); + ASSERT(senderMac->rates[1] == bps(9000000)); ASSERT(senderMac->ends[0] + senderMac->durations[0] - senderMac->starts[0] == SimTime(296, SIMTIME_US)); - ASSERT(senderMac->durations[1] == SimTime(16, SIMTIME_US)); - ASSERT(receiverMac->ends[1] - senderMac->starts[0] == SimTime(340, SIMTIME_US)); + ASSERT(senderMac->durations[1] == SimTime(60, SIMTIME_US)); + ASSERT(receiverMac->ends[1] - senderMac->starts[0] == SimTime(296, SIMTIME_US)); ASSERT(sender->acknowledgments == 1); } if (scenario == 5) { diff --git a/tests/module/Ieee80211HcfSingleProtection_1.test b/tests/module/Ieee80211HcfSingleProtection_1.test index fe64ee85701..3627d2420f0 100644 --- a/tests/module/Ieee80211HcfSingleProtection_1.test +++ b/tests/module/Ieee80211HcfSingleProtection_1.test @@ -160,7 +160,22 @@ class SingleHcf : public Hcf { auto selectedTag = selected->findTag(); auto selectedMode = selectedTag ? selectedTag->getMode() : nullptr; auto pending = dynamicPtrCast(h) ? - context->getInProgressFrames()->getPendingFrameFor(packet) : nullptr; + context->getInProgressFrames()->getPendingFrameFor(packet, false) : nullptr; + auto prepared = context->getQoSContext()->preparedData.get(); + auto preparation = prepared ? (prepared->preparation ? prepared->preparation.get() : + prepared->fragments ? prepared->fragments->source.get() : nullptr) : nullptr; + if (preparation) { + pending = nullptr; + auto queue = edca->getChannelOwner()->getPendingQueue(); + for (int i = 0; i < queue->getNumPackets(); i++) { + auto candidate = queue->getPacket(i); + const auto& ids = preparation->sourceIds; + if (std::find(ids.begin(), ids.end(), candidate->getId()) == ids.end()) { + pending = candidate; + break; + } + } + } if (pending && sender() && forecastChecks == 0) { if (scenario() != 1) pending->addTagIfAbsent()->setMode(mode(54e6)); @@ -205,7 +220,21 @@ class SingleHcf : public Hcf { void channelGranted(IChannelAccess *access) override { grants++; grantTimes.push_back(simTime()); - Hcf::channelGranted(access); + try { + Hcf::channelGranted(access); + } + catch (const cRuntimeError& error) { + if (!sender() || (scenario() != 7 && scenario() != 20) || + std::string(error.what()).find("TXOP admission: no permitted form fits") == std::string::npos) + throw; + auto owner = edca->getChannelOwner(); + ASSERT(owner->getPendingQueue()->getNumPackets() == 1); + ASSERT(owner->getInProgressFrames()->getLength() == 0 && timerStarts == 0); + auto service = check_and_cast(originatorDataService); + ASSERT(service->getNextSequenceNumber(MacAddress("02:00:00:00:00:02"), 5) == SequenceNumberCyclic(0)); + std::cout << "Single-protection production admission assertions passed.\n"; + endSimulation(); + } } void scheduleStartRxTimer(simtime_t timeout) override { timerStarts++; @@ -240,7 +269,7 @@ class SingleHcf : public Hcf { auto receive = dynamic_cast(last); finishTypes.push_back(receive ? receive->getReceivedFrame()->peekAtFront()->getType() : -1); currentData = 0; - if (sender() && scenario() == 4 && refusals) + if (sender() && scenario() == 4 && edca->getChannelOwner()->getPendingQueue()->getNumPackets() > 0) selection.dataMode = mode(54e6); Hcf::frameSequenceFinished(); } @@ -305,7 +334,7 @@ class SingleTest : public cSimpleModule { ASSERT(!mac->transmissions.empty()); for (auto frame : mac->transmissions) ASSERT(!frame.retry); if (s >= 11 && s <= 13) { - ASSERT(sender->acknowledgments == (s == 13 ? 5 : 4)); + ASSERT(sender->acknowledgments == (s == 13 ? 8 : 7)); ASSERT(sender->grants >= 3); int voice = 0, bestEffort = 0; for (auto frame : mac->transmissions) { @@ -314,7 +343,7 @@ class SingleTest : public cSimpleModule { if (frame.tid == 0) bestEffort++; } } - ASSERT(voice == 4 && bestEffort == (s == 13 ? 1 : 0)); + ASSERT(voice == 7 && bestEffort == (s == 13 ? 1 : 0)); } else if (s == 7 || s == 20) { ASSERT(sender->acknowledgments == 1); @@ -326,16 +355,16 @@ class SingleTest : public cSimpleModule { ASSERT(sender->acknowledgments >= 2); ASSERT(mac->transmissions.size() >= 2); if (s == 18) { - ASSERT(sender->grants == sender->acknowledgments); - for (auto count : sender->burstData) ASSERT(count == 1); + ASSERT(sender->grants == 1 && sender->acknowledgments == 3); + ASSERT(sender->burstData.size() == 1 && sender->burstData[0] == 3); } else ASSERT(sender->burstData[0] > 1); } else if (s == 17) { - ASSERT(sender->acknowledgments == 2); - ASSERT(mac->transmissions.size() == 2); - ASSERT(sender->burstData[0] == 2); - for (auto frame : mac->transmissions) ASSERT(frame.aggregated); + ASSERT(sender->acknowledgments == 4); + ASSERT(mac->transmissions.size() == 4); + ASSERT(sender->burstData[0] == 4); + for (auto frame : mac->transmissions) ASSERT(!frame.aggregated); } else if (s == 25) { ASSERT(sender->acknowledgments == 3); @@ -361,7 +390,7 @@ class SingleTest : public cSimpleModule { ASSERT(sender->decisions[1] == mac->transmissions[0].start + SimTime(160, SIMTIME_US)); } if (s == 1 || s == 4 || s == 8 || s == 16 || s == 22 || s == 24) { - ASSERT(sender->refusals == 1); + ASSERT(sender->refusals == (s == 1 || s == 24 ? 1 : 0)); // Preparation can refuse before a TransmitStep exists. ASSERT(sender->finishTypes[0] == ST_ACK); ASSERT(sender->finishSteps[0] == 2); ASSERT(sender->grants == 2); @@ -387,7 +416,8 @@ class SingleTest : public cSimpleModule { ASSERT(mac->transmissions.size() == 3); ASSERT(mac->transmissions[0].duration == SimTime(188, SIMTIME_US)); ASSERT(mac->transmissions[1].type == ST_RTS); - ASSERT(sender->admissionGrants[1] == 1 && sender->admissionGrants[2] == 2); + ASSERT(sender->admissionGrants.size() == 3); + ASSERT(sender->admissionGrants[1] == 2 && sender->admissionGrants[2] == 2); } if (s == 3 || s == 4) ASSERT(mac->transmissions.back().mode == sender->mode(54e6)); diff --git a/tests/module/Ieee80211TxopAdmission_1.test b/tests/module/Ieee80211TxopAdmission_1.test new file mode 100644 index 00000000000..85a00055d17 --- /dev/null +++ b/tests/module/Ieee80211TxopAdmission_1.test @@ -0,0 +1,458 @@ +%description: +Check Normal Ack admission through infrastructure association, production HCF, EDCA, radio, and peer MACs. +Positive-limit runs require complete DATA/ACK containment at 6 and 24 Mbit/s under both protection classes. +Zero-limit runs require a complete fragment burst for one allocation per TXOP, with RTS disabled or forced. +CTS loss cases check cumulative retry counts and group disposal through the production failure handler. +The fixture removes the first selected CTS responses at the sender. Observers change no admission decision. + +%extraargs: -r 0..95 + +%file: TxopAdmission.cc +#include +#include +#include +#include "inet/common/Simsignals.h" +#include "inet/common/packet/chunk/ByteCountChunk.h" +#include "inet/networklayer/common/NetworkInterface.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" +#include "inet/linklayer/ieee80211/mac/Rx.h" +#include "inet/linklayer/ieee80211/mac/ratecontrol/AarfRateControl.h" +#include "inet/linklayer/ieee80211/mac/ratecontrol/OnoeRateControl.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Radio.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +namespace inet::ieee80211 { +struct AdaptiveQueries { + virtual ~AdaptiveQueries() = default; + int queries = 0; + const physicallayer::IIeee80211Mode *lastMode = nullptr; +}; +class AdmissionOnoe : public OnoeRateControl, public AdaptiveQueries { + public: + const physicallayer::IIeee80211Mode *getRate(const MacAddress& peer) override { + queries++; + return lastMode = OnoeRateControl::getRate(peer); + } +}; +Define_Module(AdmissionOnoe); +class AdmissionAarf : public AarfRateControl, public AdaptiveQueries { + public: + const physicallayer::IIeee80211Mode *getRate(const MacAddress& peer) override { + queries++; + return lastMode = AarfRateControl::getRate(peer); + } +}; +Define_Module(AdmissionAarf); +class AdmissionBudget : public TxopProcedure { + public: + bool forced = false; + simtime_t budget; + simtime_t getRemaining() const override { return forced ? budget : TxopProcedure::getRemaining(); } + simtime_t getLimit() const override { return forced ? budget : TxopProcedure::getLimit(); } + ProtectionMechanism getProtectionMechanism() const override { + return forced ? SINGLE_PROTECTION : TxopProcedure::getProtectionMechanism(); + } +}; +class AdmissionRx : public Rx { + public: + bool forced = false; + simtime_t budget; + simtime_t getTxnavRemaining() const override { return forced ? budget : Rx::getTxnavRemaining(); } +}; +Define_Module(AdmissionRx); + +class TxopAdmissionHcf : public Hcf { + std::map bounds; + std::map zeroAllocations; + std::map fragmentStarts; + std::map fragmentNumbers; + int lostCts = 0; + bool changedModeSet = false; + bool collision = false; + simtime_t collisionDeadline; + std::map rtsQueries; + std::map, b> transmittedLengths; + std::map> retriedFragments; + std::map holderData; + public: + int dataCount = 0; + int fragmentCount = 0; + int acks = 0; + int rtsFailures = 0; + int positiveBoundaryChecks = 0; + int txnavBoundaryChecks = 0; + int cancellations = 0; + void checkExpiredState() { + for (int ac = 0; ac < 4; ac++) { + auto owner = edca->getEdcaf(AccessCategory(ac)); + ASSERT(owner->getPendingQueue()->isEmpty() && owner->getInProgressFrames()->getLength() == 0); + } + ASSERT(edca->getLifetimeHandler()->getNumFrames() == 0); + } + void describe() { + std::cout << getFullPath() << " data=" << dataCount << " failures=" << rtsFailures; + for (int ac = 0; ac < 4; ac++) { + auto owner = edca->getEdcaf(AccessCategory(ac)); + std::cout << " ac=" << ac << " queue=" << owner->getPendingQueue()->getNumPackets() + << " committed=" << owner->getInProgressFrames()->getLength(); + } + std::cout << "\n"; + } + protected: + void processUpperFrame(Packet *packet, const Ptr& header) override { + bool injectCollision = !collision && par("ctsFailures").intValue() == -3 && header->getType() == ST_DATA_WITH_QOS; + if (injectCollision) + rx->setContentionBlocked(true); + Hcf::processUpperFrame(packet, header); + if (injectCollision) { + collision = true; + auto owner = edca->getEdcaf(edca->classifyFrame(staticPtrCast(header))); + collisionDeadline = edca->getLifetimeHandler()->getDeadline(packet); + Hcf::handleInternalCollision({owner}); + auto frame = owner->getInProgressFrames()->getFrames(0); + ASSERT(owner->getInProgressFrames()->getLength() == 1); + ASSERT(!frame->peekAtFront()->getAMsduPresent()); + ASSERT(owner->getRecoveryProcedure()->getRetryCount(frame, frame->peekAtFront()) == 1); + ASSERT(edca->getLifetimeHandler()->getDeadline(frame) == collisionDeadline); + rx->setContentionBlocked(false); + } + } + void checkBoundaries() { + auto context = frameSequenceHandler->getContext(); + auto prepared = context->getQoSContext()->preparedData.get(); + if (!prepared) + return; + auto original = context->getQoSContext()->txopProcedure; + AdmissionBudget stimulus; + auto budget = &stimulus; + auto receiver = check_and_cast(rx); + auto protect = dynamic_cast(context->getLastStep()) != nullptr; + auto cost = computePreparedDataCost(*prepared, protect); + auto tick = SimTime::fromRaw(1); + context->getQoSContext()->txopProcedure = budget; + if (context->getNumSteps() == 1 && positiveBoundaryChecks == 0) { + budget->forced = true; + budget->budget = cost - tick; + ASSERT(!canAdmitPreparedData(context, *prepared, SIMTIME_ZERO, protect)); + budget->budget = cost; + ASSERT(canAdmitPreparedData(context, *prepared, SIMTIME_ZERO, protect)); + budget->budget = cost + tick; + ASSERT(canAdmitPreparedData(context, *prepared, SIMTIME_ZERO, protect)); + PreparedDataTransmission sixteen; + sixteen.dataMode = prepared->dataMode; + sixteen.ackMode = prepared->ackMode; + sixteen.fragments = std::make_unique(); + for (int i = 0; i < 16; i++) { + auto header = makeShared(*prepared->frame->peekAtFront()); + header->setFragmentNumber(i); + header->setMoreFragments(i != 15); + header->setRetry(false); + header->setAMsduPresent(false); + auto member = new Packet("sixteen-fragment-boundary", header); + member->insertAtBack(makeShared(B(2))); + member->insertAtBack(makeShared()); + sixteen.fragments->addFragment(member); + } + sixteen.frame = sixteen.fragments->fragments.front(); + budget->budget = computePreparedDataCost(sixteen, false) - tick; + ASSERT(canAdmitPreparedData(context, sixteen, SIMTIME_ZERO, false)); + auto members = sixteen.fragments->releaseFragments(); + for (int i = 0; i < 15; i++) + sixteen.fragments->addFragment(members[i]); + delete members.back(); + ASSERT(!canAdmitPreparedData(context, sixteen, SIMTIME_ZERO, false)); + budget->forced = false; + positiveBoundaryChecks++; + } + if (context->getNumSteps() > 1 && txnavBoundaryChecks == 0) { + budget->forced = receiver->forced = true; + budget->budget = cost + SimTime(1); + receiver->budget = cost - tick; + ASSERT(!canAdmitPreparedData(context, *prepared, SIMTIME_ZERO, protect)); + receiver->budget = cost; + ASSERT(!canAdmitPreparedData(context, *prepared, SIMTIME_ZERO, protect)); + receiver->budget = cost + tick; + ASSERT(canAdmitPreparedData(context, *prepared, SIMTIME_ZERO, protect)); + budget->forced = receiver->forced = false; + txnavBoundaryChecks++; + } + context->getQoSContext()->txopProcedure = original; + } + void processLowerFrame(Packet *packet, const Ptr& header) override { + auto context = frameSequenceHandler->getContext(); + auto rts = context ? dynamic_cast(context->getStepBeforeLast()) : nullptr; + auto data = rts ? dynamicPtrCast(rts->getProtectedFrame()->peekAtFront()) : nullptr; + if (data && header->getType() == ST_CTS && par("ctsFailures").intValue() == -2 && !changedModeSet) { + changedModeSet = true; + auto radio = check_and_cast(getModuleByPath("^.^.radio")); + radio->setMode(modeSet->getMode(Mbps(24))); + auto replacement = physicallayer::Ieee80211ModeSet::getModeSet("g(mixed)"); + radio->setModeSet(replacement); + getContainingNicModule(this)->emit(modesetChangedSignal, replacement); + } + if (data && header->getType() == ST_CTS && lostCts < par("ctsFailures").intValue()) { + lostCts++; + delete packet; + Hcf::corruptedFrameReceived(); + return; + } + Hcf::processLowerFrame(packet, header); + } + void frameSequenceFinished() override { + auto owner = edca->getChannelOwner(); + auto prepared = frameSequenceHandler->getContext()->getQoSContext()->preparedData.get(); + bool cancellation = changedModeSet && dataCount == 0 && cancellations == 0; + auto retained = cancellation && prepared ? prepared->frame : nullptr; + auto deadline = retained ? edca->getLifetimeHandler()->getDeadline(retained) : SIMTIME_MAX; + Hcf::frameSequenceFinished(); + if (cancellation) { + ASSERT(retained && owner->getInProgressFrames()->containsFrame(retained)); + ASSERT(owner->getRecoveryProcedure()->hasMsduRetryRecord(retained)); + ASSERT(owner->getRecoveryProcedure()->getRetryCount(retained, retained->peekAtFront()) == 0); + ASSERT(edca->getLifetimeHandler()->getDeadline(retained) == deadline); + cancellations++; + rx->setContentionBlocked(true); + } + } + void originatorProcessRtsProtectionFailed(Packet *packet) override { + auto header = dynamicPtrCast(packet->peekAtFront()); + if (!header) { + Hcf::originatorProcessRtsProtectionFailed(packet); + return; + } + auto owner = edca->getChannelOwner(); + auto recovery = owner->getRecoveryProcedure(); + auto frames = owner->getInProgressFrames(); + int count = recovery->getRetryCount(packet, header); + auto deadline = edca->getLifetimeHandler()->getDeadline(packet); + auto allocation = packet->getTag()->getAllocationIndex(); + auto members = frames->getAllocationFrames(packet); + ASSERT(recovery->hasMsduRetryRecord(packet) && !frames->isSameSizeDataRetry(packet)); + Hcf::originatorProcessRtsProtectionFailed(packet); + rtsFailures++; + if (frames->containsFrame(packet)) { + ASSERT(recovery->getRetryCount(packet, header) == count + 1); + ASSERT(edca->getLifetimeHandler()->getDeadline(packet) == deadline); + ASSERT(packet->getTag()->getAllocationIndex() == allocation); + } + else { + ASSERT(count + 1 == recovery->getShortRetryLimit() && !recovery->hasMsduRetryRecord(packet)); + for (auto member : members) + ASSERT(!frames->containsFrame(member) && edca->getLifetimeHandler()->findFrame(member->getId()) == nullptr); + } + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + checkBoundaries(); + bool accepted = Hcf::transmitFrame(packet, ifs); + if (!accepted) + return false; + auto adaptive = dynamic_cast(getSubmodule("rateControl")); + auto context = frameSequenceHandler->getContext(); + if (adaptive && packet->peekAtFront()->getType() == ST_RTS) { + auto rts = check_and_cast(context->getLastStep()); + rtsQueries[rts->getProtectedFrame()->getId()] = adaptive->queries; + } + auto data = dynamicPtrCast(packet->peekAtFront()); + if (dynamicPtrCast(packet->peekAtFront())) + holderData[edca->getChannelOwner()->getTxopProcedure()->getStart()]++; + if (!data || data->getType() != ST_DATA_WITH_QOS || data->getReceiverAddress().isMulticast()) + return true; + if (adaptive) { + ASSERT(packet->getTag()->getMode() == adaptive->lastMode); + if (rtsQueries.count(packet->getId())) + ASSERT(rtsQueries.at(packet->getId()) == adaptive->queries); + } + dataCount++; + auto txop = edca->getChannelOwner()->getTxopProcedure(); + auto allocation = packet->getTag()->getAllocationIndex(); + auto key = std::make_pair(allocation, int(data->getFragmentNumber())); + auto prior = transmittedLengths.find(key); + auto& retried = retriedFragments[allocation]; + bool exception = holderData[txop->getStart()]++ == 0 && + ((prior != transmittedLengths.end() && prior->second == packet->getDataLength()) || + (!retried.empty() && *retried.begin() < data->getFragmentNumber()) || + edca->getChannelOwner()->getInProgressFrames()->getFragmentCount(packet) == 16); + if (prior != transmittedLengths.end()) + retried.insert(data->getFragmentNumber()); + transmittedLengths.emplace(key, packet->getDataLength()); + if (collision && allocation == 0) { + ASSERT(data->getSequenceNumber() == SequenceNumberCyclic(0)); + ASSERT(edca->getLifetimeHandler()->getDeadline(packet) == collisionDeadline); + ASSERT(edca->getChannelOwner()->getRecoveryProcedure()->getRetryCount(packet, data) >= 1); + } + if (txop->getLimit() > 0 && !exception) + bounds[packet->getId()] = txop->getStart() + txop->getLimit(); + else if (txop->getLimit() == 0) { + auto result = zeroAllocations.emplace(txop->getStart(), allocation); + ASSERT(result.second || result.first->second == allocation); + } + else + bounds.erase(packet->getId()); + if (data->getMoreFragments() || data->getFragmentNumber() > 0) { + fragmentCount++; + auto result = fragmentStarts.emplace(allocation, txop->getStart()); + bool source = getParentModule()->getParentModule()->getParentModule()->isName("sta1"); + if (txop->getLimit() == 0 && source && allocation == 0) + ASSERT(result.second || result.first->second == txop->getStart()); + if (txop->getLimit() == 0 && source && allocation == 0 && !data->getMoreFragments()) + ASSERT(edca->getChannelOwner()->getPendingQueue()->getNumPackets() == 1); + if (data->getRetry()) + ASSERT(data->getFragmentNumber() < fragmentNumbers[allocation]); + else + ASSERT(data->getFragmentNumber() == fragmentNumbers[allocation]++); + } + return true; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (bounds.count(packet->getId())) + ASSERT(simTime() <= bounds.at(packet->getId())); + Hcf::transmissionComplete(packet, header); + } + void originatorProcessReceivedFrame(Packet *packet, Packet *transmitted) override { + if (packet->peekAtFront()->getType() == ST_ACK) { + if (bounds.count(transmitted->getId())) + ASSERT(simTime() <= bounds.at(transmitted->getId())); + auto data = dynamicPtrCast(transmitted->peekAtFront()); + if (data && data->getType() == ST_DATA_WITH_QOS) + acks++; + } + Hcf::originatorProcessReceivedFrame(packet, transmitted); + } +}; +Define_Module(TxopAdmissionHcf); + +class TxopAdmissionTest : public cSimpleModule, public cListener { + int received = 0; + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("subscribe")); } + void receiveSignal(cComponent *, simsignal_t, cObject *, cObject *) override { received++; } + void handleMessage(cMessage *message) override { + bool first = message->isName("subscribe"); + delete message; + if (first) { + getModuleByPath("^.sta2.app[0]")->subscribe(packetReceivedSignal, this); + scheduleAt(SimTime(1350, SIMTIME_MS), new cMessage("check")); + return; + } + int loss = par("ctsFailures").intValue(); + bool cancellation = par("rts").boolValue() && (loss == -1 || loss == -2); + int expected = cancellation ? 0 : + (par("zeroLimit").boolValue() ? 2 : 30) - (par("dropMsdu").boolValue() ? 2 : 0); + std::cout << "TXOP delivered=" << received << " expected=" << expected << "\n"; + if (received != expected) + for (const char *path : {"^.sta1.wlan[0].mac.hcf", "^.ap.wlan[0].mac.hcf"}) + check_and_cast(getModuleByPath(path))->describe(); + ASSERT(received == expected); + for (const char *path : {"^.sta1.wlan[0].mac.hcf", "^.ap.wlan[0].mac.hcf"}) { + auto hcf = check_and_cast(getModuleByPath(path)); + ASSERT(hcf->acks >= (par("zeroLimit").boolValue() ? expected * 3 : expected / 2)); + if (par("zeroLimit").boolValue()) + ASSERT(hcf->fragmentCount >= expected * 3); + if (par("rts").boolValue()) + ASSERT(hcf->rtsFailures >= par("ctsFailures").intValue()); + if (!cancellation) + ASSERT(hcf->positiveBoundaryChecks == 1); + if (par("rts").boolValue() && expected > 0) + ASSERT(hcf->txnavBoundaryChecks == 1); + if (cancellation && par("ctsFailures").intValue() == -1) + hcf->checkExpiredState(); + } + if (cancellation && par("ctsFailures").intValue() == -2) + ASSERT(check_and_cast(getModuleByPath("^.sta1.wlan[0].mac.hcf"))->cancellations == 1); + std::cout << "Normal Ack TXOP admission assertions passed.\n"; + endSimulation(); + } +}; +Define_Module(TxopAdmissionTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.Rx; +import inet.linklayer.ieee80211.mac.ratecontrol.AarfRateControl; +import inet.linklayer.ieee80211.mac.ratecontrol.OnoeRateControl; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module TxopAdmissionHcf extends Hcf { parameters: int ctsFailures; @class(::inet::ieee80211::TxopAdmissionHcf); } +simple AdmissionRx extends Rx { parameters: @class(::inet::ieee80211::AdmissionRx); } +simple AdmissionOnoe extends OnoeRateControl { parameters: @class(::inet::ieee80211::AdmissionOnoe); } +simple AdmissionAarf extends AarfRateControl { parameters: @class(::inet::ieee80211::AdmissionAarf); } +simple TxopAdmissionTest { parameters: bool zeroLimit; bool rts; int ctsFailures; bool dropMsdu; @class(::inet::ieee80211::TxopAdmissionTest); } +network TxopAdmissionNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: Ieee80211ScalarRadioMedium; + ap: AccessPoint; + sta1: WirelessHost; + sta2: WirelessHost; + test: TxopAdmissionTest; +} + +%inifile: omnetpp.ini +[General] +network = TxopAdmissionNetwork +ned-path = .;../../../../src;../../lib +sim-time-limit = 1.4s +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" +*.sta1.numApps = 1 +*.sta1.app[0].typename = "UdpBasicApp" +*.sta1.app[0].destAddresses = "sta2" +*.sta1.app[0].destPort = 1000 +*.sta1.app[0].messageLength = 700B +*.sta1.app[0].startTime = 1s +*.sta1.app[0].stopTime = ${zero} ? 1.00015s : 1.00295s +*.sta1.app[0].sendInterval = 100us +*.sta2.numApps = 1 +*.sta2.app[0].typename = "UdpSink" +*.sta2.app[0].localPort = 1000 +*.sta*.ipv4.arp.typename = "GlobalArp" +*.test.zeroLimit = ${zero=false,true} +*.test.ctsFailures = ${loss=0,2,7,-1,-2,-3} +*.test.rts = ${rts} == 0 +*.test.dropMsdu = ${rts} == 0 && ${loss} == 7 +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].bitrate = ${rate=6,24}Mbps +**.bandName = "2.4 GHz" +**.wlan[*].radio.antenna.numAntennas = 2 +**.wlan[*].classifier.typename = "QosClassifier" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "TxopAdmissionHcf" +**.wlan[*].mac.rx.typename = "AdmissionRx" +**.wlan[*].mac.hcf.ctsFailures = ${loss} +**.wlan[*].mac.hcf.isBlockAckSupported = false +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 +**.originatorMacDataService.msduAggregationPolicy.maxAMsduSize = ${zero} || ${loss} != 0 ? 300 : 1600 +**.originatorMacDataService.msduAggregationPolicy.typename = "BasicMsduAggregationPolicy" +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = ${zero} || ${loss} == -3 ? 300B : 2346B +**.rtsPolicy.rtsThreshold = ${rts=0,5000}B +**.txopProcedure.protectionMechanism = ${protection="single","multiple"} +**.txopProcedure.txopLimit = ${zero} ? 0s : 1ms +**.edcaf[*].msduLifetime = ${loss} == -1 && ${rts} == 0 ? 100us : 512ms +**.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.sta1.mobility.initialX = 0m +*.ap.mobility.initialX = 5m +*.sta2.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Normal Ack TXOP admission assertions passed. From e01bb3bd5aba46711e3f657ed92c8feeb18e9654 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 10:09:49 +0200 Subject: [PATCH 40/41] ieee80211: fix: admit Basic exchanges under the 2016 contract Before this commit, enabled Basic support bypasses prepared admission. The legal non-HT probe records eighteen late DATA completions at 24 Mbit/s under multiple protection. Each violation follows earlier DATA in the same TXOP. After this commit, Basic prepares the complete exchange before source extraction. HCF commits an admitted allocation before RTS. Accepted agreements retain the initial ordinary-MSDU exception. Short and long counters still increase after failures and internal collisions. Under the accepted R1 interpretation, those limits do not discard an MSDU under an accepted Basic agreement. Lifetime expiry removes the complete allocation. Fallback without an agreement retains the 2016 retry limits. Basic preparation excludes A-MSDUs without local and peer HT capabilities. A zero-limit TXOP permits the complete fragment group. Fragment reservations include an ACK exchange only when an immediate ACK exists. These choices explain all five fingerprint rows in this commit: - showcases/wireless/blockack, Fragmentation: the zero-limit Basic sequence sends the next fragment after SIFS instead of new contention. - showcases/wireless/fragmentation, HCFfragblockack: prepared Basic admission and fragment reservations change access for the later BAR. - showcases/wireless/txop, General: prepared Basic admission excludes non-HT A-MSDUs and checks complete exchanges. - examples/adhoc/qos, MacQos run 1: enabled Basic uses prepared admission, legal frame forms, and its 2016 recovery contract. - examples/wireless/qos, MacQosWithBlockAck: prepared Basic admission excludes non-HT A-MSDUs and checks complete exchanges. The user explicitly authorized these baseline updates on 2026-10-19. Each row records the measured C5 values, with graphical values where present. The preceding baseline commit owns inherited graphical drift. C4 owns the Normal Ack changes. This implements C5 in plan/pending/ieee80211-txop-admission-remaining-paths.md. The debug build and five selected module fixtures pass. Non-HT and mixed-peer cases cover both protection classes, forced CTS and ACK loss, collisions, expiry, and fragment Duration fields. The twenty-five-row comparison separates C3, C4, and C5 effects. Agreement negotiation remains outside this commit. Change: src.ieee80211 | behavior.change.fix | test fingerprint whatsnew | txop-admission-remaining --- .../ieee80211/mac/coordinationfunction/Hcf.cc | 16 +- tests/fingerprint/examples.csv | 4 +- tests/fingerprint/showcases.csv | 6 +- .../module/Ieee80211BasicTxopAdmission_1.test | 355 ++++++++++++++++++ ...Ieee80211BlockAckFragmentRetirement_1.test | 4 +- ...eee80211CompressedBlockAckAdmission_1.test | 2 +- 6 files changed, 372 insertions(+), 15 deletions(-) create mode 100644 tests/module/Ieee80211BasicTxopAdmission_1.test diff --git a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc index aeb5478d175..11ad151accf 100644 --- a/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +++ b/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc @@ -126,10 +126,13 @@ void Hcf::initialize(int stage) [this](Packet *packet) { return isAMsduPermitted(packet); }); check_and_cast(originatorDataService)->setFragmentationPermission([this](Packet *packet) { auto data = dynamicPtrCast(packet->peekAtFront()); - if (blockAckVariant != BlockAckVariant::COMPRESSED || !data || data->getType() != ST_DATA_WITH_QOS || !originatorBlockAckAgreementHandler) + if (!data || data->getType() != ST_DATA_WITH_QOS || !originatorBlockAckAgreementHandler) return true; auto agreement = originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()); - return !agreement || !agreement->getIsAddbaResponseReceived(); + auto peer = mib->findPeerHtState(data->getReceiverAddress()); + bool htAgreement = blockAckVariant == BlockAckVariant::COMPRESSED || + (mib->isHtOperationSupported() && peer && peer->valid); + return !agreement || !agreement->getIsAddbaResponseReceived() || !htAgreement; }); mib->subscribe(Ieee80211Mib::rateStateChangedSignal, this); for (int ac = 0; ac < AC_NUMCATEGORIES; ac++) { @@ -1315,8 +1318,7 @@ void Hcf::handleInternalCollision(std::vector internallyCollidedEdcafs) auto frames = edcaf->getInProgressFrames(); Packet *internallyCollidedFrame = nullptr; bool scopedQueuedData = false; - if ((blockAckVariant == BlockAckVariant::COMPRESSED && originatorBlockAckAgreementHandler) || - !originatorBlockAckAgreementHandler) { + { auto candidate = frames->peekFrameToTransmit(); auto data = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; auto agreement = data && originatorBlockAckAgreementHandler ? @@ -2298,7 +2300,9 @@ bool Hcf::usesModernMsduRecovery(Packet *packet) const bool Hcf::usesMsduRecovery(Packet *packet) const { - return usesModernMsduRecovery(packet); + auto header = dynamicPtrCast(packet->peekAtFront()); + return header && header->getType() == ST_DATA_WITH_QOS && !header->getReceiverAddress().isMulticast() && + ((originatorBlockAckAgreementHandler && blockAckVariant == BlockAckVariant::BASIC) || usesModernMsduRecovery(packet)); } void Hcf::registerMsduRecovery(Edcaf *edcaf, Packet *packet) @@ -2481,8 +2485,6 @@ simtime_t Hcf::forecastPreparedSuccessor(const FrameSequenceContext *context, DataPreparationResult Hcf::prepareDataTransmission(FrameSequenceContext *context) { Enter_Method("prepareDataTransmission"); - if (blockAckVariant == BlockAckVariant::BASIC && originatorBlockAckAgreementHandler) - return DataPreparationResult::LEGACY; auto frames = context->getInProgressFrames(); auto candidate = frames->peekFrameToTransmit(); auto header = candidate ? dynamicPtrCast(candidate->peekAtFront()) : nullptr; diff --git a/tests/fingerprint/examples.csv b/tests/fingerprint/examples.csv index 4cdf3bcf574..9f096dd04e3 100644 --- a/tests/fingerprint/examples.csv +++ b/tests/fingerprint/examples.csv @@ -7,7 +7,7 @@ # /examples/adhoc/ieee80211/, -f omnetpp.ini -c Ping2 -r 0, 100s, 0000-0000/tplx;0000-0000/~tNl;0000-0000/~tND, ERROR, wireless adhoc # [Config Ping2] # interactive config, needed a *.numHosts parameter /examples/adhoc/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 5749-0281/tplx;f38a-cb93/~tNl;c2ed-b352/~tND;0eb8-3e3b/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf, PASS, wireless adhoc Ipv4 -/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;57c2-84bd/tyf, PASS, wireless adhoc Ipv4 +/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 33e1-5ba7/tplx;f321-055c/~tNl;b439-5b70/~tND;5cb1-cbfe/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;97f7-655d/tyf, PASS, wireless adhoc Ipv4 /examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf, PASS, wireless adhoc Ipv4 @@ -658,7 +658,7 @@ /examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;761d-e145/tyf, PASS, wireless Ipv4 /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, 5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf, PASS, wireless Ipv4 -/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;0db4-29ea/tyf, PASS, wireless Ipv4 +/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 7866-b50d/tplx;cf3d-0664/~tNl;5912-f4f1/~tND;7ed5-dd85/tyf, PASS, wireless Ipv4 /examples/wireless/ratecontrol/, -f omnetpp.ini -c Mac -r 0, 100s, bf30-2f13/tplx;7b2f-653d/~tNl;6f09-d8eb/~tND;19fe-8b0e/tyf, PASS, wireless diff --git a/tests/fingerprint/showcases.csv b/tests/fingerprint/showcases.csv index 57eb474d4d0..ccfa984756a 100644 --- a/tests/fingerprint/showcases.csv +++ b/tests/fingerprint/showcases.csv @@ -200,7 +200,7 @@ /showcases/wireless/analogmodel/, -f omnetpp.ini -c Noise -r 0, 0.1s, dd08-a63c/tplx;e167-9c84/~tNl;d680-b8ad/~tND;0d1f-df73/tyf, PASS, wireless Ipv4 /showcases/wireless/blockack/, -f omnetpp.ini -c NoFragmentation -r 0, 1s, 9161-625d/tplx;6a02-09aa/~tNl;cbc0-3b0a/~tND, PASS, wireless Ipv4 -/showcases/wireless/blockack/, -f omnetpp.ini -c Fragmentation -r 0, 1s, 36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND, PASS, wireless Ipv4 +/showcases/wireless/blockack/, -f omnetpp.ini -c Fragmentation -r 0, 1s, 9fd0-6388/tplx;22f5-8db8/~tNl;68cc-5669/~tND, PASS, wireless Ipv4 /showcases/wireless/blockack/, -f omnetpp.ini -c MixedTraffic -r 0, 1s, 351b-d4ba/tplx;5c1f-69a8/~tNl;6182-6da3/~tND, PASS, wireless Ipv4 /showcases/wireless/crosstalk/, -f omnetpp.ini -c CompletelyOverlappingFrequencyBands -r 0, 1s, d0d7-43e0/tplx;867a-07a4/~tNl;fc60-7eb7/~tND;3ea3-43da/tyf, PASS, wireless Ipv4 @@ -267,7 +267,7 @@ /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFnofrag -r 0, 1s, 52b9-628f/tplx;3fec-74a2/~tNl;dbb5-67b0/~tND;8871-1dd1/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;74c3-9ba0/tyf, PASS, wireless Ipv4 /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, d7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf, PASS, wireless Ipv4 -/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;77f4-58c1/tyf, PASS, wireless Ipv4 +/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 99bc-a74d/tplx;fffd-4625/~tNl;5543-fbef/~tND;821e-8bed/tyf, PASS, wireless Ipv4 /showcases/wireless/handover/, -f omnetpp.ini -c General -r 0, 250s, 6150-7a8b/tplx;bcc9-11d2/~tNl;99fd-923d/~tND;02e9-9ad3/tyf, PASS, wireless @@ -341,5 +341,5 @@ /showcases/wireless/throughput/, -f omnetpp.ini -c General -r 0, 1s, 030e-c416/tplx;66e6-0bca/~tNl;3cb5-d354/~tND;e6a5-bde0/tyf, PASS, wireless Ipv4 -/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, ab91-87f3/tplx;f30c-6aa4/~tNl;6175-eb06/tyf, PASS, wireless Ipv4 +/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, 92af-e665/tplx;7960-ff7c/~tNl;0ec4-ff6b/tyf, PASS, wireless Ipv4 diff --git a/tests/module/Ieee80211BasicTxopAdmission_1.test b/tests/module/Ieee80211BasicTxopAdmission_1.test new file mode 100644 index 00000000000..cd98507956e --- /dev/null +++ b/tests/module/Ieee80211BasicTxopAdmission_1.test @@ -0,0 +1,355 @@ +%description: +Check Basic admission through production infrastructure association, HCF, EDCA, radio, and peer MACs. +Non-HT peers use no aggregation. Both protection classes use 6 and 24 Mbit/s. +The observer checks complete exchange containment and the initial ordinary-MSDU exception. +CTS loss before DATA and after DATA must retain the MSDU beyond the short limit. +Internal collisions under an accepted agreement must retain the MSDU and its absolute deadline. +The expiry case must remove the retained allocation and its recovery record. +The Normal Ack policy subclass changes only the response policy under an accepted agreement. +The zero eligibility threshold checks Basic fallback without an accepted agreement. +Mixed HT and non-HT peers retain legal Basic exchanges in both endpoint roles. + +%extraargs: -r 0..35 + +%file: BasicAdmission.cc +#include +#include +#include "inet/common/Simsignals.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" +#include "inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" +namespace inet::ieee80211 { +class BasicAdmissionAckPolicy : public OriginatorQosAckPolicy { + public: + AckPolicy computeAckPolicy(Packet *packet, const Ptr& header, + OriginatorBlockAckAgreement *agreement) const override { + if (par("normalUnderAgreement").boolValue() && agreement && agreement->getIsAddbaResponseReceived()) + return NORMAL_ACK; + return OriginatorQosAckPolicy::computeAckPolicy(packet, header, agreement); + } +}; +Define_Module(BasicAdmissionAckPolicy); +class BasicAdmissionHcf : public Hcf { + std::map bounds; + std::map holders; + std::map lengths; + std::map zeroAllocations; + int64_t target = -1; + int lostCts = 0; + bool lostAck = false; + int lostDataAcks = 0; + bool collision = false; + Packet *expiredTarget = nullptr; + Edcaf *targetOwner = nullptr; + int scenario() const { return par("scenario"); } + bool source() const { return getParentModule()->getParentModule()->getParentModule()->isName("sta1"); } + bool accepted(const Packet *packet) { + auto data = dynamicPtrCast(packet->peekAtFront()); + auto agreement = data && originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()) : nullptr; + return agreement && agreement->getIsAddbaResponseReceived(); + } + void checkBoundary(Packet *packet) { + auto it = bounds.find(packet->getId()); + if (it != bounds.end()) + ASSERT(simTime() <= it->second); + } + public: + int agreedData = 0; + int exceptions = 0; + int retainedFailures = 0; + int collisionChecks = 0; + int expiryChecks = 0; + int fallbackData = 0; + int retainedDataFailures = 0; + int injectedCtsLosses() const { return lostCts; } + void checkExpiry() { + if (!expiredTarget) + return; + ASSERT(!targetOwner->getInProgressFrames()->containsFrame(expiredTarget)); + // The deferred owner can delete the packet after the sequence ends. Inspect the record by allocation instead. + auto probe = new Packet("allocation-probe"); + probe->addTag()->setAllocationIndex(target); + ASSERT(!targetOwner->getRecoveryProcedure()->hasMsduRetryRecord(probe)); + delete probe; + expiryChecks++; + } + protected: + void processLowerFrame(Packet *packet, const Ptr& header) override { + auto context = frameSequenceHandler->getContext(); + auto rts = context ? dynamic_cast(context->getStepBeforeLast()) : nullptr; + auto protectedPacket = rts ? rts->getProtectedFrame() : nullptr; + if (source() && protectedPacket && header->getType() == ST_CTS && accepted(protectedPacket)) { + auto allocation = protectedPacket->getTag()->getAllocationIndex(); + bool select = scenario() == 1 || scenario() == 4 || (scenario() == 2 && lostAck); + if (select && target == -1) + target = allocation; + if (allocation == target && (scenario() == 4 || lostCts < 9)) { + lostCts++; + delete packet; + Hcf::corruptedFrameReceived(); + return; + } + } + if (source() && scenario() == 2 && !lostAck && header->getType() == ST_ACK && context) { + auto transmit = dynamic_cast(context->getStepBeforeLast()); + auto data = transmit ? transmit->getFrameToTransmit() : nullptr; + if (data && accepted(data)) { + target = data->getTag()->getAllocationIndex(); + lostAck = true; + delete packet; + Hcf::corruptedFrameReceived(); + return; + } + } + if (source() && scenario() == 8 && header->getType() == ST_ACK && context) { + auto transmit = dynamic_cast(context->getStepBeforeLast()); + auto data = transmit ? transmit->getFrameToTransmit() : nullptr; + if (data && accepted(data) && lostDataAcks < 9) { + lostDataAcks++; + delete packet; + Hcf::corruptedFrameReceived(); + return; + } + } + Hcf::processLowerFrame(packet, header); + } + void originatorProcessFailedFrame(Packet *packet) override { + bool tracked = source() && scenario() == 8 && accepted(packet); + auto owner = edca->getChannelOwner(); + auto deadline = tracked ? edca->getLifetimeHandler()->getDeadline(packet) : SIMTIME_MAX; + Hcf::originatorProcessFailedFrame(packet); + if (tracked) { + ASSERT(owner->getInProgressFrames()->containsFrame(packet)); + ASSERT(edca->getLifetimeHandler()->getDeadline(packet) == deadline); + ASSERT(!owner->getRecoveryProcedure()->isMsduRetryLimitReached(packet)); + retainedDataFailures++; + } + } + void originatorProcessRtsProtectionFailed(Packet *packet) override { + auto owner = edca->getChannelOwner(); + auto recovery = owner->getRecoveryProcedure(); + bool tracked = source() && accepted(packet) && + packet->getTag()->getAllocationIndex() == target; + auto deadline = tracked ? edca->getLifetimeHandler()->getDeadline(packet) : SIMTIME_MAX; + Packet shortView("short-counter-view"); + shortView.insertAtFront(packet->peekAtFront()); + shortView.addTag()->setAllocationIndex(target); + int shortCount = tracked ? recovery->getRetryCount(&shortView, shortView.peekAtFront()) : -1; + if (tracked) + ASSERT(owner->getInProgressFrames()->isSameSizeDataRetry(packet) == (scenario() == 2)); + Hcf::originatorProcessRtsProtectionFailed(packet); + if (tracked && simTime() < deadline) { + ASSERT(owner->getInProgressFrames()->containsFrame(packet)); + ASSERT(edca->getLifetimeHandler()->getDeadline(packet) == deadline); + ASSERT(recovery->hasMsduRetryRecord(packet) && !recovery->isMsduRetryLimitReached(packet)); + ASSERT(recovery->getRetryCount(&shortView, shortView.peekAtFront()) == shortCount + 1); + retainedFailures++; + if (scenario() == 4) { + expiredTarget = packet; + targetOwner = owner; + } + } + } + void frameSequenceFinished() override { + auto owner = edca->getChannelOwner(); + Hcf::frameSequenceFinished(); + if (source() && scenario() == 3 && !collision && owner) { + auto frames = owner->getInProgressFrames(); + auto candidate = frames->peekFrameToTransmit(); + if (candidate && accepted(candidate) && frames->getOutstandingFrames().empty()) { + collision = true; + auto deadline = edca->getLifetimeHandler()->getDeadline(candidate); + int limit = owner->getRecoveryProcedure()->getShortRetryLimit(); + for (int i = 0; i < limit + 2; i++) + Hcf::handleInternalCollision({owner}); + auto retained = frames->peekFrameToTransmit(); + ASSERT(retained && frames->containsFrame(retained)); + ASSERT(edca->getLifetimeHandler()->getDeadline(retained) == deadline); + ASSERT(!owner->getRecoveryProcedure()->isMsduRetryLimitReached(retained)); + ASSERT(owner->getRecoveryProcedure()->getRetryCount(retained, retained->peekAtFront()) >= limit); + collisionChecks++; + } + } + } + bool transmitFrame(Packet *packet, simtime_t ifs) override { + bool admitted = Hcf::transmitFrame(packet, ifs); + if (!admitted) + return false; + auto header = packet->peekAtFront(); + auto owner = edca->getChannelOwner(); + auto txop = owner->getTxopProcedure(); + auto data = dynamicPtrCast(header); + if (dynamicPtrCast(header)) { + bool first = holders[txop->getStart()]++ == 0; + if (data && data->getType() == ST_DATA_WITH_QOS && !data->getReceiverAddress().isMulticast()) { + auto prior = lengths.find(packet->getId()); + bool retry = prior != lengths.end() && prior->second == packet->getDataLength(); + bool exception = first && (retry || (accepted(packet) && !data->getAMsduPresent() && !data->getRetry())); + ASSERT(!data->getAMsduPresent()); + lengths.emplace(packet->getId(), packet->getDataLength()); + agreedData += accepted(packet); + fallbackData += !accepted(packet) && data->getAckPolicy() == NORMAL_ACK; + exceptions += exception; + if (scenario() == 7) + ASSERT(mib->isHtOperationSupported() == source()); + if (txop->getLimit() == 0) { + auto allocation = packet->getTag()->getAllocationIndex(); + auto result = zeroAllocations.emplace(txop->getStart(), allocation); + ASSERT(result.second || result.first->second == allocation); + if (data->getAckPolicy() == BLOCK_ACK) { + simtime_t expected = SIMTIME_ZERO; + for (auto member : owner->getInProgressFrames()->getAllocationFrames(packet)) + if (member->peekAtFront()->getFragmentNumber() == data->getFragmentNumber() + 1) + expected = modeSet->getSifsTime() + + packet->getTag()->getMode()->getDuration(member->getDataLength()); + ASSERT(data->getDurationField() == expected); + } + } + if (txop->getLimit() > 0 && !exception) + bounds[packet->getId()] = txop->getStart() + txop->getLimit(); + else + bounds.erase(packet->getId()); + } + } + return true; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + checkBoundary(packet); + Hcf::transmissionComplete(packet, header); + } + void originatorProcessReceivedFrame(Packet *packet, Packet *transmitted) override { + if (packet->peekAtFront()->getType() == ST_ACK) + checkBoundary(transmitted); + Hcf::originatorProcessReceivedFrame(packet, transmitted); + } +}; +Define_Module(BasicAdmissionHcf); +class BasicAdmissionTest : public cSimpleModule, public cListener { + int received = 0; + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("subscribe")); } + void receiveSignal(cComponent *, simsignal_t, cObject *, cObject *) override { received++; } + void handleMessage(cMessage *message) override { + bool first = message->isName("subscribe"); + delete message; + if (first) { + getModuleByPath("^.sta2.app[0]")->subscribe(packetReceivedSignal, this); + scheduleAt(SimTime(1200, SIMTIME_MS), new cMessage("check")); + return; + } + auto source = check_and_cast(getModuleByPath("^.sta1.wlan[0].mac.hcf")); + auto ap = check_and_cast(getModuleByPath("^.ap.wlan[0].mac.hcf")); + int scenario = par("scenario"); + std::cout << "Basic admission state: scenario=" << scenario << " delivered=" << received + << " agreed=" << source->agreedData << "/" << ap->agreedData + << " failures=" << source->retainedFailures << "\n"; + if (scenario != 4 && scenario != 6) { + ASSERT(source->agreedData > 0 && ap->agreedData > 0); + ASSERT(source->exceptions > 0 && ap->exceptions > 0); + } + if (scenario == 1 || scenario == 2) + ASSERT(source->injectedCtsLosses() == 9 && source->retainedFailures >= 9); + if (scenario == 3) + ASSERT(source->collisionChecks == 1); + if (scenario == 6) + ASSERT(source->agreedData == 0 && ap->agreedData == 0 && source->fallbackData > 0); + if (scenario == 8) + ASSERT(source->retainedDataFailures >= 9); + if (scenario == 4) { + source->checkExpiry(); + ASSERT(source->expiryChecks == 1 && source->retainedFailures >= 7); + } + else + ASSERT(received == 30); + std::cout << "Basic admission assertions passed: scenario=" << scenario << " delivered=" << received + << " retainedFailures=" << source->retainedFailures << " collisions=" << source->collisionChecks << "\n"; + endSimulation(); + } +}; +Define_Module(BasicAdmissionTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.linklayer.ieee80211.mac.originator.OriginatorQosAckPolicy; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module BasicAdmissionHcf extends Hcf { parameters: int scenario; @class(::inet::ieee80211::BasicAdmissionHcf); } +simple BasicAdmissionAckPolicy extends OriginatorQosAckPolicy { parameters: bool normalUnderAgreement; @class(::inet::ieee80211::BasicAdmissionAckPolicy); } +simple BasicAdmissionTest { parameters: int scenario; @class(::inet::ieee80211::BasicAdmissionTest); } +network BasicAdmissionNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: Ieee80211ScalarRadioMedium; + ap: AccessPoint; + sta1: WirelessHost; + sta2: WirelessHost; + test: BasicAdmissionTest; +} + +%inifile: omnetpp.ini +[General] +network = BasicAdmissionNetwork +ned-path = .;../../../../src;../../lib +sim-time-limit = 1.3s +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.test.scenario = ${scenario=0..8} +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" +*.sta1.numApps = 1 +*.sta1.app[0].typename = "UdpBasicApp" +*.sta1.app[0].destAddresses = "sta2" +*.sta1.app[0].destPort = 1000 +*.sta1.app[0].messageLength = 700B +*.sta1.app[0].startTime = 1s +*.sta1.app[0].stopTime = 1.00295s +*.sta1.app[0].sendInterval = 100us +*.sta2.numApps = 1 +*.sta2.app[0].typename = "UdpSink" +*.sta2.app[0].localPort = 1000 +*.sta*.ipv4.arp.typename = "GlobalArp" +*.sta*.wlan[*].opMode = ${scenario} == 7 ? "n(mixed-2.4Ghz)" : "g(erp)" +*.ap.wlan[*].opMode = ${scenario} == 7 ? "g(mixed)" : "g(erp)" +**.wlan[*].opMode = "g(erp)" +**.wlan[*].bitrate = ${rate=6,24}Mbps +**.rateSelection.mgmtFrameBitrate = ${scenario} == 7 ? 6Mbps : -1bps +**.rateSelection.controlFrameBitrate = ${scenario} == 7 ? 6Mbps : -1bps +**.bandName = "2.4 GHz" +**.wlan[*].classifier.typename = "QosClassifier" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "BasicAdmissionHcf" +**.wlan[*].mac.hcf.scenario = ${scenario} +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.hcf.originatorAckPolicy.typename = "BasicAdmissionAckPolicy" +**.hcf.originatorAckPolicy.normalUnderAgreement = ${scenario} == 2 || ${scenario} == 3 || ${scenario} == 8 +**.originatorAckPolicy.blockAckReqThreshold = 5 +**.originatorAckPolicy.maxBlockAckPolicyFrameLength = ${scenario} == 6 ? 0B : 10000B +**.originatorMacDataService.msduAggregationPolicy.typename = "" +**.originatorMacDataService.mpduAggregationPolicy.typename = "" +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = ${scenario} == 5 ? 300B : 2346B +**.rtsPolicy.rtsThreshold = 500B +**.recoveryProcedure.shortRetryLimit = 7 +**.recoveryProcedure.longRetryLimit = 7 +**.txopProcedure.protectionMechanism = ${protection="single","multiple"} +**.txopProcedure.txopLimit = ${scenario} == 5 ? 0s : 1024us +**.edcaf[*].msduLifetime = ${scenario} == 4 ? 100ms : 512ms +**.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.initialX = 0m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m + +%contains: stdout +Basic admission assertions passed: diff --git a/tests/module/Ieee80211BlockAckFragmentRetirement_1.test b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test index 5a15b2b964a..fc2b0a1a4f0 100644 --- a/tests/module/Ieee80211BlockAckFragmentRetirement_1.test +++ b/tests/module/Ieee80211BlockAckFragmentRetirement_1.test @@ -5,7 +5,7 @@ when the originator discards the last transmitted MPDU. The fixture supplies accepted Basic agreements and injects immediate ACKs and Basic Block Ack responses. Production fragmentation, inactivity expiry, retirement, and transmission remain active. Runs cover sequence 0 and wraparound at 4095, with expiry during transmission -or after the first fragment receives its Normal Ack. +or during the next fragment after the first fragment receives its Normal Ack. Later intact DATA and an unrelated peer must retain their transmissions. Additional runs transmit an earlier DATA unit before a gap in sequence allocation. The fixture extracts and disposes of the skipped DATA through the production allocator. @@ -160,7 +160,7 @@ class FragmentRetirementHcf : public Hcf { if (data->getReceiverAddress() == peer) { if (!retired) { ASSERT(data->getSequenceNumber() == SequenceNumberCyclic(start)); - ASSERT(data->getFragmentNumber() == 0); + ASSERT(data->getFragmentNumber() == 0 || (acknowledgedFirst && data->getFragmentNumber() == 1)); } else { ASSERT(data->getSequenceNumber() == SequenceNumberCyclic(start) + 1); diff --git a/tests/module/Ieee80211CompressedBlockAckAdmission_1.test b/tests/module/Ieee80211CompressedBlockAckAdmission_1.test index 30510077389..80208222a2a 100644 --- a/tests/module/Ieee80211CompressedBlockAckAdmission_1.test +++ b/tests/module/Ieee80211CompressedBlockAckAdmission_1.test @@ -570,7 +570,7 @@ class AdmissionTest : public cSimpleModule { if (scenario == 14) ASSERT(hcf->data == 1 && hcf->aggregates == 1 && hcf->queriesAtData.front() == 1); if (scenario == 15) - ASSERT(hcf->service()->preparations == 0); + ASSERT(hcf->service()->preparations > 0); if (scenario == 16) ASSERT(hcf->service()->preparations > 0 && hcf->service()->commits == 1); if (scenario == 17) { From 9a3f567dfd942a683865e02e43126b3a2fe4b18f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Gonz=C3=A1lez=20L=C3=B3pez?= Date: Mon, 19 Oct 2026 10:23:43 +0200 Subject: [PATCH 41/41] plan: add: document TXOP admission behavior and evidence Before this commit, the TXOP admission series has no committed execution record. Reviewers need its timing, ownership, retry contracts, and evidence limits in one place. The reproductions also need a distinction between historical HT Basic traffic and the legal non-HT baseline. After this commit, the plan and execution record explain those contracts and limits. The fingerprint record separates source effects from inherited graphical drift. It lists every approved value and its commit owner. The release note explains the effects for users. The separate peer-permission activation still owns the combined refusal case. The reproduction folder preserves raw console captures by hash. Its local Git attribute preserves whitespace in those captured bytes. The baseline amendments preserve every original source tree and test definition. This completes the local C6 records for plan/pending/ieee80211-txop-admission-remaining-paths.md. This commit changes no production source or recorded test baseline. Change: plan | behavior.add | - | txop-admission-remaining --- WHATSNEW | 4 + .../ieee80211-txop-admission-publication.md | 51 + .../ieee80211-txop-admission-r1-decision.md | 23 + ...0211-txop-admission-remaining-execution.md | 142 + ...-txop-admission-remaining-paths-summary.md | 352 + ...eee80211-txop-admission-remaining-paths.md | 563 + .../BasicNonHtTxopAdmissionProbe.test | 222 + .../TxopAdmissionProbe.test | 208 + .../execution-20261019/.gitattributes | 2 + .../execution-20261019/aarf.txt | 333 + .../execution-20261019/admission.txt | 5 + .../execution-20261019/architecture.txt | 11 + .../execution-20261019/basic-24-multiple.txt | 126 + .../execution-20261019/basic-24-single.txt | 90 + .../execution-20261019/basic-6-multiple.txt | 123 + .../execution-20261019/basic-6-single.txt | 119 + .../execution-20261019/build.txt | 11 + .../execution-20261019/c5-aarf.txt | 333 + .../execution-20261019/c5-architecture.txt | 11 + .../execution-20261019/c5-basic-corrected.txt | 356 + .../execution-20261019/c5-basic-runs.txt | 736 + .../execution-20261019/c5-build.txt | 12 + .../c5-causal-Aggregation-base.txt | 63 + .../c5-causal-Aggregation-head.txt | 63 + .../c5-causal-Fragmentation-base.txt | 78 + .../c5-causal-Fragmentation-head.txt | 46 + .../c5-causal-commands.json | 164 + .../c5-fingerprint-causality.md | 41 + .../execution-20261019/c5-fingerprints.txt | 18 + .../execution-20261019/c5-manifest.json | 65 + .../execution-20261019/c5-module.txt | 37 + .../c5-noaggregation-base.txt | 49 + .../c5-noaggregation-commands.json | 82 + .../c5-noaggregation-head.txt | 52 + .../execution-20261019/c5-onoe.txt | 333 + .../execution-20261019/c5-protocol.txt | 9 + .../execution-20261019/c5-tidy-hcf-final.txt | 15688 +++++++++++++++ .../execution-20261019/c5-tidy.txt | 16335 ++++++++++++++++ .../execution-20261019/c5-unit.txt | 10 + .../execution-20261019/fingerprints.txt | 17 + .../execution-20261019/manifest.json | 50 + .../execution-20261019/module.txt | 34 + .../execution-20261019/normal-ack-2.txt | 153 + .../execution-20261019/normal-ack-3.txt | 150 + .../execution-20261019/normal-ack-6.txt | 62 + .../execution-20261019/normal-ack-7.txt | 61 + .../execution-20261019/onoe.txt | 333 + .../execution-20261019/protocol.txt | 7 + .../execution-20261019/unit.txt | 8 + .../fingerprints-20261019/README.md | 79 + .../fingerprints-20261019/base-approved.txt | 34 + .../fingerprints-20261019/base.txt | 59 + .../fingerprints-20261019/c3.txt | 59 + .../fingerprints-20261019/c4-approved.txt | 19 + .../fingerprints-20261019/c4.txt | 203 + .../fingerprints-20261019/commands.json | 215 + .../fingerprints-20261019/final.txt | 34 + .../forwarded-retry-base.pcapng | Bin 0 -> 27204 bytes .../forwarded-retry-head.pcapng | Bin 0 -> 27204 bytes .../head-before-update.txt | 60 + .../fingerprints-20261019/manifest.json | 17 + .../fingerprints-20261019/pcap-commands.json | 48 + .../fingerprints-20261019/trace-commands.json | 1570 ++ .../fingerprints-20261019/trace-excerpts.json | 230 + .../fingerprints-20261019/values.json | 783 + .../observations.json | 911 + .../publication-20261019/verification.json | 257 + 67 files changed, 42419 insertions(+) create mode 100644 plan/pending/ieee80211-txop-admission-publication.md create mode 100644 plan/pending/ieee80211-txop-admission-r1-decision.md create mode 100644 plan/pending/ieee80211-txop-admission-remaining-execution.md create mode 100644 plan/pending/ieee80211-txop-admission-remaining-paths-summary.md create mode 100644 plan/pending/ieee80211-txop-admission-remaining-paths.md create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/BasicNonHtTxopAdmissionProbe.test create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/TxopAdmissionProbe.test create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/.gitattributes create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/aarf.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/admission.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/architecture.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-multiple.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-single.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-multiple.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-single.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/build.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-aarf.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-architecture.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-corrected.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-runs.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-build.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-base.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-head.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-base.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-head.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-commands.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprint-causality.md create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprints.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-manifest.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-module.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-base.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-commands.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-head.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-onoe.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-protocol.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy-hcf-final.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-unit.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/fingerprints.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/manifest.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/module.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-2.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-3.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-6.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-7.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/onoe.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/protocol.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/unit.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/README.md create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base-approved.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c3.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4-approved.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/commands.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/final.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/forwarded-retry-base.pcapng create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/forwarded-retry-head.pcapng create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/head-before-update.txt create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/manifest.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/pcap-commands.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-commands.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-excerpts.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/values.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/observations.json create mode 100644 plan/reproductions/ieee80211-txop-admission-remaining/publication-20261019/verification.json diff --git a/WHATSNEW b/WHATSNEW index e9fabaa0469..b06c5d76775 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -4,6 +4,10 @@ Recent changes in the INET Framework INET-4.7.x (in development) --------------------------- +IEEE 802.11 HCF now checks complete Basic and Normal Ack exchanges before it consumes queued QoS MSDUs. It can select one ordinary MSDU or legal fragments when a larger form cannot fit. A short TXOP tail preserves queued sources. An impossible fresh exchange stops with a diagnostic at the selected mode. Fragments retain one allocation and an absolute deadline. Modern recovery retains one cumulative retry count. Basic recovery retains the 2016 short and long counters. An accepted Basic agreement limits disposal by lifetime, including failed RTS attempts and internal collisions. Without an accepted agreement, Basic still applies its retry limits. A zero TXOP limit permits all fragments of one MSDU. These changes can alter timing, adaptive rate queries, and fingerprints. + +The aggregation, fragmentation, QoS, TXOP, and MAC examples have revised fingerprints for these changes. HCF excludes A-MSDUs without local and peer HT capabilities. HCF also derives Retry from local ACK state, so forwarded MSDUs do not retain the previous hop's Retry bit. + Notable backward incompatible changes are the following: 1. IEEE 802.11 rate control per receiver diff --git a/plan/pending/ieee80211-txop-admission-publication.md b/plan/pending/ieee80211-txop-admission-publication.md new file mode 100644 index 00000000000..7b8479f2c1a --- /dev/null +++ b/plan/pending/ieee80211-txop-admission-publication.md @@ -0,0 +1,51 @@ +# TXOP admission: publication checks + +All six source commits build in debug mode and pass their selected tests. The final source also compiles in release mode. This record supplements the [implementation evidence](ieee80211-txop-admission-remaining-execution.md) for the user's publication request on 2026-10-19. + +The branch starts at `d841dc77db7d0b141bf31e5e215a0de9bb281957`, the open upstream PR #1364 head. The checked upstream master is `0f1458fbdc1379ad93ad6d7a04975e5607b26197`. The publication remains a draft because that dependency and the separate peer-permission integration remain open. The user authorized fingerprint updates on 2026-10-19. The [baseline record](../reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/README.md) gives each value, cause, and commit owner. + +## Commit boundaries + +Each source commit has its own build and direct test result. The validation procedure restored that exact commit's tracked source and test definitions before execution. It then restored the saved final working files. The unrelated `AGENTS.md` edit remained unchanged. The table identifies the original source revisions; the baseline amendments preserve their source trees. + +| Commit | Purpose | Direct evidence | +| --- | --- | --- | +| `a8557bc651` | C1a adds bounded fragment partitions. | Debug build and the bounded-fragmentation unit fixture pass. | +| `9c4bf543d8` | C1b adds reversible fragments and group ownership. | Debug build and the fragment-preparation module fixture pass. | +| `04b2e32c65` | C2 adds allocation-scoped retry records. | Debug build and the MSDU recovery module fixture pass. | +| `d98c98fcfb` | C3 prepares common admission without Basic or modern activation. | Debug build and six Compressed and A-MPDU control fixtures pass. | +| `c419a07251` | C4 activates modern Normal Ack admission. | Debug build and eight admission, protection, cancellation, collision, and management fixtures pass. | +| `a6c85b80ba` | C5 activates Basic admission under the accepted R1 rule. | Debug build and five Basic, fragment-retirement, Compressed, and profile fixtures pass. | + +C1 uses two commits because the policy operation can stand alone before service and ownership changes. C3 changes 416 source lines. Its message explains why cost, validation, commitment, submission, and Duration consumers need the same prepared representation. C4 and C5 contain their activation tests and causal baselines. A separate first commit corrects twenty inherited graphical expectations. C6 contains the plan, release note, and evidence records. + +The [verification metadata](../reproductions/ieee80211-txop-admission-remaining/publication-20261019/verification.json) records each commit SHA, exact selector, mode, and exit status. The raw publication logs remain under `/tmp/inet-txop-publication/`. The earlier implementation artifact folder retains the detailed behavioral evidence. + +The retained console captures preserve their original bytes and hashes. A directory-specific Git attribute excludes only those `.txt` captures from whitespace checks. Authored source and prose retain their normal checks. + +## Final source checks + +Both final builds return zero: + +```sh +make MODE=debug -j8 +make MODE=release -j8 +``` + +The debug library SHA-256 is `1de36100640807565d8456334072201ff3f412a3e5fbfe28e0376a5e0fc57bf2`. It matches the implementation campaign's library exactly. The release library SHA-256 is `70436a0ffc1aa69d1a74059609e6cb1cd02035fa959fe12c95861dbebace6b2b`. Release verification covers compilation. Behavioral verification uses debug mode with assertions. + +The final repeated campaign passes 31 module fixtures, four unit fixtures, and the legacy fragmentation protocol fixture. It includes 96 Normal Ack runs and 36 Basic runs. The Onoe and AARF campaigns each pass sixteen additional runs. The [execution record](ieee80211-txop-admission-remaining-execution.md#verification-commands-and-results) gives their commands. The original three-row fingerprint campaign retained its differences before baseline approval. The later [baseline record](../reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/README.md) covers twenty-five related rows and their approved expectations. + +## Mechanical checks and their limits + +The source-seal check passes against upstream master. The eight-commit topic passes its series check against the dependency head. Five notes concern message length, fingerprint ingredient groups, and C3's 416 source lines. The messages explain each baseline row and C3's required common representation. The check reports no violation. + +The project-wide architecture, naming, and interface checks return failures. Each complete output is identical to the corresponding check at the unchanged dependency head. The interface check reports the same fifteen classes. The naming check reports the same twenty-three violations. These comparisons establish no new mechanical finding in this topic. They do not make the global checks pass. + +Clang-tidy covers the seven changed C++ implementation files through the debug compilation flags. It reports warnings in unchanged code and no warning on an added line. This evidence does not establish a clean project-wide C++ gate. No new architecture or naming exception enters the ledgers. + +The PR description contains three native Mermaid diagrams. Mermaid parses all three. The description check reports no note. This validates syntax and description structure; it does not establish a visual rendering result. + +## Open integration work + +The separate Basic peer-permission activation still owns rejection between two known HT peers and the joint fallback case. This publication does not change agreement negotiation. The plan remains under `plan/pending/` until that combined requirement has its evidence. diff --git a/plan/pending/ieee80211-txop-admission-r1-decision.md b/plan/pending/ieee80211-txop-admission-r1-decision.md new file mode 100644 index 00000000000..cf591149142 --- /dev/null +++ b/plan/pending/ieee80211-txop-admission-r1-decision.md @@ -0,0 +1,23 @@ +# Basic RTS exhaustion: decision for C5 + +The user accepted the lifetime interpretation on 2026-10-19: "Retain the MSDU until lifetime expiry." This decision satisfies R1 of [the plan](ieee80211-txop-admission-remaining-paths.md#r1-basic-rts-exhaustion-under-an-accepted-agreement). B1 already supplies the legal failing baseline. C5 can now activate Basic admission. + +IEEE Std 802.11-2016 supplies both relevant rules. Clause 10.22.2.11.1 requires the MSDU short counter and QSRC to increase after CTS failure. Its general exhaustion rule discards the MSDU at the applicable retry limit. Clause 10.24.3 instead limits MSDUs that use Block Ack by lifetime. It also permits Normal Ack under an agreement. The original PDF supplies these normative clauses on physical pages 1391–1392 and 1419–1421. The corpus does not index this edition. + +The accepted interpretation applies the specific Block Ack lifetime rule to MSDUs under an accepted Basic agreement. Associated RTS failures still increase the MSDU short counter and QSRC. Short-limit exhaustion alone does not discard that MSDU. This rule also applies before the first local DATA transmission. It applies after a local DATA transmission and after an internal collision. + +The alternative applies the RTS short limit independently of the Block Ack DATA lifetime rule. It discards the protected MSDU when that short count reaches the limit. It applies before and after local DATA transmission. Under this alternative, internal-collision exhaustion also discards the MSDU. This interpretation retains the current legacy disposal result but needs explicit acceptance too. + +Both choices use the same ownership boundary. After admission succeeds, the data service commits the ordinary MSDU or fragment group before RTS. The committed-frame owner retains the allocation identity and absolute deadline across CTS failure. The recovery owner retains both 2016 MSDU counters. Neither choice permits fragmentation under an HT-immediate agreement. + +| Condition | Accepted lifetime interpretation | Rejected independent RTS limit | +| --- | --- | --- | +| RTS short count reaches its limit before local DATA. | Retain all fragments and the MSDU record until success, lifetime expiry, or agreement disposal. | Dispose of all fragments, ACK entries, lifetime entries, and the MSDU record. | +| RTS short count reaches its limit after local DATA. | Retain the fixed transmitted bodies and lengths until another terminal condition. | Dispose of the same complete group. | +| An internal collision reaches the short limit. | Retain the ordinary source or its fragment group under the lifetime rule. | Dispose of the same complete group. | +| Lifetime expires. | Dispose of the complete group and retire its record once. | Perform the same group cleanup if the group remains. | +| Basic DATA acknowledgment fails. | Apply the Block Ack lifetime rule. | Apply the same DATA lifetime rule. | + +The two named RTS exhaustion configurations will assert the accepted choice. The internal-collision case will assert the same disposal decision. Each case will check group ownership, absolute deadlines, ACK entries, and AC recovery. A separate peer and TID will remain intact. Admission refusal will change none of these counters. + +The C5 implementation uses commitment before RTS after complete admission. HCF selects the 2016 contract for enabled Basic support, including fallback without an agreement. The recovery owner retains the counters across fragment replacement. An accepted agreement suppresses retry-limit disposal. Without an accepted agreement, the short and long limits still control disposal. The modern path uses IEEE Std 802.11-2024 and does not depend on this decision. diff --git a/plan/pending/ieee80211-txop-admission-remaining-execution.md b/plan/pending/ieee80211-txop-admission-remaining-execution.md new file mode 100644 index 00000000000..46d1ba7796d --- /dev/null +++ b/plan/pending/ieee80211-txop-admission-remaining-execution.md @@ -0,0 +1,142 @@ +# TXOP admission: execution record + +Execution date: 2026-10-19. The user requested execution of revision 9. The active checkout is `/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining`. Its branch is `work/ieee80211-txop-admission-remaining`. Its starting revision is `d841dc77db7d0b141bf31e5e215a0de9bb281957`. + +The working tree contains the Normal Ack and Basic implementations. The user accepted R1's lifetime interpretation on 2026-10-19. B1 supplies the legal failing continuation. The [decision note](ieee80211-txop-admission-r1-decision.md) records that decision. Local focused checks pass. Combined verification with the separate peer-permission activation remains pending. + +The initial task preserved the earlier `AGENTS.md` edit, peer-permission documents, and historical reproduction. It left the implementation uncommitted and changed no recorded fingerprint baseline. The later user request authorizes commits, a push, and an upstream PR. The [publication record](ieee80211-txop-admission-publication.md) supplies the commit boundaries and later checks. + +## Implemented behavior + +HCF now prepares individually addressed QoS DATA before the frame sequence can extract its queued sources. Enabled Basic support selects the 2016 contract with or without an accepted agreement. A disabled Block Ack handler uses the modern contract even when the unused variant parameter says `basic`. Accepted Compressed and A-MPDU paths retain their agreement contracts. + +HCF selects one DATA mode for the current exchange. It reuses that mode for aggregate evaluation, ordinary fallback, fragment admission, and submission. A successor reservation uses an estimate at the current mode. The successor selects its actual mode at its own admission boundary. A later exchange must fit the remaining TXOP and its separate strict TXNAV bound. + +The data service constructs duplicate fragments before commitment. The bounded policy combines the configured threshold with HCF's complete-exchange airtime bound. Commitment consumes a queued source once. It transfers the same fragment pointers with one sequence identity, one allocation identity, and the original absolute deadline. A numbered source retains those identities during replacement. Queue service metadata follows the payload regions into the fragments. + +Basic and modern no-agreement paths commit before RTS after admission succeeds. A failed associated RTS therefore updates the same MSDU record before DATA transmits. The modern record contains one cumulative count across fragment ACKs and size changes. Its short retry limit controls disposal. Basic retains separate short and long counts across fragment replacement. Under an accepted Basic agreement, retry-limit exhaustion retains the allocation until success, lifetime expiry, or agreement disposal. + +HCF updates the agreement exemption at actual RTS submission, including retries of an allocation that predates agreement acceptance. Normal Ack under an accepted Basic agreement uses the same exemption. Basic fallback without an agreement retains the short and long limits. A collision or RTS failure alone does not establish DATA retransmission history. The committed-frame owner retains local DATA history for the positive-limit exceptions. + +HCF ends a short TXOP tail without extraction of queued sources. If no permitted form fits a fresh TXOP, HCF raises a diagnostic before extraction or sequence allocation. A zero limit permits a complete fragment burst for one MSDU. The next unrelated MSDU needs another TXOP. Source expiry and agreement disposal remove complete fragment groups through the current owners. + +For example, the original disabled-Block-Ack campaign can send an A-MSDU beyond a one-millisecond TXOP. The corrected path checks the full DATA/ACK or RTS/CTS/DATA/ACK exchange first. It selects a smaller form or ends that TXOP. All four repeated Normal Ack probe runs now report zero invalid completion boundaries. + +## Step status and change scope + +| Step | Implemented work | Evidence and limits | +| --- | --- | --- | +| C1 | The fragmentation contract, Basic policy, QoS service, and committed-frame owner now support reversible fragment groups. The migration guide describes the interface changes. | The bounded-policy unit fixture and eight preparation runs pass. They cover cancellation, commitment, numbered replacement, stale sources, expiry, permission changes, and impossible bounds. | +| C2 | The recovery owner now supports allocation-scoped modern and 2016 records. Group cleanup and local fragment history use existing owners. | The direct recovery fixture passes. Accepted Basic agreements retain counters beyond both limits. Without that exemption, the configured limits apply. | +| C3 | Initial classification uses a read-only selector. Common admission retains the actual modes and costs the complete exchange. | Production module controls and one-tick boundary checks pass. BAR arbitration remains under the existing policy. | +| C4 | The modern no-agreement path now uses prepared admission, fragmentation, early RTS commitment, and group recovery. | The infrastructure fixture checks containment, zero limits, CTS loss, retry exhaustion, and cancellation. The extended fixture also checks collision-owned fragment replacement. | +| C5 | Basic now uses prepared admission, permitted fragments, commitment before RTS, and the accepted R1 rule. | Thirty-six production runs cover both protection classes and rates, forced failures, internal collisions, expiry, fallback, and legal mixed peers. The four B1 probe runs now report zero invalid boundaries. | +| C6 | User effects, migration text, focused controls, a protocol case, and selected fingerprints receive checks. | The selected fingerprint differences have causal evidence. The later approved baseline updates have a separate record. The publication record adds release compilation and mechanical checks. Combined peer-permission activation remains open. | + +The patch adds a required `dropFrame()` operation to `IAckHandler`. Both built-in handlers already implement it. The committed-frame owner needs that operation to remove the old ACK entry before numbered replacement. The migration guide records this additional interface change. + +The protection fixtures now use read-only successor observations. Their earlier destructive access invalidated the new preparation. Their assertions also reflect the earlier refusal boundary, one adaptive DATA query across RTS/CTS, complete exchange containment, and zero-limit fragment bursts. The non-HT aggregation case now requires ordinary MSDUs. + +## Verification commands and results + +All commands below run from the active checkout unless another directory is specified. All compiled tests use debug mode. Deterministic module cases use seed zero. The final library SHA-256 is `1de36100640807565d8456334072201ff3f412a3e5fbfe28e0376a5e0fc57bf2`. + +```sh +make MODE=debug -j8 +inet_run_unit_tests -m debug -f 'Ieee80211(BoundedFragmentation|SingleProtection|MultipleProtection|TxopProcedure)_.*\.test' +inet_run_module_tests -m debug -f 'Ieee80211(BasicTxopAdmission|TxopAdmission|TxopMsduRecovery|PreparedQosFragments|PreparedQosData|CompressedBlockAckAdmission|CompressedBlockAckExchange|BasicCompatibility|BlockAckVariant|BlockAckFragmentRetirement|QosRecoveryPeerIdentity|EdcaDataLifetime.*|HcfInternalCollision|HcfManagementRecovery|HcfSingleProtection|HcfMultipleProtection|SingleProtectionGroup|PreparedCancellation|AmpduAdmission|AmpduPreparation|AmpduRecovery|AmpduExchange)_.*\.test' +inet_run_protocol_tests -p inet -m debug -w wifi -f 'Legacy_Fragmentation\.test$' +doc/project/enforcement/check-architecture.sh src/inet/linklayer/ieee80211 +git diff --check +``` + +The build passed with exit status zero. Four unit fixtures, thirty-one module fixtures, and the selected protocol fixture passed. The scoped architecture check passed. The whitespace check passed. The final module campaign includes all 96 Normal Ack runs and all 36 Basic runs. The final logs use the `c5-` prefix in the [artifact folder](../reproductions/ieee80211-txop-admission-remaining/execution-20261019/). + +The first admission campaign contained 48 infrastructure runs. It covered both protection classes, 6 and 24 Mbit/s, RTS enabled or disabled, and zero or positive limits. CTS-loss cases removed zero, two, or seven selected responses through the production corrupt-frame path. The extended campaign adds source expiry during CTS wait, a mode-set change during CTS wait, and a real recovery call for an injected internal collision. The radio and both peer MACs remain production components. + +The one-tick checks call production HCF admission with controlled budget inputs. A complete exchange fails one tick above the positive budget and passes at equality. TXNAV equality fails. An exchange one tick shorter than TXNAV passes. These direct checks do not change the budgets for actual wireless transmissions. + +The direct checks also distinguish fifteen and sixteen nondynamic fragments. The sixteen-fragment exception can permit the selected first exchange beyond the positive limit. The fifteen-fragment form cannot use that exception. HCF checks a configured sixteen-fragment partition before it declares a bounded partition impossible. + +Sixteen additional runs passed with the real Onoe controller. Another sixteen passed with the real AARF controller. Test subclasses count queries and retain their returned modes without a changed controller decision. HCF must submit the returned DATA mode. DATA after CTS must retain the query count recorded at RTS submission. The observer separately tracks local DATA lengths, fragment retries, and earlier holder frames to recognize permitted positive-limit exceptions. + +The adaptive commands run from `tests/module/work/Ieee80211TxopAdmission_1` after the filtered module runner builds that fixture: + +```sh +./Ieee80211TxopAdmission_1_dbg -u Cmdenv -r 0..7,48..55 --check-signals=false '--**.rateControl.typename="AdmissionOnoe"' '--**.rateControl.initialRate=6Mbps' '--**.rateSelection.dataFrameBitrate=-1bps' +./Ieee80211TxopAdmission_1_dbg -u Cmdenv -r 0..7,48..55 --check-signals=false '--**.rateControl.typename="AdmissionAarf"' '--**.rateControl.initialRate=6Mbps' '--**.rateSelection.dataFrameBitrate=-1bps' +``` + +The retained final logs include build, unit, module, protocol, adaptive-controller, architecture, and fingerprint results. Generated per-run output resides under `tests/module/work/` and `tests/unit/work/`. The artifact manifest records their hashes and the final library hash. The earlier logs remain evidence for the independent C1–C4 work. + +The interface checker reports fifteen failing classes. The same checker reports the same fifteen failures in the unchanged A-MPDU checkout at the starting revision. The changed interfaces add pure virtual declarations and no default bodies. These inherited findings do not establish a new interface defect. + +Clang-tidy checked all seven changed C++ implementation files through a temporary compilation database with the debug build flags. It returned zero but reported warnings in unchanged code. A comparison with added lines found no warning on an added line. A final HCF check followed the correction to Basic fragment reservations. This check does not establish a clean project-wide C++ gate. + +## C5 contract and direct cases + +The accepted R1 decision authorizes the Basic activation surface already specified by revision 9. HCF owns dispatch, admission, and the commitment boundary. QosRecoveryProcedure owns the short and long counts and the accepted-agreement exemption. InProgressFrames owns committed fragments and group disposal. The source trace confirmed the legacy bypass before the C5 edit. The selected owners also handle RTS failure, Normal Ack failure, internal collisions, lifetime expiry, and agreement disposal. + +The production fixture uses infrastructure association and actual peer MAC responses. It removes selected CTS or ACK responses to trigger failure. It checks retention beyond the configured limit of seven attempts. The RTS cases inject nine CTS losses before or after local DATA. The DATA case injects nine ACK losses under an accepted agreement. The collision case invokes the production collision handler beyond the limit. Each retained allocation keeps its absolute deadline. + +The table maps the plan's named cases to the fixture scenarios. Each scenario runs at 6 and 24 Mbit/s under single and multiple protection. + +| Planned case | Fixture scenario and checks | +| --- | --- | +| BasicNonHtInitialException | Scenario 0 permits the initial ordinary MSDU under an accepted agreement. The independent completion observer excludes later DATA from that exception. | +| BasicNonHtContinuation | Scenario 0 checks complete DATA and ACK containment outside an exception. The corrected B1 probe supplies the explicit earlier failure comparison. | +| BasicNonHtRtsExhaustionBeforeData | Scenario 1 retains the allocation after nine forced CTS losses. It checks the short-counter increments without prior local DATA. | +| BasicNonHtRtsExhaustionAfterData | Scenario 2 first removes an ACK under the agreement. It then removes nine CTS responses for that transmitted allocation. | +| BasicNonHtNormalAckUnderAgreement | Scenarios 2, 3, and 8 force Normal Ack only under an accepted agreement. Setup still uses the production policy. | +| BasicNonHtDataLifetime | Scenario 4 retains failed RTS attempts beyond the short limit, then checks record removal at expiry. Scenario 8 retains nine failed DATA exchanges. | +| BasicNonHtFragments | Scenario 5 checks one allocation per zero-limit TXOP. Its Duration assertions include the next fragment and omit an absent immediate ACK. | +| BasicMsduRecoveryBoundaries | The direct recovery fixture checks distinct short and long limits, ACK resets, agreement exemption, and unrelated allocation preservation. Scenario 3 adds production collision retention. | +| Basic fallback without an agreement | Scenario 6 sets the eligibility threshold to zero. Both enabled Basic handlers use Normal Ack without setup. Both hops deliver all thirty MSDUs within the applicable bounds. | +| BasicMixedHtPeerAllowed | Scenario 7 uses HT stations and a non-HT AP with shared ERP modes. Both endpoint roles establish Basic agreements and deliver DATA. | + +The mixed-peer configuration selects `g(mixed)` at the AP. Its legacy ERP modes also occur in `n(mixed-2.4Ghz)`. The `g(erp)` catalog instead contains ERP-only mode objects. The receiver requires mode-set membership. Management and control use the shared 6 Mbit/s mode so association can complete. This configuration choice changes no production permission rule. + +The fragment-retirement control now permits the next fragment before agreement expiry after the first fragment receives its ACK. Its earlier assertion required a new contention period between those fragments. The zero-limit correction removes that period. The control still checks complete retirement, later sequence allocation, and preservation of the other peer. + +## B1: legal Basic baseline + +The [Basic probe](../reproductions/ieee80211-txop-admission-remaining/BasicNonHtTxopAdmissionProbe.test) uses non-HT `g(erp)` peers, seed zero, and production infrastructure association. It disables both aggregation policies. Its MSDUs use the retained 700-byte application payload. The fragmentation threshold is 2346 bytes, the RTS threshold is 500 bytes, and the TXOP limit is 1024 microseconds. + +The campaign uses the current debug library while Basic still selects its legacy admission path. It does not use the unavailable historical S5 library. The independent modern changes do not activate Basic admission. This evidence therefore establishes the open Basic defect on the current implementation target. + +| DATA rate | Protection | Invalid completion boundaries | Invalid continuations | +| --- | --- | ---: | ---: | +| 6 Mbit/s | Single | 10 | 0 | +| 6 Mbit/s | Multiple | 10 | 0 | +| 24 Mbit/s | Single | 0 | 0 | +| 24 Mbit/s | Multiple | 18 | 18 | + +The last row satisfies B1. Both originators establish accepted Basic agreements. Each of its eighteen violations occurs at DATA completion after earlier DATA in the same TXOP. Basic DATA with Block Ack policy needs no immediate ACK. The initial ordinary-MSDU exception cannot permit these continuations. Both hops together deliver all thirty source MSDUs in this diagnostic campaign. + +For example, one TXOP starts at 1.003257 seconds and ends at 1.004281 seconds. Its third DATA exchange starts its first holder frame at 1.004025 seconds. That leaves 256 microseconds. The protected exchange takes 374 microseconds through DATA completion. It ends at 1.004399 seconds, which exceeds the bound by 118 microseconds. The accepted Basic agreement supplies no exception for this third DATA exchange. + +The retained raw logs are [6 Mbit/s single](../reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-single.txt), [6 Mbit/s multiple](../reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-multiple.txt), [24 Mbit/s single](../reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-single.txt), and [24 Mbit/s multiple](../reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-multiple.txt). + +The initial execution used the retained original probe with command-line overrides. Its run numbers 0, 1, 4, and 5 correspond to rows 0, 1, 2, and 3 of the Basic-only probe. The final campaign builds that Basic-only probe directly. It records the first holder start and elapsed cost through each violated completion boundary. The executable resides in `/tmp/inet-txop-basic-baseline/work/BasicNonHtTxopAdmissionProbe`. It links the active checkout's debug library. All four commands returned zero. + +The original Normal Ack runs 2, 3, 6, and 7 also returned zero. A separate check rejected any `INVALID` line or runtime error. All four logs passed that check. Their exact RTS threshold remains 500 bytes. Those runs supplement the asserted infrastructure fixture. + +## Fingerprints and remaining work + +The selected fingerprint command ran from `tests/fingerprint`: + +```sh +./fingerprinttest -d -m '(showcases/wireless/(aggregation|blockack)/.*-c (NoAggregation|Aggregation|Fragmentation) -r 0)' +``` + +The original final command returned status one after three runs. All three rows differ from the recorded CSV at that revision. The [final raw result](../reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprints.txt) preserves the old and new values. That campaign changed no baseline. The user later authorized updates; the [baseline record](../reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/README.md) covers the broader related scope. + +The [causality report](../reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprint-causality.md) explains the selected differences. Aggregation first differs when the old non-HT path forms a 354-byte A-MSDU. The corrected path sends one 192-byte ordinary MPDU. Basic fragmentation first differs when the corrected zero-limit sequence sends its next fragment after SIFS. The old path releases the channel. The NoAggregation graphical value also differs on the unchanged base library. The exact wrapper command produces identical four-value results on both libraries. That graphical mismatch is inherited. + +The following work remains open: + +1. Complete the combined peer-permission activation checks when P2 exists. +2. Record the approved fingerprint values with their causal commits; the later baseline record supplies this evidence. +3. Retain the publication record's distinction between passing focused checks and inherited global findings. + +The standards evidence uses IEEE Std 802.11-2024, Clauses 10.4, 10.23.2.9, 10.23.2.12.1, and 10.3.2.6. Their canonical corpus nodes resolve. The corpus build resides in `/tmp/inet-txop-standards`. Its global linter reports unresolved references and ambiguities. The 2016 R1 evidence requires original PDF text because this corpus does not index that edition. The user explicitly accepted the R1 interpretation before C5 activation. diff --git a/plan/pending/ieee80211-txop-admission-remaining-paths-summary.md b/plan/pending/ieee80211-txop-admission-remaining-paths-summary.md new file mode 100644 index 00000000000..a50ab9682b0 --- /dev/null +++ b/plan/pending/ieee80211-txop-admission-remaining-paths-summary.md @@ -0,0 +1,352 @@ +# TXOP admission for Basic and Normal Ack: plan summary + +> **Kind:** reference · **Status:** draft · **Seal:** none · **Owns:** — · **Stands on:** [implementation plan](ieee80211-txop-admission-remaining-paths.md) + +**HCF will check the complete exchange before it removes queued MSDUs for transmission.** If an aggregate cannot fit, HCF will try a permitted smaller form. If no form fits the current tail, HCF will end the TXOP and leave the source MSDUs queued. Eligible ordinary MSDUs can use permitted fragments that fit a fresh positive TXOP. If no permitted form fits even a fresh TXOP at the selected mode, HCF will stop with a diagnostic. A real internal collision can separately commit one ordinary source for recovery before its channel grant. + +This summary describes the design in revision 9 of the [implementation plan](ieee80211-txop-admission-remaining-paths.md), dated 2026-10-19. The user subsequently requested execution. The [execution record](ieee80211-txop-admission-remaining-execution.md) owns current progress and verification. The first diagram shows the historical observations. The other diagrams describe the design and its earlier source context. + +The user accepted R1's lifetime interpretation on 2026-10-19. Under an accepted Basic agreement, failed RTS attempts and internal collisions retain the MSDU until lifetime expiry. The required counters still increase. B1 supplies the legal failing baseline. C5 now commits an admitted source before RTS through the existing frame owner. The [decision note](ieee80211-txop-admission-r1-decision.md) records the accepted rule. + +## What the reproduction establishes + +The retained reproduction establishes TXOP overruns with Block Ack disabled and under the historical HT Basic configuration. It does not establish a failure for legal non-HT Basic operation. The current preparation path identifies a coverage gap for that profile. The [reproduction record](../reproductions/ieee80211-txop-admission-remaining/observations.json) supplies the commands, library hashes, and observed endpoints. + +The source sends thirty 700-byte UDP payloads through an AP to another station. All cases use a one-millisecond TXOP, seed zero, HT mixed operation, and zero propagation time. A-MSDU aggregation and RTS protection are enabled. The cases below expose different conditions that the correction must handle. + +The Basic runs also violate the 2016 rule that requires Compressed between two HT peers. Their recorded results remain historical evidence, without a requirement to preserve successful HT Basic exchanges. New legal Basic cases must establish the correction. The Block Ack-disabled runs remain direct admission regressions. + +[B1](ieee80211-txop-admission-remaining-paths.md#b1-required-baseline-for-legal-basic-operation) has a failing non-HT Basic continuation through production association and accepted agreements. The probe disables both aggregation forms. Before C5, multiple protection at 24 Mbit/s produces eighteen DATA completions beyond the 1024-microsecond bound. Each violation follows earlier DATA in that TXOP. After C5, all four probe configurations report zero invalid boundaries and deliver thirty MSDUs. The execution record retains the exact conditions and evidence. + +| Recorded condition | Observation | Why the exchange does not qualify | +| --- | --- | --- | +| Accepted Basic agreement, 24 Mbit/s, multiple protection | The second A-MSDU ends 310 microseconds beyond the TXOP bound. | The TXOP already contains another Data or Management frame. | +| Block Ack disabled, 24 Mbit/s, multiple protection | The second A-MSDU ends 102 microseconds late. Its ACK ends 146 microseconds late. | The complete later exchange must fit. | +| Accepted Basic agreement, 6 Mbit/s, single protection | The first A-MSDU ends 1186 microseconds late. | An initial A-MSDU cannot use the exception for an ordinary MSDU. | +| No agreement, 6 Mbit/s, single protection | The first ordinary DATA ends 166 microseconds late. Its ACK ends 226 microseconds late. | No accepted agreement permits the initial ordinary-MSDU exception. | + +The diagram shows the second recorded condition. Times are microseconds after TXOP start. Node positions show event order, without a proportional time scale. The ACK belongs to the same exchange as the late DATA. + +```mermaid +flowchart LR + S["TXOP starts
0 us"] --> B["Nominal TXOP bound
1000 us"] + B --> D["Second A-MSDU ends
1102 us
102 us late"] + D --> A["ACK ends
1146 us
146 us late"] + style B fill:#fff0c2,stroke:#9a6700,color:#24292f + style D fill:#ffe3e3,stroke:#b42318,color:#24292f + style A fill:#ffe3e3,stroke:#b42318,color:#24292f +``` + +The earlier campaign completed eight S5 runs. Four selected controls also ran on this checkout and produced identical observations. The revisions were `1dd4ca2378` for S5 and `d841dc77db` for this checkout. All eight S5 runs delivered thirty payloads, despite the recorded violations. A successful process exit therefore does not establish correct admission. + +One 24 Mbit/s case with Block Ack disabled and single protection records no overrun. That result applies only to that configuration. The [full evidence section](ieee80211-txop-admission-remaining-paths.md#executed-reproduction) states the campaign limits. + +## Why a final transmission check is insufficient + +The current legacy path can remove sources before HCF knows the final exchange cost. The data service can combine MSDUs, delete their original representations, and assign a sequence number. A later refusal cannot restore the original queue form through the current interface. The [source analysis](ieee80211-txop-admission-remaining-paths.md#confirmed-mechanism) identifies the responsible selectors and data service. + +```mermaid +flowchart TB + Q["Original MSDUs belong to the queue"] --> S["A legacy selector requests a frame"] + S --> X["The data service extracts sources
It can form an A-MSDU
It assigns sequence state"] + X --> C["HCF selects modes and checks the exchange"] + C --> L["A refusal now occurs after source consumption"] + C --> O["Incomplete admission checks
can also permit an overrun"] + style X fill:#fff0c2,stroke:#9a6700,color:#24292f +``` + +With Block Ack disabled, initial frame classification can itself call the destructive accessor. The preparation callback occurs later. Removal of the Compressed-only condition therefore does not solve the queue problem. The correction must also move classification to a preview that does not extract sources. + +The current Compressed path already uses reversible preparation. The data service builds candidate copies while the original MSDUs remain queued. The proposed correction extends that mechanism to Basic and Normal Ack paths, with explicit support for fragments and their recovery state. + +## How admission will work + +HCF will first preserve BAR arbitration. A BAR is a Block Ack request; its exchange remains a separate admission decision. For QoS DATA, the data service will prepare copies of eligible sources. HCF will select one DATA mode and reuse it for every candidate form in that attempt. + +```mermaid +flowchart TB + P["Prepare candidate copies
Retain queued source identities"] --> M["Select one DATA mode"] + M --> G{"Is an A-MSDU permitted
and available?"} + G -->|Yes| A{"Does its complete
exchange qualify?"} + A -->|Yes| Y["Admit the selected form"] + A -->|No| O["Select one ordinary MSDU"] + G -->|No| O + O --> F{"Is fragmentation required
and permitted here?"} + F -->|Yes| B["Build legal fragment copies
Use the bound for a fresh TXOP"] + F -->|No| E["Evaluate the ordinary exchange"] + B --> V["Evaluate the next fragment exchange"] + E --> C{"Does this exchange qualify
in the current TXOP?"} + V --> C + C -->|Yes| Y + C -->|No| T{"Can a permitted form fit
a fresh TXOP at this mode?"} + T -->|Yes| N["End this TXOP
Discard unused copies
Keep queued sources unchanged"] + T -->|No| X["Stop with an unsupported-exchange diagnostic
Do not consume further sources"] +``` + +An ordinary form carries one unfragmented MSDU in one MPDU. The service will honor the configured fragmentation threshold before commitment. It will also use fragmentation when required to fit a fresh positive TXOP. It will not choose smaller fragments solely to consume a short TXOP tail. This policy can leave unused time at the end of a TXOP. + +Admission covers required RTS/CTS, DATA, internal interframe spaces, and the actual immediate response. Normal Ack DATA includes SIFS and ACK airtime. Basic DATA with Block Ack policy does not acquire a fictitious immediate Block Ack response. A later BAR/Block Ack exchange keeps its own cost and arbitration. + +A-MSDU use also requires local HT implementation and received peer HT capabilities. An absent Block Ack agreement does not establish that permission. If those capabilities are absent, the service will use an ordinary MSDU or permitted fragments. [Candidate forms and cost](ieee80211-txop-admission-remaining-paths.md#complete-cost-and-permitted-forms). + +Admission refusal itself will preserve queue order, source identities, ownership, absolute deadlines, sequence counters, retry counters, and queue service observations. It will not count as an RTS failure or DATA failure. Independent lifetime expiry can still remove an expired source through its normal owner. + +Commitment means that the service consumes the accepted source form and transfers the prepared MPDUs to the committed-frame owner. In this model, `InProgressFrames` owns those committed frames. The commitment point depends on RTS recovery, as the diagrams below show. + +## How Compressed, Basic, and Normal Ack differ + +The plan extends the mechanism that accepted Compressed agreements already use. The Basic extension and the Normal Ack extension outside accepted agreements remain proposed. All three paths will prepare copies, retain one selected DATA mode, and check the complete exchange before source extraction. Refusal will preserve queued MSDUs without a retry increment. + +The table compares individual QoS DATA paths. The current A-MPDU path retains its preparation and response contracts. The [full comparison](ieee80211-txop-admission-remaining-paths.md#comparison-with-current-compressed-admission) owns the detailed conditions. + +| Condition | Current Compressed, accepted agreement | Proposed Basic, accepted agreement | Proposed Normal Ack, no accepted agreement | +| --- | --- | --- | --- | +| Commitment with RTS | Retain original MSDUs through RTS/CTS. Commit immediately before DATA. | Commit before RTS after admission. R1 selects lifetime retention under the accepted agreement. | After admission succeeds, commit immediately before RTS. | +| Actual RTS failure | Update access-category recovery without a frame counter under a provisional sequence number. | Update the 2016 MSDU short retry count and access-category recovery. | Update the modern MSDU frame retry count and access-category recovery. | +| Initial ordinary MSDU exceeds a fresh positive TXOP | The stated initial-MSDU exception can apply. | The 2016 initial-MSDU exception can apply under the accepted agreement. | That exception does not apply. Prepare legal fragments when necessary. | +| Fragmentation | Preserve the prohibition under HT-immediate Block Ack. | Support permitted Basic fragments under the 2016 contract. | Use permitted fragments that account for TXOP airtime and the configured threshold. | +| Response cost | Individual DATA with Block Ack policy has no immediate ACK. BAR/Block Ack has separate admission. | Use the same exchange separation, with Basic response lengths. | Include SIFS and ACK airtime in the DATA exchange. | + +Both selected editions permit the eligible initial ordinary-MSDU exception under an accepted agreement. The exception requires the stated aggregate restrictions and at most one Data or Management frame in the TXOP. An initial A-MSDU cannot use that exception. The [exception rules below](#which-exchanges-may-exceed-a-positive-limit) retain the separate retry and zero-limit conditions. + +The selected retry contract controls commitment and RTS recovery. Normal Ack DATA under an accepted Compressed agreement commits before DATA. Basic commits before RTS under its 2016 contract. Disabled Block Ack uses the modern contract even when its unused variant parameter says `basic`. Without RTS, new transmission sources commit before DATA. An earlier collision can already own the source. + +The earlier commitment outside an agreement gives RTS recovery a stable frame identity. After actual RTS submission, the admitted form belongs to retry and lifetime procedures. A later cancellation must not restore that form to the queue as new MSDUs. + +Hypothetical example: a later exchange needs 300 microseconds, but only 200 microseconds remain. All three paths defer before RTS and preserve queued sources. If an ordinary MSDU also exceeds a fresh positive TXOP, modern no-agreement operation needs permitted fragments. Accepted Basic and Compressed agreements can instead permit the eligible initial ordinary-MSDU exception. The exception requires at most one Data or Management frame in that TXOP. + +## Which exchanges may exceed a positive limit + +Compressed and modern Normal Ack follow IEEE Std 802.11-2024, Clause 10.23.2.9. Basic follows IEEE Std 802.11-2016, Clause 10.22.2.8. Neither contract treats every initial DATA frame as exempt. The agreement state, aggregate form, actual local transmission history, and earlier TXOP contents control the result. The following table describes the scoped conditions common to both selected editions. The [standards contract](ieee80211-txop-admission-remaining-paths.md#applicable-requirements) provides the exact clauses and source pages. + +| Condition | Required treatment | +| --- | --- | +| Initial ordinary MSDU under an accepted Basic or Compressed agreement | The stated exception can apply when the TXOP contains at most one Data or Management frame. | +| Initial ordinary MSDU without an accepted agreement | The exception above does not apply. Prepare legal fragments if the complete exchange exceeds a fresh positive limit. | +| Initial A-MSDU | The ordinary-MSDU exception does not apply. Try the ordinary form when the aggregate cannot fit. | +| Local retransmission of an unchanged-size MPDU | Permit at most one Data or Management frame in the TXOP. The MPDU must not belong to a multi-MPDU A-MPDU. | +| RTS retry or internal collision before any DATA transmission | Neither event proves a DATA retransmission. Do not activate the same-size MPDU exception from either event alone. | +| Nondynamic fragments | Apply the fragment-specific conditions. Preserve the local history needed for an exception that the implementation uses. | +| Zero TXOP limit | Permit the allowed data unit, required protection, and acknowledgments. Multiple PPDUs can carry fragments of one MSDU. | + +A zero limit therefore does not mean zero allowed airtime. It also does not always mean one DATA frame. A fragment burst for one MSDU differs from a second unrelated MSDU. The correction must preserve that distinction. + +For an ordinary continuation under a positive limit, HCF must also respect the holder's reservation timer, called TXNAV. The two comparisons use different boundaries. Let `E` be the complete exchange cost after the wait, and let `I` be the wait before the exchange. + +```text +E < available TXNAV +I + E <= available positive-limit TXOP time +``` + +HCF samples these budgets after the previous exchange completes, before the next wait. Equality can satisfy positive-limit containment, but equality does not satisfy the strict TXNAV condition. Both protection classes must retain their valid Duration fields. A permitted exception must protect its actual exchange beyond the nominal bound. [Validation and timing](ieee80211-txop-admission-remaining-paths.md#validation-timing-and-state-lifetime). + +Basic's 2016 contract removes the 2005 lower-rate test and the initial PHY mode record needed for that test. It permits the initial ordinary-MSDU, previous-fragment retry, and sixteen-fragment exceptions under their stated conditions. Its retry contract still uses short and long counts for each MSDU. The [2016 Basic contract](ieee80211-txop-admission-remaining-paths.md#basic-contract-under-ieee-80211-2016) supplies the exact conditions and PDF pages. + +Basic conformance cases use legal peer pairs without A-MSDU aggregation, with legal MSDU lengths and fragmentation thresholds. The 2016 rule permits Basic between non-HT peers or between an HT peer and a non-HT peer. It requires Compressed between two HT peers. The original HT Basic reproduction remains historical evidence only. The 2020 and 2024 editions reserve Basic's former encoding. This revision does not change showcase configurations or their recorded results. + +The separate Basic peer-permission work owns enforcement of that peer restriction and its compatibility effects. Its plan remains local context outside this publication. It proposes warnings and Normal Ack fallback for explicit Basic selection between two known HT peers. At a local HT station, unknown peer classification suppresses Basic setup until management publishes sufficient state. A known non-HT local station already excludes a two-HT pair. That change needs its own PR, impact inventory, and migration evidence; it is not part of C5. + +Current ad hoc management supplies no production event that guarantees later classification. A local HT station can therefore retain Normal Ack for an unknown ad hoc peer throughout the run. The separate plan documents that limit and adds no capability discovery. Infrastructure publication will trigger permission reassessment and normal DATA progress before the current setup-intent procedure resumes. + +The plan now links the 2016 and 2020 PDFs under this checkout's `standards/` directory. Readers need those local inputs, as they need the 2024 PDF. The local link check does not establish public availability. + +## Why fragment preparation is part of the correction + +A fragment preview requires permission under the applicable agreement and PPDU conditions. IEEE Std 802.11-2024, Clause 10.2.7 prohibits MSDU fragmentation under an HT-immediate Block Ack agreement. The configured threshold and a Normal Ack policy do not remove that prohibition. The 2016 Clause 10.2.7 also prohibits fragmentation under HT-immediate and HT-delayed agreements. Non-HT Basic cases can use permitted fragments. The [fragmentation eligibility rule](ieee80211-txop-admission-remaining-paths.md#fragmentation-eligibility) supplies the scope. + +A final guard could refuse an ordinary MSDU on every fresh TXOP while its size remains fixed. The MSDU would then wait until lifetime expiry. That behavior prevents an overrun but does not supply the required transmission form. The data service must therefore prepare legal fragments before source extraction. + +The hypothetical example below uses an eligible Normal Ack MSDU outside an agreement. The service splits that 1000-octet MSDU into three fragments. The first two fragment bodies contain 400 octets each; the last contains 200 octets. Each MPDU also contains its own MAC header and FCS. The actual size bound comes from the selected PHY mode and complete exchange cost. + +```mermaid +flowchart TB + S["One 1000-octet MSDU
Its source remains unchanged before commitment"] + S --> P["The data service builds a fragment preview group"] + P --> F0["Fragment 0
400-octet body
More Fragments = 1"] + P --> F1["Fragment 1
400-octet body
More Fragments = 1"] + P --> F2["Fragment 2
200-octet body
More Fragments = 0"] + F0 --> G["One sequence number
One allocation identity
One original lifetime deadline
One MSDU retry record"] + F1 --> G + F2 --> G + G --> R["QosRecoveryProcedure owns the record
2024: one cumulative frame count
2016 Basic: short and long counts"] +``` + +The fragmentation policy will combine the airtime bound with the configured threshold. It will enforce equal nonfinal lengths, even nonfinal lengths, and the sixteen-fragment bound. Ordinary nondynamic fragmentation will not split an A-MSDU. The service will first abandon an oversized aggregate preview when ordinary fragments are needed. + +Commitment will extract an unnumbered source once and allocate one sequence identity for its fragment group. A source that already has an identity will retain it. Every fragment will retain the source's absolute deadline. A real retransmission will preserve the previously transmitted body and length. [Fragment ownership and constraints](ieee80211-txop-admission-remaining-paths.md#nondynamic-fragment-preparation). + +The retry record belongs to the MSDU, not to one fragment number or one side of the RTS threshold. A collision can occur before an ordinary source becomes smaller fragments. Fragment replacement retains the same allocation and record without another initialization. A successful nonfinal fragment ACK preserves the modern MSDU count and its short retry limit. Basic instead applies its 2016 count-specific increment and reset conditions. [MSDU retry state](ieee80211-txop-admission-remaining-paths.md#msdu-retry-state-and-fragment-disposal). + +Basic DATA sent under an accepted agreement follows Clause 10.24.3's lifetime rule rather than ordinary DATA retry limits. The new MSDU record must not impose another DATA retry limit on that path. A failed associated RTS still updates the MSDU short counter under Clause 10.22.2.11.1. A Normal Ack policy does not itself remove the agreement. + +The two retry models still differ outside an accepted agreement. The first three rows below describe that condition. The last row compares the two accepted agreement profiles. The [detailed comparison](ieee80211-txop-admission-remaining-paths.md#msdu-retry-state-and-fragment-disposal) maps each difference to a direct test. + +| Condition | Basic under 2016 | Modern operation under 2024 | +| --- | --- | --- | +| DATA fails above the RTS threshold. | Increment the long count and apply the long limit. | Increment the single frame count and apply the short limit. | +| A nonfinal fragment receives its ACK. | Reset the applicable count under the stated success conditions. | Retain the cumulative MSDU count. | +| A source becomes fragments across the RTS threshold. | Preserve both counts and the allocation identity. | Preserve the single count and the allocation identity. | +| RTS fails under an accepted Basic agreement. | Update the short count. Retain the MSDU beyond the limit under the accepted R1 rule. | Current accepted Compressed preparation updates AC recovery without a provisional MSDU count. | + +When the selected contract requires retry-limit disposal, HCF cancels retained preparation for that allocation. InProgressFrames disposes of every remaining fragment in the group. HCF removes the ACK and lifetime entries through their current owners. The recovery owner retires the MSDU record once. Expiry and agreement disposal use the same group cleanup. A final success retires the record after the group completes. + +If no permitted form fits a fresh TXOP at the selected mode, HCF raises `cRuntimeError` before further source consumption. Sequence and recovery state remain intact. The diagnostic identifies the peer, TID, selected mode, limit, and failed constraint. This deliberate model limit stops the simulation; it does not return ordinary deferral or request another contention attempt. When only the current tail is too short, HCF returns `DEFERRED` and ends the TXOP normally. An earlier collision-owned source remains committed in either case until its owner disposes of it. + +The fatal diagnostic is a proposed model policy, not an IEEE requirement. It preserves the source without a contention loop at the selected mode. A new drop reason would change the source-retention requirement. Failure at that selected mode does not establish failure at every PHY mode. + +## Why the RTS commitment point depends on recovery + +Commitment before RTS gives MSDU recovery a stable allocation identity. This boundary is an implementation choice. The selected standard requires correct retry counts and disposal at the applicable limits. It does not prescribe queue extraction or sequence allocation before RTS. The [plan's explanation](ieee80211-txop-admission-remaining-paths.md#commitment-and-rts-recovery) supplies the source references and design alternatives. + +RTS/CTS introduces a real event boundary between admission and DATA. Sources can expire, or peer capabilities can change, while HCF waits for CTS. The QoS context will retain the selected modes across that boundary. HCF will validate them without another adaptive DATA mode query. + +### With an accepted Compressed agreement + +The original sources will remain queued through RTS/CTS. After valid CTS, HCF will validate the retained preparation before the service commits it for DATA. A real RTS failure will update AC recovery through its owner and release the unused preview. It will not create a frame retry counter under a provisional DATA sequence number. + +```mermaid +sequenceDiagram + participant H as Originator HCF + participant Q as Queue and data service + participant P as Peer + participant R as Recovery owner + H->>Q: Prepare copies without extraction + H->>H: Admit the complete exchange + Note over H,Q: Original MSDUs remain queued + H->>P: RTS + alt Valid CTS arrives + P-->>H: CTS + H->>H: Validate sources, modes, and cost + alt Preparation remains valid + H->>Q: Commit the accepted form + Q-->>H: Transfer the prepared MPDUs + H->>P: DATA with the retained mode + else Preparation becomes invalid + H->>Q: Release unused copies + Note over H,Q: No stale DATA transmission + end + else CTS timeout with valid sources + H->>R: Apply agreement-scoped AC recovery + H->>Q: Release unused copies + Note over H,Q: Queued sources retain their deadlines + end +``` + +The Compressed path retains this ownership contract. It also applies to Normal Ack DATA under that accepted Compressed agreement. Basic under 2016 uses the different recovery contract below. Independent expiry can dispose of an expired original. Cancellation must not retain stale pointers. + +### With modern no-agreement recovery or Basic under 2016 + +A failed associated RTS must increment the modern no-agreement MSDU or A-MSDU count, even when DATA never transmits. IEEE Std 802.11-2024, Clause 10.23.2.12.1 supplies this requirement. Basic's 2016 Clause 10.22.2.11.1 increments the MSDU short count and the access-category short count, also under an accepted agreement. A preview predicts a sequence number without allocation. Commitment assigns the sequence and allocation identities. Both paths commit immediately before RTS after complete admission. + +R1 concerns the effect of that Basic short counter at its limit. The general 2016 retry clause requires discard at exhaustion. The Block Ack clause specifies lifetime instead of retry limits. The user accepted the lifetime interpretation for an accepted Basic agreement. C5 retains the required counters beyond both limits. Lifetime expiry still removes the complete allocation. + +The resolution must cover exhaustion before the first DATA transmission and after an earlier DATA transmission under the agreement. It must also state the effect of internal collisions. Both candidate interpretations retain the mandatory counter update and AC recovery. Absence of discard would not make Compressed's AC-only recovery sufficient for Basic. + +Hypothetical example: no agreement applies, admission succeeds, and HCF sends RTS, but no CTS arrives. DATA never transmits, yet recovery must retain an increased frame retry count for the next attempt. Commitment before RTS gives that count a permanent frame identity. A counter tied only to a disposable preview could lose its frame association after preview disposal. A later candidate could reuse the provisional sequence and acquire retry state for different sources. + +```mermaid +sequenceDiagram + participant H as Originator HCF + participant Q as Queue and data service + participant P as Peer + participant R as Recovery owner + H->>Q: Prepare copies without extraction + H->>H: Admit the complete exchange + alt No permitted form qualifies + H->>Q: Release unused copies + Note over H,Q: Original MSDUs remain queued + else An exchange qualifies + H->>Q: Commit immediately before RTS + Q-->>H: Transfer the admitted form and identity + H->>P: RTS + alt Valid CTS arrives + P-->>H: CTS + H->>H: Validate retained inputs before DATA + alt Inputs remain valid + H->>P: DATA with the retained mode + else Inputs become invalid + Note over H,R: Cancel DATA and retain committed ownership + end + else CTS timeout + H->>R: Update the selected MSDU retry count and AC recovery + Note over H,R: No DATA transmits
The committed identity retains the count + Note over H,R: Accepted R1 rule retains the MSDU until lifetime expiry
Basic commits before RTS after admission + end + end +``` + +After actual RTS submission, the form belongs to ordinary retry and lifetime procedures. It must not return to the queue as new MSDUs after a later cancellation. Before RTS, an admission refusal must leave the original queued sources unchanged. Without RTS, the service commits a new transmission source immediately before DATA. An earlier collision-owned source retains its commitment. [Commitment and RTS recovery](ieee80211-txop-admission-remaining-paths.md#commitment-and-rts-recovery). + +Commitment before DATA could satisfy these MSDU recovery requirements with persistent retry state for uncommitted sources. That state would need cleanup for expiry, cancellation, and source replacement. Commitment before RTS reuses the committed owner, as the [ownership comparison](ieee80211-txop-admission-remaining-paths.md#commitment-and-rts-recovery) explains. C5 selects that boundary. The ACK policy bit alone does not select the commitment boundary. + +## How an internal collision differs from admission refusal + +An internal collision occurs when another access function in the same station wins channel access. It is a recovery event. The handler can need a numbered frame before that frame obtains its own channel grant. It must not form an unadmitted A-MSDU to obtain that identity. + +This is the explicit exception to commitment after transmission admission. If a later admission attempt refuses the exchange, the committed source remains in InProgressFrames with its collision state. It does not return to the pending queue as new MSDUs. Sources that remain queued retain the ordinary refusal guarantees. + +```mermaid +flowchart TB + C["Another access function wins
An internal collision occurs"] --> O["Commit one ordinary source for recovery
Preserve unrelated queued MSDUs"] + O --> R["Apply the collision recovery outcome
Do not query adaptive DATA selection"] + R --> W["Wait for this access function's channel grant"] + W --> F["Prepare the first DATA form
Create fragment copies if required"] + F --> I["Retain the assigned sequence identity
Retain the original deadline and retry count"] + I --> A["Apply complete-exchange admission"] +``` + +The first DATA form can therefore use fragments from an already numbered ordinary source. The service must preserve its identity and retry count through that replacement. A collision still does not prove an earlier DATA transmission. The same-size DATA retry exception must remain unavailable until the required local transmission history exists. [Internal collision design](ieee80211-txop-admission-remaining-paths.md#internal-collision-before-data-transmission). + +## Work order and proof of completion + +The plan separates preparation from activation in six implementation steps. C1–C3 add fragment, recovery, and selector mechanisms. C4 activates modern Normal Ack with its prerequisites. C5 activates Basic after the accepted R1 decision and the legal B1 baseline. C6 supplies focused evidence and user documentation. Combined verification still requires the separate peer-permission activation. + +```mermaid +flowchart LR + C1["C1: Prepare legal fragment groups
Prove ownership and size constraints"] + C2["C2: Prepare MSDU retry records
Prove group recovery and disposal"] + C3["C3: Prepare selectors and common admission
Preserve existing path selection"] + C4["C4: Activate modern Normal Ack
Include zero-limit fragment bursts"] + C5["C5: Activate Basic under 2016
Include its no-agreement Normal Ack fallback"] + C6["C6: Complete integration evidence
Document user effects"] + R1{"Resolve R1
Basic RTS exhaustion and commitment"} + B1{"Record B1
Failing legal Basic baseline"} + C1 --> C2 --> C3 --> C4 --> C5 --> C6 + R1 -->|Required before schedule and activation| C5 + B1 -->|Required before schedule and activation| C5 +``` + +The [verification matrix](ieee80211-txop-admission-remaining-paths.md#direct-test-matrix) requires these separate forms of evidence: + +- Production exchanges must meet the applicable DATA, response, TXOP, and TXNAV conditions. +- Refusal cases must compare source identities, queue state, deadlines, sequence counters, retry counters, and queue service observations. +- Fragment cases must prove legal lengths, one source consumption, one sequence identity, inherited deadlines, and complete group disposal. +- Retry cases must follow one MSDU record through a collision, fragment replacement across the RTS threshold, nonfinal ACK, and later fragment failure. +- Basic admission cases must use their 2016 rules with legal peer pairs. The separate peer-permission PR owns rejection of invalid pairs. +- Peer cases must preserve Basic between an HT peer and a non-HT peer. HT Compressed controls must retain valid exchanges. +- Basic RTS cases must assert R1's outcome before and after an earlier local DATA transmission. An unspecified expected outcome is insufficient. +- Impossible fresh-TXOP cases must prove a terminal diagnostic before further source consumption, without another contention attempt. +- RTS timeout, source expiry, capability changes, and internal collisions must prove their distinct recovery and cancellation behavior. +- Boundary cases must cover zero limits, positive-limit equality, strict TXNAV equality, and applicable initial and retry exceptions. +- Eligibility cases must preserve the HT-immediate fragmentation prohibition, even with a low threshold or Normal Ack DATA under the accepted agreement. +- Compressed, A-MPDU, management, and group controls must detect effects from shared selector changes. + +C2 must exercise the production recovery owner and InProgressFrames through transfer, replacement, acknowledgment, and disposal. It must preserve exact Compressed and A-MPDU counter increments, acknowledgment cleanup, AC counters, and contention-window changes. Current RTS checks remain controls, but delivery or Retry bits alone do not establish counter preservation. C3 must call the production selectors and HCF admission operations with real contexts and owners. Test substitutes may supply inputs or observe results; they must not replace the logic under test. + +C4 owns `NormalAckZeroLimitFragmentBurst`. Its first MSDU must complete all fragments and required ACKs in one zero-limit TXOP. A second unrelated MSDU must wait for another TXOP. The case covers RTS disabled and forced, under both protection classes. It checks sequence identity, allocation identity, absolute deadlines, and final ACK completion. + +The plan names eight non-HT Basic configurations within its proposed test files. These cover the initial exception, continuation refusal, RTS exhaustion, Normal Ack under an agreement, DATA lifetime, fragments, and recovery boundaries. `BasicNonHtRtsExhaustionBeforeData` and `BasicNonHtRtsExhaustionAfterData` require the R1 decision before activation. Existing Basic compatibility coverage remains a control; it does not replace the new admission assertions. + +Two additional configurations provide legal controls through production exchanges. `BasicMixedHtPeerAllowed` checks legal Basic with reversed endpoint roles and DATA in both directions. `CompressedHtControl` checks valid Compressed exchanges between two HT peers. The separate peer-permission plan owns `BasicTwoHtRejected`, unknown-peer transitions, warnings, and migration of current negotiation tests. + +The earlier twelve diagnostic runs establish the reproduced failures and the comparison between checkouts. They do not verify the proposed correction. This summary adds no simulation result. The implementation tests remain proposed. + +Historical commands retain all eight S5 runs and the recorded checkout controls 0, 5, 6, and 7. Corrected-behavior verification instead uses Block Ack-disabled runs 2, 3, 6, and 7, plus the named legal Basic cases. The historical HT Basic runs remain evidence only. Neither command set changes the recorded observations. + +Whichever PR lands second must run the other plan's applicable cancellation tests against the combined source. These cover capability changes during CTS wait, retained preparation disposal, committed ownership, and teardown. The joint configuration `BasicRefusalNormalAckTxopAdmission` requires peer permission P2 and Basic-profile activation C5. C4 alone does not activate the enabled Basic profile's 2016 fallback. If P2 lands before C5, joint TXOP admission remains pending C5. The [joint verification section](ieee80211-txop-admission-remaining-paths.md#cross-plan-verification-and-activation-order) assigns the case to the later required activation. + +The correction can change contention, delivery time, and fingerprints where earlier exchanges exceeded a bound. It promises no measured throughput or fairness gain. The bounded fragmentation contract requires external migration guidance with C1. Its operation remains pure virtual under the project's contract-purity rule. An unbounded fallback followed by rejection does not supply required smaller fragments. The interface receives no default body or general adapter. + +The required scope is individually addressed QoS DATA through HCF, with Basic, disabled Block Ack, or Normal Ack fallback. DCF, HCCA, dynamic fragmentation, new acknowledgment policies, and MAC stop/start support remain outside this proposal. The plan preserves the current Compressed and A-MPDU contracts. The [scope and implementation boundary](ieee80211-txop-admission-remaining-paths.md#8-risks-decisions-and-implementation-boundary) defines the final limits. + +These documents and the reproduction remain outside the committed A-MPDU PR #1364 work. Future TXOP implementation needs its own branch or series and a newly pinned target. This revision changes documents only. diff --git a/plan/pending/ieee80211-txop-admission-remaining-paths.md b/plan/pending/ieee80211-txop-admission-remaining-paths.md new file mode 100644 index 00000000000..6a287b366a5 --- /dev/null +++ b/plan/pending/ieee80211-txop-admission-remaining-paths.md @@ -0,0 +1,563 @@ +# Implementation plan: TXOP admission for Basic and Normal Ack paths + +Plan revision: 10, 2026-10-19. Revision 10 records the accepted R1 decision and the C5 execution results. + +Implementation status: local production work and focused checks are complete. The user requested execution on 2026-10-19. The [execution record](ieee80211-txop-admission-remaining-execution.md) identifies the checks, fingerprint differences, and external integration requirement. + +Basic activation requires [R1, the RTS exhaustion rule](#r1-basic-rts-exhaustion-under-an-accepted-agreement), and [B1, the legal Basic baseline](#b1-required-baseline-for-legal-basic-operation). The user accepted lifetime retention for R1. The legal probe supplies B1. C5 now uses commitment before RTS after admission. Combined verification with the separate peer-permission activation remains pending. + +The [summary with diagrams](ieee80211-txop-admission-remaining-paths-summary.md) explains the proposal for human review. + +## 1. Problem and intended behavior + +The retained reproduction establishes TXOP overruns with Block Ack disabled. It also records overruns under the historical HT Basic configuration. Those Basic runs do not establish a failure for a legal non-HT Basic peer pair. The Compressed-only preparation path identifies a coverage gap for Basic. A failing non-HT Basic baseline remains required before C5. + +For transmission admission, HCF must calculate the complete exchange before the data service removes queued MSDUs. If the exchange cannot fit the current tail, HCF must try a permitted smaller form. If no form qualifies, HCF must end the TXOP without that extraction. Admission refusal itself must preserve source identities, queue order, ownership, absolute deadlines, sequence counters, and recovery state. A real internal collision has a separate commitment rule for recovery. An impossible fresh-TXOP exchange has the explicit terminal action below. + +The correction must also permit progress on a fresh TXOP. The ordinary form carries one unfragmented MSDU in one MPDU. Without an accepted Block Ack agreement, an initial ordinary MSDU has no general exception to a positive limit. If that exchange exceeds a fresh limit, the service must prepare permitted nondynamic fragments. Repeated refusal until lifetime expiry does not correct this case. + +The concrete continuation failure uses a one-millisecond TXOP, 24 Mbit/s DATA, A-MSDU aggregation, RTS protection, and multiple protection. With Block Ack disabled, the second A-MSDU ends at 1.001102 seconds against a 1.001-second bound. Its ACK ends at 1.001146 seconds. The correction must defer that exchange before source extraction, or select a smaller form that fits. + +Basic admission evidence will use the 2016 peer conditions. Basic remains permitted between non-HT peers and between an HT peer and a non-HT peer. Two HT peers must use Compressed for Block Ack. The separate Basic peer-permission work owns enforcement of that restriction. Its plan remains local context outside this publication. Successful Basic exchanges between two HT peers are outside this plan's required scope. + +## 2. Checkout, current path, and observed evidence + +### Source revisions and local work + +The reproduction baseline is `/home/user/omnetpp_ws/inet-compressed-blockack-s5` at `1dd4ca23785b14b058693e9e20434a4257c3831f`. Its local edits affect `AGENTS.md` and plan documents. They do not change the compiled MAC source. + +This plan resides in `/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7` at `d841dc77db7d0b141bf31e5e215a0de9bb281957`. This checkout has a local `AGENTS.md` edit. This task preserves that edit. Its A-MPDU work adds integration requirements beyond S5. + +The S5 exclusion appears at `Hcf.cc:1982`. The [current preparation entry](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) also requires an active Compressed agreement. Before implementation, pin the selected target again. Use S5 for the baseline comparison; apply this plan to the selected target with its current contracts. + +### Confirmed mechanism + +[HcfFs](../../src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc) selects the frame sequence. Without a Block Ack handler, its initial selector calls the destructive frame accessor before the preparation callback. That call can already extract queued MSDUs. Thus, removal of the profile guard alone cannot preserve the queue. + +[InProgressFrames](../../src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc) owns committed frames. Its destructive accessor calls the data service when no eligible committed frame exists. The [data service](../../src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc) can aggregate sources, delete their original representations, assign a sequence number, and create fragments. A later admission refusal cannot recover the original queue form through the current API. + +HCF's special single-protection guard applies when `isBlockAckSupported` is false. It evaluates continuation cost at final submission. It does not constrain the initial exchange through the same test. Multiple protection has continuation checks for start time and reservation legality, but those checks do not prove complete-exchange containment. + +The current reversible path retains duplicate previews through the [QoS frame context](../../src/inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h). It validates an accepted Compressed agreement before admission. It therefore cannot directly serve a null agreement, an accepted Basic agreement, or Basic fragmentation. Its single-frame commit operation also cannot transfer a group of prepared fragments. + +### Executed reproduction + +The retained [probe](../reproductions/ieee80211-txop-admission-remaining/TxopAdmissionProbe.test) derives its topology and traffic from [the Compressed exchange fixture](../../tests/module/Ieee80211CompressedBlockAckExchange_1.test). It uses real association, production queues, HCF, frame sequences, the radio, and the peer MAC. The probe adds observations through HCF overrides. Every override calls the production method; the probe changes no admission decision. + +All eight S5 runs use seed zero and debug mode. The medium has zero propagation time. Both hops use HT mixed operation in 2.4 GHz. The source sends thirty 700-byte UDP payloads through the AP. The RTS threshold is 500 bytes. The configured fragmentation threshold is 2346 bytes, which leaves these MSDUs unfragmented. + +The Basic runs use two HT peers and therefore violate the 2016 variant rule independently of their TXOP overruns. Their retained probe and observations are historical evidence. They impose no requirement to preserve successful HT Basic exchanges. New legal Basic fixtures must establish the corrected admission behavior. + +The counts below identify observation boundaries, not distinct failed MSDUs. One exchange can exceed the bound at both DATA completion and ACK completion. Basic DATA under Block Ack can have no immediate ACK; DATA completion is therefore necessary evidence. + +| Run | DATA rate | Block Ack profile | Protection | DATA completions beyond the applicable bound | ACK completions beyond the applicable bound | +| --- | --- | --- | --- | ---: | ---: | +| 0 | 6 Mbit/s | Basic | Single | 30 | 7 | +| 1 | 6 Mbit/s | Basic | Multiple | 29 | 6 | +| 2 | 6 Mbit/s | Disabled | Single | 31 | 31 | +| 3 | 6 Mbit/s | Disabled | Multiple | 32 | 32 | +| 4 | 24 Mbit/s | Basic | Single | 2 | 0 | +| 5 | 24 Mbit/s | Basic | Multiple | 14 | 0 | +| 6 | 24 Mbit/s | Disabled | Single | 0 | 0 | +| 7 | 24 Mbit/s | Disabled | Multiple | 16 | 16 | + +An accepted Basic agreement also reproduces a distinct initial failure. In run 0, the first A-MSDU ends at 1.003914 seconds against a 1.002728-second bound. The excess is 1186 microseconds. This frame has no Retry bit. It cannot use the initial ordinary-MSDU exception because it contains an A-MSDU. + +Run 5 confirms the continuation failure under an accepted Basic agreement. Its second A-MSDU ends at 1.004902 seconds against a 1.004592-second bound. The excess is 310 microseconds. A retry cannot use the single-frame exception after another Data or Management frame in the same TXOP. + +Run 2 confirms the initial failure without an agreement. Its ordinary DATA ends 166 microseconds beyond the limit. Its ACK ends 226 microseconds beyond the limit. This case requires fragmentation or another permitted transmission choice on a fresh TXOP. + +All eight diagnostic runs exit zero and deliver thirty payloads. Zero exit status means that the observation run completes; it does not mean that TXOP admission is correct. Run 6 is a clean control for this configuration only. It does not prove all single-protection paths correct. + +Runs 0, 5, 6, and 7 also execute against this checkout's debug library. Their DATA, violation, and summary observations match S5 exactly. The [observation record](../reproductions/ieee80211-txop-admission-remaining/observations.json) records library hashes, commands, counts, and selected events. Raw logs remain under `/tmp/inet-txop-admission-remaining-20261018/`. + +These runs establish airtime violations. They do not measure queue preservation on refusal, RTS failure recovery, or fragmentation behavior. The regression cases below must establish those properties after implementation. + +### B1: Required baseline for legal Basic operation + +B1 now has a failing non-HT reproduction. The [execution record](ieee80211-txop-admission-remaining-execution.md) records eighteen continuation violations at 24 Mbit/s under multiple protection. The [legal Basic probe](../reproductions/ieee80211-txop-admission-remaining/BasicNonHtTxopAdmissionProbe.test) uses accepted agreements without aggregation. The retained HT Basic runs remain historical evidence. + +The diagnostic uses production association, queues, HCF, frame sequences, radio, and peer MAC. Observation overrides call their production methods without a changed admission decision. The bounded conditions below define that campaign. + +Use the following bounded conditions: + +1. Use seed zero and non-HT `g(erp)` peers with a confirmed accepted Basic agreement. +2. Disable A-MSDU and A-MPDU aggregation. +3. Use legal MSDU sizes and a legal fragmentation threshold, initially 2346 bytes. +4. Test 6 and 24 Mbit/s DATA. Use a 1024-microsecond positive TXOP limit. Use an RTS threshold of 500 bytes. +5. Test both protection classes with the same traffic and association procedure. + +At least one continuation must exceed its positive TXOP bound before the correction. Record actual DATA completion, agreement state, earlier DATA in the TXOP, and the complete applicable exchange cost. Basic DATA with Block Ack policy has no immediate ACK. An oversized initial ordinary MSDU under an agreement can use an exception; that case alone does not prove the defect. The baseline must expose the continuation failure without that exception. + +Retain raw logs and exact checkout, library, command, configuration, run, and seed identities. Record the legal baseline separately from the historical HT observations. If these cases do not expose a violation, reassess the Basic defect scope before C5. Do not label an unexecuted or nonfailing case as a failing baseline. + +## 3. Standards contract and scope + +### Applicable requirements + +Use [IEEE Std 802.11-2024](../../standards/80211ax-2024.pdf) for the Compressed profile and Normal Ack outside the Basic profile. The source filename contains `ax`, but the document is the 2024 base standard. The clauses below contain normative requirements unless the table identifies a note. Basic uses the separate 2016 contract below, including its Normal Ack fallback. + +| Source | Requirement for this correction | Corpus identity and physical PDF pages | +| --- | --- | --- | +| Clause 10.23.2.9 | A positive TXOP limit contains the complete exchange and immediate responses, except under a listed exception. | `ieee80211-2024:clause:10.23.2.9`, pages 2012–2014 | +| Clause 10.23.2.9 | A zero limit permits one allowed data unit, its required protection, and acknowledgments. Nondynamic fragments of one MSDU can use multiple SU PPDUs. | Same node, pages 2012–2014 | +| Clause 10.23.2.9 | An initial ordinary MSDU can exceed a positive limit under a Block Ack agreement. It must not belong to an A-MSDU or a multi-MPDU A-MPDU. | Same node, pages 2012–2014 | +| Clause 10.23.2.9 | A same-size retransmitted MPDU can use the stated exception. The TXOP must contain at most one Data or Management frame. | Same node, pages 2012–2014 | +| Clause 10.23.2.9 | Outside an applicable exception, the first fragment of an initial individually addressed MSDU must fit the positive limit. | Same node, pages 2012–2014 | +| Clause 10.23.2.8 | An additional exchange must meet the TXNAV condition and the separate TXOP restriction. TXNAV is the holder's reservation timer. | `ieee80211-2024:clause:10.23.2.8`, pages 2010–2012 | +| Clause 9.2.5.2 | The first frame selects the protection class for the TXOP. Duration fields follow that class and its reservation rules. | `ieee80211-2024:clause:9.2.5.2`, pages 710–712 | +| Clause 10.2.7 | An MSDU under an HT-immediate Block Ack agreement must not be fragmented, even above the configured fragmentation threshold. | `ieee80211-2024:clause:10.2.7`, page 1882 | +| Clause 10.4 | Nondynamic fragments use one sequence number and ordered fragment numbers. Equal-size fragments precede the final fragment, which can be smaller. Nonfinal fragment lengths are even. | `ieee80211-2024:clause:10.4`, pages 1935–1936 | +| Clause 10.4 | A transmitted fragment retains its body and length across retries. Ordinary nondynamic fragmentation does not fragment an A-MSDU. | Same node, pages 1935–1936 | +| Clause 10.11 | A-MSDU transmission requires local HT implementation and a received peer HT Capabilities element for these non-DMG, non-S1G stations. | Canonical node unavailable; original PDF pages 1971–1973 | +| Clause 10.23.2.12.1 | Failed associated RTS attempts increment the frame retry count outside a Block Ack agreement. Admission refusal is not such an attempt. | `ieee80211-2024:clause:10.23.2.12.1`, pages 2016–2017 | +| Clause 10.23.2.9, Note 3 | The note explains initial-transmission limits. It is informative; the earlier normative paragraphs establish the requirements. | `ieee80211-2024:clause:10.23.2.9`, page 2013 | + +### Basic contract under IEEE 802.11-2016 + +Use [IEEE Std 802.11-2016](../../standards/80211-2016.pdf) for the Basic profile's EDCA admission and retry contract. This edition defines Basic BAR and Block Ack, although it marks both formats as obsolete. It permits the eligible initial ordinary-MSDU exception under a Block Ack agreement. The source PDF supplies this evidence because the corpus does not index this edition. These are normative clauses and tables; no canonical corpus node is available. + +| Source and physical PDF pages | Required Basic treatment | +| --- | --- | +| Clauses 9.3.1.8.2 and 9.3.1.9.2, pages 675–676 and 679 | Preserve Basic BAR and the 128-octet Block Ack bitmap, including fragment bits. | +| Clause 10.22.2.8, pages 1388–1389 | Contain the complete positive-limit TXOP, including immediate responses, unless a listed exception applies. Zero permits the allowed data unit, protection, and responses. | +| Clause 10.22.2.8, page 1388 | An initial ordinary MSDU under an accepted agreement can use the stated exception. It must not belong to an A-MSDU or multi-MPDU A-MPDU. The TXOP must contain at most one Data or Management frame. | +| Clause 10.22.2.8, pages 1388–1389 | Apply the retransmission, previous-fragment retry, and sixteen-fragment exceptions under their stated conditions. The 2005 lower-rate test does not apply. Outside an exception, prepare permitted fragments when necessary for initial containment. | +| Clause 10.22.2.11.1, pages 1391–1392 | Maintain short and long retry counts for each MSDU or A-MSDU. A failed associated RTS increments the MSDU short count and the access-category short count. Resolve R1 before Basic activation under an accepted agreement. | +| Clause 10.24.3, pages 1419–1421 | Preserve the Basic DATA/BAR/Block Ack exchange. MSDUs sent with Block Ack use the lifetime rule rather than DATA retry limits. Normal Ack can operate within the agreement. | +| Clauses 10.24.6 and 10.12, pages 1422 and 1366 | Two HT stations must use Compressed Block Ack. Basic can serve peers when at least one is non-HT. Basic fixtures must exclude A-MSDU aggregation. | +| Clauses 10.2.7 and 10.5, pages 1302 and 1343 | HT-immediate and HT-delayed agreements prohibit MSDU fragmentation. Permitted nondynamic fragments retain equal even nonfinal lengths and fixed transmitted bodies and lengths. | + +Basic retains the current reservation checks as model constraints in addition to this 2016 admission contract. Its initial ordinary-MSDU exception comes from 2016, without a borrowed 2024 rule. Its short and long retry counts remain distinct from the 2024 single frame retry count. An enabled Basic handler selects this contract without a new configuration parameter. Normal Ack fallback in that enabled profile uses the 2016 contract too. Disabled Block Ack uses the 2024 contract even if the unused variant parameter says `basic`. + +Tables 9-27 and 9-28 of [IEEE Std 802.11-2020](../../standards/80211-2020.pdf) reserve Basic's former encoding on physical PDF pages 801 and 804. The 2024 Tables 9-36 and 9-37 also reserve that encoding. The 2016 edition therefore supplies the selected Basic contract. The existing Basic reproduction uses two HT peers and A-MSDU aggregation. Retain it only as historical evidence, without a requirement for continued successful operation. It does not establish conformance to either complete edition. + +The 2016 restriction applies to the peer pair, not to an HT station alone. Positive Basic tests will cover non-HT peers and an HT peer with a non-HT peer. Positive tests between two HT peers will use Compressed for Block Ack. The separate peer-permission plan owns Basic rejection tests and their compatibility effects. No Basic label overrides the fragmentation prohibition under an actual HT-immediate agreement. + +TXOP admission will retain the current profile-permission decisions. This scoped claim does not establish complete 2016 conformance for the Basic profile. In particular, it does not correct Basic setup between two HT peers. The peer-permission change needs its own PR and impact inventory. It is not a prerequisite for C1–C5. + +The 2016 and 2020 PDFs now reside under this checkout's `standards/` directory. These relative links require the local standards inputs, as does the existing 2024 PDF link. The PDFs remain ignored workspace inputs. A local link check establishes file resolution; it does not establish public availability. + +Basic conformance fixtures must also use legal MSDU lengths and fragmentation thresholds. Existing showcase configurations do not themselves establish conformance. This revision does not change showcase modes, aggregation, traffic sizes, or recorded results. Such configuration corrections remain separate work. + +The corpus reports fresh document sources. Its linter reports global ambiguities and unresolved references. Clause 10.23.2.9 itself resolves uniquely, and its ten extracted references resolve. The relevant references include Clauses 10.4, 10.2.7, and 10.6. + +The corpus cannot retrieve Clause 10.11 as a canonical node. Text from original PDF pages 1971–1973 supplies that clause; the applicable HT conditions appear on page 1973. The 2016 evidence uses original PDF text and its clause cross-references. The listed 2016 clauses resolve directly in that PDF. The other 2024 citations need no PDF fallback. Basic does not use the 2005 or 2012 lower-rate contract. + +### R1: Basic RTS exhaustion under an accepted agreement + +Resolution, 2026-10-19: the user selected "Retain the MSDU until lifetime expiry." The [decision note](ieee80211-txop-admission-r1-decision.md) records the interpretation, owners, and terminal outcomes. The paragraphs below preserve the question that controlled activation. They describe the preimplementation state. + +R1 identifies an unresolved standards interpretation. Clause 10.22.2.11.1 explicitly increments the MSDU short counter after CTS failure. Its general discard rule applies when the short counter reaches `dot11ShortRetryLimit`. Clause 10.24.3 instead makes MSDUs sent with Block Ack subject to lifetime rather than retry limits. The current citations do not establish how that exemption applies to failed associated RTS attempts. An accepted agreement alone does not resolve this overlap. + +Current HCF increments the short counter and discards the protected MSDU at RTS exhaustion, including on its legacy Basic path. That is observed source behavior, not evidence that this interpretation is correct. The plan must not silently preserve or remove that disposal rule as a consequence of the admission change. + +The author responsible for Basic recovery in C5 owns R1. That author must provide the clause interpretation, terminal outcomes, ownership decision, and direct test expectations for maintainer review. This revision assigns the responsibility to that role; it does not identify an appointed contributor. No default interpretation authorizes activation. C5 remains unscheduled until the maintainer accepts R1 and B1 supplies the legal failing baseline. + +Before C5 activates Basic admission, record a justified interpretation with exact clause references and observable outcomes. The resolution must specify these cases: + +1. State whether short-limit exhaustion discards the MSDU before its first local DATA transmission. +2. State whether short-limit exhaustion discards the MSDU after an earlier local DATA transmission under the agreement. +3. State how internal-collision exhaustion interacts with the same MSDU and agreement. +4. State the corresponding group disposal, deadline, ACK, and recovery cleanup actions. + +Both candidate interpretations retain the required MSDU short-counter update and access-category recovery. One applies the RTS short limit independently of Block Ack DATA lifetime. The other applies the lifetime exemption to the associated RTS failures too. Neither interpretation is an approved implementation rule in this revision. The named exhaustion tests below require R1's expected outcomes before Basic activation. + +### Acceptance criteria + +The correction is complete only when all these conditions hold: + +1. For transmission admission, Basic, disabled Block Ack, and Normal Ack fallback reach admission before extraction of queued QoS DATA. Internal-collision recovery can commit one ordinary source before that source's channel grant. +2. Every admitted exchange contains the selected DATA form, required protection, applicable IFSs, and actual immediate response type. +3. Admission refusal itself preserves queued source identities, order, ownership, deadlines, sequence state, recovery state, and queue service observations. +4. Aggregate refusal can select one ordinary MSDU without a second adaptive DATA mode query. +5. An ordinary MSDU outside an agreement can use legal fragments when a fresh positive TXOP cannot contain it. An accepted Basic agreement can instead permit the conditional exception in criterion 6. +6. Zero limits and the applicable positive-limit exceptions retain their distinct conditions. Accepted Basic agreements can use the 2016 initial ordinary-MSDU exception. Initial A-MSDUs and multiple Data frames in one TXOP cannot use that exception. +7. A real RTS failure retains its required recovery under the selected edition. Basic activation requires the explicit exhaustion outcomes from R1. Fragment replacement and fragment ACKs preserve the required MSDU retry state. A refusal produces no RTS or DATA failure outcome. +8. Accepted Compressed and A-MPDU operation retain their current preparation, Block Ack, and ownership contracts. +9. Positive-limit equality is permitted where the standard permits containment. The separate TXNAV comparison retains its strict condition. +10. Both protection classes use valid Duration fields and preserve reservation behavior after a permitted exception. +11. HT-immediate Block Ack prohibits MSDU fragmentation. A Basic profile label or Normal Ack policy must not bypass that agreement condition. +12. When no permitted form fits a fresh TXOP at the selected mode, HCF stops with a diagnostic before further source consumption. It must not return ordinary deferral or repeat contention for that condition. + +The required scope covers individually addressed QoS DATA through HCF. It includes committed retries, permitted Basic fragments under 2016, and Normal Ack before or outside an agreement. It also includes fallback when no usable HT agreement exists. + +DCF, HCCA, new acknowledgment policies, dynamic fragmentation, multiuser operation, and MAC stop/start support remain separate work. Management and group-addressed paths require regression controls because they share selectors. This plan does not claim to audit all their TXOP behavior. + +## 4. Proposed design and reasons + +### Comparison with current Compressed admission + +The plan extends the admission mechanism that accepted Compressed agreements already use. The Basic extension and the Normal Ack extension outside accepted agreements remain proposed. HCF will prepare copies, retain one selected DATA mode, and check the complete exchange before source extraction. Admission refusal itself will preserve queued MSDUs without a retry increment. + +Commitment is the point at which the data service consumes sources and transfers prepared MPDUs to the committed-frame owner. For unnumbered sources, commitment also allocates the sequence identity. The table compares individual QoS DATA paths. The current A-MPDU path retains its separate preparation and response contracts. + +| Condition | Current Compressed, accepted agreement | Proposed Basic, accepted agreement | Proposed Normal Ack, no accepted agreement | +| --- | --- | --- | --- | +| Commitment with RTS | Keep original MSDUs queued through RTS/CTS. Commit immediately before DATA. | Commit before RTS after admission. The accepted R1 rule retains the MSDU beyond retry limits under the agreement. | After admission succeeds, commit immediately before RTS. | +| Actual RTS failure | Update access-category recovery. Do not create a frame counter under a provisional sequence number. | Update the 2016 MSDU short retry count and access-category recovery. | Update the modern MSDU frame retry count and access-category recovery. | +| Initial ordinary MSDU exceeds a fresh positive TXOP | The initial-MSDU exception can apply. | The 2016 initial-MSDU exception can apply under the accepted agreement. | That exception does not apply. Prepare legal fragments when necessary. | +| Fragmentation | Preserve the prohibition under HT-immediate Block Ack. | Add reversible preparation for permitted Basic fragments under 2016. | Account for TXOP airtime and the configured threshold when fragmentation is permitted. | +| Response cost | Individual DATA with Block Ack policy has no immediate ACK. BAR/Block Ack has separate admission. | Use the same exchange separation, with Basic response lengths. | Include SIFS and ACK airtime in the DATA exchange. | + +The initial ordinary-MSDU exception requires the stated aggregate restrictions and at most one Data or Management frame in the TXOP. An A-MSDU cannot use that initial-MSDU exception. A retransmission must satisfy its separate exception conditions. + +The selected retry contract controls commitment and RTS recovery. Normal Ack DATA under an accepted Compressed agreement follows the modern agreement-scoped rule. Basic's 2016 associated RTS rule updates its MSDU short counter even when an agreement exists. Basic commits before RTS after admission. ACK policy controls response airtime. Without RTS, these paths commit immediately before DATA, unless an earlier internal collision already owns the source. + +The earlier commitment outside an agreement gives the recovery owner a stable identity for failed associated RTS attempts. After actual RTS submission, the admitted form belongs to retry and lifetime procedures. A later cancellation must not restore it to the queue as new MSDUs. + +Hypothetical example: a later exchange needs 300 microseconds, but only 200 microseconds remain. All three paths defer before RTS and preserve queued sources. If an ordinary MSDU also exceeds a fresh positive TXOP, modern no-agreement operation needs permitted fragments. Accepted Basic and Compressed agreements can instead permit the stated initial ordinary-MSDU exception. The exception requires at most one Data or Management frame in that TXOP. + +### Fragmentation eligibility + +IEEE Std 802.11-2024, Clause 10.2.7 prohibits MSDU fragmentation under an HT-immediate Block Ack agreement. The service must preserve this prohibition even when the configured fragmentation threshold would otherwise require fragments. The current Compressed path retains this gate. + +Basic fragment support follows the 2016 agreement and PPDU conditions. Clause 10.2.7 of that edition prohibits MSDU fragmentation under HT-immediate and HT-delayed agreements. A Basic profile label does not override that prohibition. HCF must establish fragmentation eligibility before the service constructs fragment previews. Non-HT Basic cases can use permitted fragments under Clause 10.5. + +### Read-only selection before admission + +HCF will use the frame preview without extraction for initial classification and continuation selection. [HcfFs](../../src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc) will preserve BAR-first arbitration. It will invoke preparation before an accessor can call the destructive data-service path. A null Block Ack handler must select the Normal Ack preparation path. + +The [data-service contract](../../src/inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h) will retain its source-ID mechanism. Preparation will own duplicates and borrow source identities from the queue. HCF will select one actual DATA mode through rate selection. HCF will reuse that decision for aggregate evaluation, ordinary fallback, protection, and submission. + +Agreement validation will accept an explicit absence of agreement for Normal Ack operation. If the agreement state changes across an event boundary, HCF will cancel the preparation. An accepted Basic agreement will use its own permission and ACK policy. Compressed and A-MPDU checks will retain their current feature conditions. + +The current [originator policy](../../src/inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementPolicy.cc) and [recipient policy](../../src/inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementPolicy.cc) allow Basic regardless of their HT inputs. HCF calls these policies before setup initiation and request acceptance. The separate peer-permission plan owns changes to those decisions, warnings, and unknown-peer behavior. This TXOP plan changes admission after path selection; it does not change agreement negotiation. + +A-MSDU preparation must also require local HT implementation and the peer's received HT capabilities under Clause 10.11. An absent agreement or handler does not establish that permission. Without those capabilities, HCF must use an ordinary MSDU or permitted fragments. The Normal Ack fallback cases must verify this condition. + +### Complete cost and permitted forms + +HCF will calculate the exchange cost through the selected PHY mode objects. The cost starts with the first holder frame. It includes DATA, required RTS/CTS, internal IFSs, and the immediate response when required. The separate TXOP comparison also includes the IFS before a continuation. + +Normal Ack DATA includes SIFS and ACK duration. Basic DATA with Block Ack policy does not acquire a fictitious immediate ACK or Block Ack response. A later BAR/Block Ack exchange retains its own admission and arbitration. Its response cost uses the actual Basic or Compressed frame length. + +HCF will evaluate these forms in order: + +1. Evaluate the permitted A-MSDU form with the retained DATA mode. +2. If that form fails, evaluate the selected ordinary MSDU with the same mode. +3. If ordinary DATA needs permitted fragmentation, evaluate a legal fragment preview. +4. If no permitted form fits this TXOP, end the sequence without source extraction. + +A fragment group will use a size bound for a fresh TXOP at the retained mode. The current TXOP still admits each fragment through its own complete cost. The service must not divide an MSDU into smaller fragments solely to consume a short TXOP tail. This choice avoids tail-dependent fragment sizes and preserves the required equal-length relation. + +This choice can leave unused time at the end of a TXOP. It is an implementation policy, not a requirement to use every available interval. + +HCF will distinguish an empty candidate set, temporary admission refusal, an impossible fresh-TXOP form, and an actual transmission failure. Temporary refusal uses `DEFERRED`; an impossible fresh-TXOP form raises the diagnostic specified below. HCF will retain `LEGACY` only for paths outside this QoS DATA scope. An ordinary scoped candidate must not escape admission through that result. + +### Nondynamic fragment preparation + +This preparation applies only after the [fragmentation eligibility check](#fragmentation-eligibility). It must not create MSDU fragments under an HT-immediate Block Ack agreement. Normal Ack outside an agreement and permitted Basic cases under 2016 can use the fragment mechanism. + +The data service will extend its reversible preparation to own a complete group of fragment previews. The first preview must retain its pointer through frame-sequence steps. Additional fragment previews belong to the same preparation. The source MSDU remains queued until the selected commitment boundary. + +HCF will derive a maximum MPDU length from complete-exchange airtime through PHY mode queries. The data service will pass that bound to the fragmentation policy. The policy will combine it with the configured fragmentation threshold. The bound must account for actual header length, FCS, response mode, and RTS threshold transitions. + +The [fragmentation contract](../../src/inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h) will gain a bounded operation. Its unbounded operation will remain available to current callers. [BasicFragmentationPolicy](../../src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc) will own fragment-size calculation. HCF must not duplicate that calculation or change a module parameter for one frame. + +The new operation remains pure virtual under [contract purity](../../doc/project/rule/architecture.md#ar-org-contract-purity). This deliberate source change requires migration instructions in C1. An unbounded result followed by rejection cannot supply required smaller fragments. A fallback must not silently ignore the bound or report physical impossibility when only the selected policy lacks bounded support. This plan adds no default body or general adapter to the interface. + +The service will use the current [fragment builder](../../src/inet/linklayer/ieee80211/mac/fragmentation/Fragmentation.cc) on a duplicate. It will validate even nonfinal lengths, the final length, and the sixteen-fragment bound before source extraction. It will never apply nondynamic fragmentation to an A-MSDU. If needed, it will first abandon the aggregate preview. + +Fragment commitment will consume the source once. For an unnumbered queued source, it will assign one sequence number and one allocation identity to the whole group. A numbered source will retain those identities. Every fragment will inherit the source's absolute lifetime deadline. InProgressFrames will adopt the already constructed fragments through its current ownership mechanism. Commitment must not reconstruct or delete the first preview that a frame-sequence step references. + +The positive-limit exception check will identify actual transmission history. A Retry bit inherited from another hop is insufficient. Same-size retry validation must establish a prior local MPDU transmission and unchanged length. A fragment group will retain the history needed for the standard's previous-fragment retry exception after an earlier fragment leaves InProgressFrames. + +InProgressFrames will own that narrow fragment-group history, keyed by allocation identity. Group completion, expiry, applicable retry exhaustion, or agreement disposal will remove this history. Both selected editions permit the previous-fragment retry and sixteen-fragment exceptions under their stated conditions. Basic needs no initial PHY mode record or lower-rate comparison. Unrelated Data or Management transmissions in the TXOP still invalidate an applicable single-frame exception. + +A collision or failed RTS does not establish DATA transmission history. Basic's 2016 retransmission exception still requires an actual prior local MPDU transmission. It does not require a lower selected PHY rate. Fragment retransmissions retain the body and length of the transmitted fragment. + +A configuration can leave no legal first fragment at the selected mode. The bounded policy must distinguish no fragmentation requirement, valid fragment sizes, and no legal partition. HCF must test all permitted candidate forms and applicable exceptions before it treats that last result as an unsupported exchange. An empty queue remains a separate condition. + +When no permitted form fits a fresh TXOP, HCF will raise `cRuntimeError` before further source extraction, replacement, sequence allocation, or recovery mutation. The diagnostic will identify the peer, TID, selected mode, TXOP limit, and failed size or airtime constraint. This is a deliberate limit of the model at the selected mode. It does not establish that every PHY mode would fail. HCF must not return `DEFERRED`, discard the source, or request another contention attempt for this condition. + +This fatal diagnostic remains the proposed model policy. IEEE does not require a fatal simulation error. The policy preserves the source and avoids repeated contention without progress at the selected mode. A drop with a new reason would change the source-retention requirement. Automatic selection of another DATA mode would add a separate admission policy. + +When a form fits a fresh TXOP but not the current tail, HCF will return `DEFERRED` and end this TXOP normally. Queued originals remain queued. A source that an earlier internal collision already committed remains under recovery. This terminal error requires no new timer, retry controller, or preparation outcome. + +### MSDU retry state and fragment disposal + +The current recovery maps use sequence and fragment numbers and separate counters at the RTS threshold. Those maps cannot alone preserve the required MSDU retry state after fragment replacement or a partial fragment ACK. Sequence preservation is therefore insufficient. C2 prepares MSDU recovery before C4 or C5 activates a new admission path. + +QosRecoveryProcedure will own one retry record for each committed MSDU or A-MSDU, keyed by its current allocation identity. Every fragment in an ordinary MSDU group refers to that record. The modern no-agreement path will use one cumulative frame retry count under Clause 10.23.2.12.1. Basic will use the short and long MSDU counts under the 2016 Clause 10.22.2.11.1. These records replace the scoped per-fragment counter representation; they must not mirror its values in a second store. Current Compressed and A-MPDU recovery remain outside this replacement. + +The modern frame count uses `dot11ShortRetryLimit` regardless of the RTS threshold class. Basic uses the 2016 short or long retry limit where its retry procedure applies. MSDUs sent with Basic Block Ack instead follow Clause 10.24.3's lifetime rule. Normal Ack outside an agreement retains one retry record for a permitted A-MSDU. Accepted Basic fixtures use ordinary MSDUs or permitted fragments, without A-MSDU aggregation. + +Recovery calls that need the MSDU record must receive the protected packet or its existing allocation identity. A header-only call cannot recover that identity from a provisional sequence or fragment number. HCF already has the affected packet at these dispatch points. Agreement transitions must preserve or retire the existing record through its owner, without a parallel counter initialization. + +An actual collision, associated RTS failure, or DATA failure updates the record through the recovery owner under the selected contract. Modern frame counts do not split or reset when the fragment number or RTS threshold class changes. A successful nonfinal fragment ACK does not reset that modern MSDU count. Basic applies the 2016 increment and reset conditions, including their agreement conditions. Access-category recovery remains separate and follows the selected edition's EDCA procedure. + +Under an accepted Basic agreement, a DATA acknowledgment failure must not acquire a new MSDU retry limit from this correction. Clause 10.24.3 governs those DATA retries through lifetime. A failed associated RTS still updates the MSDU short count under Clause 10.22.2.11.1. A Normal Ack policy does not itself remove the agreement or change its scope. + +The following comparison applies to DATA outside an accepted agreement, unless the row states otherwise. Each row identifies a separate requirement and its direct test. Basic uses its 2016 contract even before agreement acceptance. The 2024 contract applies to the modern no-agreement path. + +| Trigger | Basic under 2016 | Modern operation under 2024 | Required direct test | +| --- | --- | --- | --- | +| DATA fails at or below the RTS threshold. | Increment the MSDU short count. | Increment the single frame count. | Test PSDU lengths below, equal to, and above the threshold. | +| DATA fails above the RTS threshold. | Increment the MSDU long count. Apply the long limit. | Increment the single frame count. Apply the short limit. | Use different short and long limits with repeated failures. | +| A nonfinal fragment receives its ACK. | Reset the applicable MSDU count under the stated success conditions. | Retain the cumulative MSDU count. | Fail another fragment after that ACK. | +| An ordinary source becomes fragments across the RTS threshold. | Retain both MSDU counts and the allocation identity. | Retain the single count and the allocation identity. | Replace a numbered source after a real collision. | +| The selected retry limit expires. | Check both applicable counts rather than only the current fragment's size class. | Check the cumulative count against the short limit. | Carry a prior short count into a larger form, and a prior long count into smaller fragments. | +| EDCA recovery processes failures and success. | Retain the 2016 QSRC and QLRC conditions. | Apply the 2024 QSRC and contention-window conditions. | Observe AC counters and window changes separately from MSDU counters. | +| An associated RTS fails under an accepted agreement. | Increment the MSDU short count. Retain the allocation beyond the retry limit under the accepted R1 rule. | Current Compressed preparation updates AC recovery without a provisional MSDU count. | Execute both named Basic RTS exhaustion cases. | + +Hypothetical example: a collision affects an ordinary MSDU above the RTS threshold before any DATA transmission. The service later replaces it with fragments below that threshold. The allocation identity and retry record remain the same. The first fragment inherits the collision state rather than a new counter value. A later fragment failure updates that same MSDU record under the applicable contract. + +For numbered-source replacement, the service will transfer the allocation identity without another recovery initialization. InProgressFrames will replace the original frame and its ACK entry with the prepared fragment entries at the selected commitment boundary. QosRecoveryProcedure will retain the existing MSDU record through that replacement. For a new queued source, the committed group creates one record with the selected contract's initial values. + +At an applicable retry-limit disposal, HCF will cancel retained preparation that refers to the affected allocation identity. InProgressFrames will dispose of every remaining fragment in that group through its existing deferred-deletion mechanism. HCF will remove their ACK and lifetime entries through the current owners. QosRecoveryProcedure will retire the MSDU retry record once. Expiry and agreement disposal use the same group cleanup. A final successful ACK removes the record only after no member remains; unrelated allocations remain intact. + +These cleanup requirements do not decide whether Basic RTS exhaustion triggers disposal under an accepted agreement. R1 must supply that trigger before C5 activates Basic. + +### Commitment and RTS recovery + +Commitment before RTS gives MSDU recovery a stable allocation identity. This is an implementation choice, not a standard queue boundary. The selected standard requires correct retry counts and disposal at the applicable limits. Neither selected contract prescribes when INET must extract queued sources or assign sequence numbers. + +Under the modern contract outside an accepted Block Ack agreement, a failed associated RTS must increment the MSDU or A-MSDU frame retry count. This requirement applies even when DATA never transmits. Clause 10.23.2.12.1 supplies this requirement in the [standards contract](#applicable-requirements). Basic's 2016 Clause 10.22.2.11.1 instead increments the MSDU short count and access-category short count after a failed associated RTS. + +The [data service](../../src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc) gives a preview the next sequence number without allocation. Commitment assigns the sequence and allocation identities and transfers the prepared form to InProgressFrames. The [recovery owner](../../src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc) then retains the MSDU record described above. Basic's commitment before RTS lets that owner retain the required 2016 associated RTS count. The accepted R1 rule controls exhaustion. + +Hypothetical example: no Block Ack agreement applies, admission succeeds, and HCF sends RTS. No CTS arrives, so DATA never transmits. The frame retry count must still increase. The proposed service commits before RTS so the same committed form retains that count across later attempts. If a disposable preview instead owned that count, preview disposal could lose its frame association. A later candidate could reuse the provisional sequence and acquire retry state for different sources. + +Transmission admission precedes commitment of a new source for that transmission. An earlier internal collision can already commit one ordinary source for recovery before its channel grant. Modern no-agreement operation and Basic commit a new admitted form immediately before actual RTS submission. An accepted Compressed agreement retains reversible preparation across RTS/CTS. The current [HCF failure handler](../../src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc) updates AC recovery for that Compressed path without a provisional DATA retry entry. + +The selected contract and agreement state control this distinction. The ACK policy bit alone does not control it. Normal Ack DATA under an accepted Compressed agreement follows its agreement-scoped commitment rule. Normal Ack in the Basic profile follows its 2016 MSDU recovery rule and commits before RTS. Without RTS, new transmission sources commit immediately before DATA. Collision-owned sources retain their earlier commitment. + +This earlier boundary applies only after complete-exchange admission succeeds. A refusal before RTS preserves all original queued sources. After actual RTS submission, the accepted committed form belongs to ordinary retry and lifetime procedures. A later capability change can cancel DATA, but it must not restore that attempted form as new queued MSDUs. This distinction separates admission refusal from recovery after an actual protection attempt. + +The implementation must distinguish an RTS retry from a DATA retransmission. An RTS failure before any DATA transmission does not prove the same-size MPDU exception. Outside an applicable initial-MSDU exception, it must not permit an oversized first DATA transmission merely because RTS failed. + +Commitment before DATA could also satisfy an MSDU recovery contract that requires RTS retry counts. The accepted design instead reuses the committed owner before RTS. The comparison below describes implementation costs rather than standard queue boundaries. + +| Basic ownership choice | State and behavior | Cost and limit | +| --- | --- | --- | +| Commit before RTS after admission. | The existing committed-frame owner retains the allocation, deadline, and MSDU counter through CTS failure. | Reuse the committed recovery record. After an actual RTS attempt, cancellation retains committed ownership. | +| Commit before DATA. | Sources remain queued through RTS/CTS. Persistent state outside the disposable preview must retain each source's RTS count. | Define identity transfer and cleanup for expiry, cancellation, and source replacement. | +| Reuse Compressed's AC-only failure path directly. | The preview disappears after CTS failure without an MSDU counter update. | This omits Basic's explicit 2016 counter requirement and is insufficient. | + +Basic commits before RTS because that boundary reuses the committed owner. A different retry contract alone does not require that choice. Absence of retry-limit disposal does not remove the mandatory short-counter update. Both viable choices use the same two temporal boundaries: before RTS and before DATA. + +### Internal collision before DATA transmission + +The internal-collision handler is another destructive entry. Its ordinary-only preparation currently covers active Compressed agreements. Other paths can create an aggregate before any admission decision. Extend the ordinary-only collision path to Basic and absent-agreement QoS DATA. + +An internal collision is a real recovery event. The handler can commit one ordinary source to obtain the current recovery identity. It must preserve unrelated queued MSDUs. It must not form an unadmitted aggregate or query adaptive DATA selection solely for collision recovery. + +This is the explicit exception to commitment after transmission admission. A later admission refusal preserves this committed source and its retry record in InProgressFrames. It does not restore that source to the pending queue or undo the collision count. The refusal still preserves every source that remains queued. + +That committed ordinary source can still require fragmentation before its first DATA transmission. The fragment preparation operation must accept this numbered, never-transmitted source from InProgressFrames as well as an unnumbered queued source. Its duplicates remain reversible until admission succeeds. Replacement must preserve sequence identity, allocation identity, absolute deadline, and the MSDU's retry count. + +[QosAckHandler](../../src/inet/linklayer/ieee80211/mac/originator/QosAckHandler.h) distinguishes a frame with no DATA transmission from a frame that awaits acknowledgment. Reuse that distinction before the first fragment form. A collision or RTS retry alone must not activate the same-size DATA retransmission exception. After a real DATA transmission, the service must preserve the transmitted body and length. + +```text +Queued MSDUs + | + v +Owned duplicate previews -- no permitted form --> End TXOP; retain queued MSDUs + | + | Complete exchange qualifies + v +No RTS: commit before DATA +RTS with accepted Compressed agreement: retain sources through CTS; commit before DATA +RTS with no modern agreement: commit before RTS; use MSDU recovery +RTS with 2016 Basic: commit after admission; retain the MSDU under the accepted R1 rule + | + v +InProgressFrames owns the admitted MPDU or fragment group +``` + +### Validation, timing, and state lifetime + +The QoS context will retain the selected DATA, RTS, CTS, and ACK modes across the real RTS/CTS event boundary. Validation will use pure permission and response queries. It must not make another adaptive DATA selection merely to validate an unchanged preparation. Context disposal will release unused previews after dependent frame-sequence steps. + +HCF will validate source membership, eligibility, deadlines, sequence state, agreement state, mode permissions, and the complete cost before the first submission. It will validate retained inputs again before DATA after CTS. Expiry or a capability change must cause cancellation without a stale pointer or synthetic transmission failure. + +Positive-limit admission permits complete cost plus the IFS before the exchange to equal the available TXOP time. A continuation must also satisfy the applicable strict TXNAV comparison at the previous exchange completion. Preserve the current reference point before that IFS. Do not replace these comparisons with one rounded deadline. + +For multiple protection, preserve the raw reservation interval and the current whole-microsecond Duration encoding rules. A permitted initial or retry exception must protect its actual exchange. Admission must not reduce the reservation to zero because that exchange exceeds the nominal positive limit. + +A zero limit counts the permitted data unit, not simply one DATA frame. A nondynamic fragment burst can contain several PPDUs for one MSDU. It must not admit a second unrelated MSDU. Required responses, protection, and separately permitted BAR exchanges retain their standard conditions. + +This design adds no timer, zero-delay event, random draw, configuration switch, general transaction controller, or generic queue API. The real RTS/CTS boundary justifies retained preparation state. The current owners retain sequence, lifetime, recovery, and TXOP state. + +## 5. Affected components and compatibility + +| Component | Proposed responsibility and affected files | Compatibility effect | +| --- | --- | --- | +| HCF | Admission, agreement conditions, selected modes, commitment edge, and recovery dispatch in `Hcf.cc` and `Hcf.h`. | Basic and Normal Ack trajectories can change where an old exchange exceeds a bound. | +| Frame sequences | Classification and continuation without extraction in `HcfFs.cc`, `TxOpFs.cc`, and `FrameSequenceContext.*`. | Preserve BAR-first arbitration, management selection, and A-MPDU selection. | +| QoS data service | Fragment previews, source validation, and group commitment in `IOriginatorQosMacDataService.h` and `OriginatorQosMacDataService.*`. | Add explicit fragment operations; retain single-frame and A-MPDU batch semantics. | +| Fragmentation policy | Bounded fragment-size calculation in `IFragmentationPolicy.h` and `BasicFragmentationPolicy.*`. | External policy implementations must implement the bounded contract; document the source migration. | +| Committed-frame owner | Group adoption and necessary local fragment history in `InProgressFrames.*`. | Preserve queue service effects, ACK state, and group disposal. | +| Recovery and lifetime owners | MSDU retry records and identity-aware dispatch in `QosRecoveryProcedure.*`; group cleanup through the existing lifetime owner. | The 2024 and 2016 counters follow their selected contracts. Fragment replacement does not initialize another count. | +| Tests and user documents | Direct cases under `tests/module/` and `tests/unit/`; user effects in `WHATSNEW` and the migration guide. | Explain changed timing, bounded-policy migration, and the scoped 2016 Basic evidence. The separate peer-permission PR owns negotiation migration. | + +The interface additions serve HCF and the QoS data service, both current consumers. A single-frame preview cannot represent group ownership or transfer. An unbounded fragmentation query cannot honor the actual TXOP airtime constraint. Extend those current contracts instead of a new module or parallel service. Apply [minimal-design guidance](../../doc/project/rule/quality.md#qr-design-minimal) to the final patch. + +No NED parameter, wire field, serializer, generic Packet API, or PHY duration formula needs a change. The listed MAC paths are outside the [sealed Packet subtree](../../doc/project/audit/seal-list.md). Preserve the current A-MPDU batch contract in this checkout. Fragment preparation must not reuse that contract as if fragments were an A-MPDU batch. + +## 6. Implementation steps and dependencies + +Each implementation commit must contain its direct tests. These steps define the design. The execution record identifies the implemented steps and their verification. + +| Step and purpose | Responsible component and files | Proposed change and expected result | Verification | +| --- | --- | --- | --- | +| C1. Prepare legal fragment forms. | QoS data service, fragmentation policy, InProgressFrames, and their contracts. | Add reversible fragment preparation and explicit group commitment. Preserve current dispatch and single-frame operations. Add the bounded-policy migration entry with the interface change. | Extend the preparation fixture. Check cancellation, pointer transfer, sequence allocation, deadlines, lengths, and disposal. Add bounded-size unit cases. | +| C2. Prepare MSDU recovery and group cleanup. | QosRecoveryProcedure, identity-aware dispatch contracts, InProgressFrames, and lifetime integration. | Add the tested retry records and group disposal operations. Keep current production dispatch until activation. Retain distinct 2016 and 2024 rules. | Use the real recovery and committed-frame owners for threshold, fragment ACK, allocation-transfer, and sibling-disposal cases. Require unchanged Compressed and A-MPDU counter histories and cleanup. R1-dependent Basic outcomes remain unavailable. | +| C3. Prepare selectors and common admission. | HCF, HcfFs, TxOpFs, and the QoS context. | Add read-only selection and complete-cost operations for the planned callers. Preserve current path selection until C4 or C5 activates them. | Exercise the production selectors, HCF admission operations, QoS context, and InProgressFrames. Check BAR arbitration, one DATA mode decision, cost boundaries, and Compressed and A-MPDU controls. | +| C4. Activate modern Normal Ack admission. | HCF and frame-sequence dispatch for the 2024 no-agreement path. | Select the prepared admission, fragment, and recovery operations from C1–C3. Apply commitment before RTS or DATA and the terminal diagnostic. | Add production admission and fragment cases with this commit. Include `NormalAckZeroLimitFragmentBurst` with protection and ACKs. Check queue preservation, RTS exhaustion, collision replacement, and disposal. | +| C5. Activate Basic admission under 2016. | HCF and frame-sequence dispatch for the enabled Basic profile, with or without an accepted agreement. | R1 selects lifetime retention under an accepted agreement. B1 supplies a legal failing continuation. Commit after admission before RTS. Activate Basic admission and its no-agreement Normal Ack fallback with the 2016 recovery rules. Preserve agreement negotiation. | Correct the legal baseline with the named non-HT cases. Assert R1's exhaustion outcomes and the DATA lifetime rule. Retain HT Compressed controls. Complete joint verification when peer permission is active. | +| C6. Complete integration evidence and user documentation. | Focused module suites, protection units, `WHATSNEW`, and the migration guide. | Cover shared selectors and user effects. Complete the direct evidence and documentation from C1–C5. | Run focused campaigns and required project gates. Record every changed fingerprint without a baseline update. | + +C1–C3 prepare tested mechanisms without activation of new admission paths. C4 and C5 activate only paths whose fragment, recovery, and disposal prerequisites already exist. Each activation commit includes its direct production regressions. C6 cannot defer those direct cases. The order follows [preparation before activation](../../doc/project/rule/pull-request.md#pr-split-prepare). + +R1 prevents C5 from activating Basic with an unspecified exhaustion outcome. B1 prevents activation without a failing legal Basic baseline. The C5 owner must satisfy both conditions before that step receives an implementation schedule. Neither condition prevents the independent C1–C4 work described here. The full plan remains incomplete until Basic also satisfies its acceptance criteria. The separate peer-permission PR has its own activation commit and the combined verification obligations below. + +## 7. Verification methods and expected results + +### Direct test matrix + +Create `tests/module/Ieee80211TxopAdmission_1.test` for production admission and queue invariants. Create `tests/module/Ieee80211TxopFragmentAdmission_1.test` for fragmentation through the same caller. Create `tests/module/Ieee80211TxopMsduRecovery_1.test` for direct retry-owner and group-disposal cases. Create `tests/unit/Ieee80211BoundedFragmentation_1.test` for fragment-size boundaries. These proposed files do not yet exist. + +C2 tests must call the production recovery and committed-frame owners directly before new dispatch activates. They must transfer, replace, acknowledge, and dispose of real committed frames through InProgressFrames. C3 tests must execute the production selectors and HCF admission operations with the real QoS context and committed-frame owner. Direct mechanism tests do not require full wireless exchanges before C4. Test substitutes may provide stimuli or observe results; they must not replace recovery, ownership, selector, or admission logic under test. + +C2 must also preserve the current Compressed and A-MPDU recovery behavior. The current Compressed admission fixture checks AC counter histories and absence of provisional MSDU counters after RTS failure. The A-MPDU admission fixture checks absence of member counters after RTS failure. Those assertions remain required controls. + +Extend the production exchange fixtures to assert exact counter increments after DATA or member failures. Check successful acknowledgment cleanup and unchanged AC recovery. Compare both short and long size classes with the parent revision. + +The Compressed checks belong in `Ieee80211CompressedBlockAckAdmission_1.test` and its exchange fixture. The A-MPDU checks belong in `Ieee80211AmpduAdmission_1.test` and `Ieee80211AmpduExchange_1.test`. Cover partial Block Ack and absent Block Ack responses. Unacknowledged members must retain their individual counts; acknowledged members must leave no retry entry. A delivery assertion or Retry bit alone cannot establish this requirement. + +C4 owns `NormalAckZeroLimitFragmentBurst` in the proposed fragment-admission fixture. Use two queued MSDUs and a legal fragment partition for the first MSDU. Require all fragments of that MSDU within one zero-limit TXOP, with the required ACKs. Require the second MSDU to wait for another TXOP. Repeat with RTS disabled and forced, under both protection classes. Check one sequence identity, one allocation, absolute deadlines, and final ACK completion. + +The following proposed configurations identify the direct non-HT Basic evidence. They use `g(erp)`, explicit Basic selection, no A-MSDU aggregation, legal MSDU sizes, and legal fragmentation thresholds. Their names identify cases within the proposed files; they do not require one new file per case. The existing Basic compatibility fixture remains a control for production exchanges and fragment receipt bits. + +| Proposed file and configuration | Required evidence | +| --- | --- | +| `Ieee80211TxopAdmission_1.test`: `BasicNonHtInitialException` | Admit the eligible initial ordinary MSDU under an accepted agreement. Reject the exception without that agreement or after earlier DATA. | +| `Ieee80211TxopAdmission_1.test`: `BasicNonHtContinuation` | Refuse a later exchange that cannot fit. Preserve queued sources, counters, and deadlines. | +| `Ieee80211TxopAdmission_1.test`: `BasicNonHtRtsExhaustionBeforeData` | Under an accepted agreement, exercise short-limit exhaustion before any local DATA transmission. Assert R1's selected retention or disposal outcome. | +| `Ieee80211TxopAdmission_1.test`: `BasicNonHtRtsExhaustionAfterData` | Repeat exhaustion after an earlier local DATA transmission. Apply R1's selected outcome and cleanup. | +| `Ieee80211TxopAdmission_1.test`: `BasicNonHtNormalAckUnderAgreement` | Include ACK airtime while the agreement remains accepted. Verify the final commitment and recovery rules from R1. | +| `Ieee80211TxopAdmission_1.test`: `BasicNonHtDataLifetime` | Lose Basic Block Ack responses. Preserve MSDUs until the applicable lifetime disposal rather than a DATA retry limit. | +| `Ieee80211TxopFragmentAdmission_1.test`: `BasicNonHtFragments` | Prove legal fragment sizes, one allocation, inherited deadlines, fragment history, and the Basic receipt bitmap. | +| `Ieee80211TxopMsduRecovery_1.test`: `BasicNonHtRecoveryBoundaries` | Check 2016 counters below, at, and above the RTS threshold. Compare distinct retry limits and successful fragment resets. | + +The two RTS exhaustion configurations must also check AC recovery, group siblings, ACK entries, and absolute deadlines. R1 must supply their expected terminal outcomes before C5. A test with an unspecified expected retention or disposal result does not count as evidence. + +The following configurations provide legal controls through production setup and frame exchanges. They belong in the proposed `Ieee80211TxopAdmission_1.test` file. Each configuration uses one fixed seed. The separate peer-permission plan owns invalid-pair tests and changes to current negotiation expectations. + +| Proposed configuration | Required evidence | +| --- | --- | +| `BasicMixedHtPeerAllowed` | Use production infrastructure association with one HT peer and one non-HT peer. Require known classifications and Basic exchanges without A-MSDU aggregation. Repeat with the endpoint roles reversed and DATA in both directions. | +| `CompressedHtControl` | Use two HT peers with explicit Compressed selection. Require an accepted Compressed agreement and valid DATA/BAR/Block Ack exchanges. Preserve the current delivery and recovery assertions. | + +| Condition | Required direct observation | Failure exposed before the correction | +| --- | --- | --- | +| Legal Basic agreement, later ordinary MSDU | Check actual DATA completion, TXOP start, frame count, agreement, and peer capabilities. Refuse a continuation that cannot fit. | Current continuation checks do not prove complete-exchange containment. The historical HT Basic overrun does not replace this legal case. | +| Block Ack disabled, 24 Mbit/s, multiple protection | Check actual DATA and ACK completion on both hops. | A later aggregate exceeds the complete-exchange bound. | +| Block Ack disabled, 6 Mbit/s, fresh positive TXOP | Observe legal fragments and complete payload delivery. | The first unfragmented ordinary DATA exchange exceeds the bound. | +| Aggregate fails, ordinary MSDU fits | Check exact source IDs after commitment. | Destructive aggregation consumes more sources than the admitted form needs. | +| Neither form fits the current tail | Snapshot queue order, owners, deadlines, sequence counters, retry counters, and queue service observations before preparation. Compare after refusal. | Current early extraction changes source state before admission. | +| No permitted form fits a fresh TXOP | Require the terminal diagnostic before further source consumption, sequence allocation, or recovery mutation. Check retained sources and absence of a new contention request. | Ordinary `DEFERRED` cannot distinguish an unsupported exchange from a short tail. | +| RTS disabled or threshold crossed by fallback | Observe the actual first holder frame and cost. | A retained protection decision can describe the rejected larger form. | +| No agreement, repeated real CTS timeouts | Check the same committed identity, cumulative frame retry count, AC recovery, retry-limit disposal, and preserved absolute deadlines. | Generic Compressed RTS recovery omits the frame retry increment. Preview disposal can also lose the count or attach it to different sources. | +| Internal collision before a channel grant | Check ordinary-only commitment, one recovery outcome, and intact unrelated sources. Admit a legal first fragment form from a numbered source. | A legacy collision can form an oversized aggregate before admission. | +| Accepted Basic agreement, real CTS timeout | Check the 2016 MSDU short count and AC recovery. Assert R1's exhaustion outcomes before and after local DATA. Verify the finalized ownership boundary. | Reuse of Compressed control-only recovery omits the MSDU update. Unspecified exhaustion can silently change disposal behavior. | +| Normal Ack DATA under an accepted agreement | Require commitment before DATA for accepted Compressed. Use Basic's final boundary after R1. Include SIFS and ACK airtime. | ACK policy alone does not select the applicable recovery contract. | +| Collision before fragmentation across the RTS threshold | Preserve one allocation and its retry record through replacement. Check 2024 count retention and the 2016 count-specific increment and reset conditions. | A per-fragment key or size-based counter switch can lose the collision state. | +| Failure after a nonfinal fragment ACK | Retain the 2024 MSDU count across the ACK. Apply Basic's 2016 reset rules only under their specified conditions. | Per-fragment counters cannot establish the required MSDU state. | +| Distinct short and long retry limits | Require the modern frame count to stop at the short limit across both size classes. Check Basic's 2016 limits outside an agreement. | Reuse of the old size-selected limit can violate the modern frame-count contract. | +| Basic contract under 2016 | Use non-HT peers without A-MSDU and legal data sizes. Test the initial ordinary-MSDU exception under an accepted agreement. Without an agreement, require initial containment and permitted fragments. | A 2005 admission rule would wrongly reject the eligible initial ordinary-MSDU exception. | +| Basic DATA failure under an accepted agreement | Apply Clause 10.24.3's lifetime rule. Verify that ordinary DATA retry limits do not discard the Block Ack MSDU. | Extension of MSDU retry records could impose a new retry limit on Block Ack DATA. | +| Basic between an HT peer and a non-HT peer | Observe accepted Basic setup and admitted exchanges in both directions. Exclude A-MSDU aggregation. | This control preserves legal Basic permission through the admission changes. | +| HT-immediate agreement with a low fragmentation threshold | Require no fragmented MSDUs. Repeat with Normal Ack DATA under the accepted agreement. | A profile-based extension could bypass the agreement's fragmentation prohibition. | +| Source expiry or capability change during CTS wait | Check cancellation, preview disposal, retained committed ownership where applicable, and absence of stale DATA. | A wider preparation path can retain invalid source or mode inputs. | +| AARF and Onoe | Count adaptive DATA queries. Compare admitted and submitted modes. | Independent preview and submission queries can change the chosen mode. | +| Positive-limit boundaries | Test complete cost one simulation tick below, equal to, and above the available interval. | Start-time checks do not establish complete containment. | +| TXNAV boundaries | Test cost below, equal to, and above TXNAV at the correct reference point. | A nonstrict comparison or shifted reference admits or rejects the wrong continuation. | +| Zero limit; direct C4 requirement | Test one ordinary MSDU and one permitted A-MSDU. Run `NormalAckZeroLimitFragmentBurst` for every fragment of one MSDU, with protection and ACKs. Reject a second unrelated MSDU in that TXOP. | A one-DATA-frame counter incorrectly ends a legal fragment burst. | +| Initial and retry exceptions | Test the eligible initial ordinary-MSDU exception under both accepted agreement profiles. Reject it for an initial A-MSDU or earlier DATA in the TXOP. | A profile-only exception admits an exchange without the required form and frame-count conditions. | +| Fragment history | Test prior fragment retry, ACK removal, group cleanup, and sixteen-fragment exceptions under both selected editions. Require no Basic lower-rate test. | Lost history can reject a permitted exception or permit an unsupported overrun. | +| Lifetime and retry exhaustion | Check all fragment siblings and group state after disposal. Check an independent peer and TID. | Partial cleanup can retain stale history or dispose unrelated frames. | +| Compressed and A-MPDU recovery; direct C2 requirement | Require unchanged RTS and DATA failure counts, per-member increments, acknowledgment cleanup, AC counters, and contention-window changes. | Shared recovery code can change counters even when delivery and Retry bits still look correct. | +| Compressed, A-MPDU, management, and group controls | Observe the intended production sequence and current delivery or recovery assertions. | A shared-selector change can alter paths outside the correction. | + +Use one fixed seed for each deterministic invariant. Vary only the named rate, profile, protection, RTS, limit, and event-order conditions. No throughput, fairness, probability, or broad robustness claim belongs to this verification. Additional random seeds cannot replace the exact boundary cases. + +### Cross-plan verification and activation order + +Whichever PR lands second must run the other plan's applicable cancellation tests against the combined source. Include capability changes during CTS wait, retained preview disposal, committed ownership, and agreement teardown. Run `BasicCapabilityChange` from the peer-permission fixture when it exists. Run the source-expiry and capability-change cases from this plan's admission fixture. Record absent cases as pending, not as executed evidence. + +The joint configuration is `BasicRefusalNormalAckTxopAdmission` in the proposed `Ieee80211TxopAdmission_1.test` fixture. It requires peer-permission activation P2 and this plan's Basic-profile activation C5. C4 covers the 2024 no-agreement path. C5 covers the enabled Basic profile's 2016 fallback. C5 now satisfies R1 and B1. The joint refusal case remains pending until P2 exists. + +The joint case must establish a known two-HT pair through production infrastructure association. Both endpoints explicitly select Basic. Require refused setup and Normal Ack DATA, without an automatic variant change or an accepted Basic agreement. Check complete TXOP containment, queue preservation on a short-tail refusal, and legal fragments when a fresh TXOP requires them. Use Basic's 2016 recovery rules for that fallback. + +The later required activation owns this joint configuration and its passing assertions. If P2 lands between C4 and C5, its independent tests establish refusal and Normal Ack operation only. Joint TXOP admission remains pending until C5. If C5 lands first, P2 must include the joint case with its activation. This integration obligation does not combine the production commits. + +After both sets of fixtures exist, use this additional focused filter from the implementation checkout: + +```sh +inet_run_module_tests -m debug -f 'Ieee80211(BasicPeerPermission|TxopAdmission|TxopFragmentAdmission|PreparedCancellation|PreparedQosData)_.*\.test' +``` + +### Commands for implementation verification + +Use the [focused build procedure](../../doc/project/guide/run-the-gates.md) after compiled inputs change. Run these commands from the implementation checkout. Confirm that each selector includes its proposed files before execution. + +```sh +make MODE=debug -j"$(nproc)" +inet_run_unit_tests -m debug -f 'Ieee80211(BoundedFragmentation|SingleProtection|MultipleProtection|TxopProcedure)_.*\.test' +inet_run_module_tests -m debug -f 'Ieee80211(TxopAdmission|TxopFragmentAdmission|TxopMsduRecovery|PreparedQosData|CompressedBlockAckAdmission|CompressedBlockAckExchange|BasicCompatibility|BlockAckVariant|BlockAckFragmentRetirement|QosRecoveryPeerIdentity)_.*\.test' +inet_run_module_tests -m debug -f 'Ieee80211(EdcaDataLifetime.*|HcfInternalCollision|HcfManagementRecovery|HcfSingleProtection|HcfMultipleProtection|SingleProtectionGroup|PreparedCancellation|AmpduAdmission|AmpduPreparation|AmpduRecovery|AmpduExchange)_.*\.test' +doc/project/enforcement/check-architecture.sh src/inet/linklayer/ieee80211 +``` + +Repeat the Block Ack-disabled reproduction runs 2, 3, 6, and 7 with corrected-timing assertions or the specified unsupported result. Keep Basic runs 0, 1, 4, and 5 as historical evidence. Their successful HT Basic exchanges are not an acceptance target. The named legal Basic cases must establish admission and recovery behavior. The separate peer-permission PR owns refusal of the invalid peer combination. + +Repeat the directly affected protocol fragmentation cases through their current suite selector. Select the affected IEEE 802.11 fingerprint rows from the current CSV through an explicit filter. Record the exact rows and causes before any proposed baseline change. + +Before publication, run both debug and release compilation and the current project-wide gates. This plan grants no publication or fingerprint-baseline authority. No implementation verification above ran during plan preparation. + +### Reproduce the observed baseline + +This procedure repeats the historical observation campaign against the pinned baseline libraries. It is separate from corrected-behavior verification above. Use the configured OMNeT++ environment and a debug INET library that matches the selected checkout. The procedure builds only the diagnostic executable. The observation record identifies the libraries actually used. + +The commands below rebuild the retained probe outside either checkout. The probe reports violations; it deliberately has no corrected-behavior assertion. Preserve the raw output before any extraction of observations. + +```sh +probe_checkout=/home/user/omnetpp_ws/inet-compressed-blockack-s5 +probe_plan=/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/plan +probe_parent="$(mktemp -d /tmp/inet-txop-admission.XXXXXX)" +cp "$probe_plan/reproductions/ieee80211-txop-admission-remaining/TxopAdmissionProbe.test" "$probe_parent/" +cd "$probe_parent" +mkdir work +opp_test gen -v -w work TxopAdmissionProbe.test +cd work/TxopAdmissionProbe +opp_makemake -f --deep -lINET_dbg "-L$probe_checkout/src" "-I$probe_checkout/src" +make MODE=debug -j2 +for probe_run in 0 1 2 3 4 5 6 7; do + ./TxopAdmissionProbe_dbg -u Cmdenv -n ".;$probe_checkout/src" --check-signals=false -c General -r "$probe_run" > "$probe_parent/run-$probe_run.log" 2>&1 +done +``` + +The historical comparison used runs 0, 5, 6, and 7 on this checkout at `d841dc77db7d0b141bf31e5e215a0de9bb281957`. To repeat that comparison, select its matching library before Makefile generation. Those run numbers describe historical controls, not corrected-behavior acceptance. After implementation, use runs 2, 3, 6, and 7 with the assertions specified above. Never load S5 headers with this checkout's library or the reverse. + +## 8. Risks, decisions, and implementation boundary + +Revision 9 requires the legal Basic baseline B1 before C5. The execution campaign supplies B1. The user accepted R1's lifetime interpretation on 2026-10-19. The [decision note](ieee80211-txop-admission-r1-decision.md) records that decision and the commitment boundary before RTS. C5 now uses those rules. The original HT Basic reproduction remains historical evidence. C4 retains its modern no-agreement scope. Joint fallback admission still requires peer permission P2. + +The current preparation callback occurs too late for Block Ack-disabled initial classification. This source fact requires the selector change. A final submission guard alone cannot meet the queue-preservation criterion. + +Fragment ownership and Normal Ack RTS recovery are necessary parts of the correction. Removal of the Compressed guard without those changes would create incomplete admission and recovery behavior. The plan selects concrete owners and commitment boundaries for both. + +The correction can change event order, contention, delivery time, and fingerprints where earlier exchanges exceeded a bound. Those changes require causal evidence. The clean control does not authorize a general claim of identical trajectories. + +The bounded fragmentation operation changes the C++ extension contract. The current inventory finds one built-in implementation, BasicFragmentationPolicy, and callers in the QoS and non-QoS data services. The existing non-QoS caller retains the unbounded operation. Recheck that inventory before C1 lands. Provide the external migration entry with C1. An implementation must not silently ignore the supplied airtime bound. + +An unsatisfiable fresh-TXOP condition raises the specified diagnostic before further source consumption. The implementation must distinguish that condition from temporary refusal in a short TXOP tail. This choice stops that simulation instead of a contention loop that cannot transmit the selected form. The initial ordinary-MSDU exception remains unavailable without the required accepted agreement, form, and frame-count conditions. + +The execution record distinguishes current implementation evidence from the earlier reproduction and proposed verification. The working tree now contains production changes. No recorded fingerprint baseline, commit, or remote branch changes during execution. + +The active target is the separate `inet-ieee80211-txop-admission-remaining` checkout at the pinned revision in the execution record. The plan and reproduction remain outside the committed PR #1364 changes. The execution request grants no publication or fingerprint-baseline authority. + +This plan uses the current [project map](../../doc/project/README.md), [plan procedure](../../doc/project/guide/write-an-implementation-plan.md), and [plan rules](../../doc/project/rule/planning.md). The plan procedure and rules remain drafts. The user's execution request supersedes the earlier document-only task boundary. The user supplied R1's explicit decision on 2026-10-19. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/BasicNonHtTxopAdmissionProbe.test b/plan/reproductions/ieee80211-txop-admission-remaining/BasicNonHtTxopAdmissionProbe.test new file mode 100644 index 00000000000..059cb211fc8 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/BasicNonHtTxopAdmissionProbe.test @@ -0,0 +1,222 @@ +%description: +Observe TXOP admission between non-HT peers with Basic Block Ack. +This diagnostic records invalid exchanges. It does not change a production decision. +All runs use positive 1024-microsecond TXOPs without aggregation. + +%file: Probe.cc +#include +#include +#include +#include "inet/common/Simsignals.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class ProbeHcf : public Hcf { + struct Scope { + simtime_t start; + simtime_t bound; + int count; + bool agreement; + bool aggregate; + bool retry; + bool exception; + simtime_t exchangeStart; + }; + std::map scopes; + std::map, b> lengths; + std::map protectedStarts; + simtime_t start = -1; + int count = 0; + const char *node() const { return getParentModule()->getParentModule()->getParentModule()->getFullName(); } + void observe(Packet *packet, const char *boundary) { + auto tag = packet->findTag(); + if (!tag) + return; + auto entry = scopes.find(tag->getAllocationIndex()); + if (entry == scopes.end()) + return; + const auto& scope = entry->second; + if (simTime() <= scope.bound || scope.exception) + return; + invalid++; + std::cout << "INVALID boundary=" << boundary << " node=" << node() + << " allocation=" << tag->getAllocationIndex() + << " time=" << simTime() << " txopStart=" << scope.start << " bound=" << scope.bound + << " excess=" << simTime() - scope.bound << " count=" << scope.count + << " agreement=" << scope.agreement << " aggregate=" << scope.aggregate + << " retry=" << scope.retry << "\n"; + std::cout << "EXCHANGE node=" << node() << " allocation=" << tag->getAllocationIndex() + << " firstHolderStart=" << scope.exchangeStart << " boundary=" << boundary + << " costThroughBoundary=" << simTime() - scope.exchangeStart << "\n"; + } + public: + int invalid = 0; + int agreedData = 0; + int outsideData = 0; + int aggregates = 0; + protected: + bool transmitFrame(Packet *packet, simtime_t ifs) override { + bool accepted = Hcf::transmitFrame(packet, ifs); + if (!accepted) + return false; + auto header = packet->peekAtFront(); + auto owner = edca->getChannelOwner(); + if (!owner) + return true; + auto txop = owner->getTxopProcedure(); + if (header->getType() == ST_RTS) { + auto context = frameSequenceHandler->getContext(); + auto rts = check_and_cast(context->getLastStep()); + protectedStarts[rts->getProtectedFrame()->getId()] = simTime() + ifs; + } + if (txop->getStart() != start) { + start = txop->getStart(); + count = 0; + } + if (dynamicPtrCast(header)) + count++; + if (auto data = dynamicPtrCast(header)) { + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()) : nullptr; + bool agreed = agreement && agreement->getIsAddbaResponseReceived(); + auto key = std::make_tuple(data->getReceiverAddress(), int(data->getTid()), + data->getSequenceNumber().get(), int(data->getFragmentNumber())); + auto prior = lengths.find(key); + bool sameSizeRetry = data->getRetry() && prior != lengths.end() && prior->second == packet->getDataLength(); + lengths.insert_or_assign(key, packet->getDataLength()); + bool exception = count == 1 && ((agreed && !data->getAMsduPresent() && !data->getRetry()) || sameSizeRetry); + scopes.insert_or_assign(packet->getTag()->getAllocationIndex(), Scope{start, start + txop->getLimit(), count, + agreed, data->getAMsduPresent(), data->getRetry(), exception, + protectedStarts.count(packet->getId()) ? protectedStarts.at(packet->getId()) : simTime() + ifs}); + agreedData += agreed; + outsideData += !agreed; + aggregates += data->getAMsduPresent(); + auto mode = packet->getTag()->getMode(); + std::cout << "DATA node=" << node() << " decision=" << simTime() << " ifs=" << ifs + << " allocation=" << packet->getTag()->getAllocationIndex() + << " bitrate=" << mode->getDataMode()->getNetBitrate() + << " airtime=" << mode->getDuration(packet->getDataLength()) << " bytes=" << packet->getByteLength() + << " txopStart=" << start << " bound=" << start + txop->getLimit() + << " count=" << count << " agreement=" << agreed << " aggregate=" << data->getAMsduPresent() + << " retry=" << data->getRetry() << " exception=" << exception + << " ackPolicy=" << int(data->getAckPolicy()) << "\n"; + } + return true; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) + observe(packet, "DATA-complete"); + Hcf::transmissionComplete(packet, header); + } + void originatorProcessReceivedFrame(Packet *packet, Packet *transmitted) override { + if (packet->peekAtFront()->getType() == ST_ACK) + observe(transmitted, "ACK-complete"); + Hcf::originatorProcessReceivedFrame(packet, transmitted); + } +}; +Define_Module(ProbeHcf); + +class ProbeTest : public cSimpleModule, public cListener { + int received = 0; + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("subscribe")); } + void receiveSignal(cComponent *, simsignal_t, cObject *, cObject *) override { received++; } + void handleMessage(cMessage *message) override { + if (message->isName("subscribe")) { + delete message; + getModuleByPath("^.sta2.app[0]")->subscribe(packetReceivedSignal, this); + scheduleAt(SimTime(1200, SIMTIME_MS), new cMessage("verify")); + return; + } + delete message; + for (const char *path : {"^.sta1.wlan[0].mac.hcf", "^.ap.wlan[0].mac.hcf"}) { + auto hcf = check_and_cast(getModuleByPath(path)); + std::cout << "SUMMARY node=" << path << " invalidBoundaries=" << hcf->invalid + << " agreedData=" << hcf->agreedData << " outsideData=" << hcf->outsideData + << " aggregates=" << hcf->aggregates << " delivered=" << received << "\n"; + } + endSimulation(); + } +}; +Define_Module(ProbeTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module ProbeHcf extends Hcf { parameters: @class(::inet::ieee80211::ProbeHcf); } +simple ProbeTest { parameters: @class(::inet::ieee80211::ProbeTest); } +network ProbeNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: Ieee80211ScalarRadioMedium; + ap: AccessPoint; + sta1: WirelessHost; + sta2: WirelessHost; + test: ProbeTest; +} + +%inifile: omnetpp.ini +[General] +network = ProbeNetwork +sim-time-limit = 1.3s +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" +*.sta1.numApps = 1 +*.sta1.app[0].typename = "UdpBasicApp" +*.sta1.app[0].destAddresses = "sta2" +*.sta1.app[0].destPort = 1000 +*.sta1.app[0].messageLength = 700B +*.sta1.app[0].startTime = 1s +*.sta1.app[0].stopTime = 1.00295s +*.sta1.app[0].sendInterval = 100us +*.sta2.numApps = 1 +*.sta2.app[0].typename = "UdpSink" +*.sta2.app[0].localPort = 1000 +*.sta*.ipv4.arp.typename = "GlobalArp" +**.wlan[*].opMode = "g(erp)" +**.wlan[*].bitrate = ${rate=6,24}Mbps +**.bandName = "2.4 GHz" +**.wlan[*].radio.antenna.numAntennas = 2 +**.wlan[*].classifier.typename = "QosClassifier" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "ProbeHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = true +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.originatorAckPolicy.blockAckReqThreshold = 5 +**.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +**.originatorMacDataService.msduAggregationPolicy.typename = "" +**.originatorMacDataService.mpduAggregationPolicy.typename = "" +**.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 +**.originatorMacDataService.msduAggregationPolicy.maxAMsduSize = 1600 +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 2346B +**.rtsPolicy.rtsThreshold = 500B +**.txopProcedure.protectionMechanism = ${protection="single","multiple"} +**.txopProcedure.txopLimit = 1024us +**.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.sta1.mobility.initialX = 0m +*.ap.mobility.initialX = 5m +*.sta2.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/TxopAdmissionProbe.test b/plan/reproductions/ieee80211-txop-admission-remaining/TxopAdmissionProbe.test new file mode 100644 index 00000000000..6b7e9acab9b --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/TxopAdmissionProbe.test @@ -0,0 +1,208 @@ +%description: +Observe TXOP admission through production HCF with Basic Block Ack or Block Ack disabled. +This diagnostic records invalid exchanges. It does not change a production decision. +All runs use positive one-millisecond TXOPs without fragmentation. + +%file: Probe.cc +#include +#include +#include +#include "inet/common/Simsignals.h" +#include "inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h" +#include "inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h" +#include "inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h" +#include "inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h" + +namespace inet::ieee80211 { +class ProbeHcf : public Hcf { + struct Scope { + simtime_t start; + simtime_t bound; + int count; + bool agreement; + bool aggregate; + bool retry; + bool exception; + }; + std::map scopes; + std::map, b> lengths; + simtime_t start = -1; + int count = 0; + const char *node() const { return getParentModule()->getParentModule()->getParentModule()->getFullName(); } + void observe(Packet *packet, const char *boundary) { + auto tag = packet->findTag(); + if (!tag) + return; + auto entry = scopes.find(tag->getAllocationIndex()); + if (entry == scopes.end()) + return; + const auto& scope = entry->second; + if (simTime() <= scope.bound || scope.exception) + return; + invalid++; + std::cout << "INVALID boundary=" << boundary << " node=" << node() + << " allocation=" << tag->getAllocationIndex() + << " time=" << simTime() << " txopStart=" << scope.start << " bound=" << scope.bound + << " excess=" << simTime() - scope.bound << " count=" << scope.count + << " agreement=" << scope.agreement << " aggregate=" << scope.aggregate + << " retry=" << scope.retry << "\n"; + } + public: + int invalid = 0; + int agreedData = 0; + int outsideData = 0; + int aggregates = 0; + protected: + bool transmitFrame(Packet *packet, simtime_t ifs) override { + bool accepted = Hcf::transmitFrame(packet, ifs); + if (!accepted) + return false; + auto header = packet->peekAtFront(); + auto owner = edca->getChannelOwner(); + if (!owner) + return true; + auto txop = owner->getTxopProcedure(); + if (txop->getStart() != start) { + start = txop->getStart(); + count = 0; + } + if (dynamicPtrCast(header)) + count++; + if (auto data = dynamicPtrCast(header)) { + auto agreement = originatorBlockAckAgreementHandler ? + originatorBlockAckAgreementHandler->getAgreement(data->getReceiverAddress(), data->getTid()) : nullptr; + bool agreed = agreement && agreement->getIsAddbaResponseReceived(); + auto key = std::make_tuple(data->getReceiverAddress(), int(data->getTid()), + data->getSequenceNumber().get(), int(data->getFragmentNumber())); + auto prior = lengths.find(key); + bool sameSizeRetry = data->getRetry() && prior != lengths.end() && prior->second == packet->getDataLength(); + lengths.insert_or_assign(key, packet->getDataLength()); + bool exception = count == 1 && ((agreed && !data->getAMsduPresent() && !data->getRetry()) || sameSizeRetry); + scopes.insert_or_assign(packet->getTag()->getAllocationIndex(), Scope{start, start + txop->getLimit(), count, + agreed, data->getAMsduPresent(), data->getRetry(), exception}); + agreedData += agreed; + outsideData += !agreed; + aggregates += data->getAMsduPresent(); + auto mode = packet->getTag()->getMode(); + std::cout << "DATA node=" << node() << " decision=" << simTime() << " ifs=" << ifs + << " allocation=" << packet->getTag()->getAllocationIndex() + << " bitrate=" << mode->getDataMode()->getNetBitrate() + << " airtime=" << mode->getDuration(packet->getDataLength()) << " bytes=" << packet->getByteLength() + << " txopStart=" << start << " bound=" << start + txop->getLimit() + << " count=" << count << " agreement=" << agreed << " aggregate=" << data->getAMsduPresent() + << " retry=" << data->getRetry() << " exception=" << exception << "\n"; + } + return true; + } + void transmissionComplete(Packet *packet, const Ptr& header) override { + if (dynamicPtrCast(header)) + observe(packet, "DATA-complete"); + Hcf::transmissionComplete(packet, header); + } + void originatorProcessReceivedFrame(Packet *packet, Packet *transmitted) override { + if (packet->peekAtFront()->getType() == ST_ACK) + observe(transmitted, "ACK-complete"); + Hcf::originatorProcessReceivedFrame(packet, transmitted); + } +}; +Define_Module(ProbeHcf); + +class ProbeTest : public cSimpleModule, public cListener { + int received = 0; + protected: + void initialize() override { scheduleAt(SimTime(1, SIMTIME_MS), new cMessage("subscribe")); } + void receiveSignal(cComponent *, simsignal_t, cObject *, cObject *) override { received++; } + void handleMessage(cMessage *message) override { + if (message->isName("subscribe")) { + delete message; + getModuleByPath("^.sta2.app[0]")->subscribe(packetReceivedSignal, this); + scheduleAt(SimTime(1200, SIMTIME_MS), new cMessage("verify")); + return; + } + delete message; + for (const char *path : {"^.sta1.wlan[0].mac.hcf", "^.ap.wlan[0].mac.hcf"}) { + auto hcf = check_and_cast(getModuleByPath(path)); + std::cout << "SUMMARY node=" << path << " invalidBoundaries=" << hcf->invalid + << " agreedData=" << hcf->agreedData << " outsideData=" << hcf->outsideData + << " aggregates=" << hcf->aggregates << " delivered=" << received << "\n"; + } + endSimulation(); + } +}; +Define_Module(ProbeTest); +} + +%file: test.ned +import inet.linklayer.ieee80211.mac.coordinationfunction.Hcf; +import inet.node.inet.WirelessHost; +import inet.node.wireless.AccessPoint; +import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator; +import inet.physicallayer.wireless.ieee80211.packetlevel.Ieee80211ScalarRadioMedium; +module ProbeHcf extends Hcf { parameters: @class(::inet::ieee80211::ProbeHcf); } +simple ProbeTest { parameters: @class(::inet::ieee80211::ProbeTest); } +network ProbeNetwork { + submodules: + configurator: Ipv4NetworkConfigurator; + radioMedium: Ieee80211ScalarRadioMedium; + ap: AccessPoint; + sta1: WirelessHost; + sta2: WirelessHost; + test: ProbeTest; +} + +%inifile: omnetpp.ini +[General] +network = ProbeNetwork +sim-time-limit = 1.3s +seed-set = 0 +cmdenv-express-mode = true +record-vector-results = false +record-scalar-results = false +*.radioMedium.propagation.typename = "ConstantTimePropagation" +*.radioMedium.propagation.propagationTime = 0s +*.radioMedium.sameTransmissionStartTimeCheck = "ignore" +*.sta1.numApps = 1 +*.sta1.app[0].typename = "UdpBasicApp" +*.sta1.app[0].destAddresses = "sta2" +*.sta1.app[0].destPort = 1000 +*.sta1.app[0].messageLength = 700B +*.sta1.app[0].startTime = 1s +*.sta1.app[0].stopTime = 1.00295s +*.sta1.app[0].sendInterval = 100us +*.sta2.numApps = 1 +*.sta2.app[0].typename = "UdpSink" +*.sta2.app[0].localPort = 1000 +*.sta*.ipv4.arp.typename = "GlobalArp" +**.wlan[*].opMode = "n(mixed-2.4Ghz)" +**.wlan[*].bitrate = ${rate=6,24}Mbps +**.bandName = "2.4 GHz" +**.wlan[*].radio.antenna.numAntennas = 2 +**.wlan[*].classifier.typename = "QosClassifier" +**.wlan[*].mac.qosStation = true +**.wlan[*].mac.hcf.typename = "ProbeHcf" +**.wlan[*].mac.hcf.isBlockAckSupported = ${profile="basic","disabled"} == "basic" +**.wlan[*].mac.hcf.blockAckVariant = "basic" +**.originatorAckPolicy.blockAckReqThreshold = 5 +**.originatorAckPolicy.maxBlockAckPolicyFrameLength = 10000B +**.originatorMacDataService.msduAggregationPolicy.typename = "BasicMsduAggregationPolicy" +**.originatorMacDataService.msduAggregationPolicy.subframeNumThreshold = 2 +**.originatorMacDataService.msduAggregationPolicy.maxAMsduSize = 1600 +**.originatorMacDataService.fragmentationPolicy.fragmentationThreshold = 2346B +**.rtsPolicy.rtsThreshold = 500B +**.txopProcedure.protectionMechanism = ${protection="single","multiple"} +**.txopProcedure.txopLimit = 1ms +**.wlan[*].radio.receiver.energyDetection = -105dBm +**.wlan[*].radio.receiver.sensitivity = -105dBm +**.wlan[*].radio.receiver.snirThreshold = 0dB +**.mobility.initFromDisplayString = false +**.mobility.constraintAreaMinX = 0m +**.mobility.constraintAreaMinY = 0m +**.mobility.constraintAreaMinZ = 0m +**.mobility.constraintAreaMaxX = 100m +**.mobility.constraintAreaMaxY = 100m +**.mobility.constraintAreaMaxZ = 0m +*.sta1.mobility.initialX = 0m +*.ap.mobility.initialX = 5m +*.sta2.mobility.initialX = 10m +**.mobility.initialY = 0m +**.mobility.initialZ = 0m diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/.gitattributes b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/.gitattributes new file mode 100644 index 00000000000..d889434ade6 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/.gitattributes @@ -0,0 +1,2 @@ +# Preserve exact console captures with their original whitespace. +*.txt -whitespace diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/aarf.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/aarf.txt new file mode 100644 index 00000000000..5da79322ec9 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/aarf.txt @@ -0,0 +1,333 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/work/Ieee80211TxopAdmission_1: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/lib: 33 + +Preparing for running configuration General, run #0... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-0-20261019-02:43:21-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.9e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 193.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #5752 t=1.35 Elapsed: 0.216837s (0m 00s) 96% completed (6% total) + Speed: ev/sec=26529.7 simsec/sec=5.87154 ev/simsec=4518.35 + Messages: created: 10183 present: 120 in FES: 4 Memory (RSS): 195.324MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #5752 + +Calling finish() at end of Run #0... + +Preparing for running configuration General, run #1... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-1-20261019-02:43:21-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (6% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #6014 t=1.35 Elapsed: 0.20893s (0m 00s) 96% completed (12% total) + Speed: ev/sec=28785.9 simsec/sec=6.09334 ev/simsec=4724.15 + Messages: created: 10288 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #6014 + +Calling finish() at end of Run #1... + +Preparing for running configuration General, run #2... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-2-20261019-02:43:21-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (12% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4535 t=1.35 Elapsed: 0.177801s (0m 00s) 96% completed (18% total) + Speed: ev/sec=25507 simsec/sec=7.16015 ev/simsec=3562.36 + Messages: created: 7039 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4535 + +Calling finish() at end of Run #2... + +Preparing for running configuration General, run #3... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 7e-06s (0m 00s) 0% completed (18% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #3630 t=1.35 Elapsed: 0.133576s (0m 00s) 96% completed (24% total) + Speed: ev/sec=27176.8 simsec/sec=9.53083 ev/simsec=2851.46 + Messages: created: 5340 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #3630 + +Calling finish() at end of Run #3... + +Preparing for running configuration General, run #4... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-4-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (25% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #5752 t=1.35 Elapsed: 0.206168s (0m 00s) 96% completed (31% total) + Speed: ev/sec=27900.5 simsec/sec=6.17494 ev/simsec=4518.35 + Messages: created: 10183 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #5752 + +Calling finish() at end of Run #4... + +Preparing for running configuration General, run #5... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-5-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (31% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #6014 t=1.35 Elapsed: 0.208323s (0m 00s) 96% completed (37% total) + Speed: ev/sec=28869.6 simsec/sec=6.11106 ev/simsec=4724.15 + Messages: created: 10288 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #6014 + +Calling finish() at end of Run #5... + +Preparing for running configuration General, run #6... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-6-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (37% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4535 t=1.35 Elapsed: 0.169463s (0m 00s) 96% completed (43% total) + Speed: ev/sec=26762 simsec/sec=7.51242 ev/simsec=3562.36 + Messages: created: 7039 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4535 + +Calling finish() at end of Run #6... + +Preparing for running configuration General, run #7... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-7-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (43% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #3630 t=1.35 Elapsed: 0.139787s (0m 00s) 96% completed (49% total) + Speed: ev/sec=25969.4 simsec/sec=9.1074 ev/simsec=2851.46 + Messages: created: 5340 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #3630 + +Calling finish() at end of Run #7... + +Preparing for running configuration General, run #48... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-48-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (50% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.045021s (0m 00s) 96% completed (56% total) + Speed: ev/sec=33099.3 simsec/sec=28.2796 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #48... + +Preparing for running configuration General, run #49... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-49-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 7e-06s (0m 00s) 0% completed (56% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.045476s (0m 00s) 96% completed (62% total) + Speed: ev/sec=32768.1 simsec/sec=27.9966 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #49... + +Preparing for running configuration General, run #50... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-50-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (62% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.035029s (0m 00s) 96% completed (68% total) + Speed: ev/sec=29580.6 simsec/sec=36.3485 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #50... + +Preparing for running configuration General, run #51... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-51-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (68% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.034071s (0m 00s) 96% completed (74% total) + Speed: ev/sec=30415.1 simsec/sec=37.374 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #51... + +Preparing for running configuration General, run #52... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-52-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (75% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.044556s (0m 00s) 96% completed (81% total) + Speed: ev/sec=33446.3 simsec/sec=28.576 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #52... + +Preparing for running configuration General, run #53... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-53-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 6e-06s (0m 00s) 0% completed (81% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.044375s (0m 00s) 96% completed (87% total) + Speed: ev/sec=33582 simsec/sec=28.6919 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #53... + +Preparing for running configuration General, run #54... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-54-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (87% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.033843s (0m 00s) 96% completed (93% total) + Speed: ev/sec=30618.3 simsec/sec=37.6236 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #54... + +Preparing for running configuration General, run #55... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-55-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (93% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.457MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.03284s (0m 00s) 96% completed (99% total) + Speed: ev/sec=31552.7 simsec/sec=38.7718 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.457MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #55... + +Run statistics: total 16, successful 16 + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/admission.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/admission.txt new file mode 100644 index 00000000000..95c039e7ca3 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/admission.txt @@ -0,0 +1,5 @@ +No module named 'py4j': optional inet.common.ide package will not work +[0/2] ▶ 1 inet-ieee80211-txop-admission-remaining module tests (concurrently) +[1/2]   ⏺ Ieee80211TxopAdmission_1.test PASS in 20.619 +[2/2] ◉ 1 inet-ieee80211-txop-admission-remaining module tests (concurrently) Multiple module tests: PASS in 20.619 +Single module test result: Result: PASS in 20.619 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/architecture.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/architecture.txt new file mode 100644 index 00000000000..4ffd6ff5467 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/architecture.txt @@ -0,0 +1,11 @@ +== AR-ORG-DOMAINS: N/A (scope does not intersect src/inet/common) == + +== AR-ORG-VIS-SPLIT: non-visualizer code must not #include visualizer/ == + ok + +== AR-COM-SOCKETS: N/A (scope does not intersect src/inet/applications) == + +== AR-QUAL-DETERMINISM: src/inet/linklayer/ieee80211 == + ok + +PASS: architecture checks clean. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-multiple.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-multiple.txt new file mode 100644 index 00000000000..32abfe8b957 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-multiple.txt @@ -0,0 +1,126 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #3... +Scenario: $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-02:46:13-15 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.6e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.621MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.001141 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.001063 bound=1.002087 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.003335 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.003257 bound=1.004281 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.003719 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.003257 bound=1.004281 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.004103 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.003257 bound=1.004281 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=3 time=1.004399 txopStart=1.003257 bound=1.004281 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=3 firstHolderStart=1.004025 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.004514 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.004436 bound=1.00546 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.004898 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.004436 bound=1.00546 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.005418 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.004436 bound=1.00546 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=6 time=1.005714 txopStart=1.004436 bound=1.00546 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=6 firstHolderStart=1.00534 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.00598 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005902 bound=1.006926 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.006364 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005902 bound=1.006926 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.006748 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005902 bound=1.006926 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=9 time=1.007044 txopStart=1.005902 bound=1.006926 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=9 firstHolderStart=1.00667 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.008265 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008187 bound=1.009211 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.008785 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008187 bound=1.009211 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.009169 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008187 bound=1.009211 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=12 time=1.009465 txopStart=1.008187 bound=1.009211 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=12 firstHolderStart=1.009091 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.009634 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.009556 bound=1.01058 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.010018 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.009556 bound=1.01058 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.010402 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.009556 bound=1.01058 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=15 time=1.010698 txopStart=1.009556 bound=1.01058 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=15 firstHolderStart=1.010324 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.011021 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.010807 bound=1.011831 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.011405 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.010807 bound=1.011831 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.011789 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.010807 bound=1.011831 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=18 time=1.012085 txopStart=1.010807 bound=1.011831 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=18 firstHolderStart=1.011711 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.012236 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012158 bound=1.013182 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.01262 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012158 bound=1.013182 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.01314 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012158 bound=1.013182 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=21 time=1.013436 txopStart=1.012158 bound=1.013182 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=21 firstHolderStart=1.013062 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.01356 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013482 bound=1.014506 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.013944 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013482 bound=1.014506 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.014328 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013482 bound=1.014506 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=24 time=1.014624 txopStart=1.013482 bound=1.014506 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=24 firstHolderStart=1.01425 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.014874 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.014796 bound=1.01582 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.015394 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.014796 bound=1.01582 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.015778 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.014796 bound=1.01582 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=sta1 allocation=27 time=1.016074 txopStart=1.014796 bound=1.01582 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=27 firstHolderStart=1.0157 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=sta1 decision=1.016225 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.016147 bound=1.017171 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.016609 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.016147 bound=1.017171 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.108441 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.108363 bound=1.109387 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.110563 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.110485 bound=1.111509 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.110947 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.110485 bound=1.111509 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.111331 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.110485 bound=1.111509 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=4 time=1.111627 txopStart=1.110485 bound=1.111509 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=4 firstHolderStart=1.111253 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.111805 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.111727 bound=1.112751 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.112189 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.111727 bound=1.112751 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.112709 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.111727 bound=1.112751 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=7 time=1.113005 txopStart=1.111727 bound=1.112751 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=7 firstHolderStart=1.112631 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.113201 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.113123 bound=1.114147 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.113585 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.113123 bound=1.114147 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.113969 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.113123 bound=1.114147 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=10 time=1.114265 txopStart=1.113123 bound=1.114147 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=10 firstHolderStart=1.113891 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.114461 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.114383 bound=1.115407 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.114981 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.114383 bound=1.115407 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.115365 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.114383 bound=1.115407 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=13 time=1.115661 txopStart=1.114383 bound=1.115407 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=13 firstHolderStart=1.115287 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.115803 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.115725 bound=1.116749 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.116187 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.115725 bound=1.116749 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.116571 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.115725 bound=1.116749 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=16 time=1.116867 txopStart=1.115725 bound=1.116749 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=16 firstHolderStart=1.116493 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.117172 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.116958 bound=1.117982 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.117556 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.116958 bound=1.117982 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.11794 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.116958 bound=1.117982 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=19 time=1.118236 txopStart=1.116958 bound=1.117982 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=19 firstHolderStart=1.117862 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.118414 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.118336 bound=1.11936 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.118798 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.118336 bound=1.11936 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.119318 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.118336 bound=1.11936 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=22 time=1.119614 txopStart=1.118336 bound=1.11936 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=22 firstHolderStart=1.11924 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.119828 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.11975 bound=1.120774 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.120212 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.11975 bound=1.120774 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.120596 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.11975 bound=1.120774 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=25 time=1.120892 txopStart=1.11975 bound=1.120774 excess=0.000118 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=25 firstHolderStart=1.120518 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.121133 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.121055 bound=1.122079 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.121653 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.121055 bound=1.122079 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.122037 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.121055 bound=1.122079 count=3 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +INVALID boundary=DATA-complete node=ap allocation=28 time=1.122333 txopStart=1.121055 bound=1.122079 excess=0.000254 count=3 agreement=1 aggregate=0 retry=0 +EXCHANGE node=ap allocation=28 firstHolderStart=1.121959 boundary=DATA-complete costThroughBoundary=0.000374 +DATA node=ap decision=1.122466 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.122388 bound=1.123412 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=9 agreedData=29 outsideData=1 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=9 agreedData=28 outsideData=2 aggregates=0 delivered=30 +** Event #3930 t=1.2 Elapsed: 0.12834s (0m 00s) 92% completed (92% total) + Speed: ev/sec=30626.8 simsec/sec=9.14671 ev/simsec=3348.4 + Messages: created: 4454 present: 120 in FES: 4 Memory (RSS): 199.336MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #3930 + +Calling finish() at end of Run #3... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-single.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-single.txt new file mode 100644 index 00000000000..02a1c48ebb8 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-24-single.txt @@ -0,0 +1,90 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #2... +Scenario: $rate=24, $protection="single", $repetition=0 +Assigned runID=General-2-20261019-02:46:13-14 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.8e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.723MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.000833 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.000755 bound=1.001779 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.001271 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.001193 bound=1.002217 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.001763 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.001685 bound=1.002709 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.002201 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.002123 bound=1.003147 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.002665 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.002587 bound=1.003611 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.003358 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.00328 bound=1.004304 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.003778 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.0037 bound=1.004724 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.004424 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.004346 bound=1.00537 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.004995 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.004917 bound=1.005941 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.005487 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005409 bound=1.006433 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.005916 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005838 bound=1.006862 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.006399 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.006321 bound=1.007345 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.006972 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.006894 bound=1.007918 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.007672 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.007594 bound=1.008618 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.008092 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008014 bound=1.009038 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.00887 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008792 bound=1.009816 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.009308 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.00923 bound=1.010254 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.009961 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.009883 bound=1.010907 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.010672 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.010594 bound=1.011618 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.011191 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.011113 bound=1.012137 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.011819 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.011741 bound=1.012765 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.012275 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012197 bound=1.013221 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.012713 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012635 bound=1.013659 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.013455 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013377 bound=1.014401 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.013947 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013869 bound=1.014893 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.014367 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.014289 bound=1.015313 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.015086 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.015008 bound=1.016032 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.015533 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.015455 bound=1.016479 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.015953 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.015875 bound=1.016899 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.016662 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.016584 bound=1.017608 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.017251 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.017173 bound=1.018197 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.017734 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.017656 bound=1.01868 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.018217 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.018139 bound=1.019163 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.018664 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.018586 bound=1.01961 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.019165 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.019087 bound=1.020111 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.019621 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.019543 bound=1.020567 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.020312 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.020234 bound=1.021258 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.020741 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.020663 bound=1.021687 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.021197 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.021119 bound=1.022143 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.021698 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.02162 bound=1.022644 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.022136 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.022058 bound=1.023082 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.023158 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.02308 bound=1.024104 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.023614 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.023536 bound=1.02456 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.024052 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.023974 bound=1.024998 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.024463 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.024385 bound=1.025409 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.024883 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.024805 bound=1.025829 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.025593 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.025515 bound=1.026539 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.026013 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.025935 bound=1.026959 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.026442 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.026364 bound=1.027388 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.027229 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.027151 bound=1.028175 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.02783 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.027752 bound=1.028776 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.028259 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.028181 bound=1.029205 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.028742 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.028664 bound=1.029688 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.029452 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.029374 bound=1.030398 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.030104 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.030026 bound=1.03105 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.030515 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.030437 bound=1.031461 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.031016 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.030938 bound=1.031962 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.031535 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.031457 bound=1.032481 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.032 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.031922 bound=1.032946 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=29 outsideData=1 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=25 outsideData=5 aggregates=0 delivered=30 +** Event #4372 t=1.2 Elapsed: 0.153561s (0m 00s) 92% completed (92% total) + Speed: ev/sec=28474.5 simsec/sec=7.64419 ev/simsec=3724.98 + Messages: created: 4892 present: 120 in FES: 4 Memory (RSS): 199.242MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #4372 + +Calling finish() at end of Run #2... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-multiple.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-multiple.txt new file mode 100644 index 00000000000..022901a2e9b --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-multiple.txt @@ -0,0 +1,123 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #1... +Scenario: $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-1-20261019-02:46:12-13 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.3e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.668MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=sta1 allocation=0 time=1.001142 txopStart=1 bound=1.001024 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=0 firstHolderStart=1 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=sta1 allocation=0 time=1.001202 txopStart=1 bound=1.001024 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=0 firstHolderStart=1 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=sta1 decision=1.002522 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.002444 bound=1.003468 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.003755 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.003677 bound=1.004701 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=0 time=1.004819 txopStart=1.003677 bound=1.004701 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=0 firstHolderStart=1.003677 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=0 time=1.004879 txopStart=1.003677 bound=1.004701 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=0 firstHolderStart=1.003677 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=ap decision=1.006046 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.005968 bound=1.006992 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.009347 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.009269 bound=1.010293 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.01074 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.010662 bound=1.011686 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.011937 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.011859 bound=1.012883 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=2 time=1.013001 txopStart=1.011859 bound=1.012883 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=2 firstHolderStart=1.011859 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=2 time=1.013061 txopStart=1.011859 bound=1.012883 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=2 firstHolderStart=1.011859 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=ap decision=1.014273 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.014195 bound=1.015219 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.017736 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.017658 bound=1.018682 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.01905 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.018972 bound=1.019996 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=4 time=1.020114 txopStart=1.018972 bound=1.019996 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=4 firstHolderStart=1.018972 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=4 time=1.020174 txopStart=1.018972 bound=1.019996 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=4 firstHolderStart=1.018972 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=sta1 decision=1.020388 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.02031 bound=1.021334 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.022691 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.022613 bound=1.023637 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.026344 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.02613 bound=1.027154 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.02755 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.027472 bound=1.028496 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.028756 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.028678 bound=1.029702 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=6 time=1.02982 txopStart=1.028678 bound=1.029702 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=6 firstHolderStart=1.028678 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=6 time=1.02988 txopStart=1.028678 bound=1.029702 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=6 firstHolderStart=1.028678 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=ap decision=1.031092 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.031014 bound=1.032038 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.032289 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.032211 bound=1.033235 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.033468 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.03339 bound=1.034414 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.034728 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.03465 bound=1.035674 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.035934 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.035856 bound=1.03688 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.037131 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.037053 bound=1.038077 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.038337 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.038259 bound=1.039283 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.039806 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.039728 bound=1.040752 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.041075 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.040997 bound=1.042021 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.042263 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.042185 bound=1.043209 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.043469 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.043391 bound=1.044415 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.044675 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.044597 bound=1.045621 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.045863 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.045785 bound=1.046809 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.047168 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.04709 bound=1.048114 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.0485 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.048422 bound=1.049446 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.049929 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.049851 bound=1.050875 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.051333 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.051255 bound=1.052279 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.052891 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.052677 bound=1.053701 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.054187 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.054109 bound=1.055133 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.055375 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.055297 bound=1.056321 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.05659 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.056512 bound=1.057536 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.057796 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.057718 bound=1.058742 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.059038 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.05896 bound=1.059984 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.060244 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.060166 bound=1.06119 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.061694 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.06148 bound=1.062504 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.062918 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.06284 bound=1.063864 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.064169 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.064091 bound=1.065115 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.065616 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.065538 bound=1.066562 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.06684 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.066762 bound=1.067786 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.0681 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.068022 bound=1.069046 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.069442 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.069228 bound=1.070252 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.070621 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.070543 bound=1.071567 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.071935 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.071857 bound=1.072881 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.073159 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.073081 bound=1.074105 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.07441 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.074332 bound=1.075356 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.075725 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.075511 bound=1.076535 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.076913 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.076835 bound=1.077859 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.07811 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.078032 bound=1.079056 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.079316 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.079238 bound=1.080262 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.080504 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.080426 bound=1.08145 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.081683 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.081605 bound=1.082629 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.083007 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.082793 bound=1.083817 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.084213 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.084135 bound=1.085159 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.08541 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.085332 bound=1.086356 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.086788 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.086574 bound=1.087598 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.087994 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.087916 bound=1.08894 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.095084 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.095006 bound=1.09603 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.099593 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.099515 bound=1.100539 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.101159 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.101081 bound=1.102105 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.106316 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.106238 bound=1.107262 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.111078 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.110864 bound=1.111888 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.11232 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.112242 bound=1.113266 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.113598 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.11352 bound=1.114544 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.114795 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.114717 bound=1.115741 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.116055 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.115977 bound=1.117001 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.117388 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.117174 bound=1.118198 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.118693 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.118615 bound=1.119639 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.119899 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.119821 bound=1.120845 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=2 agreedData=34 outsideData=1 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=8 agreedData=34 outsideData=4 aggregates=0 delivered=30 +** Event #4942 t=1.2 Elapsed: 0.161383s (0m 00s) 92% completed (92% total) + Speed: ev/sec=30626.4 simsec/sec=7.27359 ev/simsec=4210.63 + Messages: created: 5496 present: 120 in FES: 4 Memory (RSS): 198.934MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #4942 + +Calling finish() at end of Run #1... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-single.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-single.txt new file mode 100644 index 00000000000..6ff10b28889 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/basic-6-single.txt @@ -0,0 +1,119 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #0... +Scenario: $rate=6, $protection="single", $repetition=0 +Assigned runID=General-0-20261019-02:46:11-12 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.5e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.566MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=sta1 allocation=0 time=1.001142 txopStart=1 bound=1.001024 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=0 firstHolderStart=1 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=sta1 allocation=0 time=1.001202 txopStart=1 bound=1.001024 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=sta1 allocation=0 firstHolderStart=1 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=ap decision=1.001635 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.001557 bound=1.002581 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=0 time=1.002699 txopStart=1.001557 bound=1.002581 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=0 firstHolderStart=1.001557 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=0 time=1.002759 txopStart=1.001557 bound=1.002581 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=0 firstHolderStart=1.001557 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=sta1 decision=1.002946 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.002868 bound=1.003892 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.004371 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.004293 bound=1.005317 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.005881 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.005803 bound=1.006827 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.007274 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.007196 bound=1.00822 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.008471 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.008393 bound=1.009417 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=2 time=1.009535 txopStart=1.008393 bound=1.009417 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=2 firstHolderStart=1.008393 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=2 time=1.009595 txopStart=1.008393 bound=1.009417 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=2 firstHolderStart=1.008393 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=ap decision=1.01001 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.009932 bound=1.010956 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.011583 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.011505 bound=1.012529 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.012897 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.012819 bound=1.013843 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=4 time=1.013961 txopStart=1.012819 bound=1.013843 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=4 firstHolderStart=1.012819 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=4 time=1.014021 txopStart=1.012819 bound=1.013843 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=4 firstHolderStart=1.012819 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=sta1 decision=1.014235 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.014157 bound=1.015181 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.015723 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.015645 bound=1.016669 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.017531 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.017453 bound=1.018477 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.018764 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.018686 bound=1.01971 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.019952 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.019874 bound=1.020898 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +INVALID boundary=DATA-complete node=ap allocation=6 time=1.021016 txopStart=1.019874 bound=1.020898 excess=0.000118 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=6 firstHolderStart=1.019874 boundary=DATA-complete costThroughBoundary=0.001142 +INVALID boundary=ACK-complete node=ap allocation=6 time=1.021076 txopStart=1.019874 bound=1.020898 excess=0.000178 count=1 agreement=0 aggregate=0 retry=0 +EXCHANGE node=ap allocation=6 firstHolderStart=1.019874 boundary=ACK-complete costThroughBoundary=0.001202 +DATA node=sta1 decision=1.021527 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.021449 bound=1.022473 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.022706 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.022628 bound=1.023652 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.023912 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.023834 bound=1.024858 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.025118 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.02504 bound=1.026064 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.026342 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.026264 bound=1.027288 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.027548 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.02747 bound=1.028494 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.029013 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.028935 bound=1.029959 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.030442 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.030364 bound=1.031388 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.033401 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.033323 bound=1.034347 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.035919 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.035841 bound=1.036865 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.038522 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.038444 bound=1.039468 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.041089 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.041011 bound=1.042035 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.0438 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.043722 bound=1.044746 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.045628 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.04555 bound=1.046574 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.046942 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.046864 bound=1.047888 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.048157 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.048079 bound=1.049103 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.049363 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.049285 bound=1.050309 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.050632 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.050554 bound=1.051578 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.052064 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.051986 bound=1.05301 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.054415 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.054337 bound=1.055361 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.055639 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.055561 bound=1.056585 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.056863 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.056785 bound=1.057809 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.058042 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.057964 bound=1.058988 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.05923 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.059152 bound=1.060176 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.060698 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.06062 bound=1.061644 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.061904 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.061826 bound=1.06285 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.063083 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.063005 bound=1.064029 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.064492329244 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.064414329244 bound=1.065438329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.065797329244 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.065719329244 bound=1.066743329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.067148329244 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.067070329244 bound=1.068094329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.068345329244 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.068267329244 bound=1.069291329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.069560329244 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.069482329244 bound=1.070506329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.070757329244 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.070679329244 bound=1.071703329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.075093329244 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.075015329244 bound=1.076039329244 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.080819329244 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.080741329244 bound=1.081765329244 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.082880329244 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.082802329244 bound=1.083826329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.084717329244 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.084639329244 bound=1.085663329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.085896329244 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.085818329244 bound=1.086842329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.087138329244 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.087060329244 bound=1.088084329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.088362329244 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.088284329244 bound=1.089308329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.089622329244 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.089544329244 bound=1.090568329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.091099329244 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.091021329244 bound=1.092045329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.092368329244 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.092290329244 bound=1.093314329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.093565329244 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.093487329244 bound=1.094511329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.094843329244 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.094765329244 bound=1.095789329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.096112329244 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.096034329244 bound=1.097058329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.097652329244 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.097574329244 bound=1.098598329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.098930329244 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.098852329244 bound=1.099876329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.100127329244 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.100049329244 bound=1.101073329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.101387329244 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.101309329244 bound=1.102333329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.102584329244 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.102506329244 bound=1.103530329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.104079329244 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.104001329244 bound=1.105025329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.105384329244 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.105306329244 bound=1.106330329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.106662329244 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.106584329244 bound=1.107608329244 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=2 agreedData=34 outsideData=1 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=8 agreedData=30 outsideData=4 aggregates=0 delivered=30 +** Event #4723 t=1.2 Elapsed: 0.153078s (0m 00s) 92% completed (92% total) + Speed: ev/sec=30857.4 simsec/sec=7.66826 ev/simsec=4024.04 + Messages: created: 5266 present: 120 in FES: 4 Memory (RSS): 198.91MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #4723 + +Calling finish() at end of Run #0... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/build.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/build.txt new file mode 100644 index 00000000000..dda98462b39 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/build.txt @@ -0,0 +1,11 @@ +*** CREATING Makefile with: +opp_makemake --make-so -f --deep -o INET -O out -pINET -I. -Xinet/applications/voipstream -Xinet/emulation -Xinet/linklayer/configurator/gatescheduling/z3 -Xinet/transportlayer/tcp_lwip -Xinet/visualizer/osg +make[1]: Entering directory '/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src' +*** CCACHE detected - precompiled headers disabled +*** COMPILING with: +ccache clang++ -c -std=c++17 -O0 -Wall -glldb -fstandalone-debug -MMD -MP -MF .d -fPIC -I/usr/include/python3.14 -I/usr/include/python3.14 -Wno-deprecated-register -Wno-unused-function -fno-omit-frame-pointer -DBACKWARD_HAS_DW=1 -Wno-overloaded-virtual -DOMNETPPLIBS_IMPORT -DINET_EXPORT -I. -I/home/user/omnetpp-6.4.0aipre2/include +*** LINKING with: +clang++ -shared -fPIC -o ../out/clang-debug/src/libINET_dbg.so -Wl,--no-as-needed -Wl,--whole-archive -Wl,--no-whole-archive -loppenvir_dbg -loppsim_dbg -lstdc++ -lpython3.14 -ldl -lm -ldw -lelf -fuse-ld=lld -Wl,-rpath,/home/user/omnetpp-6.4.0aipre2/lib -Wl,-rpath,. -Wl,-rpath,/home/user/omnetpp-6.4.0aipre2/tools/linux.x86_64/lib -Wl,--export-dynamic -L/home/user/omnetpp-6.4.0aipre2/lib +Building... +make[1]: Nothing to be done for 'all-pch'. +make[1]: Leaving directory '/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src' diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-aarf.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-aarf.txt new file mode 100644 index 00000000000..cae7c20c2c0 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-aarf.txt @@ -0,0 +1,333 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/work/Ieee80211TxopAdmission_1: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/lib: 33 + +Preparing for running configuration General, run #0... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-0-20261019-09:39:07-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 4.2e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 198.238MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #5752 t=1.35 Elapsed: 0.438029s (0m 00s) 96% completed (6% total) + Speed: ev/sec=13132.4 simsec/sec=2.90646 ev/simsec=4518.35 + Messages: created: 10183 present: 120 in FES: 4 Memory (RSS): 199.793MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #5752 + +Calling finish() at end of Run #0... + +Preparing for running configuration General, run #1... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-1-20261019-09:39:08-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (6% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #6014 t=1.35 Elapsed: 0.403692s (0m 00s) 96% completed (12% total) + Speed: ev/sec=14897.9 simsec/sec=3.15356 ev/simsec=4724.15 + Messages: created: 10288 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #6014 + +Calling finish() at end of Run #1... + +Preparing for running configuration General, run #2... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-2-20261019-09:39:09-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (12% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4535 t=1.35 Elapsed: 0.368042s (0m 00s) 96% completed (18% total) + Speed: ev/sec=12322.3 simsec/sec=3.45904 ev/simsec=3562.36 + Messages: created: 7039 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4535 + +Calling finish() at end of Run #2... + +Preparing for running configuration General, run #3... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-09:39:09-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (18% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #3630 t=1.35 Elapsed: 0.257175s (0m 00s) 96% completed (24% total) + Speed: ev/sec=14115.6 simsec/sec=4.95031 ev/simsec=2851.46 + Messages: created: 5340 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #3630 + +Calling finish() at end of Run #3... + +Preparing for running configuration General, run #4... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-4-20261019-09:39:10-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (25% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #5752 t=1.35 Elapsed: 0.425928s (0m 00s) 96% completed (31% total) + Speed: ev/sec=13504.9 simsec/sec=2.98891 ev/simsec=4518.35 + Messages: created: 10183 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #5752 + +Calling finish() at end of Run #4... + +Preparing for running configuration General, run #5... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-5-20261019-09:39:10-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (31% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #6014 t=1.35 Elapsed: 0.413373s (0m 00s) 96% completed (37% total) + Speed: ev/sec=14549 simsec/sec=3.0797 ev/simsec=4724.15 + Messages: created: 10288 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #6014 + +Calling finish() at end of Run #5... + +Preparing for running configuration General, run #6... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-6-20261019-09:39:11-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.4e-05s (0m 00s) 0% completed (37% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4535 t=1.35 Elapsed: 0.370898s (0m 00s) 96% completed (43% total) + Speed: ev/sec=12227.4 simsec/sec=3.4324 ev/simsec=3562.36 + Messages: created: 7039 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4535 + +Calling finish() at end of Run #6... + +Preparing for running configuration General, run #7... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-7-20261019-09:39:11-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (43% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #3630 t=1.35 Elapsed: 0.243012s (0m 00s) 96% completed (49% total) + Speed: ev/sec=14938.1 simsec/sec=5.23877 ev/simsec=2851.46 + Messages: created: 5340 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #3630 + +Calling finish() at end of Run #7... + +Preparing for running configuration General, run #48... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-48-20261019-09:39:12-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (50% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.088399s (0m 00s) 96% completed (56% total) + Speed: ev/sec=16857.3 simsec/sec=14.4026 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #48... + +Preparing for running configuration General, run #49... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-49-20261019-09:39:12-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (56% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.096357s (0m 00s) 96% completed (62% total) + Speed: ev/sec=15464.8 simsec/sec=13.2129 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #49... + +Preparing for running configuration General, run #50... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-50-20261019-09:39:12-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (62% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.059992s (0m 00s) 96% completed (68% total) + Speed: ev/sec=17271.8 simsec/sec=21.2236 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #50... + +Preparing for running configuration General, run #51... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-51-20261019-09:39:13-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.6e-05s (0m 00s) 0% completed (68% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.112076s (0m 00s) 96% completed (74% total) + Speed: ev/sec=9245.79 simsec/sec=11.3612 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #51... + +Preparing for running configuration General, run #52... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-52-20261019-09:39:13-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (75% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.081823s (0m 00s) 96% completed (81% total) + Speed: ev/sec=18212.3 simsec/sec=15.5603 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #52... + +Preparing for running configuration General, run #53... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-53-20261019-09:39:13-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (81% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.08303s (0m 00s) 96% completed (87% total) + Speed: ev/sec=17947.1 simsec/sec=15.3337 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #53... + +Preparing for running configuration General, run #54... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-54-20261019-09:39:14-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (87% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.062415s (0m 00s) 96% completed (93% total) + Speed: ev/sec=16601.2 simsec/sec=20.3995 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #54... + +Preparing for running configuration General, run #55... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-55-20261019-09:39:14-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (93% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.961MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.057127s (0m 00s) 96% completed (99% total) + Speed: ev/sec=18138.2 simsec/sec=22.2882 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 199.961MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #55... + +Run statistics: total 16, successful 16 + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-architecture.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-architecture.txt new file mode 100644 index 00000000000..4ffd6ff5467 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-architecture.txt @@ -0,0 +1,11 @@ +== AR-ORG-DOMAINS: N/A (scope does not intersect src/inet/common) == + +== AR-ORG-VIS-SPLIT: non-visualizer code must not #include visualizer/ == + ok + +== AR-COM-SOCKETS: N/A (scope does not intersect src/inet/applications) == + +== AR-QUAL-DETERMINISM: src/inet/linklayer/ieee80211 == + ok + +PASS: architecture checks clean. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-corrected.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-corrected.txt new file mode 100644 index 00000000000..a46626d0914 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-corrected.txt @@ -0,0 +1,356 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #0... +Scenario: $rate=6, $protection="single", $repetition=0 +Assigned runID=General-0-20261019-09:39:07-12 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 4.1e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.879MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000874 bytes=632 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.001086 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.00025 bytes=164 txopStart=1.001086 bound=1.00211 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.001793 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.001715 bound=1.002739 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.003035 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.002957 bound=1.003981 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.004786 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000874 bytes=632 txopStart=1.004708 bound=1.005732 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.005812 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.00025 bytes=164 txopStart=1.005812 bound=1.006836 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.006519 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.006441 bound=1.007465 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.007707 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.007629 bound=1.008653 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.00894 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.008862 bound=1.009886 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.010155 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.010077 bound=1.011101 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.011379 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.011301 bound=1.012325 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.012648 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.01257 bound=1.013594 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.014347 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.014269 bound=1.015293 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.015535 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.000874 bytes=632 txopStart=1.015457 bound=1.016481 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.016525 ifs=0 allocation=5 bitrate=6 Mbps airtime=0.00025 bytes=164 txopStart=1.016525 bound=1.017549 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.017662 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.017584 bound=1.018608 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.019159 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.019081 bound=1.020105 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.020347 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.020269 bound=1.021293 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.02158 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.021502 bound=1.022526 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.022804 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.022726 bound=1.02375 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.024001 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.023923 bound=1.024947 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.025243 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.025165 bound=1.026189 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.026422 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.026344 bound=1.027368 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.027637 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.027559 bound=1.028583 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.029051 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.028973 bound=1.029997 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.030248 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.03017 bound=1.031194 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.03168 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.031602 bound=1.032626 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.032895 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.032817 bound=1.033841 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.034119 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.034041 bound=1.035065 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.035334 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.035256 bound=1.03628 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.036531 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.036453 bound=1.037477 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.037996 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.037918 bound=1.038942 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.039319 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.039241 bound=1.040265 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.040697 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.040619 bound=1.041643 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.041912 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.041834 bound=1.042858 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.043154 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.043076 bound=1.0441 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.044405 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.044327 bound=1.045351 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.045873 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.045795 bound=1.046819 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.047088 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.04701 bound=1.048034 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.048285 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.048207 bound=1.049231 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.049473 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.049395 bound=1.050419 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.050896 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.050818 bound=1.051842 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.053043 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.052965 bound=1.053989 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.054231 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.054153 bound=1.055177 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.055446 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.055368 bound=1.056392 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.05694 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.056862 bound=1.057886 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.058119 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.058041 bound=1.059065 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.059316 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.059238 bound=1.060262 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.06054 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.060462 bound=1.061486 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.061935 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.061857 bound=1.062881 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.063286 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.063208 bound=1.064232 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.064588 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.06451 bound=1.065534 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.065939 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.065861 bound=1.066885 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.067127 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.067049 bound=1.068073 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.068333 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.068255 bound=1.069279 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.069879 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.069801 bound=1.070825 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.071175 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.071097 bound=1.072121 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.072354 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.072276 bound=1.0733 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.073596 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.073518 bound=1.074542 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.075064 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.074986 bound=1.07601 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.076378 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.0763 bound=1.077324 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.077557 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.077479 bound=1.078503 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.078826 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.078748 bound=1.079772 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=29 outsideData=2 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=28 outsideData=4 aggregates=0 delivered=30 +** Event #4190 t=1.2 Elapsed: 0.335197s (0m 00s) 92% completed (23% total) + Speed: ev/sec=12501.2 simsec/sec=3.50183 ev/simsec=3569.92 + Messages: created: 5167 present: 120 in FES: 4 Memory (RSS): 199.273MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #4190 + +Calling finish() at end of Run #0... + +Preparing for running configuration General, run #1... +Scenario: $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-1-20261019-09:39:08-12 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (25% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.273MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000874 bytes=632 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.001088 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.00025 bytes=164 txopStart=1.001088 bound=1.002112 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.002344 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000874 bytes=632 txopStart=1.002266 bound=1.00329 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.003345 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.00025 bytes=164 txopStart=1.003345 bound=1.004369 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.005581 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.005503 bound=1.006527 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.007866 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.007788 bound=1.008812 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.011203 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.011125 bound=1.012149 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.012418 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.01234 bound=1.013364 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.013642 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.000874 bytes=632 txopStart=1.013564 bound=1.014588 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.014748 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.01467 bound=1.015694 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.015894 ifs=0 allocation=2 bitrate=6 Mbps airtime=0.00025 bytes=164 txopStart=1.015894 bound=1.016918 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.018094 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.018016 bound=1.01904 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.019336 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.019258 bound=1.020282 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.020542 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.020464 bound=1.021488 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.021775 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.021697 bound=1.022721 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.023154 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.023076 bound=1.0241 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.024432 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.024354 bound=1.025378 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.025665 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.025587 bound=1.026611 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.026916 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.026838 bound=1.027862 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.028185 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.028107 bound=1.029131 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.029364 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.029286 bound=1.03031 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.032818 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.03274 bound=1.033764 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.034186 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.034108 bound=1.035132 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.035609 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.035395 bound=1.036419 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.036869 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.036791 bound=1.037815 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.038057 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.000874 bytes=632 txopStart=1.037979 bound=1.039003 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.039145 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.039067 bound=1.040091 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.04036 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.040282 bound=1.041306 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.041497 ifs=0 allocation=6 bitrate=6 Mbps airtime=0.00025 bytes=164 txopStart=1.041497 bound=1.042521 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.043823 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.043745 bound=1.044769 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.04502 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.044942 bound=1.045966 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.046217 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.046139 bound=1.047163 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.047541 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.047327 bound=1.048351 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.048756 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.048678 bound=1.049702 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.049971 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.049893 bound=1.050917 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.051177 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.051099 bound=1.052123 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.052401 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.052323 bound=1.053347 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.053661 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.053583 bound=1.054607 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.054876 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.054798 bound=1.055822 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.056073 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.055995 bound=1.057019 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.057397 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.057183 bound=1.058207 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.058639 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.058561 bound=1.059585 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.059972 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.059758 bound=1.060782 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.062119 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.062041 bound=1.063065 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.063307 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.063229 bound=1.064253 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.065583 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.065505 bound=1.066529 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.066762 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.066684 bound=1.067708 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.068956 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.068878 bound=1.069902 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.070135 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.070057 bound=1.071081 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.071548 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.07147 bound=1.072494 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.073177 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.073099 bound=1.074123 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.07468 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.074602 bound=1.075626 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.075868 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.07579 bound=1.076814 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.077344 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.077266 bound=1.07829 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.078794 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.07858 bound=1.079604 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.08 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.079922 bound=1.080946 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.081197 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.081119 bound=1.082143 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.082466 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.082388 bound=1.083412 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.083762 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.083684 bound=1.084708 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.085077 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.084863 bound=1.085887 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.086319 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.086241 bound=1.087265 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.087543 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.087465 bound=1.088489 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.088803 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.088725 bound=1.089749 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.095333 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.095255 bound=1.096279 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=ap decision=1.097035 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.096821 bound=1.097845 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.098304 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.098226 bound=1.09925 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.099618 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.09954 bound=1.100564 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.10086 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.100782 bound=1.101806 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.102138 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.10206 bound=1.103084 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.103471 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.103257 bound=1.104281 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.104731 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.104653 bound=1.105677 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.105928 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.10585 bound=1.106874 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.107233 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.107155 bound=1.108179 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.108439 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.108361 bound=1.109385 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.10988 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.109666 bound=1.11069 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.111158 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.11108 bound=1.112104 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.112364 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.001054 bytes=766 txopStart=1.112286 bound=1.11331 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=34 outsideData=2 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=35 outsideData=6 aggregates=0 delivered=30 +** Event #4959 t=1.2 Elapsed: 0.33555s (0m 00s) 92% completed (48% total) + Speed: ev/sec=14779.1 simsec/sec=3.49791 ev/simsec=4225.11 + Messages: created: 6063 present: 120 in FES: 4 Memory (RSS): 199.273MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #4959 + +Calling finish() at end of Run #1... + +Preparing for running configuration General, run #2... +Scenario: $rate=24, $protection="single", $repetition=0 +Assigned runID=General-2-20261019-09:39:09-12 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.4e-05s (0m 00s) 0% completed (50% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.273MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.000833 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.000755 bound=1.001779 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.001359 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.001281 bound=1.002305 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.001797 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.001719 bound=1.002743 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.002667 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.002589 bound=1.003613 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.003096 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.003018 bound=1.004042 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.003809 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.003731 bound=1.004755 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.004326 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.004248 bound=1.005272 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.004899 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.004821 bound=1.005845 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.005479 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005401 bound=1.006425 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.005944 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005866 bound=1.00689 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.006687 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.006609 bound=1.007633 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.007143 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.007065 bound=1.008089 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.007942 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.007864 bound=1.008888 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.008389 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008311 bound=1.009335 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.009075 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008997 bound=1.010021 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.009504 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.009426 bound=1.01045 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.01003 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.009952 bound=1.010976 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.01054 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.010462 bound=1.011486 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.011084 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.011006 bound=1.01203 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.011657 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.011579 bound=1.012603 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.012364 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012286 bound=1.01331 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.012856 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012778 bound=1.013802 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.013617 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013539 bound=1.014563 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.014055 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013977 bound=1.015001 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.014581 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.014503 bound=1.015527 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.01501 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.014932 bound=1.015956 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.01559 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.015512 bound=1.016536 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.016028 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.01595 bound=1.016974 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.016502 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.016424 bound=1.017448 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.016949 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.016871 bound=1.017895 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.017423 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.017345 bound=1.018369 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.018757 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.018679 bound=1.019703 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.019276 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.019198 bound=1.020222 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.01974 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.019662 bound=1.020686 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.020415 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.020337 bound=1.021361 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.020916 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.020838 bound=1.021862 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.021451 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.021373 bound=1.022397 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.022247 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.022169 bound=1.023193 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.022793 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.022715 bound=1.023739 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.02341 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.023332 bound=1.024356 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.024067 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.023989 bound=1.025013 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.025125 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.025047 bound=1.026071 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.02593 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.025852 bound=1.026876 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.026412 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.026334 bound=1.027358 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.027078 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.027 bound=1.028024 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.027802 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.027724 bound=1.028748 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.028589 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.028511 bound=1.029535 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.029062 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.028984 bound=1.030008 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.029755 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.029677 bound=1.030701 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.030435 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.030357 bound=1.031381 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.031175 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.031097 bound=1.032121 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.03207 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.031992 bound=1.033016 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.03258 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.032502 bound=1.033526 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.033188 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.03311 bound=1.034134 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.03398 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.033902 bound=1.034926 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.034794 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.034716 bound=1.03574 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.035311 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.035233 bound=1.036257 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.036134 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.036056 bound=1.03708 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.037076 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.036998 bound=1.038022 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.037881 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.037803 bound=1.038827 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.038533 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.038455 bound=1.039479 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.039482 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.039404 bound=1.040428 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.040224 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.040146 bound=1.04117 count=1 agreement=1 aggregate=0 retry=1 exception=1 ackPolicy=3 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=33 outsideData=1 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=23 outsideData=7 aggregates=0 delivered=30 +** Event #4941 t=1.2 Elapsed: 0.374649s (0m 00s) 92% completed (73% total) + Speed: ev/sec=13188.7 simsec/sec=3.13287 ev/simsec=4209.78 + Messages: created: 6093 present: 120 in FES: 4 Memory (RSS): 199.523MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #4941 + +Calling finish() at end of Run #2... + +Preparing for running configuration General, run #3... +Scenario: $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-09:39:09-12 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (75% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.523MiB +DATA node=sta1 decision=1.000078 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1 bound=1.001024 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.001141 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.001063 bound=1.002087 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.003335 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.003257 bound=1.004281 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.003719 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.003257 bound=1.004281 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.005236 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005158 bound=1.006182 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.00562 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.005158 bound=1.006182 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.006457 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.006379 bound=1.007403 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.006841 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.006379 bound=1.007403 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.008349 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.008271 bound=1.009295 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.010507 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.010429 bound=1.011453 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.012665 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012587 bound=1.013611 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.013185 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.012587 bound=1.013611 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.013686 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.013608 bound=1.014632 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.015835 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.015757 bound=1.016781 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.018029 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.017951 bound=1.018975 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.018413 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.017951 bound=1.018975 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.019227 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.019149 bound=1.020173 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.02143 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.021352 bound=1.022376 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.023615 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.023537 bound=1.024561 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.023999 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.023537 bound=1.024561 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.024672 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.024594 bound=1.025618 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.025866 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.025788 bound=1.026812 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.02625 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.025788 bound=1.026812 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.027875 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.027797 bound=1.028821 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.028259 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.027797 bound=1.028821 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.028963 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.028885 bound=1.029909 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.029347 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.028885 bound=1.029909 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.030107 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.030029 bound=1.031053 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.030491 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.030029 bound=1.031053 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.031258 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.03118 bound=1.032204 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.031778 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.03118 bound=1.032204 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.032367 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.032289 bound=1.033313 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.032887 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.032289 bound=1.033313 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.033714 ifs=0.00001 allocation=16 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.033636 bound=1.03466 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.035971 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.035893 bound=1.036917 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.036355 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.035893 bound=1.036917 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.037527 ifs=0.00001 allocation=17 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.037449 bound=1.038473 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.039775 ifs=0.00001 allocation=18 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.039697 bound=1.040721 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.041996 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.041918 bound=1.042942 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.04238 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.041918 bound=1.042942 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.043276 ifs=0.00001 allocation=19 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.043198 bound=1.044222 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=ap decision=1.045461 ifs=0.00001 allocation=20 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.045383 bound=1.046407 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.047655 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.047577 bound=1.048601 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.048039 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.047577 bound=1.048601 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.049094 ifs=0.00001 allocation=21 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.049016 bound=1.05004 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +DATA node=sta1 decision=1.050164 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.050086 bound=1.05111 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.050548 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.050086 bound=1.05111 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.052065 ifs=0.00001 allocation=22 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.051987 bound=1.053011 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.052449 ifs=0.00001 allocation=23 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.051987 bound=1.053011 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.053126 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.053048 bound=1.054072 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.053646 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.053048 bound=1.054072 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.054183 ifs=0.00001 allocation=24 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.054105 bound=1.055129 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.054567 ifs=0.00001 allocation=25 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.054105 bound=1.055129 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=sta1 decision=1.055244 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.055166 bound=1.05619 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.055628 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.055166 bound=1.05619 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.05662 ifs=0.00001 allocation=26 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.056542 bound=1.057566 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.05714 ifs=0.00001 allocation=27 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.056542 bound=1.057566 count=2 agreement=1 aggregate=0 retry=0 exception=0 ackPolicy=3 +DATA node=ap decision=1.057681 ifs=0.00001 allocation=28 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.057603 bound=1.058627 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=sta1 decision=1.059821 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.059743 bound=1.060767 count=1 agreement=1 aggregate=0 retry=0 exception=1 ackPolicy=3 +DATA node=ap decision=1.060832 ifs=0.00001 allocation=29 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.060754 bound=1.061778 count=1 agreement=0 aggregate=0 retry=0 exception=0 ackPolicy=0 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=29 outsideData=1 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=21 outsideData=9 aggregates=0 delivered=30 +** Event #4904 t=1.2 Elapsed: 0.325274s (0m 00s) 92% completed (98% total) + Speed: ev/sec=15076.8 simsec/sec=3.60841 ev/simsec=4178.25 + Messages: created: 6317 present: 120 in FES: 4 Memory (RSS): 199.523MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #4904 + +Calling finish() at end of Run #3... + +Run statistics: total 4, successful 4 + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-runs.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-runs.txt new file mode 100644 index 00000000000..2fd551b984d --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-basic-runs.txt @@ -0,0 +1,736 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from ../../../../src: 1287 +Loading NED files from .: 2 +Loading NED files from ../../lib: 33 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/work/Ieee80211BasicTxopAdmission_1: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/lib: 33 + +Preparing for running configuration General, run #0... +Scenario: $scenario=0, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-0-20261019-09:38:16-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 3.8e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 199.16MiB +Basic admission state: scenario=0 delivered=30 agreed=29/28 failures=0 +Basic admission assertions passed: scenario=0 delivered=30 retainedFailures=0 collisions=0 +** Event #4190 t=1.2 Elapsed: 0.612776s (0m 00s) 92% completed (2% total) + Speed: ev/sec=6838.04 simsec/sec=1.91546 ev/simsec=3569.92 + Messages: created: 5177 present: 120 in FES: 4 Memory (RSS): 200.543MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4190 + +Calling finish() at end of Run #0... + +Preparing for running configuration General, run #1... +Scenario: $scenario=0, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-1-20261019-09:38:17-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.4e-05s (0m 00s) 0% completed (2% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.707MiB +Basic admission state: scenario=0 delivered=30 agreed=34/35 failures=0 +Basic admission assertions passed: scenario=0 delivered=30 retainedFailures=0 collisions=0 +** Event #4973 t=1.2 Elapsed: 0.48448s (0m 00s) 92% completed (5% total) + Speed: ev/sec=10265 simsec/sec=2.42267 ev/simsec=4237.04 + Messages: created: 6089 present: 120 in FES: 4 Memory (RSS): 200.707MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4973 + +Calling finish() at end of Run #1... + +Preparing for running configuration General, run #2... +Scenario: $scenario=0, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-2-20261019-09:38:18-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.8e-05s (0m 00s) 0% completed (5% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.707MiB +Basic admission state: scenario=0 delivered=30 agreed=33/23 failures=0 +Basic admission assertions passed: scenario=0 delivered=30 retainedFailures=0 collisions=0 +** Event #4941 t=1.2 Elapsed: 0.417158s (0m 00s) 92% completed (8% total) + Speed: ev/sec=11844.8 simsec/sec=2.81363 ev/simsec=4209.78 + Messages: created: 6103 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4941 + +Calling finish() at end of Run #2... + +Preparing for running configuration General, run #3... +Scenario: $scenario=0, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-09:38:18-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (8% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=0 delivered=30 agreed=29/21 failures=0 +Basic admission assertions passed: scenario=0 delivered=30 retainedFailures=0 collisions=0 +** Event #4904 t=1.2 Elapsed: 0.653808s (0m 00s) 92% completed (10% total) + Speed: ev/sec=7500.76 simsec/sec=1.79519 ev/simsec=4178.25 + Messages: created: 6335 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4904 + +Calling finish() at end of Run #3... + +Preparing for running configuration General, run #4... +Scenario: $scenario=1, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-4-20261019-09:38:19-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (11% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=1 delivered=30 agreed=44/22 failures=9 +Basic admission assertions passed: scenario=1 delivered=30 retainedFailures=9 collisions=0 +** Event #5937 t=1.2 Elapsed: 0.55043s (0m 00s) 92% completed (13% total) + Speed: ev/sec=10786.3 simsec/sec=2.13236 ev/simsec=5058.38 + Messages: created: 7412 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5937 + +Calling finish() at end of Run #4... + +Preparing for running configuration General, run #5... +Scenario: $scenario=1, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-5-20261019-09:38:20-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (13% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=1 delivered=30 agreed=29/26 failures=9 +Basic admission assertions passed: scenario=1 delivered=30 retainedFailures=9 collisions=0 +** Event #4765 t=1.2 Elapsed: 0.31628s (0m 00s) 92% completed (16% total) + Speed: ev/sec=15066.2 simsec/sec=3.71106 ev/simsec=4059.82 + Messages: created: 5848 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4765 + +Calling finish() at end of Run #5... + +Preparing for running configuration General, run #6... +Scenario: $scenario=1, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-6-20261019-09:38:21-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 7e-06s (0m 00s) 0% completed (16% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=1 delivered=30 agreed=29/32 failures=9 +Basic admission assertions passed: scenario=1 delivered=30 retainedFailures=9 collisions=0 +** Event #4794 t=1.2 Elapsed: 0.377289s (0m 00s) 92% completed (19% total) + Speed: ev/sec=12706.7 simsec/sec=3.11093 ev/simsec=4084.53 + Messages: created: 5879 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4794 + +Calling finish() at end of Run #6... + +Preparing for running configuration General, run #7... +Scenario: $scenario=1, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-7-20261019-09:38:21-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (19% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=1 delivered=30 agreed=29/15 failures=9 +Basic admission assertions passed: scenario=1 delivered=30 retainedFailures=9 collisions=0 +** Event #5788 t=1.2 Elapsed: 0.370459s (0m 00s) 92% completed (22% total) + Speed: ev/sec=15624.3 simsec/sec=3.16832 ev/simsec=4931.43 + Messages: created: 7560 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5788 + +Calling finish() at end of Run #7... + +Preparing for running configuration General, run #8... +Scenario: $scenario=2, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-8-20261019-09:38:22-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (22% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=2 delivered=30 agreed=30/28 failures=9 +Basic admission assertions passed: scenario=2 delivered=30 retainedFailures=9 collisions=0 +** Event #4899 t=1.2 Elapsed: 0.498286s (0m 00s) 92% completed (24% total) + Speed: ev/sec=9831.86 simsec/sec=2.35551 ev/simsec=4173.99 + Messages: created: 6097 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4899 + +Calling finish() at end of Run #8... + +Preparing for running configuration General, run #9... +Scenario: $scenario=2, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-9-20261019-09:38:22-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (25% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=2 delivered=30 agreed=30/26 failures=9 +Basic admission assertions passed: scenario=2 delivered=30 retainedFailures=9 collisions=0 +** Event #5184 t=1.2 Elapsed: 0.719873s (0m 00s) 92% completed (27% total) + Speed: ev/sec=7201.39 simsec/sec=1.63045 ev/simsec=4416.82 + Messages: created: 6388 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5184 + +Calling finish() at end of Run #9... + +Preparing for running configuration General, run #10... +Scenario: $scenario=2, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-10-20261019-09:38:23-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (27% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=2 delivered=30 agreed=30/22 failures=9 +Basic admission assertions passed: scenario=2 delivered=30 retainedFailures=9 collisions=0 +** Event #5349 t=1.2 Elapsed: 0.535536s (0m 00s) 92% completed (30% total) + Speed: ev/sec=9988.29 simsec/sec=2.19167 ev/simsec=4557.4 + Messages: created: 6666 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5349 + +Calling finish() at end of Run #10... + +Preparing for running configuration General, run #11... +Scenario: $scenario=2, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-11-20261019-09:38:24-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (30% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=2 delivered=30 agreed=30/19 failures=10 +Basic admission assertions passed: scenario=2 delivered=30 retainedFailures=10 collisions=0 +** Event #5681 t=1.2 Elapsed: 0.367469s (0m 00s) 92% completed (33% total) + Speed: ev/sec=15460.2 simsec/sec=3.19408 ev/simsec=4840.26 + Messages: created: 7258 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5681 + +Calling finish() at end of Run #11... + +Preparing for running configuration General, run #12... +Scenario: $scenario=3, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-12-20261019-09:38:25-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (33% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=3 delivered=30 agreed=29/29 failures=0 +Basic admission assertions passed: scenario=3 delivered=30 retainedFailures=0 collisions=1 +** Event #4427 t=1.2 Elapsed: 0.32344s (0m 00s) 92% completed (35% total) + Speed: ev/sec=13687.6 simsec/sec=3.62889 ev/simsec=3771.84 + Messages: created: 5493 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4427 + +Calling finish() at end of Run #12... + +Preparing for running configuration General, run #13... +Scenario: $scenario=3, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-13-20261019-09:38:25-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (36% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=3 delivered=30 agreed=29/25 failures=0 +Basic admission assertions passed: scenario=3 delivered=30 retainedFailures=0 collisions=1 +** Event #5028 t=1.2 Elapsed: 0.311351s (0m 00s) 92% completed (38% total) + Speed: ev/sec=16149.4 simsec/sec=3.76979 ev/simsec=4283.9 + Messages: created: 6184 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5028 + +Calling finish() at end of Run #13... + +Preparing for running configuration General, run #14... +Scenario: $scenario=3, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-14-20261019-09:38:26-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (38% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=3 delivered=30 agreed=29/22 failures=0 +Basic admission assertions passed: scenario=3 delivered=30 retainedFailures=0 collisions=1 +** Event #4996 t=1.2 Elapsed: 0.46724s (0m 00s) 92% completed (41% total) + Speed: ev/sec=10692.8 simsec/sec=2.51202 ev/simsec=4256.64 + Messages: created: 6235 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4996 + +Calling finish() at end of Run #14... + +Preparing for running configuration General, run #15... +Scenario: $scenario=3, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-15-20261019-09:38:26-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (41% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=3 delivered=30 agreed=29/16 failures=0 +Basic admission assertions passed: scenario=3 delivered=30 retainedFailures=0 collisions=1 +** Event #5547 t=1.2 Elapsed: 0.433772s (0m 00s) 92% completed (44% total) + Speed: ev/sec=12788.1 simsec/sec=2.70586 ev/simsec=4726.09 + Messages: created: 7217 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5547 + +Calling finish() at end of Run #15... + +Preparing for running configuration General, run #16... +Scenario: $scenario=4, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-16-20261019-09:38:27-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (44% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=4 delivered=1 agreed=0/0 failures=30 +Basic admission assertions passed: scenario=4 delivered=1 retainedFailures=30 collisions=0 +** Event #2018 t=1.2 Elapsed: 0.14234s (0m 00s) 92% completed (47% total) + Speed: ev/sec=14178.2 simsec/sec=8.24625 ev/simsec=1719.35 + Messages: created: 2397 present: 121 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #2018 + +Calling finish() at end of Run #16... + +Preparing for running configuration General, run #17... +Scenario: $scenario=4, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-17-20261019-09:38:27-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (47% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=4 delivered=1 agreed=0/0 failures=28 +Basic admission assertions passed: scenario=4 delivered=1 retainedFailures=28 collisions=0 +** Event #2029 t=1.2 Elapsed: 0.129226s (0m 00s) 92% completed (49% total) + Speed: ev/sec=15702.3 simsec/sec=9.08314 ev/simsec=1728.73 + Messages: created: 2314 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #2029 + +Calling finish() at end of Run #17... + +Preparing for running configuration General, run #18... +Scenario: $scenario=4, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-18-20261019-09:38:28-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.5e-05s (0m 00s) 0% completed (50% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=4 delivered=1 agreed=0/0 failures=30 +Basic admission assertions passed: scenario=4 delivered=1 retainedFailures=30 collisions=0 +** Event #1936 t=1.2 Elapsed: 0.110597s (0m 00s) 92% completed (52% total) + Speed: ev/sec=17506.9 simsec/sec=10.6135 ev/simsec=1649.49 + Messages: created: 2274 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #1936 + +Calling finish() at end of Run #18... + +Preparing for running configuration General, run #19... +Scenario: $scenario=4, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-19-20261019-09:38:28-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (52% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=4 delivered=1 agreed=0/0 failures=29 +Basic admission assertions passed: scenario=4 delivered=1 retainedFailures=29 collisions=0 +** Event #1959 t=1.2 Elapsed: 0.134818s (0m 00s) 92% completed (55% total) + Speed: ev/sec=14531.7 simsec/sec=8.70636 ev/simsec=1669.09 + Messages: created: 2278 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #1959 + +Calling finish() at end of Run #19... + +Preparing for running configuration General, run #20... +Scenario: $scenario=5, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-20-20261019-09:38:29-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (55% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=5 delivered=30 agreed=95/77 failures=0 +Basic admission assertions passed: scenario=5 delivered=30 retainedFailures=0 collisions=0 +** Event #5839 t=1.2 Elapsed: 0.513441s (0m 00s) 92% completed (58% total) + Speed: ev/sec=11372.5 simsec/sec=2.28599 ev/simsec=4974.88 + Messages: created: 7165 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5839 + +Calling finish() at end of Run #20... + +Preparing for running configuration General, run #21... +Scenario: $scenario=5, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-21-20261019-09:38:29-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 0.000138s (0m 00s) 0% completed (58% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=5 delivered=30 agreed=99/68 failures=0 +Basic admission assertions passed: scenario=5 delivered=30 retainedFailures=0 collisions=0 +** Event #6034 t=1.2 Elapsed: 0.660558s (0m 00s) 92% completed (60% total) + Speed: ev/sec=9136.58 simsec/sec=1.77719 ev/simsec=5141.02 + Messages: created: 7354 present: 120 in FES: 4 Memory (RSS): 200.832MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #6034 + +Calling finish() at end of Run #21... + +Preparing for running configuration General, run #22... +Scenario: $scenario=5, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-22-20261019-09:38:30-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (61% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.832MiB +Basic admission state: scenario=5 delivered=30 agreed=101/72 failures=0 +Basic admission assertions passed: scenario=5 delivered=30 retainedFailures=0 collisions=0 +** Event #5950 t=1.2 Elapsed: 0.552853s (0m 00s) 92% completed (63% total) + Speed: ev/sec=10762.6 simsec/sec=2.12302 ev/simsec=5069.45 + Messages: created: 7258 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5950 + +Calling finish() at end of Run #22... + +Preparing for running configuration General, run #23... +Scenario: $scenario=5, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-23-20261019-09:38:31-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (63% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=5 delivered=30 agreed=107/68 failures=0 +Basic admission assertions passed: scenario=5 delivered=30 retainedFailures=0 collisions=0 +** Event #5942 t=1.2 Elapsed: 0.499037s (0m 00s) 92% completed (66% total) + Speed: ev/sec=11907.1 simsec/sec=2.35196 ev/simsec=5062.64 + Messages: created: 7264 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5942 + +Calling finish() at end of Run #23... + +Preparing for running configuration General, run #24... +Scenario: $scenario=6, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-24-20261019-09:38:32-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (66% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=6 delivered=30 agreed=0/0 failures=0 +Basic admission assertions passed: scenario=6 delivered=30 retainedFailures=0 collisions=0 +** Event #5855 t=1.2 Elapsed: 0.421748s (0m 00s) 92% completed (69% total) + Speed: ev/sec=13883 simsec/sec=2.78299 ev/simsec=4988.51 + Messages: created: 9464 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5855 + +Calling finish() at end of Run #24... + +Preparing for running configuration General, run #25... +Scenario: $scenario=6, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-25-20261019-09:38:32-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 0.000177s (0m 00s) 0% completed (69% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=6 delivered=30 agreed=0/0 failures=0 +Basic admission assertions passed: scenario=6 delivered=30 retainedFailures=0 collisions=0 +** Event #6705 t=1.2 Elapsed: 0.473519s (0m 00s) 92% completed (72% total) + Speed: ev/sec=14165.1 simsec/sec=2.47957 ev/simsec=5712.72 + Messages: created: 10124 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #6705 + +Calling finish() at end of Run #25... + +Preparing for running configuration General, run #26... +Scenario: $scenario=6, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-26-20261019-09:38:33-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (72% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=6 delivered=30 agreed=0/0 failures=0 +Basic admission assertions passed: scenario=6 delivered=30 retainedFailures=0 collisions=0 +** Event #4276 t=1.2 Elapsed: 0.262441s (0m 00s) 92% completed (74% total) + Speed: ev/sec=16293.8 simsec/sec=4.4724 ev/simsec=3643.19 + Messages: created: 7125 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4276 + +Calling finish() at end of Run #26... + +Preparing for running configuration General, run #27... +Scenario: $scenario=6, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-27-20261019-09:38:34-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (75% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=6 delivered=30 agreed=0/0 failures=0 +Basic admission assertions passed: scenario=6 delivered=30 retainedFailures=0 collisions=0 +** Event #4301 t=1.2 Elapsed: 0.269428s (0m 00s) 92% completed (77% total) + Speed: ev/sec=15964 simsec/sec=4.35641 ev/simsec=3664.49 + Messages: created: 6964 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4301 + +Calling finish() at end of Run #27... + +Preparing for running configuration General, run #28... +Scenario: $scenario=7, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-28-20261019-09:38:35-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (77% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=7 delivered=30 agreed=34/28 failures=0 +Basic admission assertions passed: scenario=7 delivered=30 retainedFailures=0 collisions=0 +** Event #4319 t=1.2 Elapsed: 0.285922s (0m 00s) 92% completed (80% total) + Speed: ev/sec=15105.9 simsec/sec=4.10531 ev/simsec=3679.61 + Messages: created: 5362 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4319 + +Calling finish() at end of Run #28... + +Preparing for running configuration General, run #29... +Scenario: $scenario=7, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-29-20261019-09:38:35-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (80% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=7 delivered=30 agreed=39/27 failures=0 +Basic admission assertions passed: scenario=7 delivered=30 retainedFailures=0 collisions=0 +** Event #4730 t=1.2 Elapsed: 0.314081s (0m 00s) 92% completed (83% total) + Speed: ev/sec=15060.2 simsec/sec=3.73723 ev/simsec=4029.77 + Messages: created: 5802 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4730 + +Calling finish() at end of Run #29... + +Preparing for running configuration General, run #30... +Scenario: $scenario=7, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-30-20261019-09:38:35-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (83% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=7 delivered=30 agreed=29/29 failures=0 +Basic admission assertions passed: scenario=7 delivered=30 retainedFailures=0 collisions=0 +** Event #4030 t=1.2 Elapsed: 0.280467s (0m 00s) 92% completed (85% total) + Speed: ev/sec=14369.4 simsec/sec=4.18518 ev/simsec=3433.4 + Messages: created: 4863 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #4030 + +Calling finish() at end of Run #30... + +Preparing for running configuration General, run #31... +Scenario: $scenario=7, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-31-20261019-09:38:36-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (86% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=7 delivered=30 agreed=29/29 failures=0 +Basic admission assertions passed: scenario=7 delivered=30 retainedFailures=0 collisions=0 +** Event #3961 t=1.2 Elapsed: 0.276716s (0m 00s) 92% completed (88% total) + Speed: ev/sec=14314.9 simsec/sec=4.24193 ev/simsec=3374.61 + Messages: created: 4903 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #3961 + +Calling finish() at end of Run #31... + +Preparing for running configuration General, run #32... +Scenario: $scenario=8, $rate=6, $protection="single", $repetition=0 +Assigned runID=General-32-20261019-09:38:36-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (88% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=8 delivered=30 agreed=38/27 failures=0 +Basic admission assertions passed: scenario=8 delivered=30 retainedFailures=0 collisions=0 +** Event #5170 t=1.2 Elapsed: 0.279616s (0m 00s) 92% completed (91% total) + Speed: ev/sec=18490.2 simsec/sec=4.19766 ev/simsec=4404.89 + Messages: created: 6431 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5170 + +Calling finish() at end of Run #32... + +Preparing for running configuration General, run #33... +Scenario: $scenario=8, $rate=6, $protection="multiple", $repetition=0 +Assigned runID=General-33-20261019-09:38:37-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (91% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=8 delivered=30 agreed=38/26 failures=0 +Basic admission assertions passed: scenario=8 delivered=30 retainedFailures=0 collisions=0 +** Event #5442 t=1.2 Elapsed: 0.294129s (0m 00s) 92% completed (94% total) + Speed: ev/sec=18502.7 simsec/sec=3.99054 ev/simsec=4636.63 + Messages: created: 6702 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5442 + +Calling finish() at end of Run #33... + +Preparing for running configuration General, run #34... +Scenario: $scenario=8, $rate=24, $protection="single", $repetition=0 +Assigned runID=General-34-20261019-09:38:37-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (94% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=8 delivered=30 agreed=38/20 failures=0 +Basic admission assertions passed: scenario=8 delivered=30 retainedFailures=0 collisions=0 +** Event #5638 t=1.2 Elapsed: 0.300194s (0m 00s) 92% completed (97% total) + Speed: ev/sec=18781.7 simsec/sec=3.9099 ev/simsec=4803.63 + Messages: created: 7036 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5638 + +Calling finish() at end of Run #34... + +Preparing for running configuration General, run #35... +Scenario: $scenario=8, $rate=24, $protection="multiple", $repetition=0 +Assigned runID=General-35-20261019-09:38:38-881 +Setting up network "BasicAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.9e-05s (0m 00s) 0% completed (97% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.957MiB +Basic admission state: scenario=8 delivered=30 agreed=38/17 failures=0 +Basic admission assertions passed: scenario=8 delivered=30 retainedFailures=0 collisions=0 +** Event #5985 t=1.2 Elapsed: 0.36504s (0m 00s) 92% completed (99% total) + Speed: ev/sec=16396.1 simsec/sec=3.21539 ev/simsec=5099.27 + Messages: created: 7703 present: 120 in FES: 4 Memory (RSS): 200.957MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::BasicAdmissionTest) BasicAdmissionNetwork.test (id=7), at t=1.2s, event #5985 + +Calling finish() at end of Run #35... + +Run statistics: total 36, successful 36 + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-build.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-build.txt new file mode 100644 index 00000000000..434a05038ab --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-build.txt @@ -0,0 +1,12 @@ +*** CREATING Makefile with: +opp_makemake --make-so -f --deep -o INET -O out -pINET -I. -Xinet/applications/voipstream -Xinet/emulation -Xinet/linklayer/configurator/gatescheduling/z3 -Xinet/transportlayer/tcp_lwip -Xinet/visualizer/osg +make[1]: Entering directory '/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src' +*** CCACHE detected - precompiled headers disabled +*** COMPILING with: +ccache clang++ -c -std=c++17 -O0 -Wall -glldb -fstandalone-debug -MMD -MP -MF .d -fPIC -I/usr/include/python3.14 -I/usr/include/python3.14 -Wno-deprecated-register -Wno-unused-function -fno-omit-frame-pointer -DBACKWARD_HAS_DW=1 -Wno-overloaded-virtual -DOMNETPPLIBS_IMPORT -DINET_EXPORT -I. -I/home/user/omnetpp-6.4.0aipre2/include +*** LINKING with: +clang++ -shared -fPIC -o ../out/clang-debug/src/libINET_dbg.so -Wl,--no-as-needed -Wl,--whole-archive -Wl,--no-whole-archive -loppenvir_dbg -loppsim_dbg -lstdc++ -lpython3.14 -ldl -lm -ldw -lelf -fuse-ld=lld -Wl,-rpath,/home/user/omnetpp-6.4.0aipre2/lib -Wl,-rpath,. -Wl,-rpath,/home/user/omnetpp-6.4.0aipre2/tools/linux.x86_64/lib -Wl,--export-dynamic -L/home/user/omnetpp-6.4.0aipre2/lib +Building... +inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc +Creating shared library: ../out/clang-debug/src/libINET_dbg.so +make[1]: Leaving directory '/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src' diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-base.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-base.txt new file mode 100644 index 00000000000..9c3bf3c0f9c --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-base.txt @@ -0,0 +1,63 @@ +E # 88 t 0.00043623452 m 63 ce 86 msg 140 +CMB sm 63 tm 3 m transmitPacket +CM id 142 tid 142 eid 142 etid 142 c omnetpp::cMessage n "" pe -1 +- [DEBUG] Sending (inet::physicallayer::WirelessSignal)UdpBasicAppData-2+UdpBasicAppData-3 (78 us 354 B) (inet::Packet)UdpBasicAppData-2+UdpBasicAppData-3 (354 B) (inet::SequenceChunk) length = 354 B with 2832 bits in 78 us transmission duration from (inet::physicallayer::Ieee80211Radio)radio id=63, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } on (inet::physicallayer::RadioMedium)radioMedium id=3, propagation = { ConstantSpeedPropagation }, pathLoss = { FreeSpacePathLoss }, analogModel = { ScalarMediumAnalogModel, ignorePartialInterference = 0 }, obstacleLoss = , backgroundNoise = { IsotropicScalarBackgroundNoise, power = 0.01 pW, bandwidth = 22 MHz }, mediumLimitCache = { RadioMediumLimits }, neighborCache = , communicationCache = { VectorCommunicationCache }. +CMB sm 3 tm 63 m sendToRadio +- [DEBUG] Sending (inet::physicallayer::WirelessSignal)UdpBasicAppData-2+UdpBasicAppData-3 (78 us 354 B) (inet::Packet)UdpBasicAppData-2+UdpBasicAppData-3 (354 B) (inet::SequenceChunk) length = 354 B from (inet::physicallayer::Ieee80211Radio)radio id=63, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } at (288, 110, 0) m to (inet::physicallayer::Ieee80211Radio)radio id=177, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } at (480, 258, 0) m in 0.80863 us propagation time. +CM id 143 tid 143 eid 143 etid 143 c omnetpp::cMessage n "" pe -1 +CL id 144 tid 136 eid 144 etid 136 c omnetpp::cMessage n UdpBasicAppData-2+UdpBasicAppData-3 m 63 pe -1 cid 140 +BS id 143 tid 143 eid 144 etid 136 c inet::physicallayer::WirelessSignal n UdpBasicAppData-2+UdpBasicAppData-3 l 2832 m 63 pe 88 +SD sm 63 dm 6 dg 1048576 pd 0.00000080863 td 0.000078 rd 0.000078 +SH sm 6 sg 1048576 +SH sm 160 sg 4 +ES id 143 tid 143 eid 144 etid 136 c inet::physicallayer::WirelessSignal n UdpBasicAppData-2+UdpBasicAppData-3 l 2832 sm 63 st 0.00043623452 am 177 ag 4 at 0.00043704315 pe 88 i 1 +CME +CME +BS id 31 tid 31 eid 31 etid 31 c omnetpp::cMessage n transmissionTimer sm 63 st 0.00043623452 am 63 at 0.00051423452 pe 88 +ES id 31 tid 31 eid 31 etid 31 c omnetpp::cMessage n transmissionTimer sm 63 st 0.00043623452 am 63 at 0.00051423452 pe 88 +- [INFO] Transmission started: (inet::physicallayer::WirelessSignal)UdpBasicAppData-2+UdpBasicAppData-3 (78 us 354 B) (inet::Packet)UdpBasicAppData-2+UdpBasicAppData-3 (354 B) (inet::SequenceChunk) length = 354 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 0, startTime = 0.00043623452, endTime = 0.00051423452, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000058, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0) +- [INFO] Changing radio transmission state from IDLE to TRANSMITTING. +CMB sm 63 tm 62 m transmissionStateChanged +CMB sm 62 tm 71 m transmissionStateChanged +CME +CME +- [INFO] Changing radio transmitted signal part from NONE to WHOLE. + +E # 89 t 0.00043704315 m 177 ce 88 msg 143 +CM id 145 tid 145 eid 145 etid 145 c omnetpp::cMessage n receptionTimer pe -1 +- [DEBUG] Receiving Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 0, startTime = 0.00043623452, endTime = 0.00051423452, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000058, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0) from medium by (inet::physicallayer::Ieee80211Radio)radio id=177, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } arrives as Reception, transmissionId = 4, receiverdRadioId = 1, startTime = 0.00043704315, endTime = 0.00051504315, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000058, startPosition = (480, 258, 0) m, endPosition = (480, 258, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0), analogModel = { ScalarSignalAnalogModel, power = 33.2932 pW, centerFrequency = 2.412 GHz } +- [DEBUG] Computing whether reception is possible, minReceptionPower = 33.2932 pW, sensitivity = 3.16228 pW -> reception is possible +- [INFO] Reception started: attempting (inet::physicallayer::WirelessSignal)UdpBasicAppData-2+UdpBasicAppData-3 (78 us 354 B) (inet::Packet)UdpBasicAppData-2+UdpBasicAppData-3 (354 B) (inet::SequenceChunk) length = 354 B WHOLE as Reception, transmissionId = 4, receiverdRadioId = 1, startTime = 0.00043704315, endTime = 0.00051504315, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000058, startPosition = (480, 258, 0) m, endPosition = (480, 258, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0), analogModel = { ScalarSignalAnalogModel, power = 33.2932 pW, centerFrequency = 2.412 GHz } +BS id 145 tid 145 eid 145 etid 145 c omnetpp::cMessage n receptionTimer sm 177 st 0.00043704315 am 177 at 0.00051504315 pe 89 +ES id 145 tid 145 eid 145 etid 145 c omnetpp::cMessage n receptionTimer sm 177 st 0.00043704315 am 177 at 0.00051504315 pe 89 +- [INFO] Changing radio reception state from IDLE to RECEIVING. +CMB sm 177 tm 176 m receptionStateChanged +CMB sm 176 tm 185 m receptionStateChanged +CMB sm 185 tm 200 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 219 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 226 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 233 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 240 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CME +CME +- [INFO] Changing radio received signal part from NONE to WHOLE. +CMB sm 177 tm 176 m receivedSignalPartChanged +CMB sm 176 tm 185 m receivedSignalPartChanged +CME +CME + diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-head.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-head.txt new file mode 100644 index 00000000000..bd6c10880e8 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Aggregation-head.txt @@ -0,0 +1,63 @@ +E # 88 t 0.00043623452 m 63 ce 86 msg 149 +CMB sm 63 tm 3 m transmitPacket +CM id 151 tid 151 eid 151 etid 151 c omnetpp::cMessage n "" pe -1 +- [DEBUG] Sending (inet::physicallayer::WirelessSignal)UdpBasicAppData-2 (54 us 192 B) (inet::Packet)UdpBasicAppData-2 (192 B) (inet::SequenceChunk) length = 192 B with 1536 bits in 54 us transmission duration from (inet::physicallayer::Ieee80211Radio)radio id=63, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } on (inet::physicallayer::RadioMedium)radioMedium id=3, propagation = { ConstantSpeedPropagation }, pathLoss = { FreeSpacePathLoss }, analogModel = { ScalarMediumAnalogModel, ignorePartialInterference = 0 }, obstacleLoss = , backgroundNoise = { IsotropicScalarBackgroundNoise, power = 0.01 pW, bandwidth = 22 MHz }, mediumLimitCache = { RadioMediumLimits }, neighborCache = , communicationCache = { VectorCommunicationCache }. +CMB sm 3 tm 63 m sendToRadio +- [DEBUG] Sending (inet::physicallayer::WirelessSignal)UdpBasicAppData-2 (54 us 192 B) (inet::Packet)UdpBasicAppData-2 (192 B) (inet::SequenceChunk) length = 192 B from (inet::physicallayer::Ieee80211Radio)radio id=63, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } at (288, 110, 0) m to (inet::physicallayer::Ieee80211Radio)radio id=177, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } at (480, 258, 0) m in 0.80863 us propagation time. +CM id 152 tid 152 eid 152 etid 152 c omnetpp::cMessage n "" pe -1 +CL id 153 tid 117 eid 153 etid 117 c omnetpp::cMessage n UdpBasicAppData-2 m 63 pe -1 cid 149 +BS id 152 tid 152 eid 153 etid 117 c inet::physicallayer::WirelessSignal n UdpBasicAppData-2 l 1536 m 63 pe 88 +SD sm 63 dm 6 dg 1048576 pd 0.00000080863 td 0.000054 rd 0.000054 +SH sm 6 sg 1048576 +SH sm 160 sg 4 +ES id 152 tid 152 eid 153 etid 117 c inet::physicallayer::WirelessSignal n UdpBasicAppData-2 l 1536 sm 63 st 0.00043623452 am 177 ag 4 at 0.00043704315 pe 88 i 1 +CME +CME +BS id 31 tid 31 eid 31 etid 31 c omnetpp::cMessage n transmissionTimer sm 63 st 0.00043623452 am 63 at 0.00049023452 pe 88 +ES id 31 tid 31 eid 31 etid 31 c omnetpp::cMessage n transmissionTimer sm 63 st 0.00043623452 am 63 at 0.00049023452 pe 88 +- [INFO] Transmission started: (inet::physicallayer::WirelessSignal)UdpBasicAppData-2 (54 us 192 B) (inet::Packet)UdpBasicAppData-2 (192 B) (inet::SequenceChunk) length = 192 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 0, startTime = 0.00043623452, endTime = 0.00049023452, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000034, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0) +- [INFO] Changing radio transmission state from IDLE to TRANSMITTING. +CMB sm 63 tm 62 m transmissionStateChanged +CMB sm 62 tm 71 m transmissionStateChanged +CME +CME +- [INFO] Changing radio transmitted signal part from NONE to WHOLE. + +E # 89 t 0.00043704315 m 177 ce 88 msg 152 +CM id 154 tid 154 eid 154 etid 154 c omnetpp::cMessage n receptionTimer pe -1 +- [DEBUG] Receiving Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 0, startTime = 0.00043623452, endTime = 0.00049023452, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000034, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0) from medium by (inet::physicallayer::Ieee80211Radio)radio id=177, antenna = { IsotropicAntenna }, transmitter = { Ieee80211Transmitter, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 } }, receiver = { Ieee80211Receiver, channel = { Ieee80211Channel, channelNumber = 0 }, energyDetection = 3.16228 pW, sensitivity = 3.16228 pW, considering interference } arrives as Reception, transmissionId = 4, receiverdRadioId = 1, startTime = 0.00043704315, endTime = 0.00049104315, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000034, startPosition = (480, 258, 0) m, endPosition = (480, 258, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0), analogModel = { ScalarSignalAnalogModel, power = 33.2932 pW, centerFrequency = 2.412 GHz } +- [DEBUG] Computing whether reception is possible, minReceptionPower = 33.2932 pW, sensitivity = 3.16228 pW -> reception is possible +- [INFO] Reception started: attempting (inet::physicallayer::WirelessSignal)UdpBasicAppData-2 (54 us 192 B) (inet::Packet)UdpBasicAppData-2 (192 B) (inet::SequenceChunk) length = 192 B WHOLE as Reception, transmissionId = 4, receiverdRadioId = 1, startTime = 0.00043704315, endTime = 0.00049104315, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000034, startPosition = (480, 258, 0) m, endPosition = (480, 258, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0), analogModel = { ScalarSignalAnalogModel, power = 33.2932 pW, centerFrequency = 2.412 GHz } +BS id 154 tid 154 eid 154 etid 154 c omnetpp::cMessage n receptionTimer sm 177 st 0.00043704315 am 177 at 0.00049104315 pe 89 +ES id 154 tid 154 eid 154 etid 154 c omnetpp::cMessage n receptionTimer sm 177 st 0.00043704315 am 177 at 0.00049104315 pe 89 +- [INFO] Changing radio reception state from IDLE to RECEIVING. +CMB sm 177 tm 176 m receptionStateChanged +CMB sm 176 tm 185 m receptionStateChanged +CMB sm 185 tm 200 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 219 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 226 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 233 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 185 tm 240 m "medium BUSY" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CME +CME +- [INFO] Changing radio received signal part from NONE to WHOLE. +CMB sm 177 tm 176 m receivedSignalPartChanged +CMB sm 176 tm 185 m receivedSignalPartChanged +CME +CME + diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-base.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-base.txt new file mode 100644 index 00000000000..3f59f405ce4 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-base.txt @@ -0,0 +1,78 @@ +E # 39 t 0.00031761726 m 62 ce 38 msg 129 +CMB sm 62 tm 71 m "lowerFrameReceived(\"WlanAck\")" +- [INFO] Received frame from PHY: (inet::Packet)WlanAck (14 B) (inet::SequenceChunk) length = 27 B +CME +CMB sm 62 tm 69 m processLowerFrame(WlanAck) +- [INFO] Processing lower frame: WlanAck +- [INFO] Finishing last frame sequence step: history = ({(DATA ACK)}) +- [INFO] Processing received frame WlanAck as originator in frame sequence. +CMB sm 69 tm 71 m successfulFrameTransmitted +CME +CMB sm 69 tm 101 m resetCw +- [DEBUG] Contention window is reset: cw = 31 +CME +- [DEBUG] Dropping frame Data-0-frag0. +- [INFO] Starting next frame sequence step: history = ({(DATA ACK)}) +- [INFO] Frame sequence finished. +CE id 13 tid 13 eid 13 etid 13 c omnetpp::cMessage n startRxTimeout m 69 pe 22 +CMB sm 69 tm 101 m releaseChannel +- [INFO] Channel released. +CME +CMB sm 69 tm 116 m endTxop +- [INFO] Txop ended. +CME +CMB sm 69 tm 71 m setContentionBlocked +CMB sm 71 tm 86 m "medium FREE" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 71 tm 107 m "medium FREE" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 71 tm 114 m "medium FREE" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 71 tm 121 m "medium FREE" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CMB sm 71 tm 128 m "medium FREE" +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: condition "event==MEDIUM_STATE_CHANGED" holds, ignoring in current state +CME +CME +CMB sm 69 tm 101 m requestChannel +CMB sm 101 tm 114 m startContention +- [DETAIL] Starting contention: cw = 31, slots = 4, slotTime = 0.00002, ifs = 0.00007, eifs = 0.000384 +- [DEBUG] FSM Backoff procedure: processing event in state IDLE +- [DEBUG] FSM Backoff procedure: leaving state IDLE +- [DEBUG] FSM Backoff procedure: condition "(event == START && mediumFree)" holds, taking transition "Starting-IFS-and-Backoff" to state IFS_AND_BACKOFF +- [INFO] Scheduling contention end: backoffslots = 4, slotTime = 0.00002, lastBusyTime = 0.00031761726, lastIdle = 0.00021, waitInterval = 0.00015. +BS id 19 tid 19 eid 19 etid 19 c omnetpp::cMessage n startTx p 1000 sm 114 st 0.00031761726 am 114 at 0.00046761726 pe 39 +ES id 19 tid 19 eid 19 etid 19 c omnetpp::cMessage n startTx p 1000 sm 114 st 0.00031761726 am 114 at 0.00046761726 pe 39 +- [INFO] The expected channel access of the Best effort queue is: 0.00046761726 +- [DEBUG] FSM Backoff procedure: done processing associated actions +- [DEBUG] FSM Backoff procedure: entering state IFS_AND_BACKOFF +CME +CME +DM id 129 tid 118 eid 129 etid 118 c omnetpp::cMessage n WlanAck m 69 pe 39 +CMB sm 69 tm 113 m clearDroppedFrames +DM id 92 tid 92 eid 92 etid 92 c omnetpp::cMessage n Data-0-frag0 m 113 pe 18 +CME +CME + +E # 40 t 0.0004 m 53 ce 30 msg 42 +CM id 130 tid 130 eid 130 etid 130 c omnetpp::cMessage n Data-3 pe -1 +- [DEBUG] Sending to UDP protocol, msg = (Packet)Data-3 (1080 B) ApplicationPacket, sequenceNumber = 3. +BS id 130 tid 130 eid 130 etid 130 c inet::Packet n Data-3 l 8640 m 53 pe 40 +SH sm 53 sg 3 +CMB sm 53 tm 54 m arrived +- [INFO] Dispatching packet to service, protocol = udp(69), servicePrimitive = 1, inGate = (omnetpp::cGate)in[0] <-- app[0].socketOut, outGate = (omnetpp::cGate)out[1] --> udp.appIn, packet = (Packet)Data-3 (1080 B) ApplicationPacket, sequenceNumber = 3. +SH sm 54 sg 2621441 +CME +ES id 130 tid 130 eid 130 etid 130 c inet::Packet n Data-3 l 8640 sm 53 sg 3 st 0.0004 am 50 ag 0 at 0.0004 pe 40 +BS id 42 tid 42 eid 42 etid 42 c inet::ClockEvent n sendTimer k 2 sm 53 st 0.0004 am 53 at 0.0005 pe 40 +ES id 42 tid 42 eid 42 etid 42 c inet::ClockEvent n sendTimer k 2 sm 53 st 0.0004 am 53 at 0.0005 pe 40 + diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-head.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-head.txt new file mode 100644 index 00000000000..6a429e9dcd7 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-Fragmentation-head.txt @@ -0,0 +1,46 @@ +E # 39 t 0.00031761726 m 62 ce 38 msg 132 +CMB sm 62 tm 71 m "lowerFrameReceived(\"WlanAck\")" +- [INFO] Received frame from PHY: (inet::Packet)WlanAck (14 B) (inet::SequenceChunk) length = 27 B +CME +CMB sm 62 tm 69 m processLowerFrame(WlanAck) +- [INFO] Processing lower frame: WlanAck +- [INFO] Finishing last frame sequence step: history = ({(DATA ACK)}) +- [INFO] Processing received frame WlanAck as originator in frame sequence. +CMB sm 69 tm 71 m successfulFrameTransmitted +BS id 26 tid 26 eid 26 etid 26 c omnetpp::cMessage n endTxnavTimer sm 71 st 0.00031761726 am 71 at 0.000432 pe 39 +ES id 26 tid 26 eid 26 etid 26 c omnetpp::cMessage n endTxnavTimer sm 71 st 0.00031761726 am 71 at 0.000432 pe 39 +CME +CMB sm 69 tm 117 m msduAckReceived +CMB sm 117 tm 101 m resetCw +- [DEBUG] Contention window is reset: cw = 31 +CME +CME +- [DEBUG] Dropping frame Data-0-frag0. +- [INFO] Starting next frame sequence step: history = ({(DATA ACK) ()}) +- [INFO] Transmitting, frame = (inet::Packet)Data-0-frag1 (100 B) (inet::SequenceChunk) length = 100 B. +- [DEBUG] Datarate for Data-0-frag1 is set to 24 Mbps. +CMB sm 69 tm 72 m "transmitFrame(\"Data-0-frag1\")" +CL id 133 tid 96 eid 133 etid 96 c omnetpp::cMessage n Data-0-frag1 m 72 pe -1 cid 96 +BS id 27 tid 27 eid 27 etid 27 c omnetpp::cMessage n endIFS sm 72 st 0.00031761726 am 72 at 0.00032761726 pe 39 +ES id 27 tid 27 eid 27 etid 27 c omnetpp::cMessage n endIFS sm 72 st 0.00031761726 am 72 at 0.00032761726 pe 39 +CME +CMB sm 69 tm 117 m registerMsdu +CME +CE id 13 tid 13 eid 13 etid 13 c omnetpp::cMessage n startRxTimeout m 69 pe 22 +CME + +E # 40 t 0.00032761726 m 72 ce 39 msg 27 +- [DETAIL] Tx: endIfsTimer expired +CMB sm 72 tm 69 m frameTransmissionStarted +CME +CL id 134 tid 96 eid 134 etid 96 c omnetpp::cMessage n Data-0-frag1 m 72 pe -1 cid 133 +CMB sm 72 tm 62 m "sendDownFrame(\"Data-0-frag1\")" +CM id 135 tid 135 eid 135 etid 135 c omnetpp::cMessage n configureRadioMode k 1 pe -1 +BS id 135 tid 135 eid 135 etid 135 c inet::Request n configureRadioMode k 1 m 62 pe 40 +SH sm 62 sg 7 +ES id 135 tid 135 eid 135 etid 135 c inet::Request n configureRadioMode k 1 sm 62 sg 7 st 0.00032761726 am 63 ag 0 at 0.00032761726 pe 40 +BS id 134 tid 96 eid 134 etid 96 c inet::Packet n Data-0-frag1 l 800 m 62 pe 40 +SH sm 62 sg 7 +ES id 134 tid 96 eid 134 etid 96 c inet::Packet n Data-0-frag1 l 800 sm 62 sg 7 st 0.00032761726 am 63 ag 0 at 0.00032761726 pe 40 +CME + diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-commands.json b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-commands.json new file mode 100644 index 00000000000..1a735211d8a --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-causal-commands.json @@ -0,0 +1,164 @@ +[ + { + "config": "NoAggregation", + "variant": "base", + "status": 0, + "log": "/tmp/txop-causal-NoAggregation-base.log", + "eventlog": "/tmp/txop-causal-NoAggregation-base.elog", + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-c", + "NoAggregation", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/txop-causal-NoAggregation-base.elog", + "--result-dir=/tmp/txop-causal-NoAggregation-base-results" + ] + }, + { + "config": "NoAggregation", + "variant": "head", + "status": 0, + "log": "/tmp/txop-causal-NoAggregation-head.log", + "eventlog": "/tmp/txop-causal-NoAggregation-head.elog", + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/../src/../src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-c", + "NoAggregation", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/txop-causal-NoAggregation-head.elog", + "--result-dir=/tmp/txop-causal-NoAggregation-head-results" + ] + }, + { + "config": "Aggregation", + "variant": "base", + "status": 0, + "log": "/tmp/txop-causal-Aggregation-base.log", + "eventlog": "/tmp/txop-causal-Aggregation-base.elog", + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-c", + "Aggregation", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/txop-causal-Aggregation-base.elog", + "--result-dir=/tmp/txop-causal-Aggregation-base-results" + ] + }, + { + "config": "Aggregation", + "variant": "head", + "status": 0, + "log": "/tmp/txop-causal-Aggregation-head.log", + "eventlog": "/tmp/txop-causal-Aggregation-head.elog", + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/../src/../src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-c", + "Aggregation", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/txop-causal-Aggregation-head.elog", + "--result-dir=/tmp/txop-causal-Aggregation-head-results" + ] + }, + { + "config": "Fragmentation", + "variant": "base", + "status": 0, + "log": "/tmp/txop-causal-Fragmentation-base.log", + "eventlog": "/tmp/txop-causal-Fragmentation-base.elog", + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-c", + "Fragmentation", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/txop-causal-Fragmentation-base.elog", + "--result-dir=/tmp/txop-causal-Fragmentation-base-results" + ] + }, + { + "config": "Fragmentation", + "variant": "head", + "status": 0, + "log": "/tmp/txop-causal-Fragmentation-head.log", + "eventlog": "/tmp/txop-causal-Fragmentation-head.elog", + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/../src/../src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-c", + "Fragmentation", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/txop-causal-Fragmentation-head.elog", + "--result-dir=/tmp/txop-causal-Fragmentation-head-results" + ] + } +] diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprint-causality.md b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprint-causality.md new file mode 100644 index 00000000000..44deae05283 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprint-causality.md @@ -0,0 +1,41 @@ +# TXOP fingerprint differences after C5 + +The selected fingerprint campaign reports two behavior changes and one inherited graphical mismatch. No recorded baseline changes. The [raw result](c5-fingerprints.txt) contains every old and new value. + +The comparison uses debug libraries. The base checkout has revision `d841dc77db7d0b141bf31e5e215a0de9bb281957`. Its library SHA-256 is `bc3595467d81df205051bc14f684b4e7ccae7c367c0efea7358fed1599efcaf7`. The final changed library SHA-256 is `1de36100640807565d8456334072201ff3f412a3e5fbfe28e0376a5e0fc57bf2`. + +## First event differences + +The paired trace commands use the same configuration, run zero, and a ten-millisecond limit. Only the library path and output paths differ. The [command record](c5-causal-commands.json) gives the exact arguments. The excerpt files retain the event records and relevant log messages. + +| Configuration | First cause and observable result | +| --- | --- | +| Aggregation | Event 88 sends the fifth radio transmission at 0.00043623452 seconds. The base sends `UdpBasicAppData-2+UdpBasicAppData-3`, a 354-byte A-MSDU with 78 microseconds of airtime. The changed library sends `UdpBasicAppData-2`, a 192-byte ordinary MPDU with 54 microseconds of airtime. Event 90 first differs in time and module. | +| Fragmentation | Event 39 receives the ACK for `Data-0-frag0` at 0.00031761726 seconds. The base ends the sequence and releases the channel. The changed library sends `Data-0-frag1` after SIFS within the same zero-limit TXOP. Event 40 first differs in time and module. | +| NoAggregation | All 883 event times and module IDs match through ten milliseconds. The full wrapper comparison below also matches every fingerprint value. | + +The Aggregation configuration selects non-HT `g(erp)`. HCF now requires local and received peer HT capabilities before A-MSDU preparation. The changed ordinary MPDU therefore implements the intended permission condition. This behavior change explains the different packet, timing, and graphical fingerprints. + +The Fragmentation configuration uses Basic and a zero TXOP limit. The corrected sequence permits the fragment burst of one MSDU. It protects the next fragment through its Duration field. Basic DATA with Block Ack policy has no immediate ACK. The reservation therefore includes no extra response SIFS. The direct Basic fixture asserts this Duration under both protection classes. + +These are first-cause observations. They explain why later trajectories differ. They do not enumerate every later packet or establish conformance of the showcase configurations. + +## Inherited NoAggregation mismatch + +The exact wrapper command uses a one-second limit, computed checksums and FCS, and the wrapper's fake-GUI options. Both libraries finish event 95921 with the same result: + +```text +21a4-c882/tplx, ecf2-6e33/~tNl, 5d9e-8fdf/~tND, cb71-81f8/tyf +``` + +The recorded graphical expectation is `27f2-4a52/tyf`. The unchanged base also produces `cb71-81f8/tyf`. The mismatch is therefore inherited. The [base output](c5-noaggregation-base.txt), [changed output](c5-noaggregation-head.txt), and [command record](c5-noaggregation-commands.json) retain this comparison. + +## Final changed values + +| Configuration | Values that differ from the recorded CSV | +| --- | --- | +| NoAggregation | `cb71-81f8/tyf` | +| Aggregation | `b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf` | +| Fragmentation | `9fd0-6388/tplx;22f5-8db8/~tNl;68cc-5669/~tND` | + +The behavioral fixtures pass independently of these stored expectations. This campaign preceded baseline approval. The user later authorized updates on 2026-10-19. The [baseline record](../fingerprints-20261019/README.md) gives the broader scope, causal commit owners, and approved values. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprints.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprints.txt new file mode 100644 index 00000000000..b793795a5cd --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-fingerprints.txt @@ -0,0 +1,18 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '9fd0-6388/tplx;22f5-8db8/~tNl;68cc-5669/~tND', expected: '36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND' +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf' + +Failures: + /showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf') + /showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '9fd0-6388/tplx;22f5-8db8/~tNl;68cc-5669/~tND', expected: '36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND') + /showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf') +---------------------------------------------------------------------- +Ran 3 tests in 32.511s + +FAILED (failures=3) + +Check showcases.csv.UPDATED for updated fingerprints +Check showcases.csv.FAILED for failed fingerprints +Log has been saved to fingerprinttest.out +Test results differ from expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-manifest.json b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-manifest.json new file mode 100644 index 00000000000..4631816ec57 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-manifest.json @@ -0,0 +1,65 @@ +{ + "head": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "library_sha256": "1de36100640807565d8456334072201ff3f412a3e5fbfe28e0376a5e0fc57bf2", + "production_diff_sha256": "c9fcdf6d41741a78ee30414c3f1df7777264815b04ca844ce31dd26758115f15", + "base_library_sha256": "bc3595467d81df205051bc14f684b4e7ccae7c367c0efea7358fed1599efcaf7", + "causality": { + "NoAggregation": { + "base_events": 883, + "head_events": 883, + "first_event_time_or_module_difference": null + }, + "Aggregation": { + "base_events": 2078, + "head_events": 1927, + "first_event_time_or_module_difference": { + "base": "E # 90 t 0.0005089 m 53 ce 79 msg 42", + "head": "E # 90 t 0.00049023452 m 63 ce 88 msg 31" + } + }, + "Fragmentation": { + "base_events": 993, + "head_events": 1508, + "first_event_time_or_module_difference": { + "base": "E # 40 t 0.0004 m 53 ce 30 msg 42", + "head": "E # 40 t 0.00032761726 m 72 ce 39 msg 27" + } + } + }, + "results": { + "module_fixtures": 31, + "normal_ack_runs": 96, + "basic_runs": 36, + "unit_fixtures": 4, + "protocol_fixtures": 1, + "onoe_runs": 16, + "aarf_runs": 16, + "corrected_basic_probe_runs": 4, + "fingerprint_rows": 3, + "fingerprint_mismatches": 3, + "baseline_updated": false + }, + "artifacts": { + "c5-aarf.txt": "0474cf2aba5d24bf98f373d5b14902498f99d0488c6489a819e325a66405f949", + "c5-architecture.txt": "a13a5db7d35fdb39758c6d472c6798b09115edae4a47aa7541cd67aaec3b56a4", + "c5-basic-corrected.txt": "b4e670a803d49f70bdca7b2d145bf7885c9af7506a2171cd4b00c0136775c2f5", + "c5-basic-runs.txt": "878b275ed8459cc79c7870921b785d9e35c2398bbfc247dba9b2bc3df968d643", + "c5-build.txt": "d6c63d55b07f715e1cfccc30b02ba9cdcd5cd5bad79e5628c30e62e3c5f1dd9b", + "c5-causal-Aggregation-base.txt": "9f2dd10e6de0fbe8e34c2265e294a95f5f79de797c241d6d1eea75cfdaf381a9", + "c5-causal-Aggregation-head.txt": "da47f6df15a7f6479e18c24e62fc617a4424f8a4f5b10d84625f6befb9a3cbef", + "c5-causal-Fragmentation-base.txt": "8068f867558291740bc5450722e40eb7776bd093ce60169fe1d46247e008f784", + "c5-causal-Fragmentation-head.txt": "26c6de2e6c52d3a64de9966e5457479c0870bbeb1f9b3138432164217de67422", + "c5-causal-commands.json": "f7fc968cc45beb6d8f4423f4476176620b8029c338f4b51232d62546bcfa8176", + "c5-fingerprint-causality.md": "926a58fb9dd83588d88dee147f47a38964e35fe56d9ac452fd9b147bdbf5955b", + "c5-fingerprints.txt": "c786a41e2b8131d6a34c775257e5580f89cfef19ae220588e1fb48d159ea75cf", + "c5-module.txt": "34b8391c0f87b8112e25d9c790a498ac9d65611b667cc03a44e5e8d0cae6318c", + "c5-noaggregation-base.txt": "c528a65c150f5452d301c1a0ee99612e46f21d8e3a9136811c3cd40b870fef92", + "c5-noaggregation-commands.json": "51c6a78ff08664d0b32887696ef652fd4325d279d48d0c7c41dc1214b4793cd7", + "c5-noaggregation-head.txt": "19723422c7ee468be4983cb466105e40b4614dd258d24ee92e45717465d2d35d", + "c5-onoe.txt": "2539d8297399aed9f0e6a2715f23e882b1bc6677bf866f90c1e4fcfffb981d6a", + "c5-protocol.txt": "91f01e92f030a5624efa53201eda5dfb376258decd58d4e3591461f0a7e38ed7", + "c5-tidy-hcf-final.txt": "15b4b375d4db9ee19d98e6a372ecf78fe4842f62ee190e6bbf8a771b6ee710c1", + "c5-tidy.txt": "594c6ebca05ddd6055ef69d82f769e82d9d90bc85ddfb5f212ec201151e98c23", + "c5-unit.txt": "1e424d41b35c6d2856ef87afcd4cb4d5c8d479f91a66516b399062e05b071a48" + } +} diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-module.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-module.txt new file mode 100644 index 00000000000..3f9d156e969 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-module.txt @@ -0,0 +1,37 @@ +/home/user/.config/matplotlib is not a writable directory +Matplotlib created a temporary cache directory at /tmp/matplotlib-vzcw6qfy because there was an issue with the default path ({configdir}); it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing. +No module named 'py4j': optional inet.common.ide package will not work +[00/32] ▶ 31 inet-ieee80211-txop-admission-remaining module tests (concurrently) +[01/32]   ⏺ Ieee80211QosRecoveryPeerIdentity_1.test PASS in 2.238 +[02/32]   ⏺ Ieee80211EdcaDataLifetimeInvalid_3.test PASS in 2.885 +[03/32]   ⏺ Ieee80211EdcaDataLifetimeInvalid_2.test PASS in 3.064 +[04/32]   ⏺ Ieee80211BasicCompatibility_1.test PASS in 4.023 +[05/32]   ⏺ Ieee80211EdcaDataLifetimeInvalid_4.test PASS in 3.147 +[06/32]   ⏺ Ieee80211CompressedBlockAckAdmission_1.test PASS in 6.114 +[07/32]   ⏺ Ieee80211HcfManagementRecovery_1.test PASS in 6.299 +[08/32]   ⏺ Ieee80211AmpduPreparation_1.test PASS in 7.17 +[09/32]   ⏺ Ieee80211EdcaDataLifetime_1.test PASS in 7.85 +[10/32]   ⏺ Ieee80211SingleProtectionGroup_1.test PASS in 2.616 +[11/32]   ⏺ Ieee80211EdcaDataLifetimeCongestion_1.test PASS in 2.515 +[12/32]   ⏺ Ieee80211EdcaDataLifetimeAggregation_1.test PASS in 3.06 +[13/32]   ⏺ Ieee80211TxopMsduRecovery_1.test PASS in 2.219 +[14/32]   ⏺ Ieee80211EdcaDataLifetimeInvalid_1.test PASS in 2.307 +[15/32]   ⏺ Ieee80211HcfMultipleProtection_1.test PASS in 7.369 +[16/32]   ⏺ Ieee80211PreparedQosFragments_1.test PASS in 2.258 +[17/32]   ⏺ Ieee80211PreparedCancellation_1.test PASS in 2.735 +[18/32]   ⏺ Ieee80211HcfInternalCollision_1.test PASS in 3.534 +[19/32]   ⏺ Ieee80211HcfSingleProtection_1.test PASS in 12.354 +[20/32]   ⏺ Ieee80211BlockAckFragmentRetirement_1.test PASS in 10.23 +[21/32]   ⏺ Ieee80211EdcaDataLifetimeDefaults_1.test PASS in 3.156 +[22/32]   ⏺ Ieee80211EdcaDataLifetimeArbitration_1.test PASS in 3.894 +[23/32]   ⏺ Ieee80211PreparedQosData_1.test PASS in 2.14 +[24/32]   ⏺ Ieee80211HcfMultipleProtection_2.test PASS in 4.141 +[25/32]   ⏺ Ieee80211CompressedBlockAckExchange_1.test PASS in 17.018 +[26/32]   ⏺ Ieee80211AmpduExchange_1.test PASS in 21.601 +[27/32]   ⏺ Ieee80211AmpduRecovery_1.test PASS in 24.194 +[28/32]   ⏺ Ieee80211AmpduAdmission_1.test PASS in 20.837 +[29/32]   ⏺ Ieee80211BlockAckVariant_1.test PASS in 20.69 +[30/32]   ⏺ Ieee80211BasicTxopAdmission_1.test PASS in 35.232 +[31/32]   ⏺ Ieee80211TxopAdmission_1.test PASS in 39.356 +[32/32] ◉ 31 inet-ieee80211-txop-admission-remaining module tests (concurrently) Multiple module tests: 31 PASS in 51.79 +Multiple module test results: PASS, summary: 31 PASS in 51.79 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-base.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-base.txt new file mode 100644 index 00000000000..42525092921 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-base.txt @@ -0,0 +1,49 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples: 210 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases: 75 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1239 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation: 1 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks: 6 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials: 52 + +Preparing for running configuration NoAggregation, run #0... + +*** WARNING: FAKEGUI IS AN EXPERIMENTAL FEATURE -- DO NOT RELY ON FINGERPRINTS GENERATED UNDER FAKEGUI UNTIL CODE IS FINALIZED! + +Assigned runID=NoAggregation-0-20261019-09:33:31-26 +Setting up network "AggregationShowcase"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.6e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 87 present: 87 in FES: 3 Memory (RSS): 204.84MiB +** Event #19456 t=0.20349230863 Elapsed: 2.01732s (0m 02s) 20% completed (20% total) + Speed: ev/sec=9645.12 simsec/sec=0.100874 ev/simsec=95615.4 + Messages: created: 14403 present: 218 in FES: 6 Memory (RSS): 206.152MiB +** Event #38912 t=0.40625 Elapsed: 4.03296s (0m 04s) 40% completed (40% total) + Speed: ev/sec=9652.46 simsec/sec=0.100592 ev/simsec=95956.9 + Messages: created: 28669 present: 216 in FES: 3 Memory (RSS): 206.152MiB +** Event #57600 t=0.60072461726 Elapsed: 6.05662s (0m 06s) 60% completed (60% total) + Speed: ev/sec=9234.76 simsec/sec=0.0961005 ev/simsec=96094.8 + Messages: created: 42374 present: 215 in FES: 2 Memory (RSS): 206.152MiB +** Event #78336 t=0.816875 Elapsed: 8.0846s (0m 08s) 81% completed (81% total) + Speed: ev/sec=10225 simsec/sec=0.106584 ev/simsec=95933.2 + Messages: created: 57577 present: 216 in FES: 4 Memory (RSS): 206.152MiB +** Event #95921 t=1 Elapsed: 9.73083s (0m 09s) 100% completed (100% total) + Speed: ev/sec=10681.3 simsec/sec=0.111239 ev/simsec=96021.8 + Messages: created: 70475 present: 221 in FES: 5 Memory (RSS): 206.559MiB + + Simulation time limit reached -- at t=1s, event #95921 + +Calling finish() at end of Run #0... + + Fingerprint mismatch! calculated: 21a4-c882/tplx, ecf2-6e33/~tNl, 5d9e-8fdf/~tND, cb71-81f8/tyf, expected: 21a4-c882/tplx, ecf2-6e33/~tNl, 5d9e-8fdf/~tND, 27f2-4a52/tyf + + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-commands.json b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-commands.json new file mode 100644 index 00000000000..40d7ffdcbee --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-commands.json @@ -0,0 +1,82 @@ +[ + { + "variant": "base", + "status": 0, + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-f", + "omnetpp.ini", + "-c", + "NoAggregation", + "-r", + "0", + "--cmdenv-fake-gui-before-event-probability=0.001", + "--**.fadeOutMode=\"animationTime\"", + "--**.fcsMode=\"computed\"", + "--**.checksumMode=\"computed\"", + "--cmdenv-fake-gui-on-simtime-probability=0.001", + "--cmdenv-fake-gui-on-simtime-numsteps=3", + "--cmdenv-fake-gui=true", + "--cmdenv-fake-gui-on-hold-probability=0.001", + "--cmdenv-fake-gui-on-hold-numsteps=3", + "--cmdenv-fake-gui-after-event-probability=0.001", + "--**.signalAnimationSpeedChangeTimeMode=\"animationTime\"", + "--sim-time-limit=1s", + "--fingerprint=21a4-c882/tplx, ecf2-6e33/~tNl, 5d9e-8fdf/~tND, 27f2-4a52/tyf", + "--cpu-time-limit=600s", + "--vector-recording=false", + "--scalar-recording=true", + "--result-dir=/tmp/txop-exact-visual-base-results", + "--fingerprintcalculator-class=inet::FingerprintCalculator" + ] + }, + { + "variant": "head", + "status": 0, + "command": [ + "/home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg", + "-l", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/../src/../src/INET", + "-x", + "inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg", + "-n", + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials:", + "--image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images", + "-u", + "Cmdenv", + "-f", + "omnetpp.ini", + "-c", + "NoAggregation", + "-r", + "0", + "--cmdenv-fake-gui-before-event-probability=0.001", + "--**.fadeOutMode=\"animationTime\"", + "--**.fcsMode=\"computed\"", + "--**.checksumMode=\"computed\"", + "--cmdenv-fake-gui-on-simtime-probability=0.001", + "--cmdenv-fake-gui-on-simtime-numsteps=3", + "--cmdenv-fake-gui=true", + "--cmdenv-fake-gui-on-hold-probability=0.001", + "--cmdenv-fake-gui-on-hold-numsteps=3", + "--cmdenv-fake-gui-after-event-probability=0.001", + "--**.signalAnimationSpeedChangeTimeMode=\"animationTime\"", + "--sim-time-limit=1s", + "--fingerprint=21a4-c882/tplx, ecf2-6e33/~tNl, 5d9e-8fdf/~tND, 27f2-4a52/tyf", + "--cpu-time-limit=600s", + "--vector-recording=false", + "--scalar-recording=true", + "--result-dir=/tmp/txop-exact-visual-head-results", + "--fingerprintcalculator-class=inet::FingerprintCalculator" + ] + } +] diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-head.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-head.txt new file mode 100644 index 00000000000..1f07884b3d0 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-noaggregation-head.txt @@ -0,0 +1,52 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples: 210 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases: 75 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1239 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation: 1 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks: 6 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials: 52 + +Preparing for running configuration NoAggregation, run #0... + +*** WARNING: FAKEGUI IS AN EXPERIMENTAL FEATURE -- DO NOT RELY ON FINGERPRINTS GENERATED UNDER FAKEGUI UNTIL CODE IS FINALIZED! + +Assigned runID=NoAggregation-0-20261019-09:38:26-10 +Setting up network "AggregationShowcase"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.6e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 87 present: 87 in FES: 3 Memory (RSS): 208.902MiB +** Event #14848 t=0.15541211726 Elapsed: 2.01517s (0m 02s) 15% completed (15% total) + Speed: ev/sec=7368.7 simsec/sec=0.0771221 ev/simsec=95546 + Messages: created: 12016 present: 219 in FES: 4 Memory (RSS): 210.215MiB +** Event #28672 t=0.29943980863 Elapsed: 4.06325s (0m 04s) 29% completed (29% total) + Speed: ev/sec=6749.74 simsec/sec=0.0703233 ev/simsec=95981.5 + Messages: created: 23075 present: 218 in FES: 5 Memory (RSS): 210.215MiB +** Event #43264 t=0.4515625 Elapsed: 6.09799s (0m 06s) 45% completed (45% total) + Speed: ev/sec=7171.4 simsec/sec=0.0747624 ev/simsec=95922.6 + Messages: created: 34747 present: 216 in FES: 3 Memory (RSS): 210.215MiB +** Event #60160 t=0.6275 Elapsed: 8.11889s (0m 08s) 62% completed (62% total) + Speed: ev/sec=8360.66 simsec/sec=0.0870592 ev/simsec=96034.1 + Messages: created: 48267 present: 221 in FES: 5 Memory (RSS): 210.215MiB +** Event #78592 t=0.81943980863 Elapsed: 10.1394s (0m 10s) 81% completed (81% total) + Speed: ev/sec=9122.36 simsec/sec=0.0949948 ev/simsec=96030.1 + Messages: created: 63011 present: 218 in FES: 5 Memory (RSS): 210.215MiB +** Event #95921 t=1 Elapsed: 11.9198s (0m 11s) 100% completed (100% total) + Speed: ev/sec=9732.54 simsec/sec=0.101414 ev/simsec=95968 + Messages: created: 76875 present: 221 in FES: 5 Memory (RSS): 210.215MiB + + Simulation time limit reached -- at t=1s, event #95921 + +Calling finish() at end of Run #0... + + Fingerprint mismatch! calculated: 21a4-c882/tplx, ecf2-6e33/~tNl, 5d9e-8fdf/~tND, cb71-81f8/tyf, expected: 21a4-c882/tplx, ecf2-6e33/~tNl, 5d9e-8fdf/~tND, 27f2-4a52/tyf + + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-onoe.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-onoe.txt new file mode 100644 index 00000000000..b83ffca2d18 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-onoe.txt @@ -0,0 +1,333 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/work/Ieee80211TxopAdmission_1: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/lib: 33 + +Preparing for running configuration General, run #0... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-0-20261019-09:39:07-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 4.2e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 198.414MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #7806 t=1.35 Elapsed: 0.587262s (0m 00s) 96% completed (6% total) + Speed: ev/sec=13292.8 simsec/sec=2.16783 ev/simsec=6131.82 + Messages: created: 12825 present: 120 in FES: 4 Memory (RSS): 199.98MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #7806 + +Calling finish() at end of Run #0... + +Preparing for running configuration General, run #1... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-1-20261019-09:39:08-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (6% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #8126 t=1.35 Elapsed: 0.577318s (0m 00s) 96% completed (12% total) + Speed: ev/sec=14075.6 simsec/sec=2.20511 ev/simsec=6383.18 + Messages: created: 13234 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #8126 + +Calling finish() at end of Run #1... + +Preparing for running configuration General, run #2... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-2-20261019-09:39:09-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (12% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4354 t=1.35 Elapsed: 0.339259s (0m 00s) 96% completed (18% total) + Speed: ev/sec=12834.2 simsec/sec=3.7525 ev/simsec=3420.18 + Messages: created: 6826 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4354 + +Calling finish() at end of Run #2... + +Preparing for running configuration General, run #3... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-09:39:09-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (18% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4479 t=1.35 Elapsed: 0.335182s (0m 00s) 96% completed (24% total) + Speed: ev/sec=13363.4 simsec/sec=3.79818 ev/simsec=3518.37 + Messages: created: 6386 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4479 + +Calling finish() at end of Run #3... + +Preparing for running configuration General, run #4... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-4-20261019-09:39:10-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (25% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #7806 t=1.35 Elapsed: 0.549982s (0m 00s) 96% completed (31% total) + Speed: ev/sec=14193.6 simsec/sec=2.31474 ev/simsec=6131.82 + Messages: created: 12825 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #7806 + +Calling finish() at end of Run #4... + +Preparing for running configuration General, run #5... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-5-20261019-09:39:11-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.4e-05s (0m 00s) 0% completed (31% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #8126 t=1.35 Elapsed: 0.580839s (0m 00s) 96% completed (37% total) + Speed: ev/sec=13990.3 simsec/sec=2.19175 ev/simsec=6383.18 + Messages: created: 13234 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #8126 + +Calling finish() at end of Run #5... + +Preparing for running configuration General, run #6... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-6-20261019-09:39:12-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (37% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4354 t=1.35 Elapsed: 0.359106s (0m 00s) 96% completed (43% total) + Speed: ev/sec=12124.8 simsec/sec=3.54508 ev/simsec=3420.18 + Messages: created: 6826 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4354 + +Calling finish() at end of Run #6... + +Preparing for running configuration General, run #7... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-7-20261019-09:39:12-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (43% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4479 t=1.35 Elapsed: 0.321226s (0m 00s) 96% completed (49% total) + Speed: ev/sec=13943.8 simsec/sec=3.96315 ev/simsec=3518.37 + Messages: created: 6386 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4479 + +Calling finish() at end of Run #7... + +Preparing for running configuration General, run #48... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-48-20261019-09:39:13-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.2e-05s (0m 00s) 0% completed (50% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.090585s (0m 00s) 96% completed (56% total) + Speed: ev/sec=16450.6 simsec/sec=14.0552 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #48... + +Preparing for running configuration General, run #49... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-49-20261019-09:39:13-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (56% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.083382s (0m 00s) 96% completed (62% total) + Speed: ev/sec=17871.9 simsec/sec=15.2695 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #49... + +Preparing for running configuration General, run #50... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-50-20261019-09:39:13-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (62% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.068442s (0m 00s) 96% completed (68% total) + Speed: ev/sec=15138.7 simsec/sec=18.6023 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #50... + +Preparing for running configuration General, run #51... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-51-20261019-09:39:13-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (68% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.063622s (0m 00s) 96% completed (74% total) + Speed: ev/sec=16286 simsec/sec=20.0121 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #51... + +Preparing for running configuration General, run #52... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-52-20261019-09:39:14-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.3e-05s (0m 00s) 0% completed (75% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.144643s (0m 00s) 96% completed (81% total) + Speed: ev/sec=10302 simsec/sec=8.80187 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #52... + +Preparing for running configuration General, run #53... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-53-20261019-09:39:14-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (81% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.082756s (0m 00s) 96% completed (87% total) + Speed: ev/sec=18006.7 simsec/sec=15.3846 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #53... + +Preparing for running configuration General, run #54... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-54-20261019-09:39:14-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (87% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.053406s (0m 00s) 96% completed (93% total) + Speed: ev/sec=19402.2 simsec/sec=23.8413 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #54... + +Preparing for running configuration General, run #55... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-55-20261019-09:39:14-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (93% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 200.117MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.062293s (0m 00s) 96% completed (99% total) + Speed: ev/sec=16633.2 simsec/sec=20.4388 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 200.117MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #55... + +Run statistics: total 16, successful 16 + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-protocol.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-protocol.txt new file mode 100644 index 00000000000..e0a37d90872 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-protocol.txt @@ -0,0 +1,9 @@ +/home/user/.config/matplotlib is not a writable directory +Matplotlib created a temporary cache directory at /tmp/matplotlib-_amggwa2 because there was an issue with the default path ({configdir}); it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing. +No module named 'py4j': optional inet.common.ide package will not work +[0/3] ▶ 1 protocol tests (sequentially) +[0/3]   ▶ 1 inet-ieee80211-txop-admission-remaining protocol wifi tests (concurrently) +[0/3]   ⏺ legacy/Legacy_Fragmentation.test PASS in 1.673 +[2/3]   ◉ 1 inet-ieee80211-txop-admission-remaining protocol wifi tests (concurrently) Multiple protocol wifi tests: PASS in 1.673 +[3/3] ◉ 1 protocol tests (sequentially) Multiple protocol tests: Multiple protocol wifi tests: PASS in 1.673 +Single protocol test result: Single protocol wifi test result: Result: PASS in 1.673 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy-hcf-final.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy-hcf-final.txt new file mode 100644 index 00000000000..89d8247b79b --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy-hcf-final.txt @@ -0,0 +1,15688 @@ +16650 warnings generated. +./inet/common/BitVector.h:9:9: warning: invalid case style for macro definition '__INET_BITVECTOR_H' [readability-identifier-naming] + 9 | #define __INET_BITVECTOR_H + | ^~~~~~~~~~~~~~~~~~ + | INET_BITVECTOR_H +./inet/common/BitVector.h:24:5: warning: function 'containerSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | int containerSize() const { return bytes.size() * 8; } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:36:5: warning: function 'toDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | unsigned int toDecimal() const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:37:5: warning: function 'reverseToDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | unsigned int reverseToDecimal() const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:42:5: warning: function 'getBit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | bool getBit(int pos) const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:44:5: warning: function 'getSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | unsigned int getSize() const { return size; } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:45:5: warning: function 'getNumberOfBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | unsigned int getNumberOfBytes() const { return bytes.size(); } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:46:5: warning: function 'getBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | const std::vector& getBytes() const { return bytes; } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:47:5: warning: function 'computeHammingDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | int computeHammingDistance(const BitVector& u) const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:52:5: warning: function 'toString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | std::string toString() const; + | ^ + | [[nodiscard]] +./inet/common/Compat.h:9:9: warning: invalid case style for macro definition '__INET_COMPAT_H' [readability-identifier-naming] + 9 | #define __INET_COMPAT_H + | ^~~~~~~~~~~~~~~ + | INET_COMPAT_H +./inet/common/Compat.h:35:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 35 | typedef int sharedvarhandle_t; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sharedvarhandle_t = int +./inet/common/Compat.h:35:13: warning: invalid case style for typedef 'sharedvarhandle_t' [readability-identifier-naming] + 35 | typedef int sharedvarhandle_t; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Compat.h:43:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 43 | typedef int sharedcounterhandle_t; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sharedcounterhandle_t = int +./inet/common/Compat.h:43:13: warning: invalid case style for typedef 'sharedcounterhandle_t' [readability-identifier-naming] + 43 | typedef int sharedcounterhandle_t; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Compat.h:66:20: warning: invalid case style for private member 'INVALID' [readability-identifier-naming] + 66 | const uint64_t INVALID = (uint64_t)-1; + | ^~~~~~~ + | invalid +./inet/common/Compat.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void lifecycleEvent(omnetpp::SimulationLifecycleEventType eventType, omnetpp::cObject *details) override; + | ~~~~~~~ ^ +./inet/common/Compat.h:237:9: warning: invalid case style for macro definition 'cSimulationOrSharedDataManager' [readability-identifier-naming] + 237 | #define cSimulationOrSharedDataManager SharedDataManager + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | C_SIMULATION_OR_SHARED_DATA_MANAGER +./inet/common/DelayedInitializer.h:9:9: warning: invalid case style for macro definition '__INET_DELAYEDINITIALIZER_H' [readability-identifier-naming] + 9 | #define __INET_DELAYEDINITIALIZER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_DELAYEDINITIALIZER_H +./inet/common/DelayedInitializer.h:22:10: warning: use default member initializer for 'constructed' [modernize-use-default-member-init] + 22 | bool constructed; + | ^ + | {true} + 23 | const std::function initializer; + 24 | + 25 | public: + 26 | DelayedInitializer(const std::function initializer) : constructed(true), initializer(initializer) {} + | ~~~~~~~~~~~~~~~~~ +./inet/common/INETDefs.h:9:9: warning: invalid case style for macro definition '__INET_INETDEFS_H' [readability-identifier-naming] + 9 | #define __INET_INETDEFS_H + | ^~~~~~~~~~~~~~~~~ + | INET_INETDEFS_H +./inet/common/INETDefs.h:37:1: warning: replace macro with enum [modernize-macro-to-enum] + 37 | #define INET_VERSION 0x0407 + | ^~~~~~~ + | = , + 38 | #define INET_PATCH_LEVEL 0x00 + | ~~~~~~~ + | = + 39 | +./inet/common/INETDefs.h:37:9: warning: macro 'INET_VERSION' defines an integral constant; prefer an enum instead [modernize-macro-to-enum] + 37 | #define INET_VERSION 0x0407 + | ^ +./inet/common/INETDefs.h:38:9: warning: macro 'INET_PATCH_LEVEL' defines an integral constant; prefer an enum instead [modernize-macro-to-enum] + 38 | #define INET_PATCH_LEVEL 0x00 + | ^ +./inet/common/INETDefs.h:60:7: warning: invalid case style for type alias 'simtime_raw_t' [readability-identifier-naming] + 60 | using simtime_raw_t = int64_t; + | ^~~~~~~~~~~~~ + | SimtimeRawT +./inet/common/INETDefs.h:67:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 67 | typedef unsigned short ushort; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ushort = unsigned short +./inet/common/INETDefs.h:67:24: warning: invalid case style for typedef 'ushort' [readability-identifier-naming] + 67 | typedef unsigned short ushort; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/INETDefs.h:68:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 68 | typedef unsigned int uint; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using uint = unsigned int +./inet/common/INETDefs.h:68:22: warning: invalid case style for typedef 'uint' [readability-identifier-naming] + 68 | typedef unsigned int uint; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/INETDefs.h:69:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 69 | typedef unsigned long ulong; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ulong = unsigned long +./inet/common/INETDefs.h:69:23: warning: invalid case style for typedef 'ulong' [readability-identifier-naming] + 69 | typedef unsigned long ulong; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/INETDefs.h:75:7: warning: invalid case style for type alias 'void_t' [readability-identifier-naming] + 75 | using void_t = void; + | ^~~~~~ + | VoidT +./inet/common/INETDefs.h:86:4: warning: invalid case style for function '__checknull' [readability-identifier-naming] + 86 | T *__checknull(T *p, const char *expr, const char *file, int line) + | ^~~~~~~~~~~ + | checknull +./inet/common/INETDefs.h:114:99: warning: macro argument should be enclosed in parentheses [bugprone-macro-parentheses] + 114 | #define EV_FORMAT_STYLE(format) (evFlags & IPrintableObject::PRINT_FLAG_FORMATTED ? format : "") + | ^ + | ( ) +./inet/common/INETDefs_m.h:6:9: warning: invalid case style for macro definition '__INET_INETDEFS_M_H' [readability-identifier-naming] + 6 | #define __INET_INETDEFS_M_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_INETDEFS_M_H +./inet/common/INETMath.h:9:9: warning: invalid case style for macro definition '__INET_INETMATH_H' [readability-identifier-naming] + 9 | #define __INET_INETMATH_H + | ^~~~~~~~~~~~~~~~~ + | INET_INETMATH_H +./inet/common/INETMath.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | + 22 | /** + 23 | * @brief Support functions for mathematical operations. + 24 | * + 25 | * This namespace contains all kind of mathematical support functions + 26 | */ + 27 | namespace math { + | ~~~~~~~~~~~~~~ + | namespace inet::math +./inet/common/INETMath.h:90:9: warning: invalid case style for macro definition 'sNaN' [readability-identifier-naming] + 90 | #define sNaN std::numeric_limits::signaling_NaN() + | ^~~~ + | S_NA_N +./inet/common/INETMath.h:91:9: warning: invalid case style for macro definition 'NaN' [readability-identifier-naming] + 91 | #define NaN qNaN + | ^~~ + | NA_N +./inet/common/INETMath.h:194:15: warning: invalid case style for function 'n_choose_k' [readability-identifier-naming] + 194 | inline double n_choose_k(int n, int k) { + | ^~~~~~~~~~ + | nChooseK +./inet/common/INETMath.h:217:16: warning: use c++17 style variable templates [modernize-type-traits] + 217 | static_assert(!std::is_integral::value, "minnan() is only meant for doubles and double based units, use std::min() for integers"); + | ^ ~~~~~~~ + | _v +./inet/common/INETMath.h:219:9: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 219 | return a; + | ^ +./inet/common/INETMath.h:219:17: note: end of the original + 219 | return a; + | ^ +./inet/common/INETMath.h:223:9: note: clone 1 starts here + 223 | return a; + | ^ +./inet/common/INETMath.h:235:16: warning: use c++17 style variable templates [modernize-type-traits] + 235 | static_assert(!std::is_integral::value, "maxnan() is only meant for doubles and double based units, use std::max() for integers"); + | ^ ~~~~~~~ + | _v +./inet/common/INETMath.h:237:9: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 237 | return a; + | ^ +./inet/common/INETMath.h:237:17: note: end of the original + 237 | return a; + | ^ +./inet/common/INETMath.h:241:9: note: clone 1 starts here + 241 | return a; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:9:9: warning: invalid case style for macro definition '__INET_IPRINTABLEOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_IPRINTABLEOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPRINTABLEOBJECT_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:35:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 35 | virtual ~IPrintableObject() {} + | ^ ~~ + | = default; +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:40:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 40 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const { + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:40:67: note: the first parameter in the range is 'level' + 40 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const { + | ^~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:40:78: note: the last parameter in the range is 'evFlags' + 40 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const { + | ^~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:44:5: warning: function 'printToString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual std::string printToString() const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:48:5: warning: function 'printToString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual std::string printToString(int level, int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:54:5: warning: function 'getInfoStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual std::string getInfoStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:60:5: warning: function 'getDetailStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual std::string getDetailStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:66:5: warning: function 'getDebugStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual std::string getDebugStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:72:5: warning: function 'getTraceStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | virtual std::string getTraceStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:78:5: warning: function 'getCompleteStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | virtual std::string getCompleteStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:112:8: warning: invalid case style for struct 'has_print_to_string' [readability-identifier-naming] + 112 | struct has_print_to_string : std::false_type {}; + | ^~~~~~~~~~~~~~~~~~~ + | HasPrintToString + 113 | + 114 | template + 115 | struct has_print_to_string().printToString())>> + 116 | : std::true_type {}; + 117 | + 118 | template + 119 | struct has_str : std::false_type {}; + 120 | + 121 | template + 122 | struct has_str().str())>> + 123 | : std::true_type {}; + 124 | + 125 | template + 126 | std::enable_if_t::value, std::string> printToStringIfPossible(T *object, int evFlags) + | ~~~~~~~~~~~~~~~~~~~ + | HasPrintToString +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:119:8: warning: invalid case style for struct 'has_str' [readability-identifier-naming] + 119 | struct has_str : std::false_type {}; + | ^~~~~~~ + | HasStr +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:156:18: warning: use c++17 style variable templates [modernize-type-traits] + 156 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:172:18: warning: use c++17 style variable templates [modernize-type-traits] + 172 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:186:18: warning: use c++17 style variable templates [modernize-type-traits] + 186 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:202:18: warning: use c++17 style variable templates [modernize-type-traits] + 202 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:218:18: warning: use c++17 style variable templates [modernize-type-traits] + 218 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:234:18: warning: use c++17 style variable templates [modernize-type-traits] + 234 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:248:19: warning: use c++17 style variable templates [modernize-type-traits] + 248 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:256:19: warning: use c++17 style variable templates [modernize-type-traits] + 256 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +./inet/common/IVisitor.h:9:9: warning: invalid case style for macro definition '__INET_IVISITOR_H' [readability-identifier-naming] + 9 | #define __INET_IVISITOR_H + | ^~~~~~~~~~~~~~~~~ + | INET_IVISITOR_H +./inet/common/IVisitor.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IVisitor() {} + | ^ ~~ + | = default; +./inet/common/InitStageRegistry.h:9:9: warning: invalid case style for macro definition '__INET_INITSTAGEREGISTRY_H' [readability-identifier-naming] + 9 | #define __INET_INITSTAGEREGISTRY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_INITSTAGEREGISTRY_H +./inet/common/InitStageRegistry.h:12:9: warning: invalid case style for macro definition '__INET_INITSTAGES_H' [readability-identifier-naming] + 12 | #define __INET_INITSTAGES_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_INITSTAGES_H +./inet/common/InitStageRegistry.h:40:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 40 | InitStageRegistry() {} + | ^ ~~ + | = default; +./inet/common/InitStageRegistry.h:63:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | const char *getName() const { return name; } + | ^ + | [[nodiscard]] +./inet/common/InitStageRegistry.h:67:9: warning: invalid case style for macro definition 'Define_InitStage' [readability-identifier-naming] + 67 | #define Define_InitStage(name) const inet::InitStage INITSTAGE_##name(#name); EXECUTE_PRE_NETWORK_SETUP(inet::InitStageRegistry::getInstance().addInitStage(&INITSTAGE_##name)) + | ^~~~~~~~~~~~~~~~ + | DEFINE_INIT_STAGE +./inet/common/InitStageRegistry.h:69:9: warning: invalid case style for macro definition 'Define_InitStage_Dependency' [readability-identifier-naming] + 69 | #define Define_InitStage_Dependency(source, target) EXECUTE_PRE_NETWORK_SETUP(inet::InitStageRegistry::getInstance().addInitStageDependency(#source, #target)) + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | DEFINE_INIT_STAGE_DEPENDENCY +./inet/common/InitStages.h:9:9: warning: invalid case style for macro definition '__INET_INITSTAGES_H' [readability-identifier-naming] + 9 | #define __INET_INITSTAGES_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_INITSTAGES_H +./inet/common/IntervalTree.h:38:9: warning: invalid case style for macro definition '__INET_INTERVALTREE_H' [readability-identifier-naming] + 38 | #define __INET_INTERVALTREE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_INTERVALTREE_H +./inet/common/IntervalTree.h:58:18: warning: 2 adjacent parameters of 'Interval' of similar type ('simtime_t') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 58 | Interval(simtime_t low, simtime_t high, void *value) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/IntervalTree.h:58:28: note: the first parameter in the range is 'low' + 58 | Interval(simtime_t low, simtime_t high, void *value) : + | ^~~ +./inet/common/IntervalTree.h:58:43: note: the last parameter in the range is 'high' + 58 | Interval(simtime_t low, simtime_t high, void *value) : + | ^~~~ +./inet/common/IntervalTree.h:61:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 61 | virtual ~Interval() + | ^ + 62 | { + | ~ + | = default; + 63 | } + | ~ +./inet/common/IntervalTree.h:89:30: warning: invalid case style for parameter 'new_interval' [readability-identifier-naming] + 89 | Node(const Interval *new_interval); + | ^~~~~~~~~~~~ + | newInterval +./inet/common/IntervalTree.h:95:25: warning: invalid case style for protected member 'stored_interval' [readability-identifier-naming] + 95 | const Interval *stored_interval = nullptr; + | ^~~~~~~~~~~~~~~ + | storedInterval +./inet/common/IntervalTree.h:101:19: warning: invalid case style for protected member 'max_high' [readability-identifier-naming] + 101 | simtime_t max_high; + | ^~~~~~~~ + | maxHigh +./inet/common/IntervalTree.h:116:12: warning: invalid case style for struct 'it_recursion_node' [readability-identifier-naming] + 116 | struct it_recursion_node { + | ^~~~~~~~~~~~~~~~~ + | ItRecursionNode +./inet/common/IntervalTree.h:118:15: warning: invalid case style for public member 'start_node' [readability-identifier-naming] + 118 | Node *start_node = nullptr; + | ^~~~~~~~~~ + | startNode +./inet/common/IntervalTree.h:120:22: warning: invalid case style for public member 'parent_index' [readability-identifier-naming] + 120 | unsigned int parent_index = 0; + | ^~~~~~~~~~~~ + | parentIndex +./inet/common/IntervalTree.h:122:14: warning: invalid case style for public member 'try_right_branch' [readability-identifier-naming] + 122 | bool try_right_branch = false; + | ^~~~~~~~~~~~~~~~ + | tryRightBranch +./inet/common/IntervalTree.h:139:34: warning: invalid case style for parameter 'new_interval' [readability-identifier-naming] + 139 | Node *insert(const Interval *new_interval); + | ^~~~~~~~~~~~ + | newInterval +./inet/common/IntervalTree.h:180:18: warning: invalid case style for private member 'recursion_node_stack_size' [readability-identifier-naming] + 180 | unsigned int recursion_node_stack_size = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | recursionNodeStackSize +./inet/common/IntervalTree.h:181:24: warning: invalid case style for private member 'recursion_node_stack' [readability-identifier-naming] + 181 | it_recursion_node *recursion_node_stack = nullptr; + | ^~~~~~~~~~~~~~~~~~~~ + | recursionNodeStack +./inet/common/IntervalTree.h:182:18: warning: invalid case style for private member 'current_parent' [readability-identifier-naming] + 182 | unsigned int current_parent = 0; + | ^~~~~~~~~~~~~~ + | currentParent +./inet/common/IntervalTree.h:183:18: warning: invalid case style for private member 'recursion_node_stack_top' [readability-identifier-naming] + 183 | unsigned int recursion_node_stack_top = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | recursionNodeStackTop +./inet/common/IntrusivePtr.h:9:9: warning: invalid case style for macro definition '__INET_INTRUSIVEPTR_H' [readability-identifier-naming] + 9 | #define __INET_INTRUSIVEPTR_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_INTRUSIVEPTR_H +./inet/common/IntrusivePtr.h:38:18: warning: use nullptr [modernize-use-nullptr] + 38 | if (p != 0) intrusivePtrCounterIncrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:43:18: warning: use nullptr [modernize-use-nullptr] + 43 | if (p != 0) intrusivePtrCounterIncrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:47:18: warning: use nullptr [modernize-use-nullptr] + 47 | if (p != 0) intrusivePtrCounterIncrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:51:18: warning: use nullptr [modernize-use-nullptr] + 51 | if (p != 0) intrusivePtrCounterDecrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:73:17: warning: use nullptr [modernize-use-nullptr] + 73 | ptr.p = 0; + | ^ + | nullptr +./inet/common/IntrusivePtr.h:82:38: warning: operator=() does not handle self-assignment properly [bugprone-unhandled-self-assignment] + 82 | INET_ALWAYS_INLINE IntrusivePtr& operator=(IntrusivePtr const& ptr) { + | ^ +./inet/common/IntrusivePtr.h:100:48: warning: invalid case style for parameter 'add_ref' [readability-identifier-naming] + 100 | INET_ALWAYS_INLINE void reset(T *ptr, bool add_ref) { + | ^~~~~~~ + | addRef + 101 | IntrusivePtr(ptr, add_ref).swap(*this); + | ~~~~~~~ + | addRef +./inet/common/IntrusivePtr.h:104:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 104 | INET_ALWAYS_INLINE T *get() const noexcept { return p; } + | ^ + | [[nodiscard]] +./inet/common/IntrusivePtr.h:15:31: note: expanded from macro 'INET_ALWAYS_INLINE' + 15 | #define INET_ALWAYS_INLINE __attribute__((always_inline)) inline + | ^ +./inet/common/IntrusivePtr.h:116:78: warning: use nullptr [modernize-use-nullptr] + 116 | INET_ALWAYS_INLINE explicit operator bool() const noexcept { return p != 0; } + | ^ + | nullptr +./inet/common/IntrusivePtr.h:124:5: warning: function 'use_count' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | INET_ALWAYS_INLINE unsigned int use_count() const noexcept { return p->use_count(); } + | ^ + | [[nodiscard]] +./inet/common/IntrusivePtr.h:15:31: note: expanded from macro 'INET_ALWAYS_INLINE' + 15 | #define INET_ALWAYS_INLINE __attribute__((always_inline)) inline + | ^ +./inet/common/IntrusivePtr.h:124:37: warning: invalid case style for method 'use_count' [readability-identifier-naming] + 124 | INET_ALWAYS_INLINE unsigned int use_count() const noexcept { return p->use_count(); } + | ^~~~~~~~~ + | useCount +./inet/common/IntrusivePtr.h:166:23: warning: use nullptr [modernize-use-nullptr] + 166 | return p.get() == 0; + | ^ + | nullptr +./inet/common/IntrusivePtr.h:178:23: warning: use nullptr [modernize-use-nullptr] + 178 | return p.get() != 0; + | ^ + | nullptr +./inet/common/IntrusivePtr.h:200:23: warning: invalid case style for function 'get_pointer' [readability-identifier-naming] + 200 | INET_ALWAYS_INLINE T *get_pointer(IntrusivePtr const& p) noexcept + | ^~~~~~~~~~~ + | getPointer +./inet/common/IntrusivePtr.h:206:36: warning: invalid case style for function 'static_pointer_cast' [readability-identifier-naming] + 206 | INET_ALWAYS_INLINE IntrusivePtr static_pointer_cast(IntrusivePtr const& p) + | ^~~~~~~~~~~~~~~~~~~ + | staticPointerCast +./inet/common/IntrusivePtr.h:212:36: warning: invalid case style for function 'const_pointer_cast' [readability-identifier-naming] + 212 | INET_ALWAYS_INLINE IntrusivePtr const_pointer_cast(IntrusivePtr const& p) + | ^~~~~~~~~~~~~~~~~~ + | constPointerCast +./inet/common/IntrusivePtr.h:218:36: warning: invalid case style for function 'dynamic_pointer_cast' [readability-identifier-naming] + 218 | INET_ALWAYS_INLINE IntrusivePtr dynamic_pointer_cast(IntrusivePtr const& p) + | ^~~~~~~~~~~~~~~~~~~~ + | dynamicPointerCast +./inet/common/IntrusivePtr.h:242:26: warning: use default member initializer for 'c' [modernize-use-default-member-init] + 242 | mutable unsigned int c; + | ^ + | {0} + 243 | + 244 | public: + 245 | INET_ALWAYS_INLINE IntrusivePtrCounter() noexcept : c(0) {} + | ~~~~ +./inet/common/IntrusivePtr.h:245:24: warning: public constructor allows the CRTP to be constructed as a regular template class; consider making it private and declaring the derived class as friend [bugprone-crtp-constructor-accessibility] + 245 | INET_ALWAYS_INLINE IntrusivePtrCounter() noexcept : c(0) {} + | ^ +./inet/common/IntrusivePtr.h:246:24: warning: public constructor allows the CRTP to be constructed as a regular template class; consider making it private and declaring the derived class as friend [bugprone-crtp-constructor-accessibility] + 246 | INET_ALWAYS_INLINE IntrusivePtrCounter(IntrusivePtrCounter const&) noexcept : c(0) {} + | ^ +./inet/common/IntrusivePtr.h:248:37: warning: invalid case style for method 'use_count' [readability-identifier-naming] + 124 | INET_ALWAYS_INLINE unsigned int use_count() const noexcept { return c; } + | ^~~~~~~~~ + | useCount +./inet/common/IntrusivePtr.h:252:40: warning: invalid case style for method 'shared_from_this' [readability-identifier-naming] + 252 | INET_ALWAYS_INLINE IntrusivePtr shared_from_this() { return IntrusivePtr(static_cast(this)); } + | ^~~~~~~~~~~~~~~~ + | sharedFromThis +./inet/common/LayeredProtocolBase.h:9:9: warning: invalid case style for macro definition '__INET_LAYEREDPROTOCOLBASE_H' [readability-identifier-naming] + 9 | #define __INET_LAYEREDPROTOCOLBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_LAYEREDPROTOCOLBASE_H +./inet/common/LayeredProtocolBase.h:19:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 19 | virtual void handleMessageWhenUp(cMessage *message) override; + | ~~~~~~~ ^ +./inet/common/MemoryInputStream.h:9:9: warning: invalid case style for macro definition '__INET_MEMORYINPUTSTREAM_H' [readability-identifier-naming] + 9 | #define __INET_MEMORYINPUTSTREAM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MEMORYINPUTSTREAM_H +./inet/common/MemoryInputStream.h:52:10: warning: invalid case style for protected member 'isReadBeyondEnd_' [readability-identifier-naming] + 52 | bool isReadBeyondEnd_ = false; + | ^~~~~~~~~~~~~~~~ + | isReadBeyondEnd +./inet/common/MemoryInputStream.h:55:5: warning: function 'isByteAligned' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | bool isByteAligned() const { + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:60:57: warning: 2 adjacent parameters of 'MemoryInputStream' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 60 | MemoryInputStream(const std::vector& data, b length = b(-1), b position = b(0)) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryInputStream.h:60:59: note: the first parameter in the range is 'length' + 60 | MemoryInputStream(const std::vector& data, b length = b(-1), b position = b(0)) : + | ^~~~~~ +./inet/common/MemoryInputStream.h:60:77: note: the last parameter in the range is 'position' + 60 | MemoryInputStream(const std::vector& data, b length = b(-1), b position = b(0)) : + | ^~~~~~~~ +./inet/common/MemoryInputStream.h:69:46: warning: 2 adjacent parameters of 'MemoryInputStream' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 69 | MemoryInputStream(const uint8_t *buffer, b length, b position = b(0)) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryInputStream.h:69:48: note: the first parameter in the range is 'length' + 69 | MemoryInputStream(const uint8_t *buffer, b length, b position = b(0)) : + | ^~~~~~ +./inet/common/MemoryInputStream.h:69:58: note: the last parameter in the range is 'position' + 69 | MemoryInputStream(const uint8_t *buffer, b length, b position = b(0)) : + | ^~~~~~~~ +./inet/common/MemoryInputStream.h:83:5: warning: function 'isReadBeyondEnd' should be marked [[nodiscard]] [modernize-use-nodiscard] + 83 | bool isReadBeyondEnd() const { return isReadBeyondEnd_; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:88:5: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | b getLength() const { return length; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:93:5: warning: function 'getRemainingLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 93 | b getRemainingLength() const { return length - position; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:98:5: warning: function 'getPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | b getPosition() const { return position; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:100:5: warning: function 'getData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | const std::vector& getData() const { return data; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:176:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 176 | return b(i); + | ^ +./inet/common/MemoryInputStream.h:210:29: warning: 2 adjacent parameters of 'readByteRepeatedly' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryInputStream.h:210:37: note: the first parameter in the range is 'value' + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryInputStream.h:210:51: note: the last parameter in the range is 'count' + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryInputStream.h:210:29: note: + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryInputStream.h:210:44: note: 'uint8_t' and 'size_t' may be implicitly converted: 'uint8_t' (as 'unsigned char') -> 'size_t' (as 'unsigned long'), 'size_t' (as 'unsigned long') -> 'uint8_t' (as 'unsigned char') + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryInputStream.h:459:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 459 | return Ipv6Address(d[0], d[1], d[2], d[3]); + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/MemoryOutputStream.h:9:9: warning: invalid case style for macro definition '__INET_MEMORYOUTPUTSTREAM_H' [readability-identifier-naming] + 9 | #define __INET_MEMORYOUTPUTSTREAM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MEMORYOUTPUTSTREAM_H +./inet/common/MemoryOutputStream.h:46:5: warning: function 'isByteAligned' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | bool isByteAligned() const { + | ^ + | [[nodiscard]] +./inet/common/MemoryOutputStream.h:64:5: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | b getLength() const { return length; } + | ^ + | [[nodiscard]] +./inet/common/MemoryOutputStream.h:70:5: warning: function 'getData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | const std::vector& getData() const { return data; } + | ^ + | [[nodiscard]] +./inet/common/MemoryOutputStream.h:166:30: warning: 2 adjacent parameters of 'writeByteRepeatedly' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryOutputStream.h:166:38: note: the first parameter in the range is 'value' + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryOutputStream.h:166:52: note: the last parameter in the range is 'count' + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryOutputStream.h:166:30: note: + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryOutputStream.h:166:45: note: 'uint8_t' and 'size_t' may be implicitly converted: 'uint8_t' (as 'unsigned char') -> 'size_t' (as 'unsigned long'), 'size_t' (as 'unsigned long') -> 'uint8_t' (as 'unsigned char') + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryOutputStream.h:398:31: warning: 2 adjacent parameters of 'writeNBitsOfUint64Be' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryOutputStream.h:398:40: note: the first parameter in the range is 'value' + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^~~~~ +./inet/common/MemoryOutputStream.h:398:55: note: the last parameter in the range is 'n' + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^ +./inet/common/MemoryOutputStream.h:398:31: note: + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^ +./inet/common/MemoryOutputStream.h:398:47: note: 'uint64_t' and 'uint8_t' may be implicitly converted: 'uint64_t' (as 'unsigned long') -> 'uint8_t' (as 'unsigned char'), 'uint8_t' (as 'unsigned char') -> 'uint64_t' (as 'unsigned long') + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^ +./inet/common/ModuleAccess.h:9:9: warning: invalid case style for macro definition '__INET_MODULEACCESS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEACCESS_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEACCESS_H +./inet/common/ModuleMixin.h:9:9: warning: invalid case style for macro definition '__INET_MODULEMIXIN_H' [readability-identifier-naming] + 9 | #define __INET_MODULEMIXIN_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_MODULEMIXIN_H +./inet/common/ModuleMixin.h:35:17: warning: use c++17 style variable templates [modernize-type-traits] + 35 | static_assert(std::is_base_of::value, "Type parameter of ModuleMixin must be a subclass of cModule"); + | ^ ~~~~~~~ + | _v +./inet/common/ModuleMixin.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void initialize() override { T::initialize(); } + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void initialize(int stage) override { T::initialize(stage); } + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void refreshDisplay() const override + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:51:5: warning: function 'resolveDirective' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual std::string resolveDirective(char directive) const override + | ^ + | [[nodiscard]] +./inet/common/ModuleMixin.h:51:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual std::string resolveDirective(char directive) const override + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:56:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual std::string resolveExpression(const char *expression) const override + | ~~~~~~~ ^ +./inet/common/ModuleRefByGate.h:9:9: warning: invalid case style for macro definition '__INET_MODULEREFBYGATE_H' [readability-identifier-naming] + 9 | #define __INET_MODULEREFBYGATE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEREFBYGATE_H +./inet/common/ModuleRefByGate.h:67:5: warning: function 'getNullable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 67 | const T *getNullable() const { return referencedModule.getNullable(); } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByGate.h:70:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | const T *get() const { checkReference(); return referencedModule.get(); } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByGate.h:74:5: warning: function 'getReferencingGate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | const cGate *getReferencingGate() const { return referencingGate; } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByGate.h:78:5: warning: function 'getReferencedGate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | const cGate *getReferencedGate() const { return referencedGate; } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByPar.h:9:9: warning: invalid case style for macro definition '__INET_MODULEREFBYPAR_H' [readability-identifier-naming] + 9 | #define __INET_MODULEREFBYPAR_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEREFBYPAR_H +./inet/common/ModuleRefByPar.h:70:5: warning: function 'getNullable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | const T *getNullable() const { return referencedModule.getNullable(); } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByPar.h:73:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | const T *get() const { checkReference(); return referencedModule.get(); } + | ^ + | [[nodiscard]] +./inet/common/ParsimPacking.h:8:9: warning: invalid case style for macro definition '__INET_PARSIMPACKING_H' [readability-identifier-naming] + 8 | #define __INET_PARSIMPACKING_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_PARSIMPACKING_H +./inet/common/ParsimPacking.h:28:31: warning: use c++14 style type templates [modernize-type-traits] + 28 | template::value, int>::type = 0> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/ParsimPacking.h:28:46: warning: use c++17 style variable templates [modernize-type-traits] + 28 | template::value, int>::type = 0> + | ^ ~~~~~~~ + | _v +./inet/common/ParsimPacking.h:39:31: warning: use c++14 style type templates [modernize-type-traits] + 39 | template::value && !std::is_const::value, int>::type = 0> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/ParsimPacking.h:39:46: warning: use c++17 style variable templates [modernize-type-traits] + 39 | template::value && !std::is_const::value, int>::type = 0> + | ^ ~~~~~~~ + | _v +./inet/common/ParsimPacking.h:39:85: warning: use c++17 style variable templates [modernize-type-traits] + 39 | template::value && !std::is_const::value, int>::type = 0> + | ^ ~~~~~~~ + | _v +./inet/common/Protocol.h:9:9: warning: invalid case style for macro definition '__INET_PROTOCOL_H' [readability-identifier-naming] + 9 | #define __INET_PROTOCOL_H + | ^~~~~~~~~~~~~~~~~ + | INET_PROTOCOL_H +./inet/common/Protocol.h:23:18: warning: invalid case style for enum constant 'PhysicalLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~~ + | PHYSICAL_LAYER +./inet/common/Protocol.h:23:33: warning: invalid case style for enum constant 'LinkLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~ + | LINK_LAYER +./inet/common/Protocol.h:23:44: warning: invalid case style for enum constant 'NetworkLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~ + | NETWORK_LAYER +./inet/common/Protocol.h:23:58: warning: invalid case style for enum constant 'TransportLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~~~ + | TRANSPORT_LAYER +./inet/common/Protocol.h:23:74: warning: invalid case style for enum constant 'UnspecifiedLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~~~~~ + | UNSPECIFIED_LAYER + 24 | + 25 | protected: + 26 | const int id; + 27 | const std::string name; + 28 | const std::string descriptiveName; + 29 | const Layer layer; + 30 | + 31 | public: + 32 | Protocol(const char *name, const char *descriptiveName, Layer layer = UnspecifiedLayer); + | ~~~~~~~~~~~~~~~~ + | UNSPECIFIED_LAYER +./inet/common/Protocol.h:37:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | int getId() const { return id; } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:38:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | const char *getName() const { return name.c_str(); } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:39:5: warning: function 'getDescriptiveName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | const char *getDescriptiveName() const { return descriptiveName.c_str(); } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:40:5: warning: function 'getLayer' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | Layer getLayer() const { return layer; } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:42:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:52:27: warning: invalid case style for global constant 'aodv' [readability-identifier-naming] + 52 | static const Protocol aodv; + | ^~~~ + | AODV +./inet/common/Protocol.h:53:27: warning: invalid case style for global constant 'arp' [readability-identifier-naming] + 53 | static const Protocol arp; + | ^~~ + | ARP +./inet/common/Protocol.h:54:27: warning: invalid case style for global constant 'babel' [readability-identifier-naming] + 54 | static const Protocol babel; + | ^~~~~ + | BABEL +./inet/common/Protocol.h:55:27: warning: invalid case style for global constant 'bgp' [readability-identifier-naming] + 55 | static const Protocol bgp; + | ^~~ + | BGP +./inet/common/Protocol.h:56:27: warning: invalid case style for global constant 'bmac' [readability-identifier-naming] + 56 | static const Protocol bmac; + | ^~~~ + | BMAC +./inet/common/Protocol.h:57:27: warning: invalid case style for global constant 'cdp' [readability-identifier-naming] + 57 | static const Protocol cdp; + | ^~~ + | CDP +./inet/common/Protocol.h:58:27: warning: invalid case style for global constant 'clns' [readability-identifier-naming] + 58 | static const Protocol clns; + | ^~~~ + | CLNS +./inet/common/Protocol.h:59:27: warning: invalid case style for global constant 'dhcp' [readability-identifier-naming] + 59 | static const Protocol dhcp; + | ^~~~ + | DHCP +./inet/common/Protocol.h:60:27: warning: invalid case style for global constant 'dsdv2' [readability-identifier-naming] + 60 | static const Protocol dsdv2; + | ^~~~~ + | DSDV2 +./inet/common/Protocol.h:61:27: warning: invalid case style for global constant 'dsr' [readability-identifier-naming] + 61 | static const Protocol dsr; + | ^~~ + | DSR +./inet/common/Protocol.h:62:27: warning: invalid case style for global constant 'dymo' [readability-identifier-naming] + 62 | static const Protocol dymo; + | ^~~~ + | DYMO +./inet/common/Protocol.h:63:27: warning: invalid case style for global constant 'egp' [readability-identifier-naming] + 63 | static const Protocol egp; + | ^~~ + | EGP +./inet/common/Protocol.h:64:27: warning: invalid case style for global constant 'eigrp' [readability-identifier-naming] + 64 | static const Protocol eigrp; + | ^~~~~ + | EIGRP +./inet/common/Protocol.h:65:27: warning: invalid case style for global constant 'ethernetFlowCtrl' [readability-identifier-naming] + 65 | static const Protocol ethernetFlowCtrl; + | ^~~~~~~~~~~~~~~~ + | ETHERNET_FLOW_CTRL +./inet/common/Protocol.h:66:27: warning: invalid case style for global constant 'ethernetMac' [readability-identifier-naming] + 66 | static const Protocol ethernetMac; + | ^~~~~~~~~~~ + | ETHERNET_MAC +./inet/common/Protocol.h:67:27: warning: invalid case style for global constant 'ethernetPhy' [readability-identifier-naming] + 67 | static const Protocol ethernetPhy; + | ^~~~~~~~~~~ + | ETHERNET_PHY +./inet/common/Protocol.h:68:27: warning: invalid case style for global constant 'ftp' [readability-identifier-naming] + 68 | static const Protocol ftp; + | ^~~ + | FTP +./inet/common/Protocol.h:69:27: warning: invalid case style for global constant 'gpsr' [readability-identifier-naming] + 69 | static const Protocol gpsr; + | ^~~~ + | GPSR +./inet/common/Protocol.h:70:27: warning: invalid case style for global constant 'gptp' [readability-identifier-naming] + 70 | static const Protocol gptp; + | ^~~~ + | GPTP +./inet/common/Protocol.h:71:27: warning: invalid case style for global constant 'http' [readability-identifier-naming] + 71 | static const Protocol http; + | ^~~~ + | HTTP +./inet/common/Protocol.h:72:27: warning: invalid case style for global constant 'icmpv4' [readability-identifier-naming] + 72 | static const Protocol icmpv4; + | ^~~~~~ + | ICMPV4 +./inet/common/Protocol.h:73:27: warning: invalid case style for global constant 'icmpv6' [readability-identifier-naming] + 73 | static const Protocol icmpv6; + | ^~~~~~ + | ICMPV6 +./inet/common/Protocol.h:74:27: warning: invalid case style for global constant 'ieee80211DsssPhy' [readability-identifier-naming] + 74 | static const Protocol ieee80211DsssPhy; + | ^~~~~~~~~~~~~~~~ + | IEEE80211_DSSS_PHY +./inet/common/Protocol.h:75:27: warning: invalid case style for global constant 'ieee80211ErpOfdmPhy' [readability-identifier-naming] + 75 | static const Protocol ieee80211ErpOfdmPhy; + | ^~~~~~~~~~~~~~~~~~~ + | IEEE80211_ERP_OFDM_PHY +./inet/common/Protocol.h:76:27: warning: invalid case style for global constant 'ieee80211FhssPhy' [readability-identifier-naming] + 76 | static const Protocol ieee80211FhssPhy; + | ^~~~~~~~~~~~~~~~ + | IEEE80211_FHSS_PHY +./inet/common/Protocol.h:77:27: warning: invalid case style for global constant 'ieee80211HrDsssPhy' [readability-identifier-naming] + 77 | static const Protocol ieee80211HrDsssPhy; + | ^~~~~~~~~~~~~~~~~~ + | IEEE80211_HR_DSSS_PHY +./inet/common/Protocol.h:78:27: warning: invalid case style for global constant 'ieee80211HtPhy' [readability-identifier-naming] + 78 | static const Protocol ieee80211HtPhy; + | ^~~~~~~~~~~~~~ + | IEEE80211_HT_PHY +./inet/common/Protocol.h:79:27: warning: invalid case style for global constant 'ieee80211IrPhy' [readability-identifier-naming] + 79 | static const Protocol ieee80211IrPhy; + | ^~~~~~~~~~~~~~ + | IEEE80211_IR_PHY +./inet/common/Protocol.h:80:27: warning: invalid case style for global constant 'ieee80211Mac' [readability-identifier-naming] + 80 | static const Protocol ieee80211Mac; + | ^~~~~~~~~~~~ + | IEEE80211_MAC +./inet/common/Protocol.h:81:27: warning: invalid case style for global constant 'ieee80211Mgmt' [readability-identifier-naming] + 81 | static const Protocol ieee80211Mgmt; + | ^~~~~~~~~~~~~ + | IEEE80211_MGMT +./inet/common/Protocol.h:82:27: warning: invalid case style for global constant 'ieee80211OfdmPhy' [readability-identifier-naming] + 82 | static const Protocol ieee80211OfdmPhy; + | ^~~~~~~~~~~~~~~~ + | IEEE80211_OFDM_PHY +./inet/common/Protocol.h:83:27: warning: invalid case style for global constant 'ieee80211VhtPhy' [readability-identifier-naming] + 83 | static const Protocol ieee80211VhtPhy; + | ^~~~~~~~~~~~~~~ + | IEEE80211_VHT_PHY +./inet/common/Protocol.h:84:27: warning: invalid case style for global constant 'ieee802154' [readability-identifier-naming] + 84 | static const Protocol ieee802154; + | ^~~~~~~~~~ + | IEEE802154 +./inet/common/Protocol.h:85:27: warning: invalid case style for global constant 'ieee8021ae' [readability-identifier-naming] + 85 | static const Protocol ieee8021ae; + | ^~~~~~~~~~ + | IEEE8021AE +./inet/common/Protocol.h:86:27: warning: invalid case style for global constant 'ieee8021qCTag' [readability-identifier-naming] + 86 | static const Protocol ieee8021qCTag; + | ^~~~~~~~~~~~~ + | IEEE8021Q_C_TAG +./inet/common/Protocol.h:87:27: warning: invalid case style for global constant 'ieee8021qCFM' [readability-identifier-naming] + 87 | static const Protocol ieee8021qCFM; + | ^~~~~~~~~~~~ + | IEEE8021Q_CFM +./inet/common/Protocol.h:88:27: warning: invalid case style for global constant 'ieee8021qSTag' [readability-identifier-naming] + 88 | static const Protocol ieee8021qSTag; + | ^~~~~~~~~~~~~ + | IEEE8021Q_S_TAG +./inet/common/Protocol.h:89:27: warning: invalid case style for global constant 'ieee8021rTag' [readability-identifier-naming] + 89 | static const Protocol ieee8021rTag; + | ^~~~~~~~~~~~ + | IEEE8021R_TAG +./inet/common/Protocol.h:90:27: warning: invalid case style for global constant 'ieee8022llc' [readability-identifier-naming] + 90 | static const Protocol ieee8022llc; + | ^~~~~~~~~~~ + | IEEE8022LLC +./inet/common/Protocol.h:91:27: warning: invalid case style for global constant 'ieee8022snap' [readability-identifier-naming] + 91 | static const Protocol ieee8022snap; + | ^~~~~~~~~~~~ + | IEEE8022SNAP +./inet/common/Protocol.h:92:27: warning: invalid case style for global constant 'ieee802epd' [readability-identifier-naming] + 92 | static const Protocol ieee802epd; + | ^~~~~~~~~~ + | IEEE802EPD +./inet/common/Protocol.h:93:27: warning: invalid case style for global constant 'igmp' [readability-identifier-naming] + 93 | static const Protocol igmp; + | ^~~~ + | IGMP +./inet/common/Protocol.h:94:27: warning: invalid case style for global constant 'igp' [readability-identifier-naming] + 94 | static const Protocol igp; + | ^~~ + | IGP +./inet/common/Protocol.h:95:27: warning: invalid case style for global constant 'ipv4' [readability-identifier-naming] + 95 | static const Protocol ipv4; + | ^~~~ + | IPV4 +./inet/common/Protocol.h:96:27: warning: invalid case style for global constant 'ipv6' [readability-identifier-naming] + 96 | static const Protocol ipv6; + | ^~~~ + | IPV6 +./inet/common/Protocol.h:97:27: warning: invalid case style for global constant 'ipsecAh' [readability-identifier-naming] + 97 | static const Protocol ipsecAh; + | ^~~~~~~ + | IPSEC_AH +./inet/common/Protocol.h:98:27: warning: invalid case style for global constant 'ipsecEsp' [readability-identifier-naming] + 98 | static const Protocol ipsecEsp; + | ^~~~~~~~ + | IPSEC_ESP +./inet/common/Protocol.h:99:27: warning: invalid case style for global constant 'isis' [readability-identifier-naming] + 99 | static const Protocol isis; + | ^~~~ + | ISIS +./inet/common/Protocol.h:100:27: warning: invalid case style for global constant 'l2isis' [readability-identifier-naming] + 100 | static const Protocol l2isis; + | ^~~~~~ + | L2ISIS +./inet/common/Protocol.h:101:27: warning: invalid case style for global constant 'lldp' [readability-identifier-naming] + 101 | static const Protocol lldp; + | ^~~~ + | LLDP +./inet/common/Protocol.h:102:27: warning: invalid case style for global constant 'lmac' [readability-identifier-naming] + 102 | static const Protocol lmac; + | ^~~~ + | LMAC +./inet/common/Protocol.h:103:27: warning: invalid case style for global constant 'manet' [readability-identifier-naming] + 103 | static const Protocol manet; + | ^~~~~ + | MANET +./inet/common/Protocol.h:104:27: warning: invalid case style for global constant 'mld' [readability-identifier-naming] + 104 | static const Protocol mld; + | ^~~ + | MLD +./inet/common/Protocol.h:105:27: warning: invalid case style for global constant 'mobileipv6' [readability-identifier-naming] + 105 | static const Protocol mobileipv6; + | ^~~~~~~~~~ + | MOBILEIPV6 +./inet/common/Protocol.h:106:27: warning: invalid case style for global constant 'mpls' [readability-identifier-naming] + 106 | static const Protocol mpls; + | ^~~~ + | MPLS +./inet/common/Protocol.h:107:27: warning: invalid case style for global constant 'mrp' [readability-identifier-naming] + 107 | static const Protocol mrp; + | ^~~ + | MRP +./inet/common/Protocol.h:108:27: warning: invalid case style for global constant 'ospf' [readability-identifier-naming] + 108 | static const Protocol ospf; + | ^~~~ + | OSPF +./inet/common/Protocol.h:109:27: warning: invalid case style for global constant 'pim' [readability-identifier-naming] + 109 | static const Protocol pim; + | ^~~ + | PIM +./inet/common/Protocol.h:110:27: warning: invalid case style for global constant 'ppp' [readability-identifier-naming] + 110 | static const Protocol ppp; + | ^~~ + | PPP +./inet/common/Protocol.h:111:27: warning: invalid case style for global constant 'quic' [readability-identifier-naming] + 111 | static const Protocol quic; + | ^~~~ + | QUIC +./inet/common/Protocol.h:112:27: warning: invalid case style for global constant 'rip' [readability-identifier-naming] + 112 | static const Protocol rip; + | ^~~ + | RIP +./inet/common/Protocol.h:113:27: warning: invalid case style for global constant 'rtcp' [readability-identifier-naming] + 113 | static const Protocol rtcp; + | ^~~~ + | RTCP +./inet/common/Protocol.h:114:27: warning: invalid case style for global constant 'rtp' [readability-identifier-naming] + 114 | static const Protocol rtp; + | ^~~ + | RTP +./inet/common/Protocol.h:115:27: warning: invalid case style for global constant 'rsvpTe' [readability-identifier-naming] + 115 | static const Protocol rsvpTe; + | ^~~~~~ + | RSVP_TE +./inet/common/Protocol.h:116:27: warning: invalid case style for global constant 'rtsp' [readability-identifier-naming] + 116 | static const Protocol rtsp; + | ^~~~ + | RTSP +./inet/common/Protocol.h:117:27: warning: invalid case style for global constant 'sctp' [readability-identifier-naming] + 117 | static const Protocol sctp; + | ^~~~ + | SCTP +./inet/common/Protocol.h:118:27: warning: invalid case style for global constant 'srp' [readability-identifier-naming] + 118 | static const Protocol srp; + | ^~~ + | SRP +./inet/common/Protocol.h:119:27: warning: invalid case style for global constant 'ssh' [readability-identifier-naming] + 119 | static const Protocol ssh; + | ^~~ + | SSH +./inet/common/Protocol.h:120:27: warning: invalid case style for global constant 'stp' [readability-identifier-naming] + 120 | static const Protocol stp; + | ^~~ + | STP +./inet/common/Protocol.h:121:27: warning: invalid case style for global constant 'tcp' [readability-identifier-naming] + 121 | static const Protocol tcp; + | ^~~ + | TCP +./inet/common/Protocol.h:122:27: warning: invalid case style for global constant 'telnet' [readability-identifier-naming] + 122 | static const Protocol telnet; + | ^~~~~~ + | TELNET +./inet/common/Protocol.h:123:27: warning: invalid case style for global constant 'trill' [readability-identifier-naming] + 123 | static const Protocol trill; + | ^~~~~ + | TRILL +./inet/common/Protocol.h:124:27: warning: invalid case style for global constant 'tsn' [readability-identifier-naming] + 124 | static const Protocol tsn; // ieee1722, AVB, TSN + | ^~~ + | TSN +./inet/common/Protocol.h:125:27: warning: invalid case style for global constant 'tteth' [readability-identifier-naming] + 125 | static const Protocol tteth; // SAE AS6802, TTEthernet + | ^~~~~ + | TTETH +./inet/common/Protocol.h:126:27: warning: invalid case style for global constant 'udp' [readability-identifier-naming] + 126 | static const Protocol udp; + | ^~~ + | UDP +./inet/common/Protocol.h:127:27: warning: invalid case style for global constant 'xmac' [readability-identifier-naming] + 127 | static const Protocol xmac; + | ^~~~ + | XMAC +./inet/common/Protocol.h:128:27: warning: invalid case style for global constant 'xtp' [readability-identifier-naming] + 128 | static const Protocol xtp; + | ^~~ + | XTP +./inet/common/Protocol.h:131:27: warning: invalid case style for global constant 'ackingMac' [readability-identifier-naming] + 131 | static const Protocol ackingMac; + | ^~~~~~~~~ + | ACKING_MAC +./inet/common/Protocol.h:132:27: warning: invalid case style for global constant 'apskPhy' [readability-identifier-naming] + 132 | static const Protocol apskPhy; + | ^~~~~~~ + | APSK_PHY +./inet/common/Protocol.h:133:27: warning: invalid case style for global constant 'csmaCaMac' [readability-identifier-naming] + 133 | static const Protocol csmaCaMac; + | ^~~~~~~~~ + | CSMA_CA_MAC +./inet/common/Protocol.h:134:27: warning: invalid case style for global constant 'echo' [readability-identifier-naming] + 134 | static const Protocol echo; + | ^~~~ + | ECHO +./inet/common/Protocol.h:135:27: warning: invalid case style for global constant 'flooding' [readability-identifier-naming] + 135 | static const Protocol flooding; + | ^~~~~~~~ + | FLOODING +./inet/common/Protocol.h:136:27: warning: invalid case style for global constant 'linkStateRouting' [readability-identifier-naming] + 136 | static const Protocol linkStateRouting; + | ^~~~~~~~~~~~~~~~ + | LINK_STATE_ROUTING +./inet/common/Protocol.h:137:27: warning: invalid case style for global constant 'nextHopForwarding' [readability-identifier-naming] + 137 | static const Protocol nextHopForwarding; + | ^~~~~~~~~~~~~~~~~ + | NEXT_HOP_FORWARDING +./inet/common/Protocol.h:138:27: warning: invalid case style for global constant 'probabilistic' [readability-identifier-naming] + 138 | static const Protocol probabilistic; + | ^~~~~~~~~~~~~ + | PROBABILISTIC +./inet/common/Protocol.h:139:27: warning: invalid case style for global constant 'shortcutMac' [readability-identifier-naming] + 139 | static const Protocol shortcutMac; + | ^~~~~~~~~~~ + | SHORTCUT_MAC +./inet/common/Protocol.h:140:27: warning: invalid case style for global constant 'shortcutPhy' [readability-identifier-naming] + 140 | static const Protocol shortcutPhy; + | ^~~~~~~~~~~ + | SHORTCUT_PHY +./inet/common/Protocol.h:141:27: warning: invalid case style for global constant 'genericPhy' [readability-identifier-naming] + 141 | static const Protocol genericPhy; + | ^~~~~~~~~~ + | GENERIC_PHY +./inet/common/Protocol.h:142:27: warning: invalid case style for global constant 'unknown' [readability-identifier-naming] + 142 | static const Protocol unknown; + | ^~~~~~~ + | UNKNOWN +./inet/common/Protocol.h:143:27: warning: invalid case style for global constant 'wiseRoute' [readability-identifier-naming] + 143 | static const Protocol wiseRoute; + | ^~~~~~~~~ + | WISE_ROUTE +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/Ptr.h:9:9: warning: invalid case style for macro definition '__INET_PTR_H' [readability-identifier-naming] + 9 | #define __INET_PTR_H + | ^~~~~~~~~~~~ + | INET_PTR_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/Ptr.h:104:8: warning: invalid case style for function '__checknull' [readability-identifier-naming] + 104 | Ptr __checknull(const Ptr& p, const char *expr, const char *file, int line) + | ^~~~~~~~~~~ + | checknull +./inet/common/ShortBitVector.h:9:9: warning: invalid case style for macro definition '__INET_SHORTBITVECTOR_H' [readability-identifier-naming] + 9 | #define __INET_SHORTBITVECTOR_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_SHORTBITVECTOR_H +./inet/common/ShortBitVector.h:38:5: warning: function 'toDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | inline unsigned int toDecimal() const { return bits; } + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:40:5: warning: function 'reverseToDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | inline unsigned int reverseToDecimal() const + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:60:5: warning: function 'getBit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | inline bool getBit(unsigned int pos) const + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:92:5: warning: function 'isEmpty' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | inline bool isEmpty() const { return size == 0; } + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:94:5: warning: function 'getSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 94 | inline unsigned int getSize() const { return size; } + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:96:5: warning: function 'computeHammingDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | inline unsigned int computeHammingDistance(const ShortBitVector& u) const + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:122:5: warning: function 'toString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | std::string toString() const; + | ^ + | [[nodiscard]] +./inet/common/SimpleModule.h:9:9: warning: invalid case style for macro definition '__INET_SIMPLEMODULE_H' [readability-identifier-naming] + 9 | #define __INET_SIMPLEMODULE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_SIMPLEMODULE_H +./inet/common/SimpleModule.h:20:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 20 | virtual void initialize() override; + | ~~~~~~~ ^ +./inet/common/SimpleModule.h:21:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 21 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/common/Simsignals.h:9:9: warning: invalid case style for macro definition '__INET_SIMSIGNALS_H' [readability-identifier-naming] + 9 | #define __INET_SIMSIGNALS_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_SIMSIGNALS_H +./inet/common/Simsignals_m.h:6:9: warning: invalid case style for macro definition '__INET_SIMSIGNALS_M_H' [readability-identifier-naming] + 6 | #define __INET_SIMSIGNALS_M_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_SIMSIGNALS_M_H +./inet/common/Simsignals_m.h:110:10: warning: deleted member function should be public [modernize-use-equals-delete] + 110 | bool operator==(const PacketDropDetails&) = delete; + | ^ +./inet/common/Simsignals_m.h:115:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 115 | virtual ~PacketDropDetails(); + | ~~~~~~~ ^ + | override +./inet/common/Simsignals_m.h:117:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 117 | virtual PacketDropDetails *dup() const override {return new PacketDropDetails(*this);} + | ^ + | [[nodiscard]] +./inet/common/Simsignals_m.h:117:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 117 | virtual PacketDropDetails *dup() const override {return new PacketDropDetails(*this);} + | ~~~~~~~ ^ +./inet/common/Simsignals_m.h:118:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 118 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/common/Simsignals_m.h:119:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 119 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/common/Simsignals_m.h:121:5: warning: function 'getReason' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | virtual PacketDropReason getReason() const; + | ^ + | [[nodiscard]] +./inet/common/Simsignals_m.h:124:5: warning: function 'getLimit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | virtual int getLimit() const; + | ^ + | [[nodiscard]] +./inet/common/StringFormat.h:9:9: warning: invalid case style for macro definition '__INET_STRINGFORMAT_H' [readability-identifier-naming] + 9 | #define __INET_STRINGFORMAT_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_STRINGFORMAT_H +./inet/common/StringFormat.h:22:9: warning: function 'resolveDirective' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual std::string resolveDirective(char directive) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:9:9: warning: invalid case style for macro definition '__INET_TAGBASE_H' [readability-identifier-naming] + 9 | #define __INET_TAGBASE_H + | ^~~~~~~~~~~~~~~~ + | INET_TAGBASE_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:24:45: warning: 2 adjacent parameters of 'changeRegion' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 24 | virtual const Ptr changeRegion(b offsetDelta, b lengthDelta) const { return const_cast(this)->shared_from_this(); } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:24:47: note: the first parameter in the range is 'offsetDelta' + 24 | virtual const Ptr changeRegion(b offsetDelta, b lengthDelta) const { return const_cast(this)->shared_from_this(); } + | ^~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:24:62: note: the last parameter in the range is 'lengthDelta' + 24 | virtual const Ptr changeRegion(b offsetDelta, b lengthDelta) const { return const_cast(this)->shared_from_this(); } + | ^~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:26:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual void parsimPack(cCommBuffer *buffer) const override {} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:27:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual void parsimUnpack(cCommBuffer *buffer) override {} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:29:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual std::ostream& printToStream(std::ostream &stream, int level, int evFlags) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:33:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/common/TagBase_m.h:6:9: warning: invalid case style for macro definition '__INET_TAGBASE_M_H' [readability-identifier-naming] + 6 | #define __INET_TAGBASE_M_H + | ^~~~~~~~~~~~~~~~~~ + | INET_TAGBASE_M_H +./inet/common/TemporarySharedPtr.h:9:9: warning: invalid case style for macro definition '__INET_TEMPORARYSHAREDPTR_H' [readability-identifier-naming] + 9 | #define __INET_TEMPORARYSHAREDPTR_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_TEMPORARYSHAREDPTR_H +./inet/common/TemporarySharedPtr.h:29:5: warning: function 'getObjectPointer' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | any_ptr getObjectPointer(any_ptr object) const { return toAnyPtr(const_cast(getSharedPtr(object).get())); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:34:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual bool doesSupport(cObject *object) const override { return classDescriptor->doesSupport(fromAnyPtr(getObjectPointer(toAnyPtr(object)))); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:35:5: warning: function 'getBaseClassDescriptor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual cClassDescriptor *getBaseClassDescriptor() const override { return classDescriptor->getBaseClassDescriptor(); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:35:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual cClassDescriptor *getBaseClassDescriptor() const override { return classDescriptor->getBaseClassDescriptor(); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:36:5: warning: function 'getPropertyNames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const char **getPropertyNames() const override { return classDescriptor->getPropertyNames(); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:36:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual const char **getPropertyNames() const override { return classDescriptor->getPropertyNames(); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:37:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual const char *getProperty(const char *propertyname) const override { return classDescriptor->getProperty(propertyname); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:38:5: warning: function 'getFieldCount' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getFieldCount() const override { return classDescriptor->getFieldCount(); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:38:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual int getFieldCount() const override { return classDescriptor->getFieldCount(); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:39:5: warning: function 'getFieldName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual const char *getFieldName(int field) const override { return classDescriptor->getFieldName(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:39:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual const char *getFieldName(int field) const override { return classDescriptor->getFieldName(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:40:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual int findField(const char *fieldName) const override { return classDescriptor->findField(fieldName); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:41:5: warning: function 'getFieldTypeFlags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual unsigned int getFieldTypeFlags(int field) const override { return classDescriptor->getFieldTypeFlags(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:41:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual unsigned int getFieldTypeFlags(int field) const override { return classDescriptor->getFieldTypeFlags(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:42:5: warning: function 'getFieldDeclaredOn' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual const char *getFieldDeclaredOn(int field) const override { return classDescriptor->getFieldDeclaredOn(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:42:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual const char *getFieldDeclaredOn(int field) const override { return classDescriptor->getFieldDeclaredOn(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:43:5: warning: function 'getFieldTypeString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual const char *getFieldTypeString(int field) const override { return classDescriptor->getFieldTypeString(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:43:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual const char *getFieldTypeString(int field) const override { return classDescriptor->getFieldTypeString(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:44:5: warning: function 'getFieldPropertyNames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const char **getFieldPropertyNames(int field) const override { return classDescriptor->getFieldPropertyNames(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:44:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual const char **getFieldPropertyNames(int field) const override { return classDescriptor->getFieldPropertyNames(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:45:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual const char *getFieldProperty(int field, const char *propertyname) const override { return classDescriptor->getFieldProperty(field, propertyname); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:46:5: warning: function 'getFieldArraySize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual int getFieldArraySize(any_ptr object, int field) const override { return classDescriptor->getFieldArraySize(getObjectPointer(object), field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:46:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual int getFieldArraySize(any_ptr object, int field) const override { return classDescriptor->getFieldArraySize(getObjectPointer(object), field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:47:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 47 | virtual void setFieldArraySize(any_ptr object, int field, int size) const override { classDescriptor->setFieldArraySize(getObjectPointer(object), field, size); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:48:5: warning: function 'getFieldDynamicTypeString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual const char *getFieldDynamicTypeString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldDynamicTypeString(getObjectPointer(object), field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:48:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual const char *getFieldDynamicTypeString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldDynamicTypeString(getObjectPointer(object), field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:49:5: warning: function 'getFieldValueAsString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 49 | virtual std::string getFieldValueAsString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValueAsString(getObjectPointer(object), field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:49:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual std::string getFieldValueAsString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValueAsString(getObjectPointer(object), field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void setFieldValueAsString(any_ptr object, int field, int i, const char *value) const override { classDescriptor->setFieldValueAsString(getObjectPointer(object), field, i, value); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:51:5: warning: function 'getFieldStructName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual const char *getFieldStructName(int field) const override { return classDescriptor->getFieldStructName(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:51:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const char *getFieldStructName(int field) const override { return classDescriptor->getFieldStructName(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:52:5: warning: function 'getFieldStructValuePointer' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual any_ptr getFieldStructValuePointer(any_ptr object, int field, int i) const override { return classDescriptor->getFieldStructValuePointer(getObjectPointer(object), field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:52:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual any_ptr getFieldStructValuePointer(any_ptr object, int field, int i) const override { return classDescriptor->getFieldStructValuePointer(getObjectPointer(object), field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void setFieldStructValuePointer(any_ptr object, int field, int i, any_ptr ptr) const override { classDescriptor->setFieldStructValuePointer(getObjectPointer(object), field, i, ptr); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:54:5: warning: function 'getFieldValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual cValue getFieldValue(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValue(object, field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:54:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual cValue getFieldValue(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValue(object, field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void setFieldValue(any_ptr object, int field, int i, const cValue& value) const override { classDescriptor->setFieldValue(object, field, i, value); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:71:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 71 | virtual ~TemporarySharedPtr() { delete classDescriptor; } + | ~~~~~~~ ^ + | override +./inet/common/TemporarySharedPtr.h:73:5: warning: function 'getObject' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | const Ptr& getObject() const { return object; } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:74:5: warning: function 'getDescriptor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual cClassDescriptor *getDescriptor() const override { return classDescriptor; } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:74:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual cClassDescriptor *getDescriptor() const override { return classDescriptor; } + | ~~~~~~~ ^ +./inet/common/Units.h:23:9: warning: invalid case style for macro definition '__INET_UNITS_H' [readability-identifier-naming] + 23 | #define __INET_UNITS_H + | ^~~~~~~~~~~~~~ + | INET_UNITS_H +./inet/common/Units.h:40:43: warning: invalid case style for struct 'convert' [readability-identifier-naming] + 40 | template struct convert; + | ^~~~~~~ + | Convert +./inet/common/Units.h:47:8: warning: invalid case style for struct 'fixed_power' [readability-identifier-naming] + 47 | struct fixed_power; + | ^~~~~~~~~~~ + | FixedPower +./inet/common/Units.h:76:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 76 | typedef pow unit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using unit = pow +./inet/common/Units.h:76:32: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 76 | typedef pow unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:82:7: warning: invalid case style for class 'value' [readability-identifier-naming] + 82 | class value + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:88:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 88 | typedef Value value_type; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using value_type = Value +./inet/common/Units.h:88:19: warning: invalid case style for typedef 'value_type' [readability-identifier-naming] + 88 | typedef Value value_type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:89:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 89 | typedef Units unit; + | ^~~~~~~~~~~~~~~~~~ + | using unit = Units +./inet/common/Units.h:89:19: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 89 | typedef Units unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:108:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | std::string str() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get>>' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get>>' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get>' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:121:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | const value_type& get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:139:88: warning: use c++14 style type templates [modernize-type-traits] + 139 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:159:88: warning: use c++14 style type templates [modernize-type-traits] + 159 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:170:88: warning: use c++14 style type templates [modernize-type-traits] + 170 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:189:88: warning: use c++14 style type templates [modernize-type-traits] + 189 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:270:16: warning: invalid case style for private member 'm_rep' [readability-identifier-naming] + 91 | --m_rep; + | ~~~~~ + | mRep + 92 | return *this; + 93 | } + 94 | + 95 | value operator--(int) + 96 | { + 97 | value v = *this; + 98 | --m_rep; + | ~~~~~ + | mRep + 99 | return v; + 100 | } + 101 | + 102 | private: + 103 | value_type m_rep; + | ^~~~~ + | mRep +./inet/common/Units.h:316:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 316 | namespace units { + | ^~~~~~~~~~~~~~~~~ + 317 | + 318 | namespace internal { + | ~~~~~~~~~~~~~~~~~~ + | namespace units::internal +./inet/common/Units.h:326:8: warning: invalid case style for struct 'convertible' [readability-identifier-naming] + 326 | struct convertible; + | ^~~~~~~~~~~ + | Convertible +./inet/common/Units.h:330:8: warning: invalid case style for struct 'scaling_factor' [readability-identifier-naming] + 330 | struct scaling_factor; + | ^~~~~~~~~~~~~~ + | ScalingFactor + 331 | + 332 | // Converts T1 to T2. + 333 | // Stage 3 - performed after Stage 1 and Stage 2. + 334 | // The reason we perform convert in stages is so that the compiler + 335 | // can resolve templates in the order we want it to. + 336 | template + 337 | struct convert3 + 338 | { + 339 | // The default implementation assumes that the two quantities are in compatible + 340 | // units up to some scaling factor. Find the scaling factor and apply it. + 341 | template + 342 | static V fn(const V& v) + 343 | { + 344 | return v * scaling_factor::template fn() / scaling_factor::template fn(); + | ~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~ + | ScalingFactor ScalingFactor +./inet/common/Units.h:337:8: warning: invalid case style for struct 'convert3' [readability-identifier-naming] + 337 | struct convert3 + | ^~~~~~~~ + | Convert3 +./inet/common/Units.h:352:8: warning: invalid case style for struct 'convert2' [readability-identifier-naming] + 352 | struct convert2 + | ^~~~~~~~ + | Convert2 +./inet/common/Units.h:369:54: warning: invalid case style for public member 'check_convertible' [readability-identifier-naming] + 369 | legacy_static_assert::value> check_convertible; + | ^~~~~~~~~~~~~~~~~ + | checkConvertible +./inet/common/Units.h:384:45: warning: returning a constant reference parameter may cause use-after-free when the parameter is constructed from a temporary [bugprone-return-const-ref-from-parameter] + 384 | static const U& fn(const U& u) { return u; } + | ^ +./inet/common/Units.h:392:45: warning: returning a constant reference parameter may cause use-after-free when the parameter is constructed from a temporary [bugprone-return-const-ref-from-parameter] + 392 | static const U& fn(const U& u) { return u; } + | ^ +./inet/common/Units.h:495:8: warning: invalid case style for struct 'count_terms' [readability-identifier-naming] + 495 | struct count_terms + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:497:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 497 | static const int num = 0; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:498:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 498 | static const int den = 1; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:504:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 504 | static const int num = 1; + | ^~~ + | NUM + 505 | static const int den = 1; + 506 | }; + 507 | + 508 | // count_terms ignores scaling factors - that is taken care of by scaling_factor. + 509 | template + 510 | struct count_terms> + 511 | { + 512 | typedef count_terms result; + 513 | static const int num = result::num; + | ~~~ + | NUM +./inet/common/Units.h:505:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 505 | static const int den = 1; + | ^~~ + | DEN + 506 | }; + 507 | + 508 | // count_terms ignores scaling factors - that is taken care of by scaling_factor. + 509 | template + 510 | struct count_terms> + 511 | { + 512 | typedef count_terms result; + 513 | static const int num = result::num; + 514 | static const int den = result::den; + | ~~~ + | DEN +./inet/common/Units.h:512:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 512 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:512:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 512 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:513:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 513 | static const int num = result::num; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:514:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 514 | static const int den = result::den; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:520:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 520 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:520:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 520 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:521:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 521 | static const int num = result::num; + | ^~~ + | NUM +./inet/common/Units.h:522:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 522 | static const int den = result::den; + | ^~~ + | DEN +./inet/common/Units.h:529:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 529 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:529:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 529 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:530:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 530 | static const int num = result::num; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:531:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 531 | static const int den = result::den; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:538:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 538 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:538:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 538 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:539:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 539 | static const int num = result::num; + | ^~~ + | NUM +./inet/common/Units.h:540:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 540 | static const int den = result::den; + | ^~~ + | DEN +./inet/common/Units.h:547:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 547 | typedef count_terms result1; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result1 = count_terms +./inet/common/Units.h:547:35: warning: invalid case style for typedef 'result1' [readability-identifier-naming] + 547 | typedef count_terms result1; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:548:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 548 | typedef count_terms result2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result2 = count_terms +./inet/common/Units.h:548:35: warning: invalid case style for typedef 'result2' [readability-identifier-naming] + 548 | typedef count_terms result2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:549:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 549 | static const int num = + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:551:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 551 | static const int den = + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:559:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 559 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:559:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 559 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:560:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 560 | static const int num = N * result::num; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:561:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 561 | static const int den = D * result::den; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:569:8: warning: invalid case style for struct 'check_terms_equal' [readability-identifier-naming] + 569 | struct check_terms_equal + | ^~~~~~~~~~~~~~~~~ + | CheckTermsEqual + 570 | { + 571 | typedef count_terms count1; + 572 | typedef count_terms count2; + 573 | + 574 | static const bool value = + 575 | count1::num * count2::den == + 576 | count1::den * count2::num; + 577 | }; + 578 | + 579 | template + 580 | struct check_terms_equal, T1, T2> + 581 | { + 582 | static const bool value = check_terms_equal::value; + | ~~~~~~~~~~~~~~~~~ + | CheckTermsEqual +./inet/common/Units.h:571:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 571 | typedef count_terms count1; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using count1 = count_terms +./inet/common/Units.h:571:35: warning: invalid case style for typedef 'count1' [readability-identifier-naming] + 571 | typedef count_terms count1; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:572:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 572 | typedef count_terms count2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using count2 = count_terms +./inet/common/Units.h:572:35: warning: invalid case style for typedef 'count2' [readability-identifier-naming] + 572 | typedef count_terms count2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:574:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 574 | static const bool value = + | ^~~~~ + | VALUE + 575 | count1::num * count2::den == + 576 | count1::den * count2::num; + 577 | }; + 578 | + 579 | template + 580 | struct check_terms_equal, T1, T2> + 581 | { + 582 | static const bool value = check_terms_equal::value; + | ~~~~~ + | VALUE + 583 | }; + 584 | + 585 | template + 586 | struct check_terms_equal, T1, T2> + 587 | { + 588 | static const bool value = check_terms_equal::value; + | ~~~~~ + | VALUE +./inet/common/Units.h:582:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 582 | static const bool value = check_terms_equal::value; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:588:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 588 | static const bool value = check_terms_equal::value; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:594:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 594 | static const bool value = check_terms_equal::value; + | ^~~~~ + | VALUE +./inet/common/Units.h:600:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 600 | static const bool value = check_terms_equal::value; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:606:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 606 | static const bool value = check_terms_equal::value; + | ^~~~~ + | VALUE +./inet/common/Units.h:612:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 612 | static const bool value = + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:622:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 369 | static const bool value = + | ^~~~~ + | VALUE +./inet/common/Units.h:644:16: warning: returning a constant reference parameter may cause use-after-free when the parameter is constructed from a temporary [bugprone-return-const-ref-from-parameter] + 644 | return t; + | ^ +./inet/common/Units.h:786:71: warning: macro argument should be enclosed in parentheses [bugprone-macro-parentheses] + 786 | template static void fn(Stream & os) { os << string; } \ + | ^ + | ( ) +./inet/common/Units.h:798:8: warning: invalid case style for struct 'output_unit2' [readability-identifier-naming] + 798 | struct output_unit2 + | ^~~~~~~~~~~~ + | OutputUnit2 + 799 | { + 800 | template + 801 | static void fn(Stream& os) { os << "units"; } + 802 | }; + 803 | + 804 | } // namespace internal + 805 | + 806 | // Functor to write unit text to stream + 807 | template + 808 | struct output_unit + 809 | { + 810 | template + 811 | static void fn(Stream& os) { internal::output_unit2::fn(os); } + | ~~~~~~~~~~~~ + | OutputUnit2 +./inet/common/Units.h:808:8: warning: invalid case style for struct 'output_unit' [readability-identifier-naming] + 808 | struct output_unit + | ^~~~~~~~~~~ + | OutputUnit +./inet/common/Units.h:920:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 920 | typedef ::inet::units::unit unit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using unit = ::inet::units::unit +./inet/common/Units.h:920:29: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 920 | typedef ::inet::units::unit unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:948:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 948 | typedef compose, pow> sr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sr = compose, pow> +./inet/common/Units.h:948:40: warning: invalid case style for typedef 'sr' [readability-identifier-naming] + 948 | typedef compose, pow> sr; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:949:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 949 | typedef pow Hz; + | ^~~~~~~~~~~~~~~~~~~~~ + | using Hz = pow +./inet/common/Units.h:950:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 950 | typedef compose>> N; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using N = compose>> +./inet/common/Units.h:951:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 951 | typedef compose> Pa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Pa = compose> +./inet/common/Units.h:952:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 952 | typedef compose J; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | using J = compose +./inet/common/Units.h:953:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 953 | typedef compose> W; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using W = compose> +./inet/common/Units.h:954:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 954 | typedef compose> WpHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using WpHz = compose> +./inet/common/Units.h:955:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 955 | typedef compose C; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | using C = compose +./inet/common/Units.h:956:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 956 | typedef compose> V; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using V = compose> +./inet/common/Units.h:957:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 957 | typedef compose> F; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using F = compose> +./inet/common/Units.h:958:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 958 | typedef compose> Ohm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohm = compose> +./inet/common/Units.h:959:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 959 | typedef compose Ohmm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohmm = compose +./inet/common/Units.h:960:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 960 | typedef compose As; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using As = compose +./inet/common/Units.h:961:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 961 | typedef compose> Ah; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ah = compose> +./inet/common/Units.h:962:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 962 | typedef compose> S; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using S = compose> +./inet/common/Units.h:963:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 963 | typedef compose> Spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Spm = compose> +./inet/common/Units.h:964:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 964 | typedef compose Wb; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using Wb = compose +./inet/common/Units.h:965:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 965 | typedef compose> T; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using T = compose> +./inet/common/Units.h:966:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 966 | typedef compose> H; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using H = compose> +./inet/common/Units.h:967:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 967 | typedef cd lm; + | ^~~~~~~~~~~~~ + | using lm = cd +./inet/common/Units.h:967:12: warning: invalid case style for typedef 'lm' [readability-identifier-naming] + 967 | typedef cd lm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:968:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 968 | typedef compose> lx; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lx = compose> +./inet/common/Units.h:968:33: warning: invalid case style for typedef 'lx' [readability-identifier-naming] + 968 | typedef compose> lx; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:969:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 969 | typedef pow Bq; + | ^~~~~~~~~~~~~~~~~~~~~ + | using Bq = pow +./inet/common/Units.h:970:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 970 | typedef compose> Gy; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gy = compose> +./inet/common/Units.h:971:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 971 | typedef Gy Sv; + | ^~~~~~~~~~~~~ + | using Sv = Gy +./inet/common/Units.h:972:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 972 | typedef compose, mol> kat; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kat = compose, mol> +./inet/common/Units.h:972:34: warning: invalid case style for typedef 'kat' [readability-identifier-naming] + 972 | typedef compose, mol> kat; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:999:32: warning: invalid case style for struct 'deca' [readability-identifier-naming] + 999 | template struct deca + | ^~~~ + | Deca +./inet/common/Units.h:1001:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1001 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1001:32: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1001 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1003:32: warning: invalid case style for struct 'hecto' [readability-identifier-naming] + 1003 | template struct hecto + | ^~~~~ + | Hecto +./inet/common/Units.h:1005:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1005 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1005:33: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1005 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1007:32: warning: invalid case style for struct 'kilo' [readability-identifier-naming] + 1007 | template struct kilo + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1009:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1009 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1009:34: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1009 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1011:32: warning: invalid case style for struct 'mega' [readability-identifier-naming] + 1011 | template struct mega + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1013:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1013 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1013:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1013 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1015:32: warning: invalid case style for struct 'giga' [readability-identifier-naming] + 1015 | template struct giga + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1017:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1017 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1017:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1017 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1019:32: warning: invalid case style for struct 'tera' [readability-identifier-naming] + 1019 | template struct tera + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1021:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1021 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1021:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1021 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1023:32: warning: invalid case style for struct 'peta' [readability-identifier-naming] + 1023 | template struct peta + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1025:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1025 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1025:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1025 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1027:32: warning: invalid case style for struct 'exa' [readability-identifier-naming] + 1027 | template struct exa + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1029:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1029 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1029:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1029 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1031:32: warning: invalid case style for struct 'zetta' [readability-identifier-naming] + 1031 | template struct zetta + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1033:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1033 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1033:54: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1033 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1035:32: warning: invalid case style for struct 'yotta' [readability-identifier-naming] + 1035 | template struct yotta + | ^~~~~ + | Yotta +./inet/common/Units.h:1037:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1037 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1037:56: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1037 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1040:32: warning: invalid case style for struct 'deci' [readability-identifier-naming] + 1040 | template struct deci + | ^~~~ + | Deci +./inet/common/Units.h:1042:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1042 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1042:29: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1042 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1044:32: warning: invalid case style for struct 'centi' [readability-identifier-naming] + 1044 | template struct centi + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1046:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1046 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1046:30: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1046 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1048:32: warning: invalid case style for struct 'milli' [readability-identifier-naming] + 1048 | template struct milli + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1050:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1050 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1050:31: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1050 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1052:32: warning: invalid case style for struct 'micro' [readability-identifier-naming] + 1052 | template struct micro + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1054:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1054 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1054:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1054 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1056:32: warning: invalid case style for struct 'nano' [readability-identifier-naming] + 1056 | template struct nano + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1058:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1058 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1058:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1058 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1060:32: warning: invalid case style for struct 'pico' [readability-identifier-naming] + 1060 | template struct pico + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1062:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1062 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1062:52: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1062 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1064:32: warning: invalid case style for struct 'femto' [readability-identifier-naming] + 1064 | template struct femto + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1066:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1066 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1066:52: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1066 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1068:32: warning: invalid case style for struct 'atto' [readability-identifier-naming] + 1068 | template struct atto + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1070:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1070 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1070:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1070 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1072:32: warning: invalid case style for struct 'zepto' [readability-identifier-naming] + 1072 | template struct zepto + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1074:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1074 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1074:52: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1074 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1076:32: warning: invalid case style for struct 'yocto' [readability-identifier-naming] + 1076 | template struct yocto + | ^~~~~ + | Yocto +./inet/common/Units.h:1078:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1078 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1078:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1078 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1082:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1082 | typedef centi::type cm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using cm = centi::type +./inet/common/Units.h:1082:24: warning: invalid case style for typedef 'cm' [readability-identifier-naming] + 1082 | typedef centi::type cm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1083:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1083 | typedef milli::type mm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using mm = milli::type +./inet/common/Units.h:1083:24: warning: invalid case style for typedef 'mm' [readability-identifier-naming] + 1083 | typedef milli::type mm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1084:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1084 | typedef kilo::type km; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using km = kilo::type +./inet/common/Units.h:1084:23: warning: invalid case style for typedef 'km' [readability-identifier-naming] + 1084 | typedef kilo::type km; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1085:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1085 | typedef milli::type g; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using g = milli::type +./inet/common/Units.h:1085:25: warning: invalid case style for typedef 'g' [readability-identifier-naming] + 1085 | typedef milli::type g; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1086:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1086 | typedef milli::type mg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using mg = milli::type +./inet/common/Units.h:1086:24: warning: invalid case style for typedef 'mg' [readability-identifier-naming] + 1086 | typedef milli::type mg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1087:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1087 | typedef pico::type ps; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using ps = pico::type +./inet/common/Units.h:1087:23: warning: invalid case style for typedef 'ps' [readability-identifier-naming] + 1087 | typedef pico::type ps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1088:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1088 | typedef nano::type ns; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using ns = nano::type +./inet/common/Units.h:1088:23: warning: invalid case style for typedef 'ns' [readability-identifier-naming] + 1088 | typedef nano::type ns; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1089:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1089 | typedef micro::type us; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using us = micro::type +./inet/common/Units.h:1089:24: warning: invalid case style for typedef 'us' [readability-identifier-naming] + 1089 | typedef micro::type us; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1090:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1090 | typedef milli::type ms; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using ms = milli::type +./inet/common/Units.h:1090:24: warning: invalid case style for typedef 'ms' [readability-identifier-naming] + 1090 | typedef milli::type ms; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1091:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1091 | typedef pico::type pW; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using pW = pico::type +./inet/common/Units.h:1091:23: warning: invalid case style for typedef 'pW' [readability-identifier-naming] + 1091 | typedef pico::type pW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1092:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1092 | typedef nano::type nW; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using nW = nano::type +./inet/common/Units.h:1092:23: warning: invalid case style for typedef 'nW' [readability-identifier-naming] + 1092 | typedef nano::type nW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1093:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1093 | typedef micro::type uW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using uW = micro::type +./inet/common/Units.h:1093:24: warning: invalid case style for typedef 'uW' [readability-identifier-naming] + 1093 | typedef micro::type uW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1094:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1094 | typedef milli::type mW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using mW = milli::type +./inet/common/Units.h:1094:24: warning: invalid case style for typedef 'mW' [readability-identifier-naming] + 1094 | typedef milli::type mW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1095:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1095 | typedef milli::type mAh; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mAh = milli::type +./inet/common/Units.h:1095:25: warning: invalid case style for typedef 'mAh' [readability-identifier-naming] + 1095 | typedef milli::type mAh; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1096:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1096 | typedef kilo::type kHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kHz = kilo::type +./inet/common/Units.h:1096:24: warning: invalid case style for typedef 'kHz' [readability-identifier-naming] + 1096 | typedef kilo::type kHz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1097:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1097 | typedef mega::type MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using MHz = mega::type +./inet/common/Units.h:1098:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1098 | typedef giga::type GHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using GHz = giga::type +./inet/common/Units.h:1122:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1122 | typedef scale lb; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lb = scale +./inet/common/Units.h:1122:39: warning: invalid case style for typedef 'lb' [readability-identifier-naming] + 1122 | typedef scale lb; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1123:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1123 | typedef scale oz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using oz = scale +./inet/common/Units.h:1123:23: warning: invalid case style for typedef 'oz' [readability-identifier-naming] + 1123 | typedef scale oz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1124:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1124 | typedef scale tonne; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using tonne = scale +./inet/common/Units.h:1124:28: warning: invalid case style for typedef 'tonne' [readability-identifier-naming] + 1124 | typedef scale tonne; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1127:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1127 | typedef translate Celsius; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Celsius = translate +./inet/common/Units.h:1128:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1128 | typedef translate, 32> Fahrenheit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fahrenheit = translate, 32> +./inet/common/Units.h:1131:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1131 | typedef scale minute; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using minute = scale +./inet/common/Units.h:1131:25: warning: invalid case style for typedef 'minute' [readability-identifier-naming] + 1131 | typedef scale minute; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1132:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1132 | typedef scale hour; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hour = scale +./inet/common/Units.h:1132:30: warning: invalid case style for typedef 'hour' [readability-identifier-naming] + 1132 | typedef scale hour; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1133:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1133 | typedef scale day; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using day = scale +./inet/common/Units.h:1133:28: warning: invalid case style for typedef 'day' [readability-identifier-naming] + 1133 | typedef scale day; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1134:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1134 | typedef scale week; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using week = scale +./inet/common/Units.h:1134:26: warning: invalid case style for typedef 'week' [readability-identifier-naming] + 1134 | typedef scale week; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1136:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1136 | typedef scale year; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using year = scale +./inet/common/Units.h:1136:29: warning: invalid case style for typedef 'year' [readability-identifier-naming] + 1136 | typedef scale year; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1137:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1137 | typedef scale century; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using century = scale +./inet/common/Units.h:1137:29: warning: invalid case style for typedef 'century' [readability-identifier-naming] + 1137 | typedef scale century; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1138:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1138 | typedef scale millennium; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millennium = scale +./inet/common/Units.h:1138:30: warning: invalid case style for typedef 'millennium' [readability-identifier-naming] + 1138 | typedef scale millennium; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1141:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1141 | typedef scale inch; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch = scale +./inet/common/Units.h:1141:29: warning: invalid case style for typedef 'inch' [readability-identifier-naming] + 1141 | typedef scale inch; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1142:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1142 | typedef scale foot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using foot = scale +./inet/common/Units.h:1142:28: warning: invalid case style for typedef 'foot' [readability-identifier-naming] + 1142 | typedef scale foot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1143:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1143 | typedef scale yard; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using yard = scale +./inet/common/Units.h:1143:28: warning: invalid case style for typedef 'yard' [readability-identifier-naming] + 1143 | typedef scale yard; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1144:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1144 | typedef scale mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mile = scale +./inet/common/Units.h:1144:30: warning: invalid case style for typedef 'mile' [readability-identifier-naming] + 1144 | typedef scale mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1145:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1145 | typedef scale nautical_mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nautical_mile = scale +./inet/common/Units.h:1145:27: warning: invalid case style for typedef 'nautical_mile' [readability-identifier-naming] + 1145 | typedef scale nautical_mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1148:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1148 | typedef pow m2; + | ^~~~~~~~~~~~~~~~~~~~ + | using m2 = pow +./inet/common/Units.h:1148:19: warning: invalid case style for typedef 'm2' [readability-identifier-naming] + 1148 | typedef pow m2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1149:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1149 | typedef scale hectare; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hectare = scale +./inet/common/Units.h:1149:29: warning: invalid case style for typedef 'hectare' [readability-identifier-naming] + 1149 | typedef scale hectare; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1150:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1150 | typedef scale are; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using are = scale +./inet/common/Units.h:1150:27: warning: invalid case style for typedef 'are' [readability-identifier-naming] + 1150 | typedef scale are; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1151:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1151 | typedef pow inch2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch2 = pow +./inet/common/Units.h:1151:22: warning: invalid case style for typedef 'inch2' [readability-identifier-naming] + 1151 | typedef pow inch2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1152:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1152 | typedef scale acre; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using acre = scale +./inet/common/Units.h:1152:44: warning: invalid case style for typedef 'acre' [readability-identifier-naming] + 1152 | typedef scale acre; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1155:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1155 | typedef pow cm3; + | ^~~~~~~~~~~~~~~~~~~~~~ + | using cm3 = pow +./inet/common/Units.h:1155:20: warning: invalid case style for typedef 'cm3' [readability-identifier-naming] + 1155 | typedef pow cm3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1156:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1156 | typedef cm3 ml; + | ^~~~~~~~~~~~~~ + | using ml = cm3 +./inet/common/Units.h:1156:13: warning: invalid case style for typedef 'ml' [readability-identifier-naming] + 1156 | typedef cm3 ml; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1157:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1157 | typedef scale liter; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using liter = scale +./inet/common/Units.h:1157:28: warning: invalid case style for typedef 'liter' [readability-identifier-naming] + 1157 | typedef scale liter; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1158:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1158 | typedef scale dl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dl = scale +./inet/common/Units.h:1158:26: warning: invalid case style for typedef 'dl' [readability-identifier-naming] + 1158 | typedef scale dl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1159:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1159 | typedef scale cl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cl = scale +./inet/common/Units.h:1159:27: warning: invalid case style for typedef 'cl' [readability-identifier-naming] + 1159 | typedef scale cl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1160:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1160 | typedef pow m3; + | ^~~~~~~~~~~~~~~~~~~~ + | using m3 = pow +./inet/common/Units.h:1160:19: warning: invalid case style for typedef 'm3' [readability-identifier-naming] + 1160 | typedef pow m3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1163:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1163 | typedef compose> mph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mph = compose> +./inet/common/Units.h:1163:38: warning: invalid case style for typedef 'mph' [readability-identifier-naming] + 1163 | typedef compose> mph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1164:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1164 | typedef compose> kph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kph = compose> +./inet/common/Units.h:1164:36: warning: invalid case style for typedef 'kph' [readability-identifier-naming] + 1164 | typedef compose> kph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1165:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1165 | typedef compose> mps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mps = compose> +./inet/common/Units.h:1165:32: warning: invalid case style for typedef 'mps' [readability-identifier-naming] + 1165 | typedef compose> mps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1166:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1166 | typedef compose> spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using spm = compose> +./inet/common/Units.h:1166:32: warning: invalid case style for typedef 'spm' [readability-identifier-naming] + 1166 | typedef compose> spm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1167:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1167 | typedef compose> knot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using knot = compose> +./inet/common/Units.h:1167:47: warning: invalid case style for typedef 'knot' [readability-identifier-naming] + 1167 | typedef compose> knot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1168:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1168 | typedef scale mach; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mach = scale +./inet/common/Units.h:1168:32: warning: invalid case style for typedef 'mach' [readability-identifier-naming] + 1168 | typedef scale mach; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1172:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1172 | typedef fscale deg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg = fscale +./inet/common/Units.h:1172:35: warning: invalid case style for typedef 'deg' [readability-identifier-naming] + 1172 | typedef fscale deg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1173:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1173 | typedef scale deg_min; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_min = scale +./inet/common/Units.h:1173:24: warning: invalid case style for typedef 'deg_min' [readability-identifier-naming] + 1173 | typedef scale deg_min; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1174:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1174 | typedef scale deg_sec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_sec = scale +./inet/common/Units.h:1174:28: warning: invalid case style for typedef 'deg_sec' [readability-identifier-naming] + 1174 | typedef scale deg_sec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1177:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1177 | typedef scale kPa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kPa = scale +./inet/common/Units.h:1177:28: warning: invalid case style for typedef 'kPa' [readability-identifier-naming] + 1177 | typedef scale kPa; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1178:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1178 | typedef scale psi; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using psi = scale +./inet/common/Units.h:1178:39: warning: invalid case style for typedef 'psi' [readability-identifier-naming] + 1178 | typedef scale psi; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1179:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1179 | typedef scale millibar; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millibar = scale +./inet/common/Units.h:1179:24: warning: invalid case style for typedef 'millibar' [readability-identifier-naming] + 1179 | typedef scale millibar; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1182:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1182 | typedef intscale B; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using B = intscale +./inet/common/Units.h:1183:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1183 | typedef compose> bps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bps = compose> +./inet/common/Units.h:1183:32: warning: invalid case style for typedef 'bps' [readability-identifier-naming] + 1183 | typedef compose> bps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1184:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1184 | typedef kilo::type kbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kbps = kilo::type +./inet/common/Units.h:1184:25: warning: invalid case style for typedef 'kbps' [readability-identifier-naming] + 1184 | typedef kilo::type kbps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1185:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1185 | typedef mega::type Mbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Mbps = mega::type +./inet/common/Units.h:1186:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1186 | typedef giga::type Gbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gbps = giga::type +./inet/common/Units.h:1189:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1189 | typedef scale rpm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using rpm = scale +./inet/common/Units.h:1189:23: warning: invalid case style for typedef 'rpm' [readability-identifier-naming] + 1189 | typedef scale rpm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1190:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1190 | typedef scale percent; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using percent = scale +./inet/common/Units.h:1190:26: warning: invalid case style for typedef 'percent' [readability-identifier-naming] + 1190 | typedef scale percent; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1191:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1191 | typedef scale dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dozen = scale +./inet/common/Units.h:1191:28: warning: invalid case style for typedef 'dozen' [readability-identifier-naming] + 1191 | typedef scale dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1192:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1192 | typedef scale bakers_dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bakers_dozen = scale +./inet/common/Units.h:1192:28: warning: invalid case style for typedef 'bakers_dozen' [readability-identifier-naming] + 1192 | typedef scale bakers_dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1193:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1193 | typedef scale ppm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ppm = scale +./inet/common/Units.h:1193:30: warning: invalid case style for typedef 'ppm' [readability-identifier-naming] + 1193 | typedef scale ppm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1246:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1246 | typedef value unit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using unit = value +./inet/common/Units.h:1246:36: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 1246 | typedef value unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1249:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1249 | typedef value m; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using m = value +./inet/common/Units.h:1249:33: warning: invalid case style for typedef 'm' [readability-identifier-naming] + 1249 | typedef value m; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1250:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1250 | typedef value kg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kg = value +./inet/common/Units.h:1250:34: warning: invalid case style for typedef 'kg' [readability-identifier-naming] + 1250 | typedef value kg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1251:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1251 | typedef value s; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using s = value +./inet/common/Units.h:1251:33: warning: invalid case style for typedef 's' [readability-identifier-naming] + 1251 | typedef value s; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1252:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1252 | typedef value simsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using simsec = value +./inet/common/Units.h:1252:36: warning: invalid case style for typedef 'simsec' [readability-identifier-naming] + 1252 | typedef value simsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1253:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1253 | typedef value K; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using K = value +./inet/common/Units.h:1254:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1254 | typedef value A; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using A = value +./inet/common/Units.h:1255:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1255 | typedef value mol; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mol = value +./inet/common/Units.h:1255:35: warning: invalid case style for typedef 'mol' [readability-identifier-naming] + 1255 | typedef value mol; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1256:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1256 | typedef value cd; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cd = value +./inet/common/Units.h:1256:34: warning: invalid case style for typedef 'cd' [readability-identifier-naming] + 1256 | typedef value cd; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1257:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1257 | typedef value b; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using b = value +./inet/common/Units.h:1257:34: warning: invalid case style for typedef 'b' [readability-identifier-naming] + 1257 | typedef value b; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1258:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1258 | typedef value B; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using B = value +./inet/common/Units.h:1261:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1261 | typedef value rad; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using rad = value +./inet/common/Units.h:1261:35: warning: invalid case style for typedef 'rad' [readability-identifier-naming] + 1261 | typedef value rad; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1262:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1262 | typedef value sr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sr = value +./inet/common/Units.h:1262:34: warning: invalid case style for typedef 'sr' [readability-identifier-naming] + 1262 | typedef value sr; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1263:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1263 | typedef value Hz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Hz = value +./inet/common/Units.h:1264:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1264 | typedef value N; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using N = value +./inet/common/Units.h:1265:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1265 | typedef value Pa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Pa = value +./inet/common/Units.h:1266:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1266 | typedef value J; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using J = value +./inet/common/Units.h:1267:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1267 | typedef value W; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using W = value +./inet/common/Units.h:1268:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1268 | typedef value WpHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using WpHz = value +./inet/common/Units.h:1269:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1269 | typedef value C; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using C = value +./inet/common/Units.h:1270:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1270 | typedef value V; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using V = value +./inet/common/Units.h:1271:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1271 | typedef value F; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using F = value +./inet/common/Units.h:1272:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1272 | typedef value Ohm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohm = value +./inet/common/Units.h:1273:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1273 | typedef value Ohmm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohmm = value +./inet/common/Units.h:1274:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1274 | typedef value As; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using As = value +./inet/common/Units.h:1275:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1275 | typedef value Ah; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ah = value +./inet/common/Units.h:1276:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1276 | typedef value S; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using S = value +./inet/common/Units.h:1277:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1277 | typedef value Spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Spm = value +./inet/common/Units.h:1278:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1278 | typedef value Wb; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Wb = value +./inet/common/Units.h:1279:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1279 | typedef value T; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using T = value +./inet/common/Units.h:1280:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1280 | typedef value H; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using H = value +./inet/common/Units.h:1281:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1281 | typedef value lm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lm = value +./inet/common/Units.h:1281:34: warning: invalid case style for typedef 'lm' [readability-identifier-naming] + 1281 | typedef value lm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1282:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1282 | typedef value lx; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lx = value +./inet/common/Units.h:1282:34: warning: invalid case style for typedef 'lx' [readability-identifier-naming] + 1282 | typedef value lx; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1283:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1283 | typedef value Bq; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Bq = value +./inet/common/Units.h:1284:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1284 | typedef value Gy; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gy = value +./inet/common/Units.h:1285:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1285 | typedef value Sv; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Sv = value +./inet/common/Units.h:1286:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1286 | typedef value kat; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kat = value +./inet/common/Units.h:1286:35: warning: invalid case style for typedef 'kat' [readability-identifier-naming] + 1286 | typedef value kat; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1289:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1289 | typedef value cm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cm = value +./inet/common/Units.h:1289:34: warning: invalid case style for typedef 'cm' [readability-identifier-naming] + 1289 | typedef value cm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1290:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1290 | typedef value mm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mm = value +./inet/common/Units.h:1290:34: warning: invalid case style for typedef 'mm' [readability-identifier-naming] + 1290 | typedef value mm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1291:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1291 | typedef value km; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using km = value +./inet/common/Units.h:1291:34: warning: invalid case style for typedef 'km' [readability-identifier-naming] + 1291 | typedef value km; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1292:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1292 | typedef value g; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using g = value +./inet/common/Units.h:1292:33: warning: invalid case style for typedef 'g' [readability-identifier-naming] + 1292 | typedef value g; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1293:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1293 | typedef value mg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mg = value +./inet/common/Units.h:1293:34: warning: invalid case style for typedef 'mg' [readability-identifier-naming] + 1293 | typedef value mg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1294:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1294 | typedef value ms; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ms = value +./inet/common/Units.h:1294:34: warning: invalid case style for typedef 'ms' [readability-identifier-naming] + 1294 | typedef value ms; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1295:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1295 | typedef value pW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using pW = value +./inet/common/Units.h:1295:34: warning: invalid case style for typedef 'pW' [readability-identifier-naming] + 1295 | typedef value pW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1296:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1296 | typedef value nW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nW = value +./inet/common/Units.h:1296:34: warning: invalid case style for typedef 'nW' [readability-identifier-naming] + 1296 | typedef value nW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1297:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1297 | typedef value uW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using uW = value +./inet/common/Units.h:1297:34: warning: invalid case style for typedef 'uW' [readability-identifier-naming] + 1297 | typedef value uW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1298:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1298 | typedef value mW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mW = value +./inet/common/Units.h:1298:34: warning: invalid case style for typedef 'mW' [readability-identifier-naming] + 1298 | typedef value mW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1299:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1299 | typedef value mAh; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mAh = value +./inet/common/Units.h:1299:35: warning: invalid case style for typedef 'mAh' [readability-identifier-naming] + 1299 | typedef value mAh; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1300:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1300 | typedef value kHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kHz = value +./inet/common/Units.h:1300:35: warning: invalid case style for typedef 'kHz' [readability-identifier-naming] + 1300 | typedef value kHz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1301:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1301 | typedef value MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using MHz = value +./inet/common/Units.h:1302:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1302 | typedef value GHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using GHz = value +./inet/common/Units.h:1303:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1303 | typedef value ps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ps = value +./inet/common/Units.h:1303:34: warning: invalid case style for typedef 'ps' [readability-identifier-naming] + 1303 | typedef value ps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1304:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1304 | typedef value ns; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ns = value +./inet/common/Units.h:1304:34: warning: invalid case style for typedef 'ns' [readability-identifier-naming] + 1304 | typedef value ns; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1305:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1305 | typedef value us; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using us = value +./inet/common/Units.h:1305:34: warning: invalid case style for typedef 'us' [readability-identifier-naming] + 1305 | typedef value us; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1306:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1306 | typedef value ms; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ms = value +./inet/common/Units.h:1307:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1307 | typedef value psimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using psimsec = value +./inet/common/Units.h:1307:37: warning: invalid case style for typedef 'psimsec' [readability-identifier-naming] + 1307 | typedef value psimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1308:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1308 | typedef value nsimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nsimsec = value +./inet/common/Units.h:1308:37: warning: invalid case style for typedef 'nsimsec' [readability-identifier-naming] + 1308 | typedef value nsimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1309:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1309 | typedef value usimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using usimsec = value +./inet/common/Units.h:1309:37: warning: invalid case style for typedef 'usimsec' [readability-identifier-naming] + 1309 | typedef value usimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1310:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1310 | typedef value msimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using msimsec = value +./inet/common/Units.h:1310:37: warning: invalid case style for typedef 'msimsec' [readability-identifier-naming] + 1310 | typedef value msimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1313:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1313 | typedef value lb; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lb = value +./inet/common/Units.h:1313:34: warning: invalid case style for typedef 'lb' [readability-identifier-naming] + 1313 | typedef value lb; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1314:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1314 | typedef value oz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using oz = value +./inet/common/Units.h:1314:34: warning: invalid case style for typedef 'oz' [readability-identifier-naming] + 1314 | typedef value oz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1315:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1315 | typedef value tonne; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using tonne = value +./inet/common/Units.h:1315:37: warning: invalid case style for typedef 'tonne' [readability-identifier-naming] + 1315 | typedef value tonne; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1317:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1317 | typedef value Celsius; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Celsius = value +./inet/common/Units.h:1318:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1318 | typedef value Fahrenheit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fahrenheit = value +./inet/common/Units.h:1320:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1320 | typedef value minute; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using minute = value +./inet/common/Units.h:1320:38: warning: invalid case style for typedef 'minute' [readability-identifier-naming] + 1320 | typedef value minute; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1321:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1321 | typedef value hour; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hour = value +./inet/common/Units.h:1321:36: warning: invalid case style for typedef 'hour' [readability-identifier-naming] + 1321 | typedef value hour; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1322:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1322 | typedef value day; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using day = value +./inet/common/Units.h:1322:35: warning: invalid case style for typedef 'day' [readability-identifier-naming] + 1322 | typedef value day; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1323:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1323 | typedef value week; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using week = value +./inet/common/Units.h:1323:36: warning: invalid case style for typedef 'week' [readability-identifier-naming] + 1323 | typedef value week; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1324:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1324 | typedef value month; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using month = value +./inet/common/Units.h:1324:37: warning: invalid case style for typedef 'month' [readability-identifier-naming] + 1324 | typedef value month; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1325:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1325 | typedef value year; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using year = value +./inet/common/Units.h:1325:36: warning: invalid case style for typedef 'year' [readability-identifier-naming] + 1325 | typedef value year; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1326:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1326 | typedef value century; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using century = value +./inet/common/Units.h:1326:39: warning: invalid case style for typedef 'century' [readability-identifier-naming] + 1326 | typedef value century; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1327:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1327 | typedef value millennium; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millennium = value +./inet/common/Units.h:1327:42: warning: invalid case style for typedef 'millennium' [readability-identifier-naming] + 1327 | typedef value millennium; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1329:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1329 | typedef value inch; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch = value +./inet/common/Units.h:1329:36: warning: invalid case style for typedef 'inch' [readability-identifier-naming] + 1329 | typedef value inch; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1330:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1330 | typedef value foot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using foot = value +./inet/common/Units.h:1330:36: warning: invalid case style for typedef 'foot' [readability-identifier-naming] + 1330 | typedef value foot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1331:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1331 | typedef value yard; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using yard = value +./inet/common/Units.h:1331:36: warning: invalid case style for typedef 'yard' [readability-identifier-naming] + 1331 | typedef value yard; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1332:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1332 | typedef value mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mile = value +./inet/common/Units.h:1332:36: warning: invalid case style for typedef 'mile' [readability-identifier-naming] + 1332 | typedef value mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1333:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1333 | typedef value nautical_mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nautical_mile = value +./inet/common/Units.h:1333:45: warning: invalid case style for typedef 'nautical_mile' [readability-identifier-naming] + 1333 | typedef value nautical_mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1335:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1335 | typedef value m2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using m2 = value +./inet/common/Units.h:1335:34: warning: invalid case style for typedef 'm2' [readability-identifier-naming] + 1335 | typedef value m2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1336:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1336 | typedef value hectare; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hectare = value +./inet/common/Units.h:1336:39: warning: invalid case style for typedef 'hectare' [readability-identifier-naming] + 1336 | typedef value hectare; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1337:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1337 | typedef value are; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using are = value +./inet/common/Units.h:1337:35: warning: invalid case style for typedef 'are' [readability-identifier-naming] + 1337 | typedef value are; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1338:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1338 | typedef value inch2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch2 = value +./inet/common/Units.h:1338:37: warning: invalid case style for typedef 'inch2' [readability-identifier-naming] + 1338 | typedef value inch2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1339:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1339 | typedef value acre; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using acre = value +./inet/common/Units.h:1339:36: warning: invalid case style for typedef 'acre' [readability-identifier-naming] + 1339 | typedef value acre; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1341:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1341 | typedef value cm3; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cm3 = value +./inet/common/Units.h:1341:35: warning: invalid case style for typedef 'cm3' [readability-identifier-naming] + 1341 | typedef value cm3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1342:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1342 | typedef value ml; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ml = value +./inet/common/Units.h:1342:34: warning: invalid case style for typedef 'ml' [readability-identifier-naming] + 1342 | typedef value ml; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1343:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1343 | typedef value cl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cl = value +./inet/common/Units.h:1343:34: warning: invalid case style for typedef 'cl' [readability-identifier-naming] + 1343 | typedef value cl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1344:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1344 | typedef value liter; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using liter = value +./inet/common/Units.h:1344:37: warning: invalid case style for typedef 'liter' [readability-identifier-naming] + 1344 | typedef value liter; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1345:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1345 | typedef value dl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dl = value +./inet/common/Units.h:1345:34: warning: invalid case style for typedef 'dl' [readability-identifier-naming] + 1345 | typedef value dl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1346:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1346 | typedef value m3; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using m3 = value +./inet/common/Units.h:1346:34: warning: invalid case style for typedef 'm3' [readability-identifier-naming] + 1346 | typedef value m3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1348:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1348 | typedef value mph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mph = value +./inet/common/Units.h:1348:35: warning: invalid case style for typedef 'mph' [readability-identifier-naming] + 1348 | typedef value mph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1349:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1349 | typedef value kph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kph = value +./inet/common/Units.h:1349:35: warning: invalid case style for typedef 'kph' [readability-identifier-naming] + 1349 | typedef value kph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1350:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1350 | typedef value mps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mps = value +./inet/common/Units.h:1350:35: warning: invalid case style for typedef 'mps' [readability-identifier-naming] + 1350 | typedef value mps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1351:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1351 | typedef value spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using spm = value +./inet/common/Units.h:1351:35: warning: invalid case style for typedef 'spm' [readability-identifier-naming] + 1351 | typedef value spm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1352:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1352 | typedef value knot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using knot = value +./inet/common/Units.h:1352:36: warning: invalid case style for typedef 'knot' [readability-identifier-naming] + 1352 | typedef value knot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1353:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1353 | typedef value mach; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mach = value +./inet/common/Units.h:1353:36: warning: invalid case style for typedef 'mach' [readability-identifier-naming] + 1353 | typedef value mach; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1355:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1355 | typedef value deg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg = value +./inet/common/Units.h:1355:35: warning: invalid case style for typedef 'deg' [readability-identifier-naming] + 1355 | typedef value deg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1356:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1356 | typedef value deg_min; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_min = value +./inet/common/Units.h:1356:39: warning: invalid case style for typedef 'deg_min' [readability-identifier-naming] + 1356 | typedef value deg_min; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1357:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1357 | typedef value deg_sec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_sec = value +./inet/common/Units.h:1357:39: warning: invalid case style for typedef 'deg_sec' [readability-identifier-naming] + 1357 | typedef value deg_sec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1359:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1359 | typedef value kPa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kPa = value +./inet/common/Units.h:1359:35: warning: invalid case style for typedef 'kPa' [readability-identifier-naming] + 1359 | typedef value kPa; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1360:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1360 | typedef value psi; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using psi = value +./inet/common/Units.h:1360:35: warning: invalid case style for typedef 'psi' [readability-identifier-naming] + 1360 | typedef value psi; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1361:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1361 | typedef value millibar; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millibar = value +./inet/common/Units.h:1361:40: warning: invalid case style for typedef 'millibar' [readability-identifier-naming] + 1361 | typedef value millibar; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1363:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1363 | typedef value bps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bps = value +./inet/common/Units.h:1363:35: warning: invalid case style for typedef 'bps' [readability-identifier-naming] + 1363 | typedef value bps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1364:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1364 | typedef value kbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kbps = value +./inet/common/Units.h:1364:36: warning: invalid case style for typedef 'kbps' [readability-identifier-naming] + 1364 | typedef value kbps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1365:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1365 | typedef value Mbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Mbps = value +./inet/common/Units.h:1366:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1366 | typedef value Gbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gbps = value +./inet/common/Units.h:1368:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1368 | typedef value percent; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using percent = value +./inet/common/Units.h:1368:39: warning: invalid case style for typedef 'percent' [readability-identifier-naming] + 1368 | typedef value percent; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1369:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1369 | typedef value rpm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using rpm = value +./inet/common/Units.h:1369:35: warning: invalid case style for typedef 'rpm' [readability-identifier-naming] + 1369 | typedef value rpm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1370:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1370 | typedef value dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dozen = value +./inet/common/Units.h:1370:37: warning: invalid case style for typedef 'dozen' [readability-identifier-naming] + 1370 | typedef value dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1371:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1371 | typedef value bakers_dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bakers_dozen = value +./inet/common/Units.h:1371:44: warning: invalid case style for typedef 'bakers_dozen' [readability-identifier-naming] + 1371 | typedef value bakers_dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1372:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1372 | typedef value ppm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ppm = value +./inet/common/Units.h:1372:35: warning: invalid case style for typedef 'ppm' [readability-identifier-naming] + 1372 | typedef value ppm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1508:59: warning: invalid case style for global constant 'k' [readability-identifier-naming] + 1508 | const value>> k(1.3806504e-23); + | ^ + | K +./inet/common/Units.h:1509:32: warning: invalid case style for global constant 'mu' [readability-identifier-naming] + 1509 | const value mu(1.660538782e-27); + | ^~ + | MU +./inet/common/Units.h:1512:59: warning: invalid case style for global constant 'e0' [readability-identifier-naming] + 1512 | const value>> e0(8.854187817e-12); + | ^~ + | E0 +./inet/common/Units.h:1513:32: warning: invalid case style for global constant 'me' [readability-identifier-naming] + 1513 | const value me(9.10938215e-31); + | ^~ + | ME +./inet/common/Units.h:1514:31: warning: invalid case style for global constant 'eV' [readability-identifier-naming] + 1514 | const value eV(1.602176487e-19); + | ^~ + | E_V +./inet/common/Units.h:1515:31: warning: invalid case style for global constant 'e' [readability-identifier-naming] + 1515 | const value e(1.602176487e-19); + | ^ + | E +./inet/common/Units.h:1517:34: warning: invalid case style for global constant 'alpha' [readability-identifier-naming] + 1517 | const value alpha(7.2973525376e-3); + | ^~~~~ + | ALPHA +./inet/common/Units.h:1518:34: warning: invalid case style for global constant 'inv_alpha' [readability-identifier-naming] + 1518 | const value inv_alpha(137.035999679); + | ^~~~~~~~~ + | INV_ALPHA +./inet/common/Units.h:1519:59: warning: invalid case style for global constant 'u0' [readability-identifier-naming] + 1519 | const value>> u0(12.566370614e-7); + | ^~ + | U0 +./inet/common/Units.h:1520:32: warning: invalid case style for global constant 'phi0' [readability-identifier-naming] + 1520 | const value phi0(2.067833667e-15); // ?? + | ^~~~ + | PHI0 +./inet/common/Units.h:1523:50: warning: invalid case style for global constant 'h' [readability-identifier-naming] + 1523 | const value> h(6.62606896e-34); + | ^ + | H +./inet/common/Units.h:1524:50: warning: invalid case style for global constant 'h_bar' [readability-identifier-naming] + 1524 | const value> h_bar(1.054571628e-34); + | ^~~~~ + | H_BAR +./inet/common/Units.h:1525:32: warning: invalid case style for global constant 'mp' [readability-identifier-naming] + 1525 | const value mp(1.672621637e-27); + | ^~ + | MP +./inet/common/Units.h:1526:27: warning: invalid case style for global constant 'mpme' [readability-identifier-naming] + 1526 | const value mpme(1836.15267247); + | ^~~~ + | MPME +./inet/common/Units.h:1527:40: warning: invalid case style for global constant 'Rinf' [readability-identifier-naming] + 1527 | const value> Rinf(10973731.568527); + | ^~~~ + | RINF +./inet/common/Units.h:1528:59: warning: invalid case style for global constant 'c' [readability-identifier-naming] + 1528 | const value>> c(299792458); + | ^ + | C +./inet/common/Units.h:1529:87: warning: invalid case style for global constant 'rho' [readability-identifier-naming] + 1529 | const value, pow>>> rho(5.6704e-8); + | ^~~ + | RHO +./inet/common/Units.h:1532:33: warning: invalid case style for global constant 'pi' [readability-identifier-naming] + 1532 | const value pi(3.141592653589793); + | ^~ + | PI +./inet/common/Units.h:1533:31: warning: invalid case style for global constant 'lightyear' [readability-identifier-naming] + 1533 | const value lightyear(9.4605284e15); + | ^~~~~~~~~ + | LIGHTYEAR +./inet/common/Units.h:1534:59: warning: invalid case style for global constant 'g' [readability-identifier-naming] + 1534 | const value>> g(9.80665); + | ^ + | G +./inet/common/Units_m.h:6:9: warning: invalid case style for macro definition '__INET_UNITS_M_H' [readability-identifier-naming] + 6 | #define __INET_UNITS_M_H + | ^~~~~~~~~~~~~~~~ + | INET_UNITS_M_H +./inet/common/checksum/ChecksumMode_m.h:6:9: warning: invalid case style for macro definition '__INET_CHECKSUMMODE_M_H' [readability-identifier-naming] + 6 | #define __INET_CHECKSUMMODE_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_CHECKSUMMODE_M_H +./inet/common/geometry/base/GeometricObjectBase.h:9:9: warning: invalid case style for macro definition '__INET_GEOMETRICOBJECTBASE_H' [readability-identifier-naming] + 9 | #define __INET_GEOMETRICOBJECTBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_GEOMETRICOBJECTBASE_H +./inet/common/geometry/base/GeometricObjectBase.h:22:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 22 | GeometricObjectBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/GeometricObjectBase.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~GeometricObjectBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/GeometricObjectBase.h:29:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual bool isNil() const = 0; + | ^ + | [[nodiscard]] +./inet/common/geometry/base/GeometricObjectBase.h:34:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual bool isUnspecified() const = 0; + | ^ + | [[nodiscard]] +./inet/common/geometry/base/ShapeBase.h:9:9: warning: invalid case style for macro definition '__INET_SHAPEBASE_H' [readability-identifier-naming] + 9 | #define __INET_SHAPEBASE_H + | ^~~~~~~~~~~~~~~~~~ + | INET_SHAPEBASE_H +./inet/common/geometry/base/ShapeBase.h:23:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 23 | ShapeBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/ShapeBase.h:24:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 24 | virtual ~ShapeBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/ShapeBase.h:29:5: warning: function 'computeBoundingBoxSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual Coord computeBoundingBoxSize() const = 0; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:9:9: warning: invalid case style for macro definition '__INET_COORD_H' [readability-identifier-naming] + 9 | #define __INET_COORD_H + | ^~~~~~~~~~~~~~ + | INET_COORD_H +./inet/common/geometry/common/Coord.h:49:11: warning: 3 adjacent parameters of 'Coord' of similar type ('double') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 49 | Coord(double x, double y, double z = 0.0) : x(x), y(y), z(z) {} + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/geometry/common/Coord.h:49:18: note: the first parameter in the range is 'x' + 49 | Coord(double x, double y, double z = 0.0) : x(x), y(y), z(z) {} + | ^ +./inet/common/geometry/common/Coord.h:49:38: note: the last parameter in the range is 'z' + 49 | Coord(double x, double y, double z = 0.0) : x(x), y(y), z(z) {} + | ^ +./inet/common/geometry/common/Coord.h:54:5: warning: function 'xyz' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | Coord xyz() const { return *this; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:55:5: warning: function 'getXyz' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | Coord getXyz() const { return Coord(*this).xyz(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:58:5: warning: function 'getYzx' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | Coord getYzx() const { return Coord(*this).yzx(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:61:5: warning: function 'getZxy' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | Coord getZxy() const { return Coord(*this).zxy(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:63:5: warning: function 'getX' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | double getX() const { return x; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:66:5: warning: function 'getY' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | double getY() const { return y; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:69:5: warning: function 'getZ' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | double getZ() const { return z; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:73:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | inline std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:76:38: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 76 | Coord operator-() const { return Coord(-x, -y, -z); } + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:139:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 139 | return Coord(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:189:5: warning: function 'getClamped' should be marked [[nodiscard]] [modernize-use-nodiscard] + 189 | Coord getClamped(double l, double u) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:200:5: warning: function 'getSign' should be marked [[nodiscard]] [modernize-use-nodiscard] + 200 | Coord getSign() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:211:5: warning: function 'getAbs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 211 | Coord getAbs() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:222:5: warning: function 'getStep' should be marked [[nodiscard]] [modernize-use-nodiscard] + 222 | Coord getStep(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:233:5: warning: function 'getDividedElementwise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 233 | Coord getDividedElementwise(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:244:5: warning: function 'getMultipliedElementwise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 244 | Coord getMultipliedElementwise(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:251:5: warning: function 'distance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 251 | double distance(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:258:5: warning: function 'sqrdist' should be marked [[nodiscard]] [modernize-use-nodiscard] + 258 | double sqrdist(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:265:5: warning: function 'sqrTorusDist' should be marked [[nodiscard]] [modernize-use-nodiscard] + 265 | double sqrTorusDist(const Coord& b, const Coord& size) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:270:5: warning: function 'squareLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 270 | double squareLength() const { return x * x + y * y + z * z; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:275:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 275 | double length() const { return sqrt(squareLength()); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:282:5: warning: function 'getNormalized' should be marked [[nodiscard]] [modernize-use-nodiscard] + 282 | Coord getNormalized() const { return Coord(*this).normalize(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:290:5: warning: function 'isInBoundary' should be marked [[nodiscard]] [modernize-use-nodiscard] + 290 | bool isInBoundary(const Coord& lowerBound, const Coord& upperBound) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:296:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 296 | bool isNil() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:303:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 303 | bool isUnspecified() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:310:5: warning: function 'min' should be marked [[nodiscard]] [modernize-use-nodiscard] + 310 | Coord min(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:311:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 311 | return Coord(x < a.x ? x : a.x, y < a.y ? y : a.y, z < a.z ? z : a.z); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:317:5: warning: function 'max' should be marked [[nodiscard]] [modernize-use-nodiscard] + 317 | Coord max(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:318:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 318 | return Coord(x > a.x ? x : a.x, y > a.y ? y : a.y, z > a.z ? z : a.z); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:346:20: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 346 | return Coord(x, y, z); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/EulerAngles.h:2:9: warning: invalid case style for macro definition '__INET_EULERANGLES_H' [readability-identifier-naming] + 2 | #define __INET_EULERANGLES_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_EULERANGLES_H +./inet/common/geometry/common/EulerAngles.h:41:17: warning: 3 adjacent parameters of 'EulerAngles' of similar type ('rad') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 41 | EulerAngles(rad alpha, rad beta, rad gamma) + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/geometry/common/EulerAngles.h:41:21: note: the first parameter in the range is 'alpha' + 41 | EulerAngles(rad alpha, rad beta, rad gamma) + | ^~~~~ +./inet/common/geometry/common/EulerAngles.h:41:42: note: the last parameter in the range is 'gamma' + 41 | EulerAngles(rad alpha, rad beta, rad gamma) + | ^~~~~ +./inet/common/geometry/common/EulerAngles.h:44:5: warning: function 'getAlpha' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | rad getAlpha() const { return alpha; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:47:5: warning: function 'getBeta' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | rad getBeta() const { return beta; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:50:5: warning: function 'getGamma' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | rad getGamma() const { return gamma; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:53:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | inline std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:55:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | bool isNil() const + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:60:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | bool isUnspecified() const + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:73:63: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 73 | EulerAngles operator+(const EulerAngles a) const { return EulerAngles(alpha + a.alpha, beta + a.beta, gamma + a.gamma); } + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/EulerAngles.h:75:63: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 75 | EulerAngles operator-(const EulerAngles a) const { return EulerAngles(alpha - a.alpha, beta - a.beta, gamma - a.gamma); } + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/EulerAngles.h:77:52: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 77 | EulerAngles operator*(double f) const { return EulerAngles(alpha * f, beta * f, gamma * f); } + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/Quaternion.h:9:9: warning: invalid case style for macro definition '__INET_QUATERNION_H' [readability-identifier-naming] + 9 | #define __INET_QUATERNION_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_QUATERNION_H +./inet/common/geometry/common/Quaternion.h:28:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 28 | Quaternion() {} + | ^ ~~ + | = default; +./inet/common/geometry/common/Quaternion.h:29:16: warning: 2 adjacent parameters of 'Quaternion' of similar type ('double') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 29 | Quaternion(double real, double i, double j, double k) : s(real), v(i, j, k) {} + | ^~~~~~~~~~~~~~~~~~~~~ +./inet/common/geometry/common/Quaternion.h:29:23: note: the first parameter in the range is 'real' + 29 | Quaternion(double real, double i, double j, double k) : s(real), v(i, j, k) {} + | ^~~~ +./inet/common/geometry/common/Quaternion.h:29:36: note: the last parameter in the range is 'i' + 29 | Quaternion(double real, double i, double j, double k) : s(real), v(i, j, k) {} + | ^ +./inet/common/geometry/common/Quaternion.h:38:5: warning: function 'getS' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | double getS() const { return s; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:41:5: warning: function 'getV' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | const Coord& getV() const { return v; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:48:17: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 48 | Quaternion& operator=(const Quaternion& q) { s = q.s; v = q.v; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/common/geometry/common/Quaternion.h:68:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 68 | double length() const { return std::sqrt(s * s + v * v); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:71:5: warning: function 'lengthSquared' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | double lengthSquared() const { return s * s + v * v; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:77:5: warning: function 'normalized' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | Quaternion normalized() const { return (*this) / length(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:82:5: warning: function 'conjugated' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | Quaternion conjugated() const { return Quaternion(s, -v.x, -v.y, -v.z); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:82:44: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 82 | Quaternion conjugated() const { return Quaternion(s, -v.x, -v.y, -v.z); } + | ^~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/Quaternion.h:88:5: warning: function 'inverse' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | Quaternion inverse() const { Quaternion q(*this); q.invert(); return q; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:100:5: warning: function 'getRotationAxis' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | Coord getRotationAxis() const { Coord axis; double angle; getRotationAxisAndAngle(axis, angle); return axis; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:101:5: warning: function 'getRotationAngle' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | double getRotationAngle() const { return std::acos(s) * 2; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:105:5: warning: function 'rotate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 105 | Coord rotate(const Coord& v) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:108:5: warning: function 'toEulerAngles' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | EulerAngles toEulerAngles(bool homogenous = false) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:125:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 125 | inline std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:9:9: warning: invalid case style for macro definition '__INET_ROTATIONMATRIX_H' [readability-identifier-naming] + 9 | #define __INET_ROTATIONMATRIX_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ROTATIONMATRIX_H +./inet/common/geometry/common/RotationMatrix.h:27:5: warning: function 'computeDeterminant' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | double computeDeterminant() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:34:5: warning: function 'rotateVector' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | Coord rotateVector(const Coord& vector) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:35:5: warning: function 'rotateVectorInverse' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | Coord rotateVectorInverse(const Coord& vector) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:37:5: warning: function 'toEulerAngles' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | EulerAngles toEulerAngles() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:38:5: warning: function 'toQuaternion' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | Quaternion toQuaternion() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:9:9: warning: invalid case style for macro definition '__INET_LINESEGMENT_H' [readability-identifier-naming] + 9 | #define __INET_LINESEGMENT_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_LINESEGMENT_H +./inet/common/geometry/object/LineSegment.h:32:5: warning: function 'getPoint1' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const Coord& getPoint1() const { return point1; } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:34:5: warning: function 'getPoint2' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | const Coord& getPoint2() const { return point2; } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:36:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | double length() const { return point2.distance(point1); } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:38:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual bool isNil() const override { return this == &NIL; } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:38:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual bool isNil() const override { return this == &NIL; } + | ~~~~~~~ ^ +./inet/common/geometry/object/LineSegment.h:39:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual bool isUnspecified() const override { return point1.isUnspecified() || point2.isUnspecified(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual bool isUnspecified() const override { return point1.isUnspecified() || point2.isUnspecified(); } + | ~~~~~~~ ^ +./inet/common/lifecycle/ILifecycle.h:9:9: warning: invalid case style for macro definition '__INET_ILIFECYCLE_H' [readability-identifier-naming] + 9 | #define __INET_ILIFECYCLE_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ILIFECYCLE_H +./inet/common/lifecycle/ILifecycle.h:25:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 25 | virtual ~IDoneCallback() {} + | ^ ~~ + | = default; +./inet/common/lifecycle/ILifecycle.h:38:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 38 | virtual ~ILifecycle() {} + | ^ ~~ + | = default; +./inet/common/lifecycle/LifecycleOperation.h:9:9: warning: invalid case style for macro definition '__INET_LIFECYCLEOPERATION_H' [readability-identifier-naming] + 9 | #define __INET_LIFECYCLEOPERATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_LIFECYCLEOPERATION_H +./inet/common/lifecycle/LifecycleOperation.h:28:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 28 | typedef std::map StringMap; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using StringMap = std::map +./inet/common/lifecycle/LifecycleOperation.h:39:9: warning: member initializer for 'rootModule' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:39:30: warning: member initializer for 'currentStage' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:39:47: warning: member initializer for 'insideInitiateOperation' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:39:79: warning: member initializer for 'operationCompletionCallback' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:41:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 41 | virtual ~LifecycleOperation() { + | ~~~~~~~ ^ + | override +./inet/common/lifecycle/LifecycleOperation.h:66:5: warning: function 'getRootModule' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | cModule *getRootModule() const { return rootModule; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/LifecycleOperation.h:71:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | virtual int getNumStages() const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/LifecycleOperation.h:76:5: warning: function 'getCurrentStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | int getCurrentStage() const { return currentStage; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:9:9: warning: invalid case style for macro definition '__INET_MODULEOPERATIONS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEOPERATIONS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEOPERATIONS_H +./inet/common/lifecycle/ModuleOperations.h:38:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:38:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ~~~~~~~ ^ +./inet/common/lifecycle/ModuleOperations.h:62:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:62:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ~~~~~~~ ^ +./inet/common/lifecycle/ModuleOperations.h:83:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 83 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:83:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalBase.h:9:9: warning: invalid case style for macro definition '__INET_OPERATIONALBASE_H' [readability-identifier-naming] + 9 | #define __INET_OPERATIONALBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_OPERATIONALBASE_H +./inet/common/lifecycle/OperationalMixin.h:9:9: warning: invalid case style for macro definition '__INET_OPERATIONALMIXIN_H' [readability-identifier-naming] + 9 | #define __INET_OPERATIONALMIXIN_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_OPERATIONALMIXIN_H +./inet/common/lifecycle/OperationalMixin.h:32:38: warning: invalid case style for parameter 'operation_' [readability-identifier-naming] + 32 | void set(LifecycleOperation *operation_, IDoneCallback *doneCallback_, State endState_) { operation = operation_; doneCallback = doneCallback_; endState = endState_; isDelayedFinish = false; } + | ^~~~~~~~~~ ~~~~~~~~~~ + | operation operation +./inet/common/lifecycle/OperationalMixin.h:32:65: warning: invalid case style for parameter 'doneCallback_' [readability-identifier-naming] + 32 | void set(LifecycleOperation *operation_, IDoneCallback *doneCallback_, State endState_) { operation = operation_; doneCallback = doneCallback_; endState = endState_; isDelayedFinish = false; } + | ^~~~~~~~~~~~~ ~~~~~~~~~~~~~ + | doneCallback doneCallback +./inet/common/lifecycle/OperationalMixin.h:32:86: warning: invalid case style for parameter 'endState_' [readability-identifier-naming] + 32 | void set(LifecycleOperation *operation_, IDoneCallback *doneCallback_, State endState_) { operation = operation_; doneCallback = doneCallback_; endState = endState_; isDelayedFinish = false; } + | ^~~~~~~~~ ~~~~~~~~~ + | endState endState +./inet/common/lifecycle/OperationalMixin.h:41:5: warning: function 'numInitStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:41:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void refreshDisplay() const override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:45:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual void handleMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual bool handleOperationStage(LifecycleOperation *operation, IDoneCallback *doneCallback) override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:59:5: warning: function 'isInitializeStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual bool isInitializeStage(int stage) const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:60:5: warning: function 'isModuleStartStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual bool isModuleStartStage(int stage) const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:61:5: warning: function 'isModuleStopStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | virtual bool isModuleStopStage(int stage) const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:66:5: warning: function 'isUp' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual bool isUp() const { return operationalState != NOT_OPERATING /* && operationalState != OPERATION_SUSPENDED */; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:67:5: warning: function 'isDown' should be marked [[nodiscard]] [modernize-use-nodiscard] + 67 | virtual bool isDown() const { return operationalState == NOT_OPERATING /* || operationalState == OPERATION_SUSPENDED */; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:79:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 79 | virtual ~OperationalMixin(); + | ~~~~~~~ ^ + | override +./inet/common/packet/Packet.h:9:9: warning: invalid case style for macro definition '__INET_PACKET_H' [readability-identifier-naming] + 9 | #define __INET_PACKET_H + | ^~~~~~~~~~~~~~~ + | INET_PACKET_H +./inet/common/packet/Packet.h:136:5: warning: function 'getContent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 136 | const Chunk *getContent() const { return content.get(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:137:5: warning: function 'getDissection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 137 | const ChunkTemporarySharedPtr *getDissection() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:138:5: warning: function 'getFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 138 | const ChunkTemporarySharedPtr *getFront() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:139:5: warning: function 'getData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 139 | const ChunkTemporarySharedPtr *getData() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:140:5: warning: function 'getBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 140 | const ChunkTemporarySharedPtr *getBack() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:141:20: warning: invalid case style for method '_getTag' [readability-identifier-naming] + 141 | const TagBase *_getTag(int index) { return tags.getTag(index).get(); } + | ^~~~~~~ + | getTag +./inet/common/packet/Packet.h:142:52: warning: invalid case style for method '_getRegionTag' [readability-identifier-naming] + 142 | const SharingRegionTagSet::RegionTag& _getRegionTag(int index) { return regionTags.getRegionTag(index); } + | ^~~~~~~~~~~~~ + | getRegionTag +./inet/common/packet/Packet.h:179:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 179 | virtual Packet *dup() const override { return new Packet(*this); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:179:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 179 | virtual Packet *dup() const override { return new Packet(*this); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:180:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 180 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:181:5: warning: function 'hasBitError' should be marked [[nodiscard]] [modernize-use-nodiscard] + 181 | virtual bool hasBitError() const override { return cPacket::hasBitError() || content->isIncorrect(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:181:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 181 | virtual bool hasBitError() const override { return cPacket::hasBitError() || content->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:182:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 182 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:183:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 183 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:189:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 189 | virtual void encapsulate(cPacket *packet) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:190:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 190 | virtual cPacket *decapsulate() override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:191:5: warning: function 'getEncapsulatedPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 191 | virtual cPacket *getEncapsulatedPacket() const override { return nullptr; } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:191:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 191 | virtual cPacket *getEncapsulatedPacket() const override { return nullptr; } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:192:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 192 | virtual void setControlInfo(cObject *p) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:193:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 193 | virtual void setBitLength(int64_t value) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:203:5: warning: function 'getTotalLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 203 | b getTotalLength() const { return totalLength; } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:209:5: warning: function 'getBitLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 209 | virtual int64_t getBitLength() const override { return getDataLength().get(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:209:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 209 | virtual int64_t getBitLength() const override { return getDataLength().get(); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:216:5: warning: function 'getDataLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 216 | b getDataLength() const { return getTotalLength() - frontIterator.getPosition() - backIterator.getPosition(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:225:5: warning: function 'getFrontOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 225 | b getFrontOffset() const { return frontIterator.getPosition(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:237:5: warning: function 'getBackOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 237 | b getBackOffset() const { return getTotalLength() - backIterator.getPosition(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:255:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 255 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:266:5: warning: function 'peekAtBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 266 | const Ptr peekAtBack(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:276:5: warning: function 'peekData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 276 | const Ptr peekData(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:287:5: warning: function 'peekDataAsBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 287 | const Ptr peekDataAsBits(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:298:5: warning: function 'peekDataAsBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 298 | const Ptr peekDataAsBytes(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:309:5: warning: function 'peekAll' should be marked [[nodiscard]] [modernize-use-nodiscard] + 309 | const Ptr peekAll(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:320:5: warning: function 'peekAllAsBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 320 | const Ptr peekAllAsBits(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:331:5: warning: function 'peekAllAsBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 331 | const Ptr peekAllAsBytes(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:342:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 342 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:353:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 353 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:381:5: warning: function 'peekAtBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 381 | const Ptr peekAtBack(b length, int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:397:5: warning: function 'peekData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 397 | const Ptr peekData(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:409:5: warning: function 'peekAll' should be marked [[nodiscard]] [modernize-use-nodiscard] + 409 | const Ptr peekAll(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:436:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 436 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:436:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 436 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:436:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 436 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:519:5: warning: function 'hasAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 519 | bool hasAtFront(b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:519:5: warning: function 'hasAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 519 | bool hasAtFront(b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:531:5: warning: function 'hasAtBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 531 | bool hasAtBack(b length) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:542:5: warning: function 'hasData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 542 | bool hasData() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:552:5: warning: function 'hasAll' should be marked [[nodiscard]] [modernize-use-nodiscard] + 552 | bool hasAll() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:563:5: warning: function 'hasDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 563 | bool hasDataAt(b offset, b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:577:5: warning: function 'hasAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 577 | bool hasAt(b offset, b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1259:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1259 | virtual SharingTagSet& getTags() override { return tags; } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1264:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1264 | int getNumTags() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1271:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1271 | const Ptr getTag(int index) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1292:26: warning: function 'hasTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1292 | template bool hasTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1313:26: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1313 | template const Ptr getTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1313:26: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1313 | template const Ptr getTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1313:26: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1313 | template const Ptr getTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1359:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1359 | virtual SharingRegionTagSet& getRegionTags() override { return regionTags; } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1364:5: warning: function 'getNumRegionTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1364 | int getNumRegionTags() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1371:5: warning: function 'getRegionTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1371 | const Ptr getRegionTag(int index) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1480:5: warning: function 'getFullName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1480 | virtual const char *getFullName() const override; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1480:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1480 | virtual const char *getFullName() const override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1487:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1487 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1492:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1492 | virtual std::string str() const override; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1492:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1492 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:9:9: warning: invalid case style for macro definition '__INET_BITCOUNTCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BITCOUNTCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_BITCOUNTCHUNK_H +./inet/common/packet/chunk/BitCountChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:50:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual BitCountChunk *dup() const override { return new BitCountChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:51:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:68:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual ChunkType getChunkType() const override { return CT_BITCOUNT; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:69:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= b(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:71:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual bool canRemoveAtFront(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool canRemoveAtBack(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:79:30: warning: 2 adjacent parameters of 'canRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~~~~~~~~~~~~~ +./inet/common/packet/chunk/BitCountChunk.h:79:32: note: the first parameter in the range is 'offset' + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitCountChunk.h:79:42: note: the last parameter in the range is 'length' + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitCountChunk.h:81:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:9:9: warning: invalid case style for macro definition '__INET_BITSCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BITSCHUNK_H + | ^~~~~~~~~~~~~~~~~~ + | INET_BITSCHUNK_H +./inet/common/packet/chunk/BitsChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:50:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual BitsChunk *dup() const override { return new BitsChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:51:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:69:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual ChunkType getChunkType() const override { return CT_BITS; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:70:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual b getChunkLength() const override { return b(bits.size()); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:72:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool canRemoveAtFront(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool canRemoveAtBack(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:80:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:80:30: warning: 2 adjacent parameters of 'canRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~~~~~~~~~~~~~ +./inet/common/packet/chunk/BitsChunk.h:80:32: note: the first parameter in the range is 'offset' + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitsChunk.h:80:42: note: the last parameter in the range is 'length' + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitsChunk.h:82:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:9:9: warning: invalid case style for macro definition '__INET_BYTECOUNTCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BYTECOUNTCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_BYTECOUNTCHUNK_H +./inet/common/packet/chunk/ByteCountChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:50:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual ByteCountChunk *dup() const override { return new ByteCountChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:51:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:68:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual ChunkType getChunkType() const override { return CT_BYTECOUNT; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:69:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= B(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:71:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual bool canRemoveAtFront(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool canRemoveAtBack(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool canRemoveAt(b offset, b length) const override { return offset.get() % 8 == 0 && length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:81:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:9:9: warning: invalid case style for macro definition '__INET_BYTESCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BYTESCHUNK_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_BYTESCHUNK_H +./inet/common/packet/chunk/BytesChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:51:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual BytesChunk *dup() const override { return new BytesChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:52:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:76:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual ChunkType getChunkType() const override { return CT_BYTES; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:77:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual b getChunkLength() const override { return B(bytes.size()); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:81:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:82:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:83:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual bool canRemoveAtFront(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:86:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual bool canRemoveAtBack(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:87:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual bool canRemoveAt(b offset, b length) const override { return offset.get() % 8 == 0 && length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:89:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:9:9: warning: invalid case style for macro definition '__INET_CHUNK_H' [readability-identifier-naming] + 9 | #define __INET_CHUNK_H + | ^~~~~~~~~~~~~~ + | INET_CHUNK_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:294:20: warning: invalid case style for global constant 'unspecifiedLength' [readability-identifier-naming] + 294 | static const b unspecifiedLength; + | ^~~~~~~~~~~~~~~~~ + | UNSPECIFIED_LENGTH +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:298:20: warning: invalid case style for protected member 'isForward_' [readability-identifier-naming] + 298 | const bool isForward_; + | ^~~~~~~~~~ + | isForward + 299 | b position; + 300 | int index; + 301 | + 302 | public: + 303 | Iterator(b position) : isForward_(true), position(position), index(position == b(0) ? 0 : -1) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ + | isForward + 304 | Iterator(B position) : isForward_(true), position(position), index(position == b(0) ? 0 : -1) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ + | isForward + 305 | explicit Iterator(bool isForward, b position, int index) : isForward_(isForward), position(position), index(index) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ + | isForward + 306 | Iterator(const Iterator& other) : isForward_(other.isForward_), position(other.position), index(other.index) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ ~~~~~~~~~~ + | isForward isForward + 307 | + 308 | bool isCorrect() { return position >= b(0) && index >= -1; } + 309 | + 310 | bool isForward() const { return isForward_; } + | ~~~~~~~~~~ + | isForward + 311 | bool isBackward() const { return !isForward_; } + | ~~~~~~~~~~ + | isForward +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:310:9: warning: function 'isForward' should be marked [[nodiscard]] [modernize-use-nodiscard] + 310 | bool isForward() const { return isForward_; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:311:9: warning: function 'isBackward' should be marked [[nodiscard]] [modernize-use-nodiscard] + 311 | bool isBackward() const { return !isForward_; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:313:9: warning: function 'getPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 313 | b getPosition() const { return position; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:316:9: warning: function 'getIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 316 | int getIndex() const { return index; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:363:52: warning: invalid case style for method '_getTag' [readability-identifier-naming] + 363 | const SharingRegionTagSet::RegionTag& _getTag(int index) const { return regionTags.getRegionTag(index); } + | ^~~~~~~ + | getTag +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:380:29: warning: 2 adjacent parameters of 'doRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 380 | virtual void doRemoveAt(b offset, b length) { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:380:31: note: the first parameter in the range is 'offset' + 380 | virtual void doRemoveAt(b offset, b length) { throw cRuntimeError("Invalid operation"); } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:380:41: note: the last parameter in the range is 'length' + 380 | virtual void doRemoveAt(b offset, b length) { throw cRuntimeError("Invalid operation"); } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:391:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 391 | typedef bool (*PeekPredicate)(const Ptr&); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using PeekPredicate = bool (*)(const Ptr&) +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:392:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 392 | typedef const Ptr (*PeekConverter)(const Ptr& chunk, const Chunk::Iterator& iterator, b length, int flags); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using PeekConverter = Ptr (*)(const Ptr& chunk, const Chunk::Iterator& iterator, b length, int flags) +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:438:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 438 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:440:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 440 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:441:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 441 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:555:30: warning: 2 adjacent parameters of 'canRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 555 | virtual bool canRemoveAt(b offset, b length) const { return false; } + | ^~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:555:32: note: the first parameter in the range is 'offset' + 555 | virtual bool canRemoveAt(b offset, b length) const { return false; } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:555:42: note: the last parameter in the range is 'length' + 555 | virtual bool canRemoveAt(b offset, b length) const { return false; } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:670:13: warning: use c++17 style variable templates [modernize-type-traits] + 670 | if (std::is_same::value) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:691:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 691 | virtual SharingRegionTagSet& getRegionTags() override { return regionTags; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:822:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 822 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:834:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 834 | virtual std::string str() const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:870:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 870 | typedef TemporarySharedPtr ChunkTemporarySharedPtr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ChunkTemporarySharedPtr = TemporarySharedPtr +./inet/common/packet/chunk/Chunk_m.h:6:9: warning: invalid case style for macro definition '__INET_CHUNK_M_H' [readability-identifier-naming] + 6 | #define __INET_CHUNK_M_H + | ^~~~~~~~~~~~~~~~ + | INET_CHUNK_M_H +./inet/common/packet/chunk/Chunk_m.h:59:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 59 | typedef Ptr ChunkPtr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ChunkPtr = Ptr +./inet/common/packet/chunk/EmptyChunk.h:9:9: warning: invalid case style for macro definition '__INET_EMPTYCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_EMPTYCHUNK_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_EMPTYCHUNK_H +./inet/common/packet/chunk/EmptyChunk.h:23:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:33:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual EmptyChunk *dup() const override { return new EmptyChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:34:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:39:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual ChunkType getChunkType() const override { return CT_EMPTY; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:40:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual b getChunkLength() const override { return b(0); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:42:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:42:69: warning: 2 adjacent parameters of 'printFieldsToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/packet/chunk/EmptyChunk.h:42:73: note: the first parameter in the range is 'level' + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ^~~~~ +./inet/common/packet/chunk/EmptyChunk.h:42:84: note: the last parameter in the range is 'evFlags' + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ^~~~~~~ +./inet/common/packet/chunk/EncryptedChunk.h:9:9: warning: invalid case style for macro definition '__INET_ENCRYPTEDCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_ENCRYPTEDCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ENCRYPTEDCHUNK_H +./inet/common/packet/chunk/EncryptedChunk.h:35:12: warning: invalid case style for method '_getChunk' [readability-identifier-naming] + 35 | Chunk *_getChunk() const { return chunk.get(); } // only for class descriptor + | ^~~~~~~~~ + | getChunk +./inet/common/packet/chunk/EncryptedChunk.h:37:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:46:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual EncryptedChunk *dup() const override { return new EncryptedChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:47:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 47 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool isMutable() const override { return Chunk::isMutable() || chunk->isMutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:67:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual bool isImmutable() const override { return Chunk::isImmutable() && chunk->isImmutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:69:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual bool isComplete() const override { return Chunk::isComplete() && chunk->isComplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual bool isIncomplete() const override { return Chunk::isIncomplete() || chunk->isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:72:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual bool isCorrect() const override { return Chunk::isCorrect() && chunk->isCorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool isIncorrect() const override { return Chunk::isIncorrect() || chunk->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool isProperlyRepresented() const override { return Chunk::isProperlyRepresented() && chunk->isProperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool isImproperlyRepresented() const override { return Chunk::isImproperlyRepresented() || chunk->isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:81:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual ChunkType getChunkType() const override { return CT_ENCRYPTED; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:82:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= b(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:84:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:86:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:9:9: warning: invalid case style for macro definition '__INET_FIELDSCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_FIELDSCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_FIELDSCHUNK_H +./inet/common/packet/chunk/FieldsChunk.h:43:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:54:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 54 | virtual ~FieldsChunk(); + | ~~~~~~~ ^ + | override +./inet/common/packet/chunk/FieldsChunk.h:56:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void handleChange() override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:64:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual ChunkType getChunkType() const override { return CT_FIELDS; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:68:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(chunkLength >= b(0)); return chunkLength; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:72:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:9:9: warning: invalid case style for macro definition '__INET_SEQUENCECHUNK_H' [readability-identifier-naming] + 9 | #define __INET_SEQUENCECHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_SEQUENCECHUNK_H +./inet/common/packet/chunk/SequenceChunk.h:50:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:58:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:67:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual SequenceChunk *dup() const override { return new SequenceChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:68:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:71:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual bool isComplete() const override { return !isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:86:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual bool isIncomplete() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual bool isCorrect() const override { return !isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:89:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual bool isIncorrect() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual bool isProperlyRepresented() const override { return !isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual bool isImproperlyRepresented() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:97:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 97 | virtual void moveIterator(Iterator& iterator, b length) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:98:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 98 | virtual void seekIterator(Iterator& iterator, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual bool canInsertAtFront(const Ptr& chunk) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:104:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual bool canInsertAtBack(const Ptr& chunk) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:109:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual bool canRemoveAtFront(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:110:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual bool canRemoveAtBack(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:115:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 115 | virtual ChunkType getChunkType() const override { return CT_SEQUENCE; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:116:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 116 | virtual b getChunkLength() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:117:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 117 | virtual bool isEmpty() const override { return chunks.size() != 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:120:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 120 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:9:9: warning: invalid case style for macro definition '__INET_SLICECHUNK_H' [readability-identifier-naming] + 9 | #define __INET_SLICECHUNK_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_SLICECHUNK_H +./inet/common/packet/chunk/SliceChunk.h:42:12: warning: invalid case style for method '_getChunk' [readability-identifier-naming] + 42 | Chunk *_getChunk() const { return chunk.get(); } // only for class descriptor + | ^~~~~~~~~ + | getChunk +./inet/common/packet/chunk/SliceChunk.h:44:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:61:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual SliceChunk *dup() const override { return new SliceChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:62:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:65:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:68:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:84:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual bool isMutable() const override { return Chunk::isMutable() || chunk->isMutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual bool isImmutable() const override { return Chunk::isImmutable() && chunk->isImmutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:87:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual bool isComplete() const override { return Chunk::isComplete() && chunk->isComplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual bool isIncomplete() const override { return Chunk::isIncomplete() || chunk->isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:90:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual bool isCorrect() const override { return Chunk::isCorrect() && chunk->isCorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual bool isIncorrect() const override { return Chunk::isIncorrect() || chunk->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual bool isProperlyRepresented() const override { return Chunk::isProperlyRepresented() && chunk->isProperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:94:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 94 | virtual bool isImproperlyRepresented() const override { return Chunk::isImproperlyRepresented() || chunk->isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:99:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual ChunkType getChunkType() const override { return CT_SLICE; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:100:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 100 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= b(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:102:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 102 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:104:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:105:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 105 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:107:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual bool canRemoveAtFront(b length) const override { return false; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:108:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual bool canRemoveAtBack(b length) const override { return false; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:110:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:9:9: warning: invalid case style for macro definition '__INET_STREAMBUFFERCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_STREAMBUFFERCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_STREAMBUFFERCHUNK_H +./inet/common/packet/chunk/StreamBufferChunk.h:38:12: warning: invalid case style for method '_getStreamData' [readability-identifier-naming] + 38 | Chunk *_getStreamData() const { return streamData.get(); } // only for class descriptor + | ^~~~~~~~~~~~~~ + | getStreamData +./inet/common/packet/chunk/StreamBufferChunk.h:40:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:49:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual StreamBufferChunk *dup() const override { return new StreamBufferChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:50:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:56:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:72:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual bool isMutable() const override { return Chunk::isMutable() || streamData->isMutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool isImmutable() const override { return Chunk::isImmutable() && streamData->isImmutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool isComplete() const override { return Chunk::isComplete() && streamData->isComplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool isIncomplete() const override { return Chunk::isIncomplete() || streamData->isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool isCorrect() const override { return Chunk::isCorrect() && streamData->isCorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool isIncorrect() const override { return Chunk::isIncorrect() || streamData->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:81:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual bool isProperlyRepresented() const override { return Chunk::isProperlyRepresented() && streamData->isProperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:82:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual bool isImproperlyRepresented() const override { return Chunk::isImproperlyRepresented() || streamData->isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:87:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual ChunkType getChunkType() const override { return CT_STREAM; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:89:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual b getChunkLength() const override { return streamData->getChunkLength(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:93:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:9:9: warning: invalid case style for macro definition '__INET_CPACKETCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_CPACKETCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_CPACKETCHUNK_H +./inet/common/packet/chunk/cPacketChunk.h:21:16: warning: invalid case style for class 'cPacketChunk' [readability-identifier-naming] + 21 | class INET_API cPacketChunk : public Chunk + | ^~~~~~~~~~~~ + | CPacketChunk + 22 | { + 23 | protected: + 24 | cPacket *packet; + 25 | + 26 | protected: + 27 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + 28 | + 29 | public: + 30 | /** @name Constructors, destructors and duplication related functions */ + 31 | //@{ + 32 | cPacketChunk(cPacket *packet = nullptr); + | ~~~~~~~~~~~~ + | CPacketChunk + 33 | cPacketChunk(const cPacketChunk& other); + | ~~~~~~~~~~~~ ~~~~~~~~~~~~ + | CPacketChunk CPacketChunk + 34 | ~cPacketChunk(); + | ~~~~~~~~~~~~ + | CPacketChunk + 35 | + 36 | virtual cPacketChunk *dup() const override { return new cPacketChunk(*this); } + | ~~~~~~~~~~~~ ~~~~~~~~~~~~ + | CPacketChunk CPacketChunk +./inet/common/packet/chunk/cPacketChunk.h:27:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:34:5: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + 34 | ~cPacketChunk(); + | ^ + | override +./inet/common/packet/chunk/cPacketChunk.h:36:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual cPacketChunk *dup() const override { return new cPacketChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:37:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:51:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual ChunkType getChunkType() const override { return CT_CPACKET; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:52:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(packet->getBitLength() >= 0); return b(packet->getBitLength()); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:56:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/tag/IRegionTaggedObject.h:9:9: warning: invalid case style for macro definition '__INET_IREGIONTAGGEDOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_IREGIONTAGGEDOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IREGIONTAGGEDOBJECT_H +./inet/common/packet/tag/ITaggedObject.h:9:9: warning: invalid case style for macro definition '__INET_ITAGGEDOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_ITAGGEDOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_ITAGGEDOBJECT_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:9:9: warning: invalid case style for macro definition '__INET_SHARINGREGIONTAGSET_H' [readability-identifier-naming] + 9 | #define __INET_SHARINGREGIONTAGSET_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_SHARINGREGIONTAGSET_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:56:9: warning: function '_getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | const T *_getTag() const { return tag.get(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:56:18: warning: invalid case style for method '_getTag' [readability-identifier-naming] + 56 | const T *_getTag() const { return tag.get(); } + | ^~~~~~~ + | getTag +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:59:19: warning: 2 adjacent parameters of 'RegionTag' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 59 | RegionTag(b offset, b length, const Ptr& tag) : offset(offset), length(length), tag(tag) { + | ^~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:59:21: note: the first parameter in the range is 'offset' + 59 | RegionTag(b offset, b length, const Ptr& tag) : offset(offset), length(length), tag(tag) { + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:59:31: note: the last parameter in the range is 'length' + 59 | RegionTag(b offset, b length, const Ptr& tag) : offset(offset), length(length), tag(tag) { + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:88:9: warning: function 'getOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | b getOffset() const { return offset; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:97:9: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | b getLength() const { return length; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:106:9: warning: function 'getStartOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 106 | b getStartOffset() const { return offset; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:107:9: warning: function 'getEndOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 107 | b getEndOffset() const { return offset + length; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:109:9: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | const Ptr& getTag() const { return tag; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:112:9: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 112 | virtual std::string str() const override { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:112:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 112 | virtual std::string str() const override { + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:120:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 120 | typedef RegionTag TagBaseRegionTag; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using TagBaseRegionTag = RegionTag +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:137:5: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 137 | int getTagIndex(const std::type_info& typeInfo, b offset, b length) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:138:26: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 138 | template int getTagIndex(b offset, b length) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:154:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 154 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:155:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 155 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:163:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 163 | inline int getNumTags() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:168:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 168 | inline const Ptr& getTag(int index) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:178:5: warning: function 'getRegionTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 178 | inline const RegionTag& getRegionTag(int index) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:9:9: warning: invalid case style for macro definition '__INET_SHARINGTAGSET_H' [readability-identifier-naming] + 9 | #define __INET_SHARINGTAGSET_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_SHARINGTAGSET_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:47:5: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | int getTagIndex(const std::type_info& typeInfo) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:48:26: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | template int getTagIndex() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:63:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:72:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | inline int getNumTags() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:77:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | inline const Ptr& getTag(int index) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:100:26: warning: function 'hasTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | template bool hasTag() const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:9:9: warning: invalid case style for macro definition '__INET_TAGSET_H' [readability-identifier-naming] + 9 | #define __INET_TAGSET_H + | ^~~~~~~~~~~~~~~ + | INET_TAGSET_H +./inet/common/packet/tag/TagSet.h:40:5: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | int getTagIndex(const std::type_info& typeInfo) const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:41:26: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | template int getTagIndex() const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:47:5: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + 47 | ~TagSet(); + | ^ + | override +./inet/common/packet/tag/TagSet.h:55:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | inline int getNumTags() const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:60:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | inline cObject *getTag(int index) const; + | ^ + | [[nodiscard]] +./inet/common/precompiled.h:9:9: warning: invalid case style for macro definition '__INET_PRECOMPILED_H' [readability-identifier-naming] + 9 | #define __INET_PRECOMPILED_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_PRECOMPILED_H +./inet/environment/common/Material.h:9:9: warning: invalid case style for macro definition '__INET_MATERIAL_H' [readability-identifier-naming] + 9 | #define __INET_MATERIAL_H + | ^~~~~~~~~~~~~~~~~ + | INET_MATERIAL_H +./inet/environment/common/Material.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/common/Material.h:31:5: warning: function 'getResistivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual Ohmm getResistivity() const override { return resistivity; } + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual Ohmm getResistivity() const override { return resistivity; } + | ~~~~~~~ ^ +./inet/environment/common/Material.h:32:5: warning: function 'getRelativePermittivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual double getRelativePermittivity() const override { return relativePermittivity; } + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:32:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual double getRelativePermittivity() const override { return relativePermittivity; } + | ~~~~~~~ ^ +./inet/environment/common/Material.h:33:5: warning: function 'getRelativePermeability' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual double getRelativePermeability() const override { return relativePermeability; } + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:33:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual double getRelativePermeability() const override { return relativePermeability; } + | ~~~~~~~ ^ +./inet/environment/common/Material.h:34:5: warning: function 'getDielectricLossTangent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual double getDielectricLossTangent(Hz frequency) const override; + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:34:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual double getDielectricLossTangent(Hz frequency) const override; + | ~~~~~~~ ^ +./inet/environment/common/Material.h:35:5: warning: function 'getRefractiveIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual double getRefractiveIndex() const override; + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:35:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual double getRefractiveIndex() const override; + | ~~~~~~~ ^ +./inet/environment/common/Material.h:36:5: warning: function 'getPropagationSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual mps getPropagationSpeed() const override; + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:36:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual mps getPropagationSpeed() const override; + | ~~~~~~~ ^ +./inet/environment/contract/IGround.h:9:9: warning: invalid case style for macro definition '__INET_IGROUND_H' [readability-identifier-naming] + 9 | #define __INET_IGROUND_H + | ^~~~~~~~~~~~~~~~ + | INET_IGROUND_H +./inet/environment/contract/IGround.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IGround.h:26:5: warning: function 'computeGroundProjection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual Coord computeGroundProjection(const Coord& position) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IGround.h:34:5: warning: function 'computeGroundNormal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual Coord computeGroundNormal(const Coord& position) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:9:9: warning: invalid case style for macro definition '__INET_IMATERIAL_H' [readability-identifier-naming] + 9 | #define __INET_IMATERIAL_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IMATERIAL_H +./inet/environment/contract/IMaterial.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IMaterial.h:23:5: warning: function 'getResistivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual Ohmm getResistivity() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:24:5: warning: function 'getRelativePermittivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual double getRelativePermittivity() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:25:5: warning: function 'getRelativePermeability' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual double getRelativePermeability() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:26:5: warning: function 'getDielectricLossTangent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual double getDielectricLossTangent(Hz frequency) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:27:5: warning: function 'getRefractiveIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual double getRefractiveIndex() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:28:5: warning: function 'getPropagationSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual mps getPropagationSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterialRegistry.h:9:9: warning: invalid case style for macro definition '__INET_IMATERIALREGISTRY_H' [readability-identifier-naming] + 9 | #define __INET_IMATERIALREGISTRY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMATERIALREGISTRY_H +./inet/environment/contract/IMaterialRegistry.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment + 16 | + 17 | class INET_API IMaterialRegistry + 18 | { + 19 | public: + 20 | virtual const Material *getMaterial(const char *name) const = 0; + 21 | }; + 22 | + 23 | } // namespace physicalenvironment + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicalenvironment + 24 | + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/environment/contract/IObjectCache.h:9:9: warning: invalid case style for macro definition '__INET_IOBJECTCACHE_H' [readability-identifier-naming] + 9 | #define __INET_IOBJECTCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IOBJECTCACHE_H +./inet/environment/contract/IObjectCache.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IPhysicalEnvironment.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALENVIRONMENT_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALENVIRONMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALENVIRONMENT_H +./inet/environment/contract/IPhysicalEnvironment.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | + 22 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IPhysicalEnvironment.h:27:5: warning: function 'getObjectCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual IObjectCache *getObjectCache() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:28:5: warning: function 'getGround' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual IGround *getGround() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:30:5: warning: function 'getSpaceMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const Coord& getSpaceMin() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:31:5: warning: function 'getSpaceMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const Coord& getSpaceMax() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:32:5: warning: function 'getMaterialRegistry' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const IMaterialRegistry *getMaterialRegistry() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:34:5: warning: function 'getNumObjects' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual int getNumObjects() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:35:5: warning: function 'getObject' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const IPhysicalObject *getObject(int index) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:36:5: warning: function 'getObjectById' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const IPhysicalObject *getObjectById(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALOBJECT_H +./inet/environment/contract/IPhysicalObject.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IPhysicalObject.h:22:5: warning: function 'getPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual const Coord& getPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:23:5: warning: function 'getOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual const Quaternion& getOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:25:5: warning: function 'getShape' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual const ShapeBase *getShape() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:26:5: warning: function 'getMaterial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const IMaterial *getMaterial() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:28:5: warning: function 'getLineWidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual double getLineWidth() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:29:5: warning: function 'getLineColor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const cFigure::Color& getLineColor() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:30:5: warning: function 'getFillColor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const cFigure::Color& getFillColor() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:31:5: warning: function 'getOpacity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual double getOpacity() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:32:5: warning: function 'getTexture' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const char *getTexture() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:33:5: warning: function 'getTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const char *getTags() const = 0; + | ^ + | [[nodiscard]] +./inet/features.h:21:9: warning: invalid case style for macro definition 'INET_WITH_BGPv4' [readability-identifier-naming] + 21 | #define INET_WITH_BGPv4 + | ^~~~~~~~~~~~~~~ + | INET_WITH_BG_PV4 +./inet/features.h:105:9: warning: invalid case style for macro definition 'INET_WITH_IPv4' [readability-identifier-naming] + 105 | #define INET_WITH_IPv4 + | ^~~~~~~~~~~~~~ + | INET_WITH_I_PV4 +./inet/features.h:109:9: warning: invalid case style for macro definition 'INET_WITH_IPv6' [readability-identifier-naming] + 109 | #define INET_WITH_IPv6 + | ^~~~~~~~~~~~~~ + | INET_WITH_I_PV6 +./inet/features.h:133:9: warning: invalid case style for macro definition 'INET_WITH_OSPFv2' [readability-identifier-naming] + 133 | #define INET_WITH_OSPFv2 + | ^~~~~~~~~~~~~~~~ + | INET_WITH_OSP_FV2 +./inet/features.h:137:9: warning: invalid case style for macro definition 'INET_WITH_OSPFv3' [readability-identifier-naming] + 137 | #define INET_WITH_OSPFv3 + | ^~~~~~~~~~~~~~~~ + | INET_WITH_OSP_FV3 +./inet/linklayer/base/MacProtocolBase.h:9:9: warning: invalid case style for macro definition '__INET_MACPROTOCOLBASE_H' [readability-identifier-naming] + 9 | #define __INET_MACPROTOCOLBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MACPROTOCOLBASE_H +./inet/linklayer/base/MacProtocolBase.h:42:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 42 | virtual ~MacProtocolBase(); + | ~~~~~~~ ^ + | override +./inet/linklayer/base/MacProtocolBase.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void handleMessageWhenDown(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:59:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual bool isUpperMessage(cMessage *message) const override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual bool isLowerMessage(cMessage *message) const override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:62:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual bool isInitializeStage(int stage) const override { return stage == INITSTAGE_LINK_LAYER; } + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:63:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual bool isModuleStartStage(int stage) const override { return stage == ModuleStartOperation::STAGE_LINK_LAYER; } + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual bool isModuleStopStage(int stage) const override { return stage == ModuleStopOperation::STAGE_LINK_LAYER; } + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual void handleStartOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual void handleStopOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:80:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual void handleCrashOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/common/FcsMode_m.h:6:9: warning: invalid case style for macro definition '__INET_FCSMODE_M_H' [readability-identifier-naming] + 6 | #define __INET_FCSMODE_M_H + | ^~~~~~~~~~~~~~~~~~ + | INET_FCSMODE_M_H +./inet/linklayer/common/FcsMode_m.h:46:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 46 | typedef ChecksumMode FcsMode; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using FcsMode = ChecksumMode +./inet/linklayer/common/MacAddress.h:8:9: warning: invalid case style for macro definition '__INET_MACADDRESS_H' [readability-identifier-naming] + 8 | #define __INET_MACADDRESS_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_MACADDRESS_H +./inet/linklayer/common/MacAddress.h:75:17: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 75 | MacAddress& operator=(const MacAddress& other) { address = other.address; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/linklayer/common/MacAddress.h:80:5: warning: function 'getAddressSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | unsigned int getAddressSize() const { return MAC_ADDRESS_SIZE; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:85:5: warning: function 'getAddressByte' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | unsigned char getAddressByte(unsigned int k) const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:124:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | bool isBroadcast() const { return address == MAC_ADDRESS_MASK; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:129:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 129 | bool isMulticast() const { return getAddressByte(0) & 0x01; }; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:134:5: warning: function 'isLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 134 | bool isLocal() const { return getAddressByte(0) & 0x02; }; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:139:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 139 | bool isUnspecified() const { return address == 0; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:144:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 144 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:149:5: warning: function 'getInt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 149 | uint64_t getInt() const { return address; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:154:5: warning: function 'equals' should be marked [[nodiscard]] [modernize-use-nodiscard] + 154 | bool equals(const MacAddress& other) const { return address == other.address; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:169:5: warning: function 'compareTo' should be marked [[nodiscard]] [modernize-use-nodiscard] + 169 | int compareTo(const MacAddress& other) const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:175:5: warning: function 'formInterfaceIdentifier' should be marked [[nodiscard]] [modernize-use-nodiscard] + 175 | InterfaceToken formInterfaceIdentifier() const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress_m.h:6:9: warning: invalid case style for macro definition '__INET_MACADDRESS_M_H' [readability-identifier-naming] + 6 | #define __INET_MACADDRESS_M_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_MACADDRESS_M_H +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_IEEE80211DATASEQUENCETAG_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_IEEE80211DATASEQUENCETAG_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_IEE_E80211_DATASEQUENCETAG_M_H +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 33 | + 34 | class Ieee80211DataSequenceTag; + 35 | + 36 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:44:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 44 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 45 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:67:10: warning: deleted member function should be public [modernize-use-equals-delete] + 67 | bool operator==(const Ieee80211DataSequenceTag&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:72:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 72 | virtual ~Ieee80211DataSequenceTag(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:74:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual Ieee80211DataSequenceTag *dup() const override {return new Ieee80211DataSequenceTag(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:6:9: warning: invalid case style for macro definition '__INET_IEEE80211FRAME_M_H' [readability-identifier-naming] + 6 | #define __INET_IEEE80211FRAME_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_FRAME_M_H +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:37:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 37 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 38 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:91:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 91 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 92 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:106:36: warning: performing an implicit widening conversion to type 'const value_type' (aka 'const long') of a multiplication performed in type 'int' [bugprone-implicit-widening-of-multiplication-result] + 106 | const b QOSCONTROL_PART_LENGTH = b(2 * 8); // QoS Control field length (bits) + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:106:36: note: make conversion explicit to silence this warning + 12 | const b QOSCONTROL_PART_LENGTH = b(2 * 8); // QoS Control field length (bits) + | ^~~~~ + | static_cast( ) +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:106:36: note: perform multiplication in a wider type + 106 | const b QOSCONTROL_PART_LENGTH = b(2 * 8); // QoS Control field length (bits) + | ^ + | static_cast( ) +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:228:10: warning: deleted member function should be public [modernize-use-equals-delete] + 228 | bool operator==(const Ieee80211MacTrailer&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:233:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 233 | virtual ~Ieee80211MacTrailer(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:235:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 235 | virtual Ieee80211MacTrailer *dup() const override {return new Ieee80211MacTrailer(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:236:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 236 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:237:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 237 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:292:11: warning: invalid case style for protected member 'AID' [readability-identifier-naming] + 292 | short AID = -1; + | ^~~ + | aid +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:294:26: warning: invalid case style for protected member 'MACArrive' [readability-identifier-naming] + 294 | ::omnetpp::simtime_t MACArrive = SIMTIME_ZERO; + | ^~~~~~~~~ + | macArrive +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:300:10: warning: deleted member function should be public [modernize-use-equals-delete] + 300 | bool operator==(const Ieee80211MacHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:305:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 305 | virtual ~Ieee80211MacHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:307:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 307 | virtual Ieee80211MacHeader *dup() const override {return new Ieee80211MacHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:308:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 308 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:309:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 309 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:342:31: warning: invalid case style for parameter 'AID' [readability-identifier-naming] + 342 | virtual void setAID(short AID); + | ^~~ + | aid +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:349:52: warning: invalid case style for parameter 'MACArrive' [readability-identifier-naming] + 349 | virtual void setMACArrive(::omnetpp::simtime_t MACArrive); + | ^~~~~~~~~ + | macArrive +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:382:10: warning: deleted member function should be public [modernize-use-equals-delete] + 382 | bool operator==(const Ieee80211OneAddressHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:387:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 387 | virtual ~Ieee80211OneAddressHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:389:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 389 | virtual Ieee80211OneAddressHeader *dup() const override {return new Ieee80211OneAddressHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:390:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 390 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:391:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 391 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:418:10: warning: deleted member function should be public [modernize-use-equals-delete] + 418 | bool operator==(const Ieee80211AckFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:423:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 423 | virtual ~Ieee80211AckFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:425:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 425 | virtual Ieee80211AckFrame *dup() const override {return new Ieee80211AckFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:426:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 426 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:427:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 427 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:455:10: warning: deleted member function should be public [modernize-use-equals-delete] + 455 | bool operator==(const Ieee80211TwoAddressHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:460:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 460 | virtual ~Ieee80211TwoAddressHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:462:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 462 | virtual Ieee80211TwoAddressHeader *dup() const override {return new Ieee80211TwoAddressHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:463:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 463 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:464:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 464 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:495:10: warning: deleted member function should be public [modernize-use-equals-delete] + 495 | bool operator==(const Ieee80211RtsFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:500:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 500 | virtual ~Ieee80211RtsFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:502:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 502 | virtual Ieee80211RtsFrame *dup() const override {return new Ieee80211RtsFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:503:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 503 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:504:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 504 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:531:10: warning: deleted member function should be public [modernize-use-equals-delete] + 531 | bool operator==(const Ieee80211CtsFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:536:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 536 | virtual ~Ieee80211CtsFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:538:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 538 | virtual Ieee80211CtsFrame *dup() const override {return new Ieee80211CtsFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:539:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 539 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:540:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 540 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:572:10: warning: deleted member function should be public [modernize-use-equals-delete] + 572 | bool operator==(const Ieee80211DataOrMgmtHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:577:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 577 | virtual ~Ieee80211DataOrMgmtHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:579:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 579 | virtual Ieee80211DataOrMgmtHeader *dup() const override {return new Ieee80211DataOrMgmtHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:580:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 580 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:581:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 581 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:646:10: warning: deleted member function should be public [modernize-use-equals-delete] + 646 | bool operator==(const Ieee80211DataHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:651:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 651 | virtual ~Ieee80211DataHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:653:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 653 | virtual Ieee80211DataHeader *dup() const override {return new Ieee80211DataHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:654:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 654 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:655:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 655 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:657:5: warning: method 'inet::ieee80211::Ieee80211DataHeader::getAddress4' has a similar name and the same signature as virtual method 'inet::ieee80211::Ieee80211DataOrMgmtHeader::getAddress3'; did you mean to override it? [bugprone-virtual-near-miss] + 657 | virtual const ::inet::MacAddress& getAddress4() const; + | ^ ~~~~~~~~~~~ + | getAddress3 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:658:5: warning: method 'inet::ieee80211::Ieee80211DataHeader::getAddress4ForUpdate' has a similar name and the same signature as virtual method 'inet::ieee80211::Ieee80211DataOrMgmtHeader::getAddress3ForUpdate'; did you mean to override it? [bugprone-virtual-near-miss] + 658 | virtual ::inet::MacAddress& getAddress4ForUpdate() { handleChange();return const_cast<::inet::MacAddress&>(const_cast(this)->getAddress4());} + | ^ ~~~~~~~~~~~~~~~~~~~~ + | getAddress3ForUpdate +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:659:5: warning: method 'inet::ieee80211::Ieee80211DataHeader::setAddress4' has a similar name and the same signature as virtual method 'inet::ieee80211::Ieee80211DataOrMgmtHeader::setAddress3'; did you mean to override it? [bugprone-virtual-near-miss] + 659 | virtual void setAddress4(const ::inet::MacAddress& address4); + | ^ ~~~~~~~~~~~ + | setAddress3 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:696:10: warning: deleted member function should be public [modernize-use-equals-delete] + 696 | bool operator==(const Ieee80211MgmtHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:701:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 701 | virtual ~Ieee80211MgmtHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:703:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 703 | virtual Ieee80211MgmtHeader *dup() const override {return new Ieee80211MgmtHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:704:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 704 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:705:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 705 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:735:10: warning: deleted member function should be public [modernize-use-equals-delete] + 735 | bool operator==(const Ieee80211ActionFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:740:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 740 | virtual ~Ieee80211ActionFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:742:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 742 | virtual Ieee80211ActionFrame *dup() const override {return new Ieee80211ActionFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:743:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 743 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:744:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 744 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:773:12: warning: invalid case style for protected member 'actionBody_arraysize' [readability-identifier-naming] + 773 | size_t actionBody_arraysize = 0; + | ^~~~~~~~~~~~~~~~~~~~ + | actionBodyArraysize +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:779:10: warning: deleted member function should be public [modernize-use-equals-delete] + 779 | bool operator==(const Ieee80211ActionFrameOther&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:784:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 784 | virtual ~Ieee80211ActionFrameOther(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:786:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 786 | virtual Ieee80211ActionFrameOther *dup() const override {return new Ieee80211ActionFrameOther(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:787:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 787 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:788:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 788 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:826:10: warning: deleted member function should be public [modernize-use-equals-delete] + 826 | bool operator==(const Ieee80211MsduSubframeHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:831:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 831 | virtual ~Ieee80211MsduSubframeHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:833:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 833 | virtual Ieee80211MsduSubframeHeader *dup() const override {return new Ieee80211MsduSubframeHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:834:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 834 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:835:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 835 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:871:10: warning: deleted member function should be public [modernize-use-equals-delete] + 871 | bool operator==(const Ieee80211MpduSubframeHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:876:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 876 | virtual ~Ieee80211MpduSubframeHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:878:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 878 | virtual Ieee80211MpduSubframeHeader *dup() const override {return new Ieee80211MpduSubframeHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:879:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 879 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:880:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 880 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:931:13: warning: invalid case style for protected member '_fragmentNumber' [readability-identifier-naming] + 931 | uint8_t _fragmentNumber = 0; + | ^~~~~~~~~~~~~~~ + | fragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:938:10: warning: deleted member function should be public [modernize-use-equals-delete] + 938 | bool operator==(const Ieee80211AddbaRequest&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:943:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 943 | virtual ~Ieee80211AddbaRequest(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:945:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 945 | virtual Ieee80211AddbaRequest *dup() const override {return new Ieee80211AddbaRequest(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:946:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 946 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:947:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 947 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:967:21: warning: invalid case style for method 'get_fragmentNumber' [readability-identifier-naming] + 967 | virtual uint8_t get_fragmentNumber() const; + | ^~~~~~~~~~~~~~~~~~ + | getFragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:968:18: warning: invalid case style for method 'set_fragmentNumber' [readability-identifier-naming] + 968 | virtual void set_fragmentNumber(uint8_t _fragmentNumber); + | ^~~~~~~~~~~~~~~~~~ + | setFragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:968:45: warning: invalid case style for parameter '_fragmentNumber' [readability-identifier-naming] + 968 | virtual void set_fragmentNumber(uint8_t _fragmentNumber); + | ^~~~~~~~~~~~~~~ + | fragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1021:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1021 | bool operator==(const Ieee80211AddbaResponse&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1026:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1026 | virtual ~Ieee80211AddbaResponse(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1028:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1028 | virtual Ieee80211AddbaResponse *dup() const override {return new Ieee80211AddbaResponse(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1029:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1029 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1030:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1030 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1094:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1094 | bool operator==(const Ieee80211Delba&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1099:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1099 | virtual ~Ieee80211Delba(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1101:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1101 | virtual Ieee80211Delba *dup() const override {return new Ieee80211Delba(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1102:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1102 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1103 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1152:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1152 | bool operator==(const Ieee80211BlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1157:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1157 | virtual ~Ieee80211BlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1159:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1159 | virtual Ieee80211BlockAckReq *dup() const override {return new Ieee80211BlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1160:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1160 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1161:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1161 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1211:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1211 | bool operator==(const Ieee80211BasicBlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1216:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1216 | virtual ~Ieee80211BasicBlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1218:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1218 | virtual Ieee80211BasicBlockAckReq *dup() const override {return new Ieee80211BasicBlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1219:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1219 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1220:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1220 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1269:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1269 | bool operator==(const Ieee80211CompressedBlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1274:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1274 | virtual ~Ieee80211CompressedBlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1276:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1276 | virtual Ieee80211CompressedBlockAckReq *dup() const override {return new Ieee80211CompressedBlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1277:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1277 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1278 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1314:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1314 | bool operator==(const Ieee80211MultiTidBlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1319:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1319 | virtual ~Ieee80211MultiTidBlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1321:43: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1321 | virtual Ieee80211MultiTidBlockAckReq *dup() const override {return new Ieee80211MultiTidBlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1322:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1322 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1323:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1323 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1363:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1363 | bool operator==(const Ieee80211BlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1368:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1368 | virtual ~Ieee80211BlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1370:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1370 | virtual Ieee80211BlockAck *dup() const override {return new Ieee80211BlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1371:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1371 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1372:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1372 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1434:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1434 | bool operator==(const Ieee80211BasicBlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1439:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1439 | virtual ~Ieee80211BasicBlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1441:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1441 | virtual Ieee80211BasicBlockAck *dup() const override {return new Ieee80211BasicBlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1442:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1442 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1443:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1443 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1501:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1501 | bool operator==(const Ieee80211CompressedBlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1506:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1506 | virtual ~Ieee80211CompressedBlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1508:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1508 | virtual Ieee80211CompressedBlockAck *dup() const override {return new Ieee80211CompressedBlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1509:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1509 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1510:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1510 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1554:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1554 | bool operator==(const Ieee80211MultiTidBlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1559:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1559 | virtual ~Ieee80211MultiTidBlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1561:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1561 | virtual Ieee80211MultiTidBlockAck *dup() const override {return new Ieee80211MultiTidBlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1562:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1562 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1563:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1563 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MAC_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MAC_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MAC_H +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:26:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 26 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 27 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:66:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:67:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual void initialize(int) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, intval_t value, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual void configureNetworkInterface() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual void handleMessageWhenUp(cMessage *message) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual void handleUpperCommand(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:82:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual void handleSelfMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual void handleUpperPacket(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual void handleLowerPacket(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual void handleStartOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:94:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 94 | virtual void handleStopOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:95:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 95 | virtual void handleCrashOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:102:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 102 | virtual ~Ieee80211Mac(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:106:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual void sendUp(cMessage *message) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:110:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual void resetPeerAgreements(const MacAddress& peer) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h:4:9: warning: invalid case style for macro definition '__INET_MPDUAGGREGATIONUTILS_H' [readability-identifier-naming] + 4 | #define __INET_MPDUAGGREGATIONUTILS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MPDUAGGREGATIONUTILS_H +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:9:9: warning: invalid case style for macro definition '__INET_BLOCKACKRECORD_H' [readability-identifier-naming] + 9 | #define __INET_BLOCKACKRECORD_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_BLOCKACKRECORD_H +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:34:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 34 | virtual ~BlockAckRecord() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:42:5: warning: function 'getCompressedAckState' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | bool getCompressedAckState(SequenceNumberCyclic sequenceNumber) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:43:5: warning: function 'hasCompleteReceipt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | bool hasCompleteReceipt(SequenceNumberCyclic sequenceNumber) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:44:5: warning: function 'getWindowStart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | SequenceNumberCyclic getWindowStart() const { return windowStart; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORBLOCKACKAGREEMENT_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORBLOCKACKAGREEMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORBLOCKACKAGREEMENT_H +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:40:5: warning: function 'hasPendingProbe' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | bool hasPendingProbe() const { return pendingProbe; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:52:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 52 | virtual ~OriginatorBlockAckAgreement() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:52:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 52 | virtual ~OriginatorBlockAckAgreement() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:54:5: warning: function 'getBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual int getBufferSize() const { return bufferSize; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:55:5: warning: function 'getWindowSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | int getWindowSize() const { return std::min(bufferSize, 64); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:60:5: warning: function 'containsSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | bool containsSequence(SequenceNumberCyclic sequence) const + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:80:5: warning: function 'getIsAddbaResponseReceived' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual bool getIsAddbaResponseReceived() const { return isAddbaResponseReceived; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:81:5: warning: function 'getIsAddbaRequestSent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual bool getIsAddbaRequestSent() const { return isAddbaRequestSent; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:82:5: warning: function 'getIsAMsduSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual bool getIsAMsduSupported() const { return isAMsduSupported; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:84:5: warning: function 'isAMsduPermitted' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | bool isAMsduPermitted() const { return isAMsduSupported && responseAMsduSupported; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:85:5: warning: function 'getDialogToken' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | int getDialogToken() const { return dialogToken; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:88:5: warning: function 'getFirstDataTransmitted' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | bool getFirstDataTransmitted() const { return highestTransmittedDataIndex >= 0; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:89:5: warning: function 'getHighestTransmittedDataIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | int64_t getHighestTransmittedDataIndex() const { return highestTransmittedDataIndex; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:96:5: warning: function 'getIsDelayedBlockAckPolicySupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | virtual bool getIsDelayedBlockAckPolicySupported() const { return isDelayedBlockAckPolicySupported; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:97:5: warning: function 'getReceiverAddr' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual MacAddress getReceiverAddr() const { return receiverAddr; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:98:5: warning: function 'getTid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual Tid getTid() const { return tid; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:99:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 99 | virtual const simtime_t getBlockAckTimeoutValue() const { return blockAckTimeoutValue; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:100:5: warning: function 'getNumSentBaPolicyFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | virtual int getNumSentBaPolicyFrames() const { return numSentBaPolicyFrames; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:36:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual simtime_t computeEarliestExpirationTime() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:37:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | const std::map& getAgreements() const override { return blockAckAgreements; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:38:5: warning: function 'getProcedures' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | const std::map& getProcedures() const override { return procedures; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void noteEligibleDataTransmission(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void beginSetupIntent(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void beginTeardown(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual void failTeardown(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void finishProcedure(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void markRequestAttempted(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:45:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual void acknowledgeRequest(MacAddress peer, Tid tid, simtime_t timeout) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:49:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 49 | virtual ~OriginatorBlockAckAgreementHandler(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void processTransmittedAddbaReq(const Ptr& addbaReq) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void processTransmittedDataFrame(Packet *packet, const Ptr& dataHeader, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void processReceivedBlockAck(const Ptr& blockAck, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void processReceivedAddbaResp(const Ptr& addbaResp, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void processReceivedDelba(const Ptr& delba, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void processTransmittedDelba(const Ptr& delba) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:56:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual void blockAckAgreementExpired(IProcedureCallback *procedureCallback, IBlockAckAgreementHandlerCallback *agreementHandlerCallback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:58:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual OriginatorBlockAckAgreement *getAgreement(MacAddress receiverAddr, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API OriginatorBlockAckProcedure : public IOriginatorBlockAckProcedure + 17 | { + 18 | public: + 19 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + 20 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + 21 | }; + 22 | + 23 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 24 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:19:5: warning: function 'buildCompressedBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 19 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:19:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 19 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:20:5: warning: function 'buildBasicBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 20 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:20:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 20 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTBLOCKACKAGREEMENT_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTBLOCKACKAGREEMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTBLOCKACKAGREEMENT_H +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:33:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 33 | virtual ~RecipientBlockAckAgreement() { delete blockAckRecord; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:37:5: warning: function 'getBlockAckRecord' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual BlockAckRecord *getBlockAckRecord() const { return blockAckRecord; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:38:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual simtime_t getBlockAckTimeoutValue() const { return blockAckTimeoutValue; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:39:5: warning: function 'getBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual int getBufferSize() const { return bufferSize; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:40:5: warning: function 'getVariant' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | BlockAckVariant getVariant() const { return variant; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:55:5: warning: function 'getHighestReceivedSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | const SequenceNumberCyclic& getHighestReceivedSequence() const { return highestReceivedSequence; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:56:5: warning: function 'getHighestReceivedFragment' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | int getHighestReceivedFragment() const { return highestReceivedFragment; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:57:5: warning: function 'getStartingSequenceNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual SequenceNumberCyclic getStartingSequenceNumber() const { return startingSequenceNumber; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:40:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual simtime_t computeEarliestExpirationTime() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:41:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | const std::map, RecipientBlockAckAgreement *>& getAgreements() const override { return blockAckAgreements; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:42:5: warning: function 'isTeardownPending' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | bool isTeardownPending(MacAddress peer, Tid tid) const override { return pendingTeardowns.count({peer, tid}) != 0; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:47:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 47 | virtual ~RecipientBlockAckAgreementHandler(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual void processTransmittedAddbaResp(const Ptr& addbaResp, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual void processReceivedAddbaRequest(const Ptr& addbaRequest, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void processReceivedDelba(const Ptr& delba, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void qosFrameReceived(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void implicitBlockAckRequested(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void processTransmittedDelba(const Ptr& delba) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void blockAckAgreementExpired(IProcedureCallback *procedureCallback, IBlockAckAgreementHandlerCallback *agreementHandlerCallback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:56:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual RecipientBlockAckAgreement *getAgreement(Tid tid, MacAddress originatorAddr) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void processReceivedBlockAckReq(Packet *blockAckPacket, const Ptr& blockAckReq, IRecipientQosAckPolicy *ackPolicy, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual void processTransmittedBlockAck(const Ptr& blockAck) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:9:9: warning: invalid case style for macro definition '__INET_BLOCKACKREORDERING_H' [readability-identifier-naming] + 9 | #define __INET_BLOCKACKREORDERING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_BLOCKACKREORDERING_H +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:27:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 27 | typedef std::vector Fragments; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fragments = std::vector +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:28:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 28 | typedef std::map ReorderBuffer; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ReorderBuffer = std::map +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:30:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 30 | typedef std::vector> ReleasedFrames; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ReleasedFrames = std::vector> +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:9:9: warning: invalid case style for macro definition '__INET_RECEIVEBUFFER_H' [readability-identifier-naming] + 9 | #define __INET_RECEIVEBUFFER_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_RECEIVEBUFFER_H +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:21:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 21 | typedef std::vector Fragments; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fragments = std::vector +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:22:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 22 | typedef std::map ReorderBuffer; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ReorderBuffer = std::map +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:9:9: warning: invalid case style for macro definition '__INET_DCAF_H' [readability-identifier-naming] + 9 | #define __INET_DCAF_H + | ^~~~~~~~~~~~~ + | INET_DCAF_H +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:42:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:46:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void requestChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void releaseChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void channelAccessGranted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:58:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual void expectedChannelAccess(simtime_t time) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:61:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual void incrementCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:62:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual void resetCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:63:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual int getCw() override { return cw; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:9:9: warning: invalid case style for macro definition '__INET_EDCA_H' [readability-identifier-naming] + 9 | #define __INET_EDCA_H + | ^~~~~~~~~~~~~ + | INET_EDCA_H +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:30:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:34:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 34 | virtual ~Edca(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:9:9: warning: invalid case style for macro definition '__INET_EDCAF_H' [readability-identifier-naming] + 9 | #define __INET_EDCAF_H + | ^~~~~~~~~~~~~~ + | INET_EDCAF_H +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:26:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 26 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 27 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:65:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:67:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:78:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 78 | virtual ~Edcaf(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual void requestChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual void releaseChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:95:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 95 | virtual void channelAccessGranted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:96:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 96 | virtual void expectedChannelAccess(simtime_t time) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:99:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual void incrementCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:100:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 100 | virtual void resetCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:101:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 101 | virtual int getCw() override { return cw; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:9:9: warning: invalid case style for macro definition '__INET_HCCA_H' [readability-identifier-naming] + 9 | #define __INET_HCCA_H + | ^~~~~~~~~~~~~ + | INET_HCCA_H +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:23:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:24:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 24 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void requestChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void releaseChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/AccessCategory.h:9:9: warning: invalid case style for macro definition '__INET_ACCESSCATEGORY_H' [readability-identifier-naming] + 9 | #define __INET_ACCESSCATEGORY_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ACCESSCATEGORY_H +./inet/linklayer/ieee80211/mac/common/AccessCategory.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211DEFS_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211DEFS_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_DEFS_H +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:16:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 16 | typedef int8_t FragmentNumber; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using FragmentNumber = int8_t +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:17:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 17 | typedef int8_t Tid; + | ^~~~~~~~~~~~~~~~~~ + | using Tid = int8_t +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:18:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 18 | typedef int16_t SequenceNumber; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using SequenceNumber = int16_t +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:30:5: warning: function 'modulo4096' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | SequenceNumber modulo4096(SequenceNumber value) const { return (value % 4096 + 4096) % 4096; } // always returns positive result + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:31:5: warning: function 'distance4096' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | SequenceNumber distance4096(SequenceNumber other) const { ASSERT(0 <= other && other < 4096); return (value - other + 4096) % 4096; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:38:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | SequenceNumber get() const { ASSERT(value != -1); return value; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:40:5: warning: function 'isSpecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | bool isSpecified() const { return value != -1; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:42:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | std::string str() const { return value == -1 ? std::string("unspecified") : std::to_string(value); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:9:9: warning: invalid case style for macro definition '__INET_MODESETLISTENER_H' [readability-identifier-naming] + 9 | #define __INET_MODESETLISTENER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODESETLISTENER_H +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API ModeSetListener : public SimpleModule, public cListener + 18 | { + 19 | protected: + 20 | physicallayer::Ieee80211ModeSet *modeSet = nullptr; + 21 | + 22 | protected: + 23 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + 24 | virtual void initialize(int stage) override; + 25 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + 26 | }; + 27 | + 28 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 29 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:23:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:24:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 24 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:25:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:9:9: warning: invalid case style for macro definition '__INET_SEQUENCECONTROLFIELD_H' [readability-identifier-naming] + 9 | #define __INET_SEQUENCECONTROLFIELD_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_SEQUENCECONTROLFIELD_H +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:26: warning: 2 adjacent parameters of 'SequenceControlField' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:41: note: the first parameter in the range is 'sequenceNumber' + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:72: note: the last parameter in the range is 'fragmentNumber' + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:26: note: + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:57: note: 'SequenceNumber' and 'FragmentNumber' may be implicitly converted: 'SequenceNumber' (as 'short') -> 'FragmentNumber' (as 'signed char'), 'FragmentNumber' (as 'signed char') -> 'SequenceNumber' (as 'short') + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:35:5: warning: function 'getSequenceNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | SequenceNumber getSequenceNumber() const { return sequenceNumber; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:36:5: warning: function 'getFragmentNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | FragmentNumber getFragmentNumber() const { return fragmentNumber; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:9:9: warning: invalid case style for macro definition '__INET_STATIONRETRYCOUNTERS_H' [readability-identifier-naming] + 9 | #define __INET_STATIONRETRYCOUNTERS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_STATIONRETRYCOUNTERS_H +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:23:5: warning: function 'getStationLongRetryCount' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | int getStationLongRetryCount() const { return stationLongRetryCount; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:24:5: warning: function 'getStationShortRetryCount' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | int getStationShortRetryCount() const { return stationShortRetryCount; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/AmpduReception.h:4:9: warning: invalid case style for macro definition '__INET_AMPDURECEPTION_H' [readability-identifier-naming] + 4 | #define __INET_AMPDURECEPTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_AMPDURECEPTION_H +./inet/linklayer/ieee80211/mac/contract/AmpduReception.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h:4:9: warning: invalid case style for macro definition '__INET_BLOCKACKVARIANT_H' [readability-identifier-naming] + 4 | #define __INET_BLOCKACKVARIANT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_BLOCKACKVARIANT_H +./inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h:6:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 6 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 7 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 8 | + 9 | enum class BlockAckVariant { BASIC, COMPRESSED }; + 10 | + 11 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 12 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_FRAMETRANSMISSIONDETAILS_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_FRAMETRANSMISSIONDETAILS_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_FRAMETRANSMISSIONDETAILS_M_H +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 33 | + 34 | class FrameTransmissionDetails; + 35 | + 36 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:42:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 42 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 43 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:90:10: warning: deleted member function should be public [modernize-use-equals-delete] + 90 | bool operator==(const FrameTransmissionDetails&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:95:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 95 | virtual ~FrameTransmissionDetails(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:97:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual FrameTransmissionDetails *dup() const override {return new FrameTransmissionDetails(*this);} + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:97:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 97 | virtual FrameTransmissionDetails *dup() const override {return new FrameTransmissionDetails(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:98:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 98 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:99:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:101:5: warning: function 'getStatus' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | virtual FrameTransmissionStatus getStatus() const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IAckHandler.h:9:9: warning: invalid case style for macro definition '__INET_IACKHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IACKHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IACKHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IAckHandler.h:11:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 11 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 12 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IAckHandler.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~IAckHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h:9:9: warning: invalid case style for macro definition '__INET_IBLOCKACKAGREEMENTHANDLERCALLBACK_H' [readability-identifier-naming] + 9 | #define __INET_IBLOCKACKAGREEMENTHANDLERCALLBACK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IBLOCKACKAGREEMENTHANDLERCALLBACK_H +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API IBlockAckAgreementHandlerCallback + 17 | { + 18 | public: + 19 | virtual ~IBlockAckAgreementHandlerCallback() {} + 20 | + 21 | // The coordinator recomputes the earliest absolute deadline across both agreement roles. + 22 | virtual void scheduleInactivityTimer() = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~IBlockAckAgreementHandlerCallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h:4:9: warning: invalid case style for macro definition '__INET_IBLOCKACKAGREEMENTLIFECYCLE_H' [readability-identifier-naming] + 4 | #define __INET_IBLOCKACKAGREEMENTLIFECYCLE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IBLOCKACKAGREEMENTLIFECYCLE_H +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h:8:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 8 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 9 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 10 | + 11 | // Management supplies the old peer identity before association replacement or loss. + 12 | class INET_API IBlockAckAgreementLifecycle + 13 | { + 14 | public: + 15 | virtual ~IBlockAckAgreementLifecycle() {} + 16 | virtual void resetPeerAgreements(const MacAddress& peer) = 0; + 17 | }; + 18 | + 19 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 20 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h:15:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 15 | virtual ~IBlockAckAgreementLifecycle() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:9:9: warning: invalid case style for macro definition '__INET_ICHANNELACCESS_H' [readability-identifier-naming] + 9 | #define __INET_ICHANNELACCESS_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ICHANNELACCESS_H +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:24:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 24 | virtual ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:30:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 30 | virtual ~IChannelAccess() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IContention.h:9:9: warning: invalid case style for macro definition '__INET_ICONTENTION_H' [readability-identifier-naming] + 9 | #define __INET_ICONTENTION_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_ICONTENTION_H +./inet/linklayer/ieee80211/mac/contract/IContention.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IContention.h:40:9: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 40 | ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IContention.h:46:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 46 | virtual ~IContention() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h:9:9: warning: invalid case style for macro definition '__INET_ICOORDINATIONFUNCTION_H' [readability-identifier-naming] + 9 | #define __INET_ICOORDINATIONFUNCTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ICOORDINATIONFUNCTION_H +./inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~ICoordinationFunction() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:9:9: warning: invalid case style for macro definition '__INET_ICTSPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_ICTSPOLICY_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ICTSPOLICY_H +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API ICtsPolicy + 18 | { + 19 | public: + 20 | virtual ~ICtsPolicy() {} + 21 | + 22 | virtual bool isCtsNeeded(const Ptr& rtsFrame) const = 0; + 23 | virtual simtime_t computeCtsDurationField(Packet *packet, const Ptr& rtsFrame) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~ICtsPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:22:5: warning: function 'isCtsNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isCtsNeeded(const Ptr& rtsFrame) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/ICtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_ICTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_ICTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_ICTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/ICtsProcedure.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 18 | + 19 | class INET_API ICtsProcedure + 20 | { + 21 | public: + 22 | virtual ~ICtsProcedure() {} + 23 | + 24 | virtual void processReceivedRts(Packet *rtsPacket, const Ptr& rtsFrame, ICtsPolicy *ctsPolicy, IProcedureCallback *callback) = 0; + 25 | virtual void processTransmittedCts(const Ptr& ctsFrame) = 0; + 26 | }; + 27 | + 28 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 29 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ICtsProcedure.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~ICtsProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IDs.h:9:9: warning: invalid case style for macro definition '__INET_IDS_H' [readability-identifier-naming] + 9 | #define __INET_IDS_H + | ^~~~~~~~~~~~ + | INET_IDS_H +./inet/linklayer/ieee80211/mac/contract/IDs.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | /** + 18 | * Abstract interface for distribution service. + 19 | */ + 20 | class INET_API IDs + 21 | { + 22 | public: + 23 | virtual ~IDs() {} + 24 | + 25 | virtual void processDataFrame(Packet *packet, const Ptr& header) = 0; + 26 | }; + 27 | + 28 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 29 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IDs.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IDs() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IEdcaCollisionController.h:9:9: warning: invalid case style for macro definition '__INET_IEDCACOLLISIONCONTROLLER_H' [readability-identifier-naming] + 9 | #define __INET_IEDCACOLLISIONCONTROLLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEDCACOLLISIONCONTROLLER_H +./inet/linklayer/ieee80211/mac/contract/IEdcaCollisionController.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class Edcaf; + 17 | + 18 | class INET_API IEdcaCollisionController + 19 | { + 20 | public: + 21 | virtual ~IEdcaCollisionController() {} + 22 | + 23 | virtual void expectedChannelAccess(Edcaf *channelAccess, simtime_t time) = 0; + 24 | virtual bool isInternalCollision(Edcaf *channelAccess) = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IEdcaCollisionController.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IEdcaCollisionController() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFragmentation.h:9:9: warning: invalid case style for macro definition '__INET_IFRAGMENTATION_H' [readability-identifier-naming] + 9 | #define __INET_IFRAGMENTATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAGMENTATION_H +./inet/linklayer/ieee80211/mac/contract/IFragmentation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class Ieee80211DataOrMgmtHeader; + 17 | + 18 | class INET_API IFragmentation + 19 | { + 20 | public: + 21 | virtual ~IFragmentation() {} + 22 | + 23 | virtual std::vector *fragmentFrame(Packet *frame, const std::vector& fragmentSizes) = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IFragmentation.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IFragmentation() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IFRAGMENTATIONPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IFRAGMENTATIONPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAGMENTATIONPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h:29:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 29 | virtual ~IFragmentationPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:9:9: warning: invalid case style for macro definition '__INET_IFRAMESEQUENCE_H' [readability-identifier-naming] + 9 | #define __INET_IFRAMESEQUENCE_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAMESEQUENCE_H +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:34:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 34 | virtual ~IFrameSequenceStep() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual Type getType() override { return Type::TRANSMIT; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual Type getType() override { return Type::RECEIVE; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:63:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 63 | virtual ~IFrameSequence() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:69:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual std::string getHistory() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:9:9: warning: invalid case style for macro definition '__INET_IFRAMESEQUENCEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IFRAMESEQUENCEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAMESEQUENCEHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:27:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 27 | virtual ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:42:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 42 | virtual ~IFrameSequenceHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:44:5: warning: function 'getContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const FrameSequenceContext *getContext() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:45:5: warning: function 'getFrameSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual const IFrameSequence *getFrameSequence() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h:9:9: warning: invalid case style for macro definition '__INET_IMPDUAGGREGATION_H' [readability-identifier-naming] + 9 | #define __INET_IMPDUAGGREGATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMPDUAGGREGATION_H +./inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IMpduAggregation() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IMPDUAGGREGATIONPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IMPDUAGGREGATIONPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMPDUAGGREGATIONPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:33:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 33 | virtual ~IMpduAggregationPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:36:5: warning: function 'isEnabled' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual bool isEnabled() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:38:5: warning: function 'selectFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual std::vector selectFrames(const std::vector& candidates, const MpduAggregationLimits& limits) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IMsduAggregation.h:9:9: warning: invalid case style for macro definition '__INET_IMSDUAGGREGATION_H' [readability-identifier-naming] + 9 | #define __INET_IMSDUAGGREGATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMSDUAGGREGATION_H +./inet/linklayer/ieee80211/mac/contract/IMsduAggregation.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IMsduAggregation + 18 | { + 19 | public: + 20 | virtual ~IMsduAggregation() {} + 21 | + 22 | virtual Packet *aggregateFrames(std::vector *frames) = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IMsduAggregation.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IMsduAggregation() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IMsduAggregationPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IMSDUAGGREGATIONPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IMSDUAGGREGATIONPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMSDUAGGREGATIONPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IMsduAggregationPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IMsduAggregationPolicy + 18 | { + 19 | public: + 20 | virtual ~IMsduAggregationPolicy() {} + 21 | + 22 | virtual std::vector *computeAggregateFrames(queueing::IPacketQueue *queue) = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IMsduAggregationPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IMsduAggregationPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IOriginatorAckPolicy + 18 | { + 19 | public: + 20 | virtual ~IOriginatorAckPolicy() {} + 21 | + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + 23 | virtual simtime_t getAckTimeout(Packet *packet, const Ptr& header) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IOriginatorAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:22:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:25:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 25 | typedef std::pair AgreementId; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using AgreementId = std::pair +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:32:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 32 | virtual ~IOriginatorBlockAckAgreementHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:33:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const std::map& getAgreements() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:34:5: warning: function 'getProcedures' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual const std::map& getProcedures() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORBLOCKACKAGREEMENTPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORBLOCKACKAGREEMENTPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORBLOCKACKAGREEMENTPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IOriginatorBlockAckAgreementPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:25:5: warning: function 'isProfileAllowed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:31:5: warning: function 'isMsduSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual bool isMsduSupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:32:5: warning: function 'computeAddbaFailureTimeout' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual simtime_t computeAddbaFailureTimeout() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:33:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual simtime_t getBlockAckTimeoutValue() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:34:5: warning: function 'isDelayedAckPolicySupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual bool isDelayedAckPolicySupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:35:5: warning: function 'getMaximumAllowedBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual int getMaximumAllowedBufferSize() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IOriginatorBlockAckProcedure + 18 | { + 19 | public: + 20 | virtual ~IOriginatorBlockAckProcedure() {} + 21 | + 22 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + 23 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IOriginatorBlockAckProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:22:5: warning: function 'buildCompressedBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:23:5: warning: function 'buildBasicBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API IOriginatorMacDataService + 17 | { + 18 | public: + 19 | static simsignal_t packetFragmentedSignal; + 20 | static simsignal_t packetAggregatedSignal; + 21 | + 22 | public: + 23 | virtual ~IOriginatorMacDataService() {} + 24 | + 25 | virtual std::vector *extractFramesToTransmit(queueing::IPacketQueue *pendingQueue) = 0; + 26 | }; + 27 | + 28 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IOriginatorMacDataService() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORQOSACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORQOSACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORQOSACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IOriginatorQoSAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:27:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:8:9: warning: invalid case style for macro definition '__INET_IORIGINATORQOSMACDATASERVICE_H' [readability-identifier-naming] + 8 | #define __INET_IORIGINATORQOSMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORQOSMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:58:5: warning: function 'getNextSequenceNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:59:5: warning: function 'hasAMsduAggregation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual bool hasAMsduAggregation() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:60:5: warning: function 'hasAMpduAggregation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual bool hasAMpduAggregation() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:63:5: warning: function 'isBatchValid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual bool isBatchValid(const PreparedQosBatch& batch, simtime_t start) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:66:5: warning: function 'buildAggregate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual Packet *buildAggregate(const PreparedQosBatch& batch, const MpduAggregationLimits& limits) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:69:5: warning: function 'isPreparationValid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IProcedureCallback.h:9:9: warning: invalid case style for macro definition '__INET_IPROCEDURECALLBACK_H' [readability-identifier-naming] + 9 | #define __INET_IPROCEDURECALLBACK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPROCEDURECALLBACK_H +./inet/linklayer/ieee80211/mac/contract/IProcedureCallback.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IProcedureCallback + 18 | { + 19 | public: + 20 | virtual ~IProcedureCallback() {} + 21 | + 22 | virtual void transmitControlResponseFrame(Packet *responsePacket, const Ptr& responseHeader, Packet *receivedPacket, const Ptr& receivedHeader) = 0; + 23 | virtual void processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IProcedureCallback.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IProcedureCallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h:9:9: warning: invalid case style for macro definition '__INET_IQOSRATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_IQOSRATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IQOSRATESELECTION_H +./inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h:28:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 28 | virtual ~IQosRateSelection() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRateControl.h:9:9: warning: invalid case style for macro definition '__INET_IRATECONTROL_H' [readability-identifier-naming] + 9 | #define __INET_IRATECONTROL_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IRATECONTROL_H +./inet/linklayer/ieee80211/mac/contract/IRateControl.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRateControl.h:27:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 27 | virtual ~IRateControl() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRateSelection.h:9:9: warning: invalid case style for macro definition '__INET_IRATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_IRATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRATESELECTION_H +./inet/linklayer/ieee80211/mac/contract/IRateSelection.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRateSelection.h:31:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 31 | virtual ~IRateSelection() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IRecipientAckPolicy + 18 | { + 19 | public: + 20 | virtual ~IRecipientAckPolicy() {} + 21 | + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + 23 | virtual simtime_t computeAckDurationField(Packet *packet, const Ptr& header) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IRecipientAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:22:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientAckProcedure.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 17 | + 18 | class INET_API IRecipientAckProcedure + 19 | { + 20 | public: + 21 | virtual ~IRecipientAckProcedure() {} + 22 | + 23 | virtual void processReceivedFrame(Packet *packet, const Ptr& dataOrMgmtHeader, IRecipientAckPolicy *ackPolicy, IProcedureCallback *callback) = 0; + 24 | virtual void processTransmittedAck(const Ptr& ack) = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRecipientAckProcedure.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IRecipientAckProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:25:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 25 | virtual ~IRecipientBlockAckAgreementHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:27:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual const std::map, RecipientBlockAckAgreement *>& getAgreements() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:30:5: warning: function 'isTeardownPending' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual bool isTeardownPending(MacAddress peer, Tid tid) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTBLOCKACKAGREEMENTPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTBLOCKACKAGREEMENTPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTBLOCKACKAGREEMENTPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IRecipientBlockAckAgreementPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:22:5: warning: function 'isProfileAllowed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:27:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual simtime_t getBlockAckTimeoutValue() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:28:5: warning: function 'aMsduSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual bool aMsduSupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:29:5: warning: function 'delayedBlockAckPolicySupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual bool delayedBlockAckPolicySupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:30:5: warning: function 'getMaximumAllowedBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual int getMaximumAllowedBufferSize() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h:14:9: warning: invalid case style for macro definition '__INET_IRECIPIENTBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 14 | #define __INET_IRECIPIENTBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 18 | + 19 | class INET_API IRecipientBlockAckProcedure + 20 | { + 21 | public: + 22 | virtual ~IRecipientBlockAckProcedure() {} + 23 | + 24 | virtual void processReceivedBlockAckReq(Packet *packet, const Ptr& blockAckReq, IRecipientQosAckPolicy *ackPolicy, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, IProcedureCallback *callback) = 0; + 25 | virtual void processTransmittedBlockAck(const Ptr& blockAck) = 0; + 26 | virtual Ptr buildCompressedBlockAck(MacAddress peer, Tid tid, RecipientBlockAckAgreement *agreement) = 0; + 27 | }; + 28 | + 29 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 30 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~IRecipientBlockAckProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientMacDataService.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientMacDataService.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IRecipientMacDataService() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTQOSACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTQOSACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTQOSACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~IRecipientQosAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:24:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTQOSMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTQOSMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTQOSMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h:26:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 26 | virtual ~IRecipientQosMacDataService() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IRECOVERYPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IRECOVERYPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECOVERYPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:25:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 25 | virtual ~ICwCalculator() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:33:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 33 | virtual ~IRecoveryProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRTSPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRTSPOLICY_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_IRTSPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IRtsPolicy + 18 | { + 19 | public: + 20 | virtual ~IRtsPolicy() {} + 21 | + 22 | virtual bool isRtsNeeded(Packet *packet, const Ptr& protectedHeader) const = 0; + 23 | virtual simtime_t getCtsTimeout(Packet *packet, const Ptr& rtsFrame) const = 0; + 24 | virtual int getRtsThreshold() const = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IRtsPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:24:5: warning: function 'getRtsThreshold' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual int getRtsThreshold() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IRTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IRTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IRTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API IRtsProcedure + 17 | { + 18 | public: + 19 | virtual ~IRtsProcedure() {} + 20 | + 21 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const = 0; + 22 | virtual void processTransmittedRts(const Ptr& rtsFrame) = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~IRtsProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:21:5: warning: function 'buildRtsFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRx.h:9:9: warning: invalid case style for macro definition '__INET_IRX_H' [readability-identifier-naming] + 9 | #define __INET_IRX_H + | ^~~~~~~~~~~~ + | INET_IRX_H +./inet/linklayer/ieee80211/mac/contract/IRx.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRx.h:33:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 33 | virtual ~IRx() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRx.h:35:5: warning: function 'isReceptionInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual bool isReceptionInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRx.h:38:5: warning: function 'isMediumFree' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual bool isMediumFree() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRx.h:41:5: warning: function 'getTxnavRemaining' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual simtime_t getTxnavRemaining() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/ISequenceNumberAssignment.h:9:9: warning: invalid case style for macro definition '__INET_ISEQUENCENUMBERASSIGNMENT_H' [readability-identifier-naming] + 9 | #define __INET_ISEQUENCENUMBERASSIGNMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISEQUENCENUMBERASSIGNMENT_H +./inet/linklayer/ieee80211/mac/contract/ISequenceNumberAssignment.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API ISequenceNumberAssignment + 17 | { + 18 | public: + 19 | virtual ~ISequenceNumberAssignment() {} + 20 | + 21 | virtual void assignSequenceNumber(const Ptr& header) = 0; + 22 | }; + 23 | + 24 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ISequenceNumberAssignment.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~ISequenceNumberAssignment() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ITransmitLifetimeHandler.h:9:9: warning: invalid case style for macro definition '__INET_ITRANSMITLIFETIMEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_ITRANSMITLIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ITRANSMITLIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/contract/ITransmitLifetimeHandler.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API ITransmitLifetimeHandler + 17 | { + 18 | public: + 19 | virtual ~ITransmitLifetimeHandler() {} + 20 | + 21 | virtual void frameGotInProgess(const Ptr& header) = 0; + 22 | virtual void frameTransmitted(const Ptr& header) = 0; + 23 | + 24 | virtual bool isLifetimeExpired(const Ptr& header) = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ITransmitLifetimeHandler.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~ITransmitLifetimeHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ITx.h:9:9: warning: invalid case style for macro definition '__INET_ITX_H' [readability-identifier-naming] + 9 | #define __INET_ITX_H + | ^~~~~~~~~~~~ + | INET_ITX_H +./inet/linklayer/ieee80211/mac/contract/ITx.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/ITx.h:26:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 26 | virtual ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ITx.h:40:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 40 | virtual ~ITx() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:9:9: warning: invalid case style for macro definition '__INET_DCF_H' [readability-identifier-naming] + 9 | #define __INET_DCF_H + | ^~~~~~~~~~~~ + | INET_DCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:32:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 32 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 33 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:86:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:87:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:89:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual void handleMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:90:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual void channelGranted(IChannelAccess *channelAccess) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:106:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual bool transmitFrame(Packet *packet, simtime_t ifs) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:107:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual void frameSequenceStarted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:108:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual void originatorProcessRtsProtectionFailed(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:109:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual void originatorProcessTransmittedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:110:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual void originatorProcessReceivedFrame(Packet *packet, Packet *lastTransmittedPacket) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:111:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 111 | virtual void originatorProcessFailedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:112:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 112 | virtual void frameSequenceFinished() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:113:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 113 | virtual void scheduleStartRxTimer(simtime_t timeout) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:116:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 116 | virtual void frameTransmissionStarted(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:117:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 117 | virtual void transmissionComplete(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:120:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 120 | virtual void transmitControlResponseFrame(Packet *responsePacket, const Ptr& responseHeader, Packet *receivedPacket, const Ptr& receivedHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:121:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 121 | virtual void processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:127:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 127 | virtual ~Dcf(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:130:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 130 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:131:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 131 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:132:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 132 | virtual void corruptedFrameReceived() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:9:9: warning: invalid case style for macro definition '__INET_HCF_H' [readability-identifier-naming] + 9 | #define __INET_HCF_H + | ^~~~~~~~~~~~ + | INET_HCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:46:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 46 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 47 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:169:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:170:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:171:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 171 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:172:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 172 | virtual void handleMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:173:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 173 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:174:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 174 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, bool value, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:175:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 175 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, intval_t value, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:176:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 176 | virtual void refreshDisplay() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:261:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 261 | virtual void originatorProcessRtsProtectionFailed(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:262:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 262 | virtual void originatorProcessTransmittedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:263:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 263 | virtual void originatorProcessReceivedFrame(Packet *packet, Packet *lastTransmittedPacket) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:264:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 264 | virtual void originatorProcessFailedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:265:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 265 | virtual void frameSequenceStarted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:266:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 266 | virtual void frameSequenceFinished() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:267:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 267 | virtual bool transmitFrame(Packet *packet, simtime_t ifs) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:268:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 268 | virtual void scheduleStartRxTimer(simtime_t timeout) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:271:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 271 | virtual void channelGranted(IChannelAccess *channelAccess) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:274:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 274 | virtual void transmissionComplete(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:277:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 277 | virtual void transmitControlResponseFrame(Packet *responsePacket, const Ptr& responseHeader, Packet *receivedPacket, const Ptr& receivedHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 278 | virtual void processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:281:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 281 | virtual void scheduleInactivityTimer() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:286:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 286 | virtual ~Hcf(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:290:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 290 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:291:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 291 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:293:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 293 | virtual void corruptedFrameReceived() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:9:9: warning: invalid case style for macro definition '__INET_MCF_H' [readability-identifier-naming] + 9 | #define __INET_MCF_H + | ^~~~~~~~~~~~ + | INET_MCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:25:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:28:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 28 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void corruptedFrameReceived() override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:9:9: warning: invalid case style for macro definition '__INET_PCF_H' [readability-identifier-naming] + 9 | #define __INET_PCF_H + | ^~~~~~~~~~~~ + | INET_PCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:28:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 28 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:32:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:33:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual void corruptedFrameReceived() override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:9:9: warning: invalid case style for macro definition '__INET_FRAMESEQUENCECONTEXT_H' [readability-identifier-naming] + 9 | #define __INET_FRAMESEQUENCECONTEXT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_FRAMESEQUENCECONTEXT_H +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:29:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 29 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 30 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:108:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 108 | virtual ~FrameSequenceContext(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:110:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 110 | virtual simtime_t getDuration() const { return simTime() - startTime; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:114:5: warning: function 'getNumSteps' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | virtual int getNumSteps() const { return steps.size(); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:115:5: warning: function 'getStep' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | virtual IFrameSequenceStep *getStep(int i) const { return steps[i]; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:116:5: warning: function 'getLastStep' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | virtual IFrameSequenceStep *getLastStep() const { return steps.size() > 0 ? steps.back() : nullptr; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:117:5: warning: function 'getStepBeforeLast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 117 | virtual IFrameSequenceStep *getStepBeforeLast() const { return steps.size() > 1 ? steps[steps.size() - 2] : nullptr; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:119:5: warning: function 'getInProgressFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 119 | virtual InProgressFrames *getInProgressFrames() const { return inProgressFrames; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:121:5: warning: function 'getDataFrameToTransmit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | Packet *getDataFrameToTransmit() const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:122:5: warning: function 'getRtsProcedure' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | virtual IRtsProcedure *getRtsProcedure() const { return rtsProcedure; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:123:5: warning: function 'getRtsPolicy' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | virtual IRtsPolicy *getRtsPolicy() const { return rtsPolicy; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:125:5: warning: function 'getNonQoSContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 125 | virtual NonQoSContext *getNonQoSContext() const { return nonQoSContext; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:126:5: warning: function 'getQoSContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 126 | virtual QoSContext *getQoSContext() const { return qosContext; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:130:5: warning: function 'getIfs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 130 | virtual simtime_t getIfs() const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:132:5: warning: function 'isForUs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 132 | virtual bool isForUs(const Ptr& header) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:133:5: warning: function 'isSentByUs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual bool isSentByUs(const Ptr& header) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:139:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 139 | virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:146:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 146 | virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:9:9: warning: invalid case style for macro definition '__INET_FRAMESEQUENCEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_FRAMESEQUENCEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_FRAMESEQUENCEHANDLER_H +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:33:5: warning: function 'getContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const FrameSequenceContext *getContext() const override { return context; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:33:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual const FrameSequenceContext *getContext() const override { return context; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:34:5: warning: function 'getFrameSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual const IFrameSequence *getFrameSequence() const override { return frameSequence; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:34:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual const IFrameSequence *getFrameSequence() const override { return frameSequence; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void startFrameSequence(IFrameSequence *frameSequence, FrameSequenceContext *context, IFrameSequenceHandler::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void processResponse(Packet *frame) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void transmissionComplete() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:38:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual void handleStartRxTimeout() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void interruptFrameSequence() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual bool isSequenceRunning() override { return frameSequence != nullptr; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:42:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 42 | virtual ~FrameSequenceHandler(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:9:9: warning: invalid case style for macro definition '__INET_FRAMESEQUENCESTEP_H' [readability-identifier-naming] + 9 | #define __INET_FRAMESEQUENCESTEP_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_FRAMESEQUENCESTEP_H +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:36:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 36 | virtual ~TransmitStep() { if (owner) delete frameToTransmit; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:38:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual Completion getCompletion() override { return completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void setCompletion(Completion completion) override { this->completion = completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:40:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual Packet *getFrameToTransmit() override { return frameToTransmit; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:41:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual simtime_t getIfs() override { return ifs; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:42:5: warning: function 'getPpduEnd' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | simtime_t getPpduEnd() const { return ppduEnd; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:52:21: warning: 2 adjacent parameters of 'RtsTransmitStep' of similar type ('Packet *') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 52 | RtsTransmitStep(Packet *protectedFrame, Packet *frame, simtime_t ifs) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:52:29: note: the first parameter in the range is 'protectedFrame' + 52 | RtsTransmitStep(Packet *protectedFrame, Packet *frame, simtime_t ifs) : + | ^~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:52:53: note: the last parameter in the range is 'frame' + 52 | RtsTransmitStep(Packet *protectedFrame, Packet *frame, simtime_t ifs) : + | ^~~~~ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:66:5: warning: function 'getPreparedData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | const PreparedDataTransmission *getPreparedData() const { return prepared.get(); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:80:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 80 | virtual ~ReceiveStep() { delete receivedFrame; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:82:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual Completion getCompletion() override { return completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:83:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual void setCompletion(Completion completion) override { this->completion = completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:84:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual simtime_t getTimeout() override { return timeout; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:85:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual Packet *getReceivedFrame() override { return receivedFrame; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:86:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual void setFrameToReceive(Packet *frame) override { this->receivedFrame = frame; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:9:9: warning: invalid case style for macro definition '__INET_GENERICFRAMESEQUENCES_H' [readability-identifier-naming] + 9 | #define __INET_GENERICFRAMESEQUENCES_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_GENERICFRAMESEQUENCES_H +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:34:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 34 | virtual ~SequentialFs(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:38:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:41:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:41:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:54:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 54 | virtual ~OptionalFs() { delete element; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:61:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:62:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:64:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:64:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:79:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 79 | virtual ~RepeatingFs() { delete element; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:87:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:90:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:90:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:103:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 103 | virtual ~AlternativesFs(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:109:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:110:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:111:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 111 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:113:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 113 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:113:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 113 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:8:9: warning: invalid case style for macro definition '__INET_HCFFS_H' [readability-identifier-naming] + 8 | #define __INET_HCFFS_H + | ^~~~~~~~~~~~~~ + | INET_HCFFS_H +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 12 | + 13 | class INET_API HcfFs : public AlternativesFs + 14 | { + 15 | public: + 16 | HcfFs(); + 17 | virtual ~HcfFs() {} + 18 | + 19 | virtual int selectHcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 20 | virtual int selectDataOrManagementSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 21 | virtual bool isSelfCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *context); + 22 | virtual bool hasMoreTxOps(RepeatingFs *frameSequence, FrameSequenceContext *context); + 23 | virtual bool hasMoreTxOpsAndMulticast(RepeatingFs *frameSequence, FrameSequenceContext *context); + 24 | }; + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:17:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 17 | virtual ~HcfFs() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:17:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 17 | virtual ~HcfFs() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/McfFs.h:9:9: warning: invalid case style for macro definition '__INET_MCFFS_H' [readability-identifier-naming] + 9 | #define __INET_MCFFS_H + | ^~~~~~~~~~~~~~ + | INET_MCFFS_H +./inet/linklayer/ieee80211/mac/framesequence/McfFs.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API McfFs : public AlternativesFs + 17 | { + 18 | public: + 19 | McfFs(); + 20 | + 21 | virtual int selectMcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 22 | }; + 23 | + 24 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/framesequence/PcfFs.h:9:9: warning: invalid case style for macro definition '__INET_PCFFS_H' [readability-identifier-naming] + 9 | #define __INET_PCFFS_H + | ^~~~~~~~~~~~~~ + | INET_PCFFS_H +./inet/linklayer/ieee80211/mac/framesequence/PcfFs.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API PcfFs : public AlternativesFs + 17 | { + 18 | public: + 19 | PcfFs(); + 20 | + 21 | virtual int selectPcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 22 | }; + 23 | + 24 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/lifetime/DcfReceiveLifetimeHandler.h:8:9: warning: invalid case style for macro definition '__INET_DCFRECEIVELIFETIMEHANDLER_H' [readability-identifier-naming] + 8 | #define __INET_DCFRECEIVELIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_DCFRECEIVELIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/lifetime/DcfReceiveLifetimeHandler.h:12:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 12 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 13 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 14 | + 15 | class INET_API DcfReceiveLifetimeHandler + 16 | { + 17 | protected: + 18 | simtime_t maxReceiveLifetime; + 19 | }; + 20 | + 21 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 22 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:9:9: warning: invalid case style for macro definition '__INET_DCFTRANSMITLIFETIMEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_DCFTRANSMITLIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_DCFTRANSMITLIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:28:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 28 | virtual void frameGotInProgess(const Ptr& header); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:29:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 29 | virtual void frameTransmitted(const Ptr& header); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:31:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 31 | virtual bool isLifetimeExpired(const Ptr& header); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:9:9: warning: invalid case style for macro definition '__INET_EDCATRANSMITLIFETIMEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_EDCATRANSMITLIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_EDCATRANSMITLIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:53:5: warning: function 'getEarliestDeadline' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | simtime_t getEarliestDeadline(const std::set& referencedFrames) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:54:5: warning: function 'getExpiredFrameIds' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | std::vector getExpiredFrameIds(const std::set& referencedFrames) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:56:5: warning: function 'findFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | Packet *findFrame(int64_t packetId) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:57:5: warning: function 'getNumFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | size_t getNumFrames() const { return frames.size(); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:9:9: warning: invalid case style for macro definition '__INET_ACKHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_ACKHANDLER_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ACKHANDLER_H +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:40:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 40 | virtual ~AckHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:40:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 40 | virtual ~AckHandler() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) override; // TODO rename + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual bool isEligibleToTransmit(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual bool isOutstandingFrame(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void dropFrame(const Ptr& dataOrMgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:9:9: warning: invalid case style for macro definition '__INET_NONQOSRECOVERYPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_NONQOSRECOVERYPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_NONQOSRECOVERYPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:41:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORQOSMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORQOSMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORQOSMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:23:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 23 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 24 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void initialize() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:62:51: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual std::unique_ptr prepareFragments(queueing::IPacketQueue *queue, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual bool isFragmentPreparationValid(const PreparedQosFragments& preparation, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool commitPreparedFragments(PreparedQosFragments& preparation, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:73:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:74:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool hasAMsduAggregation() const override { return aMsduAggregationPolicy != nullptr; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool hasAMpduAggregation() const override { return aMpduAggregationPolicy && aMpduAggregationPolicy->isEnabled(); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:77:47: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual std::unique_ptr prepareBatch(queueing::IPacketQueue *queue, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool isBatchValid(const PreparedQosBatch& batch, simtime_t start) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:80:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual bool commitPreparedBatch(PreparedQosBatch& batch, std::vector& committed) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:81:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual Packet *buildAggregate(const PreparedQosBatch& batch, const MpduAggregationLimits& limits) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:82:46: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual std::unique_ptr prepareFrame(queueing::IPacketQueue *queue, bool allowAggregation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:83:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:84:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual Packet *commitPreparedFrame(PreparedQosData& preparation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:85:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 85 | virtual ~OriginatorQosMacDataService(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:91:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual std::vector *extractFramesToTransmit(queueing::IPacketQueue *pendingQueue) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:9:9: warning: invalid case style for macro definition '__INET_QOSACKHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_QOSACKHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_QOSACKHANDLER_H +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:42:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 42 | typedef std::pair> QoSKey; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using QoSKey = std::pair> +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:43:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 43 | typedef std::pair Key; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Key = std::pair +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:56:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 56 | virtual ~QosAckHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:56:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 56 | virtual ~QosAckHandler() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void dropFrame(const Ptr& dataOrMgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool isEligibleToTransmit(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual bool isOutstandingFrame(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:9:9: warning: invalid case style for macro definition '__INET_QOSRECOVERYPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_QOSRECOVERYPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_QOSRECOVERYPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:59:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_RTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_RTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_RTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API RtsProcedure : public IRtsProcedure + 17 | { + 18 | protected: + 19 | int numSentRts = 0; + 20 | + 21 | public: + 22 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const override; + 23 | virtual void processTransmittedRts(const Ptr& rtsFrame) override; + 24 | }; + 25 | + 26 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:22:5: warning: function 'buildRtsFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:22:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 22 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:23:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual void processTransmittedRts(const Ptr& rtsFrame) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:9:9: warning: invalid case style for macro definition '__INET_TXOPPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_TXOPPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_TXOPPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:42:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:69:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORPROTECTIONMECHANISM_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORPROTECTIONMECHANISM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORPROTECTIONMECHANISM_H +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:24:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 24 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:25:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:32:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 32 | virtual ~OriginatorProtectionMechanism() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:32:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 32 | virtual ~OriginatorProtectionMechanism() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:8:9: warning: invalid case style for macro definition '__INET_SINGLEPROTECTIONMECHANISM_H' [readability-identifier-naming] + 8 | #define __INET_SINGLEPROTECTIONMECHANISM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_SINGLEPROTECTIONMECHANISM_H +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:33:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:34:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:43:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 43 | virtual ~SingleProtectionMechanism() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:43:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 43 | virtual ~SingleProtectionMechanism() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:9:9: warning: invalid case style for macro definition '__INET_INPROGRESSFRAMES_H' [readability-identifier-naming] + 9 | #define __INET_INPROGRESSFRAMES_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_INPROGRESSFRAMES_H +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:51:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 51 | virtual ~InProgressFrames(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:56:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211PEERMODESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211PEERMODESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_PEERMODESELECTION_H +./inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:9:9: warning: invalid case style for macro definition '__INET_QOSRATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_QOSRATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_QOSRATESELECTION_H +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:59:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:61:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:85:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& rtsFrame, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:86:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& dataOrMgmtHeader, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:87:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& blockAckReq, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:88:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:91:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txopProcedure) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:9:9: warning: invalid case style for macro definition '__INET_RATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_RATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_RATESELECTION_H +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:59:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:61:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:93:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& rtsFrame, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:94:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 94 | virtual const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& dataOrMgmtHeader, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:96:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 96 | virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_CTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_CTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_CTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:26:5: warning: function 'buildCts' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const Ptr buildCts(const Ptr& rtsFrame) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void processReceivedRts(Packet *rtsPacket, const Ptr& rtsFrame, ICtsPolicy *ctsPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void processTransmittedCts(const Ptr& ctsFrame) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:26:5: warning: function 'buildAck' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const Ptr buildAck(const Ptr& dataOrMgmtHeader) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void processReceivedFrame(Packet *packet, const Ptr& dataOrMgmtHeader, IRecipientAckPolicy *ackPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void processTransmittedAck(const Ptr& ack) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTQOSACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTQOSACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTQOSACKPOLICY_H +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:25:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:26:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:32:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual bool isAckNeeded(const Ptr& header) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:33:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual bool isBlockAckNeeded(const Ptr& blockAckReq, RecipientBlockAckAgreement *agreement) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:35:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual simtime_t computeAckDurationField(Packet *packet, const Ptr& header) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:36:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual simtime_t computeBasicBlockAckDurationField(Packet *packet, const Ptr& basicBlockAckReq) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:37:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual simtime_t computeCompressedBlockAckDurationField(Packet *packet, const Ptr& blockAckReq) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_IEEE80211MGMTFRAME_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_IEEE80211MGMTFRAME_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_IEE_E80211_MGMTFRAME_M_H +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:64:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 64 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 65 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:73:10: warning: invalid case style for public member 'ESS' [readability-identifier-naming] + 73 | bool ESS = false; + | ^~~ + | ess +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:74:10: warning: invalid case style for public member 'IBSS' [readability-identifier-naming] + 74 | bool IBSS = false; + | ^~~~ + | ibss +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:75:10: warning: invalid case style for public member 'CFPollable' [readability-identifier-naming] + 75 | bool CFPollable = false; + | ^~~~~~~~~~ + | cfPollable +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:76:10: warning: invalid case style for public member 'CFPollRequest' [readability-identifier-naming] + 76 | bool CFPollRequest = false; + | ^~~~~~~~~~~~~ + | cfPollRequest +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:78:10: warning: invalid case style for public member 'DelayedBlockAck' [readability-identifier-naming] + 78 | bool DelayedBlockAck = false; + | ^~~~~~~~~~~~~~~ + | delayedBlockAck +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:79:10: warning: invalid case style for public member 'InmediateBlockAck' [readability-identifier-naming] + 79 | bool InmediateBlockAck = false; + | ^~~~~~~~~~~~~~~~~ + | inmediateBlockAck +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:83:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 83 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211CapabilityInformation& a); + | ^~~~~~~~~~~ + | doPacking + 84 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211CapabilityInformation& a); + 85 | + 86 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211CapabilityInformation& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:84:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 84 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211CapabilityInformation& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 85 | + 86 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211CapabilityInformation& obj) { __doPacking(b, obj); } + 87 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211CapabilityInformation& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:102:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 102 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211HandoverParameters& a); + | ^~~~~~~~~~~ + | doPacking + 103 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HandoverParameters& a); + 104 | + 105 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HandoverParameters& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:103:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 103 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HandoverParameters& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 104 | + 105 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HandoverParameters& obj) { __doPacking(b, obj); } + 106 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211HandoverParameters& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:254:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 254 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211SupportedRatesElement& a); + | ^~~~~~~~~~~ + | doPacking + 255 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211SupportedRatesElement& a); + 256 | + 257 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211SupportedRatesElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:255:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 255 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211SupportedRatesElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 256 | + 257 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211SupportedRatesElement& obj) { __doPacking(b, obj); } + 258 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211SupportedRatesElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:272:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 272 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211ExtendedSupportedRatesElement& a); + | ^~~~~~~~~~~ + | doPacking + 273 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211ExtendedSupportedRatesElement& a); + 274 | + 275 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211ExtendedSupportedRatesElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:273:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 273 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211ExtendedSupportedRatesElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 274 | + 275 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211ExtendedSupportedRatesElement& obj) { __doPacking(b, obj); } + 276 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211ExtendedSupportedRatesElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:312:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 312 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211HtCapabilitiesElement& a); + | ^~~~~~~~~~~ + | doPacking + 313 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtCapabilitiesElement& a); + 314 | + 315 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtCapabilitiesElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:313:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 313 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtCapabilitiesElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 314 | + 315 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtCapabilitiesElement& obj) { __doPacking(b, obj); } + 316 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtCapabilitiesElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:339:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 339 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211HtOperationElement& a); + | ^~~~~~~~~~~ + | doPacking + 340 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtOperationElement& a); + 341 | + 342 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtOperationElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:340:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 340 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtOperationElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 341 | + 342 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtOperationElement& obj) { __doPacking(b, obj); } + 343 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtOperationElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:381:12: warning: invalid case style for protected member 'unmodelledElements_arraysize' [readability-identifier-naming] + 381 | size_t unmodelledElements_arraysize = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | unmodelledElementsArraysize +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:383:12: warning: invalid case style for protected member 'unmodelledElementPositions_arraysize' [readability-identifier-naming] + 383 | size_t unmodelledElementPositions_arraysize = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | unmodelledElementPositionsArraysize +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:389:10: warning: deleted member function should be public [modernize-use-equals-delete] + 389 | bool operator==(const Ieee80211MgmtFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:394:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 394 | virtual ~Ieee80211MgmtFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:396:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 396 | virtual Ieee80211MgmtFrame *dup() const override {return new Ieee80211MgmtFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:397:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 397 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:398:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 398 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:470:10: warning: invalid case style for protected member 'isLast_' [readability-identifier-naming] + 470 | bool isLast_ = false; + | ^~~~~~~ + | isLast +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:476:10: warning: deleted member function should be public [modernize-use-equals-delete] + 476 | bool operator==(const Ieee80211AuthenticationFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:481:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 481 | virtual ~Ieee80211AuthenticationFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:483:43: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 483 | virtual Ieee80211AuthenticationFrame *dup() const override {return new Ieee80211AuthenticationFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:484:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 484 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:485:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 485 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:522:10: warning: deleted member function should be public [modernize-use-equals-delete] + 522 | bool operator==(const Ieee80211DeauthenticationFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:527:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 527 | virtual ~Ieee80211DeauthenticationFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:529:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 529 | virtual Ieee80211DeauthenticationFrame *dup() const override {return new Ieee80211DeauthenticationFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:530:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 530 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:531:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 531 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:562:10: warning: deleted member function should be public [modernize-use-equals-delete] + 562 | bool operator==(const Ieee80211DisassociationFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:567:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 567 | virtual ~Ieee80211DisassociationFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:569:43: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 569 | virtual Ieee80211DisassociationFrame *dup() const override {return new Ieee80211DisassociationFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:570:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 570 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:571:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 571 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:596:27: warning: invalid case style for protected member 'SSID' [readability-identifier-naming] + 596 | ::omnetpp::opp_string SSID; + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:603:10: warning: deleted member function should be public [modernize-use-equals-delete] + 603 | bool operator==(const Ieee80211ProbeRequestFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:608:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 608 | virtual ~Ieee80211ProbeRequestFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:610:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 610 | virtual Ieee80211ProbeRequestFrame *dup() const override {return new Ieee80211ProbeRequestFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:611:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 611 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:612:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 612 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:615:39: warning: invalid case style for parameter 'SSID' [readability-identifier-naming] + 615 | virtual void setSSID(const char * SSID); + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:645:27: warning: invalid case style for protected member 'SSID' [readability-identifier-naming] + 645 | ::omnetpp::opp_string SSID; + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:652:10: warning: deleted member function should be public [modernize-use-equals-delete] + 652 | bool operator==(const Ieee80211AssociationRequestFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:657:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 657 | virtual ~Ieee80211AssociationRequestFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:659:47: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 659 | virtual Ieee80211AssociationRequestFrame *dup() const override {return new Ieee80211AssociationRequestFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:660:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 660 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:661:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 661 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:670:39: warning: invalid case style for parameter 'SSID' [readability-identifier-naming] + 670 | virtual void setSSID(const char * SSID); + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:701:10: warning: deleted member function should be public [modernize-use-equals-delete] + 701 | bool operator==(const Ieee80211ReassociationRequestFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:706:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 706 | virtual ~Ieee80211ReassociationRequestFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:708:49: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 708 | virtual Ieee80211ReassociationRequestFrame *dup() const override {return new Ieee80211ReassociationRequestFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:709:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 709 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:710:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 710 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:747:10: warning: deleted member function should be public [modernize-use-equals-delete] + 747 | bool operator==(const Ieee80211AssociationResponseFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:752:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 752 | virtual ~Ieee80211AssociationResponseFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:754:48: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 754 | virtual Ieee80211AssociationResponseFrame *dup() const override {return new Ieee80211AssociationResponseFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:755:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 755 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:756:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 756 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:794:10: warning: deleted member function should be public [modernize-use-equals-delete] + 794 | bool operator==(const Ieee80211ReassociationResponseFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:799:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 799 | virtual ~Ieee80211ReassociationResponseFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:801:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 801 | virtual Ieee80211ReassociationResponseFrame *dup() const override {return new Ieee80211ReassociationResponseFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:802:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 802 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:803:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 803 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:834:27: warning: invalid case style for protected member 'SSID' [readability-identifier-naming] + 834 | ::omnetpp::opp_string SSID; + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:844:10: warning: deleted member function should be public [modernize-use-equals-delete] + 844 | bool operator==(const Ieee80211BeaconFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:849:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 849 | virtual ~Ieee80211BeaconFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:851:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 851 | virtual Ieee80211BeaconFrame *dup() const override {return new Ieee80211BeaconFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:852:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 852 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:853:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 853 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:865:39: warning: invalid case style for parameter 'SSID' [readability-identifier-naming] + 865 | virtual void setSSID(const char * SSID); + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:904:10: warning: deleted member function should be public [modernize-use-equals-delete] + 904 | bool operator==(const Ieee80211ProbeResponseFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:909:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 909 | virtual ~Ieee80211ProbeResponseFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:911:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 911 | virtual Ieee80211ProbeResponseFrame *dup() const override {return new Ieee80211ProbeResponseFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:912:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 912 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:913:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 913 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_IEEE80211MGMTTRANSACTIONTAG_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_IEEE80211MGMTTRANSACTIONTAG_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_IEE_E80211_MGMTTRANSACTIONTAG_M_H +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 33 | + 34 | class Ieee80211MgmtTransactionTag; + 35 | + 36 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:44:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 44 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 45 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:69:10: warning: deleted member function should be public [modernize-use-equals-delete] + 69 | bool operator==(const Ieee80211MgmtTransactionTag&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:74:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 74 | virtual ~Ieee80211MgmtTransactionTag(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:76:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual Ieee80211MgmtTransactionTag *dup() const override {return new Ieee80211MgmtTransactionTag(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h:8:9: warning: invalid case style for macro definition '__INET_IEEE80211HTCAPABILITIES_H' [readability-identifier-naming] + 8 | #define __INET_IEEE80211HTCAPABILITIES_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTCAPABILITIES_H +./inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mib/Ieee80211Mib.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MIB_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MIB_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MIB_H +./inet/linklayer/ieee80211/mib/Ieee80211Mib.h:103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mib/Ieee80211RateSet.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211RATESET_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211RATESET_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_RATESET_H +./inet/linklayer/ieee80211/mib/Ieee80211RateSet.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/mobility/contract/IMobility.h:9:9: warning: invalid case style for macro definition '__INET_IMOBILITY_H' [readability-identifier-naming] + 9 | #define __INET_IMOBILITY_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IMOBILITY_H +./inet/mobility/contract/IMobility.h:43:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 43 | virtual ~IMobility() {} + | ^ ~~ + | = default; +./inet/mobility/contract/IMobility.h:45:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual int getId() const = 0; + | ^ + | [[nodiscard]] +./inet/mobility/contract/IMobility.h:50:5: warning: function 'getMaxSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual double getMaxSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/mobility/contract/IMobility.h:85:5: warning: function 'getConstraintAreaMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const Coord& getConstraintAreaMax() const = 0; + | ^ + | [[nodiscard]] +./inet/mobility/contract/IMobility.h:90:5: warning: function 'getConstraintAreaMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const Coord& getConstraintAreaMin() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/common/InterfaceToken.h:9:9: warning: invalid case style for macro definition '__INET_INTERFACETOKEN_H' [readability-identifier-naming] + 9 | #define __INET_INTERFACETOKEN_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_INTERFACETOKEN_H +./inet/networklayer/common/InterfaceToken.h:24:14: warning: invalid case style for private member '_normal' [readability-identifier-naming] + 24 | uint32_t _normal, _low; + | ^~~~~~~ + | normal + 25 | short _len; // in bits, 1..64 + 26 | + 27 | private: + 28 | void copy(const InterfaceToken& t) { _normal = t._normal; _low = t._low; _len = t._len; } + | ~~~~~~~ ~~~~~~~ + | normal normal + 29 | + 30 | public: + 31 | InterfaceToken() { _normal = _low = _len = 0; } + | ~~~~~~~ + | normal + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ~~~~~~~ + | normal + 33 | InterfaceToken(const InterfaceToken& t) { copy(t); } + 34 | InterfaceToken& operator=(const InterfaceToken& t) { copy(t); return *this; } + 35 | int length() const { return _len; } + 36 | uint32_t low() const { return _low; } + 37 | uint32_t normal() const { return _normal; } + | ~~~~~~~ + | normal +./inet/networklayer/common/InterfaceToken.h:24:23: warning: invalid case style for private member '_low' [readability-identifier-naming] + 24 | uint32_t _normal, _low; + | ^~~~ + | low + 25 | short _len; // in bits, 1..64 + 26 | + 27 | private: + 28 | void copy(const InterfaceToken& t) { _normal = t._normal; _low = t._low; _len = t._len; } + | ~~~~ ~~~~ + | low low + 29 | + 30 | public: + 31 | InterfaceToken() { _normal = _low = _len = 0; } + | ~~~~ + | low + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ~~~~ + | low + 33 | InterfaceToken(const InterfaceToken& t) { copy(t); } + 34 | InterfaceToken& operator=(const InterfaceToken& t) { copy(t); return *this; } + 35 | int length() const { return _len; } + 36 | uint32_t low() const { return _low; } + | ~~~~ + | low +./inet/networklayer/common/InterfaceToken.h:25:11: warning: invalid case style for private member '_len' [readability-identifier-naming] + 25 | short _len; // in bits, 1..64 + | ^~~~ + | len + 26 | + 27 | private: + 28 | void copy(const InterfaceToken& t) { _normal = t._normal; _low = t._low; _len = t._len; } + | ~~~~ ~~~~ + | len len + 29 | + 30 | public: + 31 | InterfaceToken() { _normal = _low = _len = 0; } + | ~~~~ + | len + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ~~~~ + | len + 33 | InterfaceToken(const InterfaceToken& t) { copy(t); } + 34 | InterfaceToken& operator=(const InterfaceToken& t) { copy(t); return *this; } + 35 | int length() const { return _len; } + | ~~~~ + | len +./inet/networklayer/common/InterfaceToken.h:32:20: warning: 3 adjacent parameters of 'InterfaceToken' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/common/InterfaceToken.h:32:29: note: the first parameter in the range is 'low' + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^~~ +./inet/networklayer/common/InterfaceToken.h:32:55: note: the last parameter in the range is 'len' + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^~~ +./inet/networklayer/common/InterfaceToken.h:32:20: note: + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^ +./inet/networklayer/common/InterfaceToken.h:32:51: note: 'uint32_t' and 'int' may be implicitly converted: 'uint32_t' (as 'unsigned int') -> 'int', 'int' -> 'uint32_t' (as 'unsigned int') + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^ +./inet/networklayer/common/InterfaceToken.h:35:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | int length() const { return _len; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/InterfaceToken.h:36:5: warning: function 'low' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | uint32_t low() const { return _low; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/InterfaceToken.h:37:5: warning: function 'normal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | uint32_t normal() const { return _normal; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:9:9: warning: invalid case style for macro definition '__INET_L3ADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_L3ADDRESS_H + | ^~~~~~~~~~~~~~~~~~ + | INET_L3_ADDRESS_H +./inet/networklayer/common/L3Address.h:35:9: warning: invalid case style for enum constant 'IPv4' [readability-identifier-naming] + 35 | IPv4, + | ^~~~ + | I_PV4 +./inet/networklayer/common/L3Address.h:36:9: warning: invalid case style for enum constant 'IPv6' [readability-identifier-naming] + 36 | IPv6, + | ^~~~ + | I_PV6 +./inet/networklayer/common/L3Address.h:48:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | uint64_t get(AddressType type) const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:53:5: warning: use '= default' to define a trivial copy constructor [modernize-use-equals-default] + 53 | L3Address(const L3Address& other) : hi(other.hi), lo(other.lo) {} + | ^ ~~~~~~~~~~~~ ~~~~~~~~~~~~~~~ + | = default; +./inet/networklayer/common/L3Address.h:70:5: warning: function 'toIpv4' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | Ipv4Address toIpv4() const { return getType() == NONE ? Ipv4Address() : Ipv4Address(get(IPv4)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:71:5: warning: function 'toIpv6' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | Ipv6Address toIpv6() const { return getType() == NONE ? Ipv6Address() : Ipv6Address(hi, get(IPv6)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:72:5: warning: function 'toMac' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | MacAddress toMac() const { return getType() == NONE ? MacAddress() : MacAddress(get(MAC)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:73:5: warning: function 'toModuleId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | ModuleIdAddress toModuleId() const { return getType() == NONE ? ModuleIdAddress() : ModuleIdAddress(get(MODULEID)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:74:5: warning: function 'toModulePath' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | ModulePathAddress toModulePath() const { return getType() == NONE ? ModulePathAddress() : ModulePathAddress(get(MODULEPATH)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:75:5: warning: function 'toClns' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | ClnsAddress toClns() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:77:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:78:5: warning: function 'getType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | AddressType getType() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:79:5: warning: function 'getAddressType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | const IL3AddressType *getAddressType() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:84:5: warning: function 'getPrefix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | L3Address getPrefix(int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:88:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | bool isUnspecified() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:89:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | bool isUnicast() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:90:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | bool isMulticast() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:91:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | bool isBroadcast() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:92:5: warning: function 'isLinkLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | bool isLinkLocal() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:94:16: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 94 | L3Address& operator=(const L3Address& other) { hi = other.hi; lo = other.lo; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/networklayer/common/L3Address.h:101:5: warning: function 'matches' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | bool matches(const L3Address& other, int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:103:5: warning: function 'mapToMulticastMacAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | MacAddress mapToMulticastMacAddress() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:9:9: warning: invalid case style for macro definition '__INET_MODULEIDADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEIDADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEIDADDRESS_H +./inet/networklayer/common/ModuleIdAddress.h:32:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | int getId() const { return id; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:35:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | bool isUnspecified() const { return id == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:36:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | bool isUnicast() const { return id > 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:37:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | bool isMulticast() const { return id < -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:38:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | bool isBroadcast() const { return id == -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:58:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | std::string str() const { std::ostringstream s; s << id; return s.str(); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:9:9: warning: invalid case style for macro definition '__INET_MODULEPATHADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEPATHADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEPATHADDRESS_H +./inet/networklayer/common/ModulePathAddress.h:32:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | int getId() const { return id; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:35:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | bool isUnspecified() const { return id == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:36:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | bool isUnicast() const { return id > 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:37:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | bool isMulticast() const { return id < -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:38:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | bool isBroadcast() const { return id == -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:59:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:9:9: warning: invalid case style for macro definition '__INET_NETWORKINTERFACE_H' [readability-identifier-naming] + 9 | #define __INET_NETWORKINTERFACE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_NETWORKINTERFACE_H +./inet/networklayer/common/NetworkInterface.h:38:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 38 | virtual ~MacEstimateCostProcess() {} + | ^ ~~ + | = default; +./inet/networklayer/common/NetworkInterface.h:79:5: warning: function 'getNetworkInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | NetworkInterface *getNetworkInterface() const { return ie; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:80:5: warning: function 'getFieldId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | int getFieldId() const { return field; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:81:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual std::string str() const override; + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:81:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:140:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 140 | virtual bool deliver(cMessage *msg, const SendOptions &options, simtime_t t) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:165:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 165 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:166:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 166 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:167:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 167 | virtual void handleParameterChange(const char *name) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:168:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 168 | virtual std::string resolveDirective(char directive) const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:169:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual void receiveSignal(cComponent *source, simsignal_t signal, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:170:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual cGate *createGateObject(cGate::Type type) override { + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:183:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 183 | virtual std::string getFullPath() const override { return cModule::getFullPath(); } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:184:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 184 | virtual const char *getName() const override { return cModule::getName(); } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:186:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 186 | virtual void arrived(cMessage *message, cGate *gate, const SendOptions& options, simtime_t time) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:190:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 190 | virtual ~NetworkInterface(); + | ~~~~~~~ ^ + | override +./inet/networklayer/common/NetworkInterface.h:191:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 191 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:194:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 194 | virtual bool supportsPacketSending(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:195:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 195 | virtual bool supportsPacketPushing(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:196:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 196 | virtual bool supportsPacketPulling(const cGate *gate) const override { return false; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:197:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 197 | virtual bool supportsPacketPassing(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:198:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 198 | virtual bool supportsPacketStreaming(const cGate *gate) const override { return false; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:199:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 199 | virtual bool canPushSomePacket(const cGate *gate) const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:200:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 200 | virtual bool canPushPacket(Packet *packet, const cGate *gate) const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:201:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 201 | virtual void pushPacket(Packet *packet, const cGate *gate) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:202:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 202 | virtual void pushPacketStart(Packet *packet, const cGate *gate, bps datarate) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:203:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 203 | virtual void pushPacketEnd(Packet *packet, const cGate *gate) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:204:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:204:86: warning: 2 adjacent parameters of 'pushPacketProgress' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/common/NetworkInterface.h:204:88: note: the first parameter in the range is 'position' + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~ +./inet/networklayer/common/NetworkInterface.h:204:100: note: the last parameter in the range is 'extraProcessableLength' + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/common/NetworkInterface.h:390:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 390 | virtual bool handleOperationStage(LifecycleOperation *operation, IDoneCallback *doneCallback) override; + | ~~~~~~~ ^ +./inet/networklayer/contract/IInterfaceTable.h:9:9: warning: invalid case style for macro definition '__INET_IINTERFACETABLE_H' [readability-identifier-naming] + 9 | #define __INET_IINTERFACETABLE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IINTERFACETABLE_H +./inet/networklayer/contract/IInterfaceTable.h:26:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 26 | typedef std::vector MulticastGroupList; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using MulticastGroupList = std::vector +./inet/networklayer/contract/IInterfaceTable.h:45:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 45 | virtual ~IInterfaceTable() {} + | ^ ~~ + | = default; +./inet/networklayer/contract/IInterfaceTable.h:50:5: warning: function 'getFullPath' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual std::string getFullPath() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:55:5: warning: function 'getHostModule' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual cModule *getHostModule() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:60:5: warning: function 'isLocalAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual bool isLocalAddress(const L3Address& address) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:66:5: warning: function 'isNeighborAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual bool isNeighborAddress(const L3Address& address) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:71:5: warning: function 'findInterfaceByAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | virtual NetworkInterface *findInterfaceByAddress(const L3Address& address) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:91:5: warning: function 'getNumInterfaces' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual int getNumInterfaces() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:102:5: warning: function 'getInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 102 | virtual NetworkInterface *getInterface(int pos) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:109:5: warning: function 'findInterfaceById' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | virtual NetworkInterface *findInterfaceById(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:116:5: warning: function 'getInterfaceById' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | virtual NetworkInterface *getInterfaceById(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:121:5: warning: function 'getBiggestInterfaceId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | virtual int getBiggestInterfaceId() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:127:5: warning: function 'findInterfaceByNodeOutputGateId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 127 | virtual NetworkInterface *findInterfaceByNodeOutputGateId(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:133:5: warning: function 'findInterfaceByNodeInputGateId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual NetworkInterface *findInterfaceByNodeInputGateId(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:150:5: warning: function 'findFirstLoopbackInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 150 | virtual NetworkInterface *findFirstLoopbackInterface() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:157:5: warning: function 'findFirstNonLoopbackInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 157 | virtual NetworkInterface *findFirstNonLoopbackInterface() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:162:5: warning: function 'findFirstMulticastInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 162 | virtual NetworkInterface *findFirstMulticastInterface() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:167:5: warning: function 'collectMulticastGroups' should be marked [[nodiscard]] [modernize-use-nodiscard] + 167 | virtual MulticastGroupList collectMulticastGroups() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:17:9: warning: invalid case style for macro definition '__INET_CLNSADDRESS_H' [readability-identifier-naming] + 17 | #define __INET_CLNSADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_CLNSADDRESS_H +./inet/networklayer/contract/clns/ClnsAddress.h:46:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | bool isUnspecified() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:52:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | std::string str(bool printUnspec = true) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:57:5: warning: function 'equals' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | bool equals(const ClnsAddress& toCmp) const { return systemID == toCmp.systemID && areaID == toCmp.areaID; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:59:5: warning: function 'getAreaId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | uint64_t getAreaId() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:60:5: warning: function 'getSystemId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | uint64_t getSystemId() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:61:5: warning: function 'getNsel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | uint8_t getNsel() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:16:9: warning: invalid case style for macro definition '__INET_IPV4ADDRESS_H' [readability-identifier-naming] + 16 | #define __INET_IPV4ADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IP_V4_ADDRESS_H +./inet/networklayer/contract/ipv4/Ipv4Address.h:44:17: warning: invalid case style for method '_checkNetmaskLength' [readability-identifier-naming] + 44 | static void _checkNetmaskLength(int length); + | ^~~~~~~~~~~~~~~~~~~ + | checkNetmaskLength +./inet/networklayer/contract/ipv4/Ipv4Address.h:46:21: warning: invalid case style for method '_makeNetmask' [readability-identifier-naming] + 46 | static uint32_t _makeNetmask(int length) { return length >= 32 ? 0xffffffffu : ~(0xffffffffu >> length); } + | ^~~~~~~~~~~~ + | makeNetmask +./inet/networklayer/contract/ipv4/Ipv4Address.h:81:9: warning: invalid case style for enum constant 'IPv6_TO_IPv4_RELAY' [readability-identifier-naming] + 81 | IPv6_TO_IPv4_RELAY, // 192.88.99.0/24 + | ^~~~~~~~~~~~~~~~~~ + | I_PV6_TO_I_PV4_RELAY +./inet/networklayer/contract/ipv4/Ipv4Address.h:134:5: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 134 | ~Ipv4Address() {} + | ^ ~~ + | = default; +./inet/networklayer/contract/ipv4/Ipv4Address.h:158:18: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 158 | Ipv4Address& operator=(const Ipv4Address& obj) { addr = obj.addr; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/networklayer/contract/ipv4/Ipv4Address.h:165:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 165 | bool isUnspecified() const { return addr == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:170:5: warning: function 'equals' should be marked [[nodiscard]] [modernize-use-nodiscard] + 170 | bool equals(const Ipv4Address& toCmp) const { return addr == toCmp.addr; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:175:5: warning: function 'doAnd' should be marked [[nodiscard]] [modernize-use-nodiscard] + 175 | Ipv4Address doAnd(const Ipv4Address& ip) const { return Ipv4Address(addr & ip.addr); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:181:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 181 | std::string str(bool printUnspec = true) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:186:5: warning: function 'getInt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 186 | uint32_t getInt() const { return addr; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:192:5: warning: function 'getDByte' should be marked [[nodiscard]] [modernize-use-nodiscard] + 192 | int getDByte(int i) const { return (addr >> (3 - i) * 8) & 0xFF; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:198:5: warning: function 'getIPClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 198 | char getIPClass() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:203:5: warning: function 'getAddressCategory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 203 | AddressCategory getAddressCategory() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:209:5: warning: function 'isLimitedBroadcastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 209 | bool isLimitedBroadcastAddress() const { return addr == 0xFFFFFFFF; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:215:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 215 | bool isMulticast() const { return (addr & 0xF0000000) == 0xE0000000; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:220:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 220 | bool isUnicast() const { return !isMulticast() && !isLimitedBroadcastAddress(); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:228:5: warning: function 'isLinkLocalMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 228 | bool isLinkLocalMulticast() const { return (addr & 0xFFFFFF00) == 0xE0000000; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:234:5: warning: function 'isSsm' should be marked [[nodiscard]] [modernize-use-nodiscard] + 234 | bool isSsm() const { return (addr & 0xFF000000) == 0xE8000000; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:241:5: warning: function 'getNetwork' should be marked [[nodiscard]] [modernize-use-nodiscard] + 241 | Ipv4Address getNetwork() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:247:5: warning: function 'getNetworkMask' should be marked [[nodiscard]] [modernize-use-nodiscard] + 247 | Ipv4Address getNetworkMask() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:252:5: warning: function 'isNetwork' should be marked [[nodiscard]] [modernize-use-nodiscard] + 252 | bool isNetwork(const Ipv4Address& toCmp) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:257:5: warning: function 'prefixMatches' should be marked [[nodiscard]] [modernize-use-nodiscard] + 257 | bool prefixMatches(const Ipv4Address& to_cmp, int numbits) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:257:43: warning: invalid case style for parameter 'to_cmp' [readability-identifier-naming] + 257 | bool prefixMatches(const Ipv4Address& to_cmp, int numbits) const; + | ^~~~~~ + | toCmp +./inet/networklayer/contract/ipv4/Ipv4Address.h:267:5: warning: function 'getNumMatchingPrefixBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 267 | int getNumMatchingPrefixBits(const Ipv4Address& to_cmp) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:267:53: warning: invalid case style for parameter 'to_cmp' [readability-identifier-naming] + 267 | int getNumMatchingPrefixBits(const Ipv4Address& to_cmp) const; + | ^~~~~~ + | toCmp +./inet/networklayer/contract/ipv4/Ipv4Address.h:272:5: warning: function 'getNetmaskLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 272 | int getNetmaskLength() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:277:5: warning: function 'getPrefix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 277 | Ipv4Address getPrefix(int prefixLength) const { return doAnd(makeNetmask(prefixLength)); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:283:5: warning: function 'isValidNetmask' should be marked [[nodiscard]] [modernize-use-nodiscard] + 283 | bool isValidNetmask() const { return addr == _makeNetmask(getNetmaskLength()); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:296:5: warning: function 'makeBroadcastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 296 | Ipv4Address makeBroadcastAddress(Ipv4Address netmask) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:319:5: warning: function 'mapToMulticastMacAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 319 | MacAddress mapToMulticastMacAddress() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:9:9: warning: invalid case style for macro definition '__INET_IPV6ADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_IPV6ADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IP_V6_ADDRESS_H +./inet/networklayer/contract/ipv6/Ipv6Address.h:20:5: warning: invalid case style for enum constant 'IPv6_ADDRESS_SIZE' [readability-identifier-naming] + 20 | IPv6_ADDRESS_SIZE = 16 // bytes + | ^~~~~~~~~~~~~~~~~ + | I_PV6_ADDRESS_SIZE +./inet/networklayer/contract/ipv6/Ipv6Address.h:101:17: warning: 2 adjacent parameters of 'Ipv6Address' of similar type ('uint64_t') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 101 | Ipv6Address(uint64_t hi, uint64_t lo) + | ^~~~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/contract/ipv6/Ipv6Address.h:101:26: note: the first parameter in the range is 'hi' + 101 | Ipv6Address(uint64_t hi, uint64_t lo) + | ^~ +./inet/networklayer/contract/ipv6/Ipv6Address.h:101:39: note: the last parameter in the range is 'lo' + 101 | Ipv6Address(uint64_t hi, uint64_t lo) + | ^~ +./inet/networklayer/contract/ipv6/Ipv6Address.h:141:5: warning: function 'compare' should be marked [[nodiscard]] [modernize-use-nodiscard] + 141 | int compare(const Ipv6Address& addr) const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:177:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 177 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:201:5: warning: function 'words' should be marked [[nodiscard]] [modernize-use-nodiscard] + 201 | const uint32_t *words() const { return d; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:206:5: warning: function 'getScope' should be marked [[nodiscard]] [modernize-use-nodiscard] + 206 | Scope getScope() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:224:5: warning: function 'getPrefix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 224 | Ipv6Address getPrefix(int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:230:5: warning: function 'getSuffix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 230 | Ipv6Address getSuffix(int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:250:5: warning: function 'formSolicitedNodeMulticastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 250 | Ipv6Address formSolicitedNodeMulticastAddress() const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:255:5: warning: function 'isSolicitedNodeMulticastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 255 | bool isSolicitedNodeMulticastAddress() const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:265:5: warning: function 'formSubnetRouterAnycastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 265 | Ipv6Address formSubnetRouterAnycastAddress(int prefixLength) const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:278:5: warning: function 'matches' should be marked [[nodiscard]] [modernize-use-nodiscard] + 278 | bool matches(const Ipv6Address& prefix, int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:283:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 283 | bool isUnspecified() const { return (d[0] | d[1] | d[2] | d[3]) == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:286:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 286 | bool isMulticast() const { return getScope() == MULTICAST; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:289:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 289 | bool isUnicast() const { return getScope() != MULTICAST && getScope() != UNSPECIFIED; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:292:5: warning: function 'isLoopback' should be marked [[nodiscard]] [modernize-use-nodiscard] + 292 | bool isLoopback() const { return getScope() == LOOPBACK; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:295:5: warning: function 'isLinkLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 295 | bool isLinkLocal() const { return getScope() == LINK; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:298:5: warning: function 'isSiteLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 298 | bool isSiteLocal() const { return getScope() == SITE; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:301:5: warning: function 'isGlobal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 301 | bool isGlobal() const { return getScope() == GLOBAL; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:306:5: warning: function 'getMulticastScope' should be marked [[nodiscard]] [modernize-use-nodiscard] + 306 | int getMulticastScope() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:313:5: warning: function 'isSsm' should be marked [[nodiscard]] [modernize-use-nodiscard] + 313 | bool isSsm() const { return isMulticast() && ((d[0] >> 20) & 0x0F) == 0x03; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:321:5: warning: function 'isEmbeddedRp' should be marked [[nodiscard]] [modernize-use-nodiscard] + 321 | bool isEmbeddedRp() const { return isMulticast() && ((d[0] >> 20) & 0x0F) == 0x07; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:329:5: warning: function 'getEmbeddedRpAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 329 | Ipv6Address getEmbeddedRpAddress() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:331:5: warning: function 'mapToMulticastMacAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 331 | MacAddress mapToMulticastMacAddress() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:9:9: warning: invalid case style for macro definition '__INET_APSKMODULATIONBASE_H' [readability-identifier-naming] + 9 | #define __INET_APSKMODULATIONBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_APSKMODULATIONBASE_H +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:32:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:35:5: warning: function 'getConstellation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const std::vector *getConstellation() const { return constellation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:36:5: warning: function 'getConstellationSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual unsigned int getConstellationSize() const override { return constellationSize; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:36:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual unsigned int getConstellationSize() const override { return constellationSize; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:37:5: warning: function 'getCodeWordSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual unsigned int getCodeWordSize() const override { return codeWordSize; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:37:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual unsigned int getCodeWordSize() const override { return codeWordSize; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:39:5: warning: function 'mapToConstellationDiagram' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual const ApskSymbol *mapToConstellationDiagram(const ShortBitVector& symbol) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/PhysicalLayerDefs.h:9:9: warning: invalid case style for macro definition '__INET_PHYSICALLAYERDEFS_H' [readability-identifier-naming] + 9 | #define __INET_PHYSICALLAYERDEFS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYERDEFS_H +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:9:9: warning: invalid case style for macro definition '__INET_TRANSMISSIONBASE_H' [readability-identifier-naming] + 9 | #define __INET_TRANSMISSIONBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_TRANSMISSIONBASE_H +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:50:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 50 | virtual ~TransmissionBase(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:52:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual int getId() const override { return id; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:52:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual int getId() const override { return id; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:54:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:56:5: warning: function 'getTransmitterRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual const IRadio *getTransmitterRadio() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:56:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual const IRadio *getTransmitterRadio() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:57:5: warning: function 'getTransmitterRadioId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual int getTransmitterRadioId() const override { return transmitterRadioId; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:57:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual int getTransmitterRadioId() const override { return transmitterRadioId; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:58:5: warning: function 'getTransmitterAntennaGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual const IAntennaGain *getTransmitterAntennaGain() const override { return transmitterGain.get(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:58:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual const IAntennaGain *getTransmitterAntennaGain() const override { return transmitterGain.get(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:59:5: warning: function 'getMedium' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual const IRadioMedium *getMedium() const override { return radioMedium; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:59:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual const IRadioMedium *getMedium() const override { return radioMedium; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:60:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual const Packet *getPacket() const override { return packetModel != nullptr ? packetModel->getPacket() : packet; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:60:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual const Packet *getPacket() const override { return packetModel != nullptr ? packetModel->getPacket() : packet; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:62:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual const simtime_t getStartTime() const override { return startTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:62:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual const simtime_t getStartTime() const override { return startTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:63:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual const simtime_t getEndTime() const override { return endTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:63:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual const simtime_t getEndTime() const override { return endTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:64:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:64:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:65:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:65:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:67:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 67 | virtual const simtime_t getPreambleStartTime() const override { return startTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:67:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual const simtime_t getPreambleStartTime() const override { return startTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:68:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 68 | virtual const simtime_t getPreambleEndTime() const override { return startTime + preambleDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:68:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual const simtime_t getPreambleEndTime() const override { return startTime + preambleDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:69:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual const simtime_t getHeaderStartTime() const override { return startTime + preambleDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:69:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual const simtime_t getHeaderStartTime() const override { return startTime + preambleDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:70:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | virtual const simtime_t getHeaderEndTime() const override { return endTime - dataDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:70:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual const simtime_t getHeaderEndTime() const override { return endTime - dataDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:71:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | virtual const simtime_t getDataStartTime() const override { return endTime - dataDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:71:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual const simtime_t getDataStartTime() const override { return endTime - dataDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:72:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | virtual const simtime_t getDataEndTime() const override { return endTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:72:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual const simtime_t getDataEndTime() const override { return endTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:74:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual const simtime_t getDuration() const override { return endTime - startTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:74:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual const simtime_t getDuration() const override { return endTime - startTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:75:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:75:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:77:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | virtual const simtime_t getPreambleDuration() const override { return preambleDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:77:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual const simtime_t getPreambleDuration() const override { return preambleDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:78:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | virtual const simtime_t getHeaderDuration() const override { return headerDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:78:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual const simtime_t getHeaderDuration() const override { return headerDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:79:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | virtual const simtime_t getDataDuration() const override { return dataDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:79:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual const simtime_t getDataDuration() const override { return dataDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:81:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual const Coord& getStartPosition() const override { return startPosition; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:81:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual const Coord& getStartPosition() const override { return startPosition; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:82:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual const Coord& getEndPosition() const override { return endPosition; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:82:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual const Coord& getEndPosition() const override { return endPosition; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:84:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | virtual const Quaternion& getStartOrientation() const override { return startOrientation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:84:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual const Quaternion& getStartOrientation() const override { return startOrientation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:85:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const Quaternion& getEndOrientation() const override { return endOrientation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:85:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual const Quaternion& getEndOrientation() const override { return endOrientation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:87:5: warning: function 'getPacketModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 87 | virtual const ITransmissionPacketModel *getPacketModel() const override { return packetModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:87:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual const ITransmissionPacketModel *getPacketModel() const override { return packetModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:88:5: warning: function 'getBitModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | virtual const ITransmissionBitModel *getBitModel() const override { return bitModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:88:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual const ITransmissionBitModel *getBitModel() const override { return bitModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:89:5: warning: function 'getSymbolModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | virtual const ITransmissionSymbolModel *getSymbolModel() const override { return symbolModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:89:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual const ITransmissionSymbolModel *getSymbolModel() const override { return symbolModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:90:5: warning: function 'getSampleModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const ITransmissionSampleModel *getSampleModel() const override { return sampleModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:90:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual const ITransmissionSampleModel *getSampleModel() const override { return sampleModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:91:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const ITransmissionAnalogModel *getAnalogModel() const override { return analogModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:91:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual const ITransmissionAnalogModel *getAnalogModel() const override { return analogModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/contract/bitlevel/ICode.h:9:9: warning: invalid case style for macro definition '__INET_ICODE_H' [readability-identifier-naming] + 9 | #define __INET_ICODE_H + | ^~~~~~~~~~~~~~ + | INET_ICODE_H +./inet/physicallayer/wireless/common/contract/bitlevel/ICode.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 15 | + 16 | class INET_API ICode : public IPrintableObject + 17 | { + 18 | }; + 19 | + 20 | } /* namespace physicallayer */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 21 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:9:9: warning: invalid case style for macro definition '__INET_IFECCODER_H' [readability-identifier-naming] + 9 | #define __INET_IFECCODER_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IFECCODER_H +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:20:5: warning: function 'getCodeRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 20 | virtual double getCodeRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:21:5: warning: function 'getEncodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual int getEncodedLength(int decodedLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:22:5: warning: function 'getDecodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual int getDecodedLength(int encodedLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:23:5: warning: function 'computeNetBitErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual double computeNetBitErrorRate(double grossBitErrorRate) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:29:5: warning: function 'encode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual BitVector encode(const BitVector& informationBits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:30:5: warning: function 'decode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual std::pair decode(const BitVector& encodedBits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:31:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const IForwardErrorCorrection *getForwardErrorCorrection() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:9:9: warning: invalid case style for macro definition '__INET_IINTERLEAVER_H' [readability-identifier-naming] + 9 | #define __INET_IINTERLEAVER_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IINTERLEAVER_H +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 16 | + 17 | class INET_API IInterleaving : public IPrintableObject + 18 | { + 19 | }; + 20 | + 21 | class INET_API IInterleaver : public IPrintableObject + 22 | { + 23 | public: + 24 | virtual BitVector interleave(const BitVector& bits) const = 0; + 25 | virtual BitVector deinterleave(const BitVector& bits) const = 0; + 26 | virtual const IInterleaving *getInterleaving() const = 0; + 27 | }; + 28 | + 29 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:24:5: warning: function 'interleave' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual BitVector interleave(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:25:5: warning: function 'deinterleave' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual BitVector deinterleave(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:26:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const IInterleaving *getInterleaving() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:9:9: warning: invalid case style for macro definition '__INET_ISCRAMBLER_H' [readability-identifier-naming] + 9 | #define __INET_ISCRAMBLER_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ISCRAMBLER_H +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:21:5: warning: function 'getGeneratorPolynomial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | const ShortBitVector& getGeneratorPolynomial() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:22:5: warning: function 'getSeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | const ShortBitVector& getSeed() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:28:5: warning: function 'scramble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual BitVector scramble(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:29:5: warning: function 'descramble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual BitVector descramble(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:30:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const IScrambling *getScrambling() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALANALOGMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALANALOGMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALANALOGMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:27:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual const simtime_t getPreambleDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:32:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getHeaderDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:37:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual const simtime_t getDataDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:42:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALBITMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALBITMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALBITMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:29:5: warning: function 'getHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual b getHeaderLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:34:5: warning: function 'getDataLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual b getDataLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:39:5: warning: function 'getHeaderGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual bps getHeaderGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:44:5: warning: function 'getDataGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual bps getDataGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:49:5: warning: function 'getAllBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 49 | virtual const BitVector *getAllBits() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:55:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual const IForwardErrorCorrection *getForwardErrorCorrection() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:56:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual const IScrambling *getScrambling() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:57:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual const IInterleaving *getInterleaving() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:63:5: warning: function 'getBitErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual double getBitErrorRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALPACKETMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALPACKETMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALPACKETMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | + 19 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:31:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const Packet *getPacket() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:36:5: warning: function 'getHeaderNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual bps getHeaderNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:41:5: warning: function 'getDataNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual bps getDataNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:51:5: warning: function 'getPacketErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual double getPacketErrorRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALSAMPLEMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALSAMPLEMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALSAMPLEMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:27:5: warning: function 'getHeaderSampleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual int getHeaderSampleLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:29:5: warning: function 'getHeaderSampleRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual double getHeaderSampleRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:31:5: warning: function 'getDataSampleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual int getDataSampleLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:33:5: warning: function 'getDataSampleRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual double getDataSampleRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:35:5: warning: function 'getSamples' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const std::vector *getSamples() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALSYMBOLMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALSYMBOLMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALSYMBOLMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:28:5: warning: function 'getHeaderSymbolLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual int getHeaderSymbolLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:33:5: warning: function 'getHeaderSymbolRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual double getHeaderSymbolRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:38:5: warning: function 'getDataSymbolLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getDataSymbolLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:43:5: warning: function 'getDataSymbolRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual double getDataSymbolRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:48:5: warning: function 'getAllSymbols' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual const std::vector *getAllSymbols() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:54:5: warning: function 'getHeaderModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual const IModulation *getHeaderModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:55:5: warning: function 'getDataModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual const IModulation *getDataModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:61:5: warning: function 'getSymbolErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | virtual double getSymbolErrorRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISymbol.h:9:9: warning: invalid case style for macro definition '__INET_ISYMBOL_H' [readability-identifier-naming] + 9 | #define __INET_ISYMBOL_H + | ^~~~~~~~~~~~~~~~ + | INET_ISYMBOL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISymbol.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 16 | + 17 | class INET_API ISymbol + 18 | { + 19 | public: + 20 | virtual ~ISymbol() {} + 21 | }; + 22 | + 23 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 24 | + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/bitlevel/ISymbol.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~ISymbol() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:9:9: warning: invalid case style for macro definition '__INET_IANTENNA_H' [readability-identifier-naming] + 9 | #define __INET_IANTENNA_H + | ^~~~~~~~~~~~~~~~~ + | INET_IANTENNA_H +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:29:5: warning: function 'getMobility' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual IMobility *getMobility() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:34:5: warning: function 'isDirectional' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual bool isDirectional() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:41:5: warning: function 'getGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual Ptr getGain() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:46:5: warning: function 'getNumAntennas' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual int getNumAntennas() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntennaGain.h:8:9: warning: invalid case style for macro definition '__INET_IANTENNAGAIN_H' [readability-identifier-naming] + 8 | #define __INET_IANTENNAGAIN_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IANTENNAGAIN_H +./inet/physicallayer/wireless/common/contract/packetlevel/IAntennaGain.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:9:9: warning: invalid case style for macro definition '__INET_IAPSKMODULATION_H' [readability-identifier-naming] + 9 | #define __INET_IAPSKMODULATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IAPSKMODULATION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 16 | + 17 | /** + 18 | * This interface represents an amplitude phase shift keying method. + 19 | */ + 20 | class INET_API IApskModulation : public IModulation + 21 | { + 22 | public: + 23 | virtual unsigned int getCodeWordSize() const = 0; + 24 | virtual unsigned int getConstellationSize() const = 0; + 25 | }; + 26 | + 27 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:23:5: warning: function 'getCodeWordSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual unsigned int getCodeWordSize() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:24:5: warning: function 'getConstellationSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual unsigned int getConstellationSize() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:9:9: warning: invalid case style for macro definition '__INET_IARRIVAL_H' [readability-identifier-naming] + 9 | #define __INET_IARRIVAL_H + | ^~~~~~~~~~~~~~~~~ + | INET_IARRIVAL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:29:5: warning: function 'getStartPropagationTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const simtime_t getStartPropagationTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:30:5: warning: function 'getEndPropagationTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const simtime_t getEndPropagationTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:32:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:33:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:35:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:36:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:38:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual const simtime_t getPreambleStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:39:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual const simtime_t getPreambleEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:40:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual const simtime_t getHeaderStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:41:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual const simtime_t getHeaderEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:42:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual const simtime_t getDataStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:43:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual const simtime_t getDataEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:45:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:46:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:48:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual const Quaternion& getStartOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:49:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 49 | virtual const Quaternion& getEndOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IBackgroundNoise.h:9:9: warning: invalid case style for macro definition '__INET_IBACKGROUNDNOISE_H' [readability-identifier-naming] + 9 | #define __INET_IBACKGROUNDNOISE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IBACKGROUNDNOISE_H +./inet/physicallayer/wireless/common/contract/packetlevel/IBackgroundNoise.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 17 | + 18 | /** + 19 | * This interface models a source which provides background noise over space and time. + 20 | */ + 21 | class INET_API IBackgroundNoise : public virtual IPrintableObject + 22 | { + 23 | public: + 24 | virtual const INoise *computeNoise(const IListening *listening) const = 0; + 25 | }; + 26 | + 27 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:9:9: warning: invalid case style for macro definition '__INET_ICOMMUNICATIONCACHE_H' [readability-identifier-naming] + 9 | #define __INET_ICOMMUNICATIONCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ICOMMUNICATIONCACHE_H +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:31:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 31 | virtual ~ICommunicationCache() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:31:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 31 | virtual ~ICommunicationCache() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:37:5: warning: function 'getRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual const IRadio *getRadio(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:39:5: warning: function 'getNumRadios' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual int getNumRadios() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:46:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const ITransmission *getTransmission(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:48:5: warning: function 'getNumTransmissions' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual int getNumTransmissions() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:9:9: warning: invalid case style for macro definition '__INET_IINTERFERENCE_H' [readability-identifier-naming] + 9 | #define __INET_IINTERFERENCE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IINTERFERENCE_H +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:26:5: warning: function 'getBackgroundNoise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const INoise *getBackgroundNoise() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:28:5: warning: function 'getInterferingReceptions' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual const std::vector *getInterferingReceptions() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:9:9: warning: invalid case style for macro definition '__INET_ILISTENING_H' [readability-identifier-naming] + 9 | #define __INET_ILISTENING_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ILISTENING_H +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:26:5: warning: function 'getReceiverRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const IRadio *getReceiverRadio() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:28:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:29:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:31:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:32:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:9:9: warning: invalid case style for macro definition '__INET_ILISTENINGDECISION_H' [readability-identifier-naming] + 9 | #define __INET_ILISTENINGDECISION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ILISTENINGDECISION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:25:5: warning: function 'getListening' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual const IListening *getListening() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:27:5: warning: function 'isListeningPossible' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual bool isListeningPossible() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumAnalogModel.h:9:9: warning: invalid case style for macro definition '__INET_IMEDIUMANALOGMODEL_H' [readability-identifier-naming] + 9 | #define __INET_IMEDIUMANALOGMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMEDIUMANALOGMODEL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumAnalogModel.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:9:9: warning: invalid case style for macro definition '__INET_IMEDIUMLIMITCACHE_H' [readability-identifier-naming] + 9 | #define __INET_IMEDIUMLIMITCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMEDIUMLIMITCACHE_H +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:38:5: warning: function 'getMinConstraintArea' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual Coord getMinConstraintArea() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:44:5: warning: function 'getMaxConstraintArea' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual Coord getMaxConstraintArea() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:50:5: warning: function 'getMaxSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual mps getMaxSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:56:5: warning: function 'getMaxTransmissionPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual W getMaxTransmissionPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:62:5: warning: function 'getMinInterferencePower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual W getMinInterferencePower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:68:5: warning: function 'getMinReceptionPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 68 | virtual W getMinReceptionPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:74:5: warning: function 'getMaxAntennaGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual double getMaxAntennaGain() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:80:5: warning: function 'getMinInterferenceTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual const simtime_t& getMinInterferenceTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:86:5: warning: function 'getMaxTransmissionDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 86 | virtual const simtime_t& getMaxTransmissionDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:92:5: warning: function 'getMaxCommunicationRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | virtual m getMaxCommunicationRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:98:5: warning: function 'getMaxInterferenceRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual m getMaxInterferenceRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:9:9: warning: invalid case style for macro definition '__INET_IMODULATION_H' [readability-identifier-naming] + 9 | #define __INET_IMODULATION_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IMODULATION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:32:5: warning: function 'calculateBER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual double calculateBER(double snir, Hz bandwidth, bps bitrate) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:38:5: warning: function 'calculateSER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual double calculateSER(double snir, Hz bandwidth, bps bitrate) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IMODULATION_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IMODULATION_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IMODULATION_M_H +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | + 35 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 36 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation_m.h:46:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 46 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 47 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 48 | + 49 | + 50 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 51 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/packetlevel/INeighborCache.h:9:9: warning: invalid case style for macro definition '__INET_INEIGHBORCACHE_H' [readability-identifier-naming] + 9 | #define __INET_INEIGHBORCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_INEIGHBORCACHE_H +./inet/physicallayer/wireless/common/contract/packetlevel/INeighborCache.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:9:9: warning: invalid case style for macro definition '__INET_INOISE_H' [readability-identifier-naming] + 9 | #define __INET_INOISE_H + | ^~~~~~~~~~~~~~~ + | INET_INOISE_H +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:26:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:27:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:29:5: warning: function 'computeMinPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual W computeMinPower(simtime_t startTime, simtime_t endTime) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:30:5: warning: function 'computeMaxPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual W computeMaxPower(simtime_t startTime, simtime_t endTime) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IObstacleLoss.h:9:9: warning: invalid case style for macro definition '__INET_IOBSTACLELOSS_H' [readability-identifier-naming] + 9 | #define __INET_IOBSTACLELOSS_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IOBSTACLELOSS_H +./inet/physicallayer/wireless/common/contract/packetlevel/IObstacleLoss.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IObstacleLoss.h:31:5: warning: function 'computeObstacleLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual double computeObstacleLoss(Hz frequency, const Coord& transmissionPosition, const Coord& receptionPosition) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:9:9: warning: invalid case style for macro definition '__INET_IPATHLOSS_H' [readability-identifier-naming] + 9 | #define __INET_IPATHLOSS_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IPATHLOSS_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:47:5: warning: function 'computeDistancePathLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual double computeDistancePathLoss(mps propagationSpeed, Hz frequency, m distance) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:53:5: warning: function 'computeRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | virtual m computeRange(mps propagationSpeed, Hz frequency, double loss) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayer.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALLAYER_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALLAYER_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALLAYER_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayer.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IPhysicalLayer() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayerFrame.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALLAYERFRAME_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALLAYERFRAME_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALLAYERFRAME_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayerFrame.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IPhysicalLayerFrame() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/IPropagation.h:9:9: warning: invalid case style for macro definition '__INET_IPROPAGATION_H' [readability-identifier-naming] + 9 | #define __INET_IPROPAGATION_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IPROPAGATION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPropagation.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IPropagation.h:30:5: warning: function 'getPropagationSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual mps getPropagationSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:9:9: warning: invalid case style for macro definition '__INET_IRADIO_H' [readability-identifier-naming] + 9 | #define __INET_IRADIO_H + | ^~~~~~~~~~~~~~~ + | INET_IRADIO_H +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:196:5: warning: function 'getRadioGate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 196 | virtual const cGate *getRadioGate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:202:5: warning: function 'getRadioMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 202 | virtual RadioMode getRadioMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:214:5: warning: function 'getReceptionState' should be marked [[nodiscard]] [modernize-use-nodiscard] + 214 | virtual ReceptionState getReceptionState() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:220:5: warning: function 'getTransmissionState' should be marked [[nodiscard]] [modernize-use-nodiscard] + 220 | virtual TransmissionState getTransmissionState() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:226:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 226 | virtual int getId() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:232:5: warning: function 'getAntenna' should be marked [[nodiscard]] [modernize-use-nodiscard] + 232 | virtual const IAntenna *getAntenna() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:237:5: warning: function 'getTransmitter' should be marked [[nodiscard]] [modernize-use-nodiscard] + 237 | virtual const ITransmitter *getTransmitter() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:242:5: warning: function 'getReceiver' should be marked [[nodiscard]] [modernize-use-nodiscard] + 242 | virtual const IReceiver *getReceiver() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:248:5: warning: function 'getMedium' should be marked [[nodiscard]] [modernize-use-nodiscard] + 248 | virtual const IRadioMedium *getMedium() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:255:5: warning: function 'getTransmissionInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 255 | virtual const ITransmission *getTransmissionInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:261:5: warning: function 'getTransmissionsInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 261 | virtual std::vector getTransmissionsInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:268:5: warning: function 'getReceptionInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 268 | virtual const ITransmission *getReceptionInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:274:5: warning: function 'getReceptionsInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 274 | virtual std::vector getReceptionsInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:282:5: warning: function 'getTransmittedSignalPart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 282 | virtual IRadioSignal::SignalPart getTransmittedSignalPart() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:290:5: warning: function 'getReceivedSignalPart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 290 | virtual IRadioSignal::SignalPart getReceivedSignalPart() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:9:9: warning: invalid case style for macro definition '__INET_IRADIOMEDIUM_H' [readability-identifier-naming] + 9 | #define __INET_IRADIOMEDIUM_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IRADIOMEDIUM_H +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:32:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 32 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 33 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:97:5: warning: function 'getMaterial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual const physicalenvironment::IMaterial *getMaterial() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:103:5: warning: function 'getPropagation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | virtual const IPropagation *getPropagation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:109:5: warning: function 'getPathLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | virtual const IPathLoss *getPathLoss() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:115:5: warning: function 'getObstacleLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | virtual const IObstacleLoss *getObstacleLoss() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:121:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | virtual const IMediumAnalogModel *getAnalogModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:127:5: warning: function 'getBackgroundNoise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 127 | virtual const IBackgroundNoise *getBackgroundNoise() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:133:5: warning: function 'getPhysicalEnvironment' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual const physicalenvironment::IPhysicalEnvironment *getPhysicalEnvironment() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:135:5: warning: function 'getMediumLimitCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 135 | virtual const IMediumLimitCache *getMediumLimitCache() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:136:5: warning: function 'getNeighborCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 136 | virtual const INeighborCache *getNeighborCache() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:137:5: warning: function 'getCommunicationCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 137 | virtual const ICommunicationCache *getCommunicationCache() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:157:5: warning: function 'getRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 157 | virtual const IRadio *getRadio(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:175:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 175 | virtual const ITransmission *getTransmission(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:183:5: warning: function 'getTransmissionTimingSnapshot' should be marked [[nodiscard]] [modernize-use-nodiscard] + 183 | virtual TransmissionTimingSnapshot getTransmissionTimingSnapshot(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:192:5: warning: function 'computePrecedingSignalGap' should be marked [[nodiscard]] [modernize-use-nodiscard] + 192 | virtual std::optional computePrecedingSignalGap(int currentTransmissionId, + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioSignal.h:9:9: warning: invalid case style for macro definition '__INET_IRADIOSIGNAL_H' [readability-identifier-naming] + 9 | #define __INET_IRADIOSIGNAL_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IRADIOSIGNAL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioSignal.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:9:9: warning: invalid case style for macro definition '__INET_IRECEIVER_H' [readability-identifier-naming] + 9 | #define __INET_IRECEIVER_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IRECEIVER_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:22:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 22 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 23 | + 24 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:50:5: warning: function 'getMinInterferencePower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual W getMinInterferencePower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:57:5: warning: function 'getMinReceptionPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual W getMinReceptionPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTION_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTION_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:32:5: warning: function 'getReceiverRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const IRadio *getReceiverRadio() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:38:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual const ITransmission *getTransmission() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:44:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:50:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:52:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:53:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:55:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual const simtime_t getPreambleStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:56:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual const simtime_t getPreambleEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:57:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual const simtime_t getHeaderStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:58:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual const simtime_t getHeaderEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:59:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual const simtime_t getDataStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:60:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual const simtime_t getDataEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:65:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:70:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:75:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const simtime_t getPreambleDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:80:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual const simtime_t getHeaderDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:85:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const simtime_t getDataDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:91:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:97:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:103:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | virtual const Quaternion& getStartOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:109:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | virtual const Quaternion& getEndOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:114:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | virtual const IReceptionAnalogModel *getAnalogModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTIONDECISION_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTIONDECISION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTIONDECISION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:29:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:34:5: warning: function 'getSignalPart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual IRadioSignal::SignalPart getSignalPart() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:40:5: warning: function 'isReceptionPossible' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual bool isReceptionPossible() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:46:5: warning: function 'isReceptionAttempted' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual bool isReceptionAttempted() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:51:5: warning: function 'isReceptionSuccessful' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual bool isReceptionSuccessful() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionPathLoss.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTIONPATHLOSS_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTIONPATHLOSS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTIONPATHLOSS_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionPathLoss.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTIONRESULT_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTIONRESULT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTIONRESULT_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:31:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:37:5: warning: function 'getDecisions' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual const std::vector *getDecisions() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:43:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual const Packet *getPacket() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:9:9: warning: invalid case style for macro definition '__INET_ISNIR_H' [readability-identifier-naming] + 9 | #define __INET_ISNIR_H + | ^~~~~~~~~~~~~~ + | INET_ISNIR_H +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:21:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:23:5: warning: function 'getNoise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual const INoise *getNoise() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:25:5: warning: function 'getMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual double getMin() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:26:5: warning: function 'getMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual double getMax() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:27:5: warning: function 'getMean' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual double getMean() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:9:9: warning: invalid case style for macro definition '__INET_ITRANSMISSION_H' [readability-identifier-naming] + 9 | #define __INET_ITRANSMISSION_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_ITRANSMISSION_H +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:24:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 24 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 25 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:47:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual int getId() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:53:5: warning: function 'getTransmitterRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | virtual const IRadio *getTransmitterRadio() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:59:5: warning: function 'getTransmitterRadioId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual int getTransmitterRadioId() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:64:5: warning: function 'getTransmitterAntennaGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual const IAntennaGain *getTransmitterAntennaGain() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:70:5: warning: function 'getMedium' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | virtual const IRadioMedium *getMedium() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:76:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | virtual const Packet *getPacket() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:82:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:88:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:90:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:91:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:93:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 93 | virtual const simtime_t getPreambleStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:94:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 94 | virtual const simtime_t getPreambleEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:95:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 95 | virtual const simtime_t getHeaderStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:96:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | virtual const simtime_t getHeaderEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:97:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual const simtime_t getDataStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:98:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual const simtime_t getDataEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:103:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:108:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:113:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 113 | virtual const simtime_t getPreambleDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:118:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 118 | virtual const simtime_t getHeaderDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:123:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | virtual const simtime_t getDataDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:128:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 128 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:133:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:138:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 138 | virtual const Quaternion& getStartOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:143:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 143 | virtual const Quaternion& getEndOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:145:5: warning: function 'getPacketModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 145 | virtual const ITransmissionPacketModel *getPacketModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:146:5: warning: function 'getBitModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 146 | virtual const ITransmissionBitModel *getBitModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:147:5: warning: function 'getSymbolModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 147 | virtual const ITransmissionSymbolModel *getSymbolModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:148:5: warning: function 'getSampleModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 148 | virtual const ITransmissionSampleModel *getSampleModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:153:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 153 | virtual const ITransmissionAnalogModel *getAnalogModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:9:9: warning: invalid case style for macro definition '__INET_ITRANSMITTER_H' [readability-identifier-naming] + 9 | #define __INET_ITRANSMITTER_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_ITRANSMITTER_H +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:30:5: warning: function 'getMaxPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual W getMaxPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:36:5: warning: function 'getMaxCommunicationRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual m getMaxCommunicationRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:42:5: warning: function 'getMaxInterferenceRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual m getMaxInterferenceRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:9:9: warning: invalid case style for macro definition '__INET_IWIRELESSSIGNAL_H' [readability-identifier-naming] + 9 | #define __INET_IWIRELESSSIGNAL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IWIRELESSSIGNAL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | + 19 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:31:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const ITransmission *getTransmission() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:36:5: warning: function 'getArrival' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const IArrival *getArrival() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:41:5: warning: function 'getListening' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual const IListening *getListening() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:46:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_RADIOCONTROLINFO_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_RADIOCONTROLINFO_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_RADIOCONTROLINFO_M_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | class ConfigureRadioCommand; + 35 | + 36 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:46:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 46 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 47 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:99:10: warning: deleted member function should be public [modernize-use-equals-delete] + 99 | bool operator==(const ConfigureRadioCommand&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:104:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 104 | virtual ~ConfigureRadioCommand(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:106:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 106 | virtual ConfigureRadioCommand *dup() const override {return new ConfigureRadioCommand(*this);} + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:106:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual ConfigureRadioCommand *dup() const override {return new ConfigureRadioCommand(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:107:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:108:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:110:5: warning: function 'getRadioMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 110 | virtual int getRadioMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:113:5: warning: function 'getPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 113 | virtual ::inet::W getPower() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:116:5: warning: function 'getBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | virtual ::inet::bps getBitrate() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:119:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 119 | virtual const IModulation * getModulation() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:123:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | virtual ::inet::Hz getCenterFrequency() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:126:5: warning: function 'getBandwidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 126 | virtual ::inet::Hz getBandwidth() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:6:9: warning: invalid case style for macro definition '__INET_SIGNALTAG_M_H' [readability-identifier-naming] + 6 | #define __INET_SIGNALTAG_M_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_SIGNALTAG_M_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:81:10: warning: deleted member function should be public [modernize-use-equals-delete] + 81 | bool operator==(const SignalTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:86:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 86 | virtual ~SignalTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:88:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual SignalTagBase *dup() const override {return new SignalTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:89:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:90:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:117:10: warning: deleted member function should be public [modernize-use-equals-delete] + 117 | bool operator==(const SignalPowerTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:122:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 122 | virtual ~SignalPowerTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:124:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 124 | virtual SignalPowerTagBase *dup() const override {return new SignalPowerTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:125:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 125 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:126:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 126 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:155:10: warning: deleted member function should be public [modernize-use-equals-delete] + 155 | bool operator==(const SignalPowerReq&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:160:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 160 | virtual ~SignalPowerReq(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:162:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 162 | virtual SignalPowerReq *dup() const override {return new SignalPowerReq(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:163:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 163 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:164:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 164 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:190:10: warning: deleted member function should be public [modernize-use-equals-delete] + 190 | bool operator==(const SignalPowerInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:195:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 195 | virtual ~SignalPowerInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:197:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 197 | virtual SignalPowerInd *dup() const override {return new SignalPowerInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:198:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 198 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:199:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 199 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:228:10: warning: deleted member function should be public [modernize-use-equals-delete] + 228 | bool operator==(const SignalBandTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:233:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 233 | virtual ~SignalBandTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:235:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 235 | virtual SignalBandTagBase *dup() const override {return new SignalBandTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:236:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 236 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:237:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 237 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:269:10: warning: deleted member function should be public [modernize-use-equals-delete] + 269 | bool operator==(const SignalBandReq&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:274:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 274 | virtual ~SignalBandReq(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:276:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 276 | virtual SignalBandReq *dup() const override {return new SignalBandReq(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:277:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 277 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 278 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:304:10: warning: deleted member function should be public [modernize-use-equals-delete] + 304 | bool operator==(const SignalBandInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:309:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 309 | virtual ~SignalBandInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:311:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 311 | virtual SignalBandInd *dup() const override {return new SignalBandInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:312:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 312 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:313:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 313 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:344:10: warning: deleted member function should be public [modernize-use-equals-delete] + 344 | bool operator==(const SignalBitrateTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:349:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 349 | virtual ~SignalBitrateTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:351:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 351 | virtual SignalBitrateTagBase *dup() const override {return new SignalBitrateTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:352:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 352 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:353:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 353 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:388:10: warning: deleted member function should be public [modernize-use-equals-delete] + 388 | bool operator==(const SignalBitrateReq&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:393:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 393 | virtual ~SignalBitrateReq(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:395:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 395 | virtual SignalBitrateReq *dup() const override {return new SignalBitrateReq(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:396:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 396 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:397:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 397 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:423:10: warning: deleted member function should be public [modernize-use-equals-delete] + 423 | bool operator==(const SignalBitrateInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:428:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 428 | virtual ~SignalBitrateInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:430:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 430 | virtual SignalBitrateInd *dup() const override {return new SignalBitrateInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:431:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 431 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:432:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 432 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:464:10: warning: deleted member function should be public [modernize-use-equals-delete] + 464 | bool operator==(const SnirInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:469:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 469 | virtual ~SnirInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:471:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 471 | virtual SnirInd *dup() const override {return new SnirInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:472:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 472 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:473:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 473 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:514:10: warning: deleted member function should be public [modernize-use-equals-delete] + 514 | bool operator==(const ErrorRateInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:519:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 519 | virtual ~ErrorRateInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:521:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 521 | virtual ErrorRateInd *dup() const override {return new ErrorRateInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:522:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 522 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:523:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 523 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:564:10: warning: deleted member function should be public [modernize-use-equals-delete] + 564 | bool operator==(const SignalTimeInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:569:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 569 | virtual ~SignalTimeInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:571:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 571 | virtual SignalTimeInd *dup() const override {return new SignalTimeInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:572:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 572 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:573:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 573 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h:4:9: warning: invalid case style for macro definition '__INET_TRANSMISSIONTIMINGSNAPSHOT_H' [readability-identifier-naming] + 4 | #define __INET_TRANSMISSIONTIMINGSNAPSHOT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_TRANSMISSIONTIMINGSNAPSHOT_H +./inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/modulation/ApskSymbol.h:9:9: warning: invalid case style for macro definition '__INET_APSKSYMBOL_H' [readability-identifier-naming] + 9 | #define __INET_APSKSYMBOL_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_APSKSYMBOL_H +./inet/physicallayer/wireless/common/modulation/ApskSymbol.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 19 | + 20 | class INET_API ApskSymbol : public std::complex, public ISymbol + 21 | { + 22 | public: + 23 | ApskSymbol() : std::complex() {} + 24 | ApskSymbol(const double& r) : std::complex(r) {} + 25 | ApskSymbol(const double& q, const double& i) : std::complex(q, i) {} + 26 | ApskSymbol(const std::complex& w) : std::complex(w) {} + 27 | }; + 28 | + 29 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 30 | + 31 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:9:9: warning: invalid case style for macro definition '__INET_ADDITIVESCRAMBLING_H' [readability-identifier-naming] + 9 | #define __INET_ADDITIVESCRAMBLING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ADDITIVESCRAMBLING_H +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:26:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:28:5: warning: function 'getGeneratorPolynomial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const ShortBitVector& getGeneratorPolynomial() const { return generatorPolynomial; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:29:5: warning: function 'getSeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | const ShortBitVector& getSeed() const { return seed; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:9:9: warning: invalid case style for macro definition '__INET_CONVOLUTIONALCODE_H' [readability-identifier-naming] + 9 | #define __INET_CONVOLUTIONALCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_CONVOLUTIONALCODE_H +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:30:5: warning: function 'getCodeRatePuncturingK' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | int getCodeRatePuncturingK() const { return codeRatePuncturingK; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:31:5: warning: function 'getCodeRatePuncturingN' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | int getCodeRatePuncturingN() const { return codeRatePuncturingN; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:32:5: warning: function 'getConstraintLengthVector' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const char *getConstraintLengthVector() const { return constraintLengthVector; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:33:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | const char *getMode() const { return mode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:34:5: warning: function 'getPuncturingMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | const char *getPuncturingMatrix() const { return puncturingMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:35:5: warning: function 'getTransferFunctionMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | const char *getTransferFunctionMatrix() const { return transferFunctionMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:37:5: warning: function 'getCodeRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual double getCodeRate() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:37:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual double getCodeRate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:38:5: warning: function 'getEncodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getEncodedLength(int decodedLength) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:38:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual int getEncodedLength(int decodedLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:39:5: warning: function 'getDecodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual int getDecodedLength(int encodedLength) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:39:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual int getDecodedLength(int encodedLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:40:5: warning: function 'computeNetBitErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual double computeNetBitErrorRate(double grossBitErrorRate) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:40:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual double computeNetBitErrorRate(double grossBitErrorRate) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:9:9: warning: invalid case style for macro definition '__INET_CONVOLUTIONALCODER_H' [readability-identifier-naming] + 9 | #define __INET_CONVOLUTIONALCODER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_CONVOLUTIONALCODER_H +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:40:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 40 | typedef std::vector> ShortBitVectorMatrix; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ShortBitVectorMatrix = std::vector> +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:26: warning: 6 adjacent parameters of 'TrellisGraphNode' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:30: note: the first parameter in the range is 'symbol' + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^~~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:118: note: the last parameter in the range is 'depth' + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:105: note: 'int' and 'unsigned int' may be implicitly converted + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:77:5: warning: function 'eXOR' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | inline bool eXOR(bool alpha, bool beta) const { return alpha != beta; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:79:5: warning: function 'inputSymbolToOutputSymbol' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | ShortBitVector inputSymbolToOutputSymbol(const ShortBitVector& state, const ShortBitVector& inputSymbol) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:80:5: warning: function 'modulo2Adder' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | bool modulo2Adder(const ShortBitVector& shiftRegisters, const ShortBitVector& generatorPolynomial) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:82:5: warning: function 'puncturing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | BitVector puncturing(const BitVector& informationBits) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:84:5: warning: function 'getPuncturedIndices' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | BitVector getPuncturedIndices(unsigned int length) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:85:5: warning: function 'computeHammingDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | inline unsigned int computeHammingDistance(const ShortBitVector& u, const ShortBitVector& excludedBits, const ShortBitVector& w) const + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:97:5: warning: function 'isCompletelyDecoded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | bool isCompletelyDecoded(unsigned int encodedLength, unsigned int decodedLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:114:5: warning: function 'octalToBinary' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | ShortBitVector octalToBinary(int octalNum, int fixedSize) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:115:5: warning: function 'octalToDec' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | int octalToDec(int octalNum) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:120:5: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + 120 | ~ConvolutionalCoder(); + | ^ + | override +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:122:5: warning: function 'encode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | BitVector encode(const BitVector& informationBits) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:123:5: warning: function 'decode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | std::pair decode(const BitVector& encodedBits) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:124:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | const ConvolutionalCode *getForwardErrorCorrection() const override { return convolutionalCode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:129:5: warning: function 'getMemorySizeSum' should be marked [[nodiscard]] [modernize-use-nodiscard] + 129 | unsigned int getMemorySizeSum() const { return memorySizeSum; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:130:5: warning: function 'getConstraintLengthVector' should be marked [[nodiscard]] [modernize-use-nodiscard] + 130 | const std::vector& getConstraintLengthVector() const { return constraintLengths; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:131:5: warning: function 'getTransferFunctionMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 131 | const ShortBitVectorMatrix& getTransferFunctionMatrix() const { return transferFunctionMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:132:5: warning: function 'getPuncturingMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 132 | const std::vector& getPuncturingMatrix() const { return puncturingMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:133:5: warning: function 'getNumberOfStates' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | int getNumberOfStates() const { return numberOfStates; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:134:5: warning: function 'getNumberOfOutputSymbols' should be marked [[nodiscard]] [modernize-use-nodiscard] + 134 | int getNumberOfOutputSymbols() const { return numberOfOutputSymbols; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:135:5: warning: function 'getNumberOfInputSymbols' should be marked [[nodiscard]] [modernize-use-nodiscard] + 135 | int getNumberOfInputSymbols() const { return numberOfInputSymbols; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:140:5: warning: function 'getStateTransitionTable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 140 | const int **getStateTransitionTable() const { return (const int **)stateTransitions; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:141:5: warning: function 'getOutputTable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 141 | const int **getOutputTable() const { return (const int **)inputSymbols; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211ConvolutionalCode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211CONVOLUTIONALCODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211CONVOLUTIONALCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_CONVOLUTIONALCODE_H +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211ConvolutionalCode.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211HTINTERLEAVING_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211HTINTERLEAVING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTINTERLEAVING_H +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:67: note: the first parameter in the range is 'level' + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ^~~~~ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:78: note: the last parameter in the range is 'evFlags' + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ^~~~~~~ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMINTERLEAVING_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMINTERLEAVING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMINTERLEAVING_H +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:26:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:28:5: warning: function 'getNumberOfCodedBitsPerSubcarrier' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | int getNumberOfCodedBitsPerSubcarrier() const { return numberOfCodedBitsPerSubcarrier; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:29:5: warning: function 'getNumberOfCodedBitsPerSymbol' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | int getNumberOfCodedBitsPerSymbol() const { return numberOfCodedBitsPerSymbol; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:9:9: warning: invalid case style for macro definition '__INET_IIEEE80211MODE_H' [readability-identifier-naming] + 9 | #define __INET_IIEEE80211MODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IIEE_E80211_MODE_H +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:21:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:22:5: warning: function 'createPreamble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual Ptr createPreamble() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:28:5: warning: function 'getNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual bps getNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:29:5: warning: function 'getGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual bps getGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:30:5: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual b getLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:31:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:32:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getSymbolInterval() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:33:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const IModulation *getModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:34:5: warning: function 'createHeader' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual Ptr createHeader() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:40:5: warning: function 'getBandwidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual Hz getBandwidth() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:41:5: warning: function 'getNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual bps getNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:42:5: warning: function 'getGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual bps getGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:43:5: warning: function 'getPaddingLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual b getPaddingLength(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:44:5: warning: function 'getCompleteLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual b getCompleteLength(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:45:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual const simtime_t getDuration(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:46:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const simtime_t getSymbolInterval() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:47:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual const IModulation *getModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:48:5: warning: function 'getNumberOfSpatialStreams' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual int getNumberOfSpatialStreams() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:58:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual ModulationClass getModulationClass() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:60:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual PreambleType getLegacyPreambleType() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:65:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual bps getNonHtReferenceRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:69:5: warning: function 'getHtMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual int getHtMcsIndex() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:72:5: warning: function 'isHtShortGuardInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | virtual bool isHtShortGuardInterval() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:73:5: warning: function 'getLegacyCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | virtual int getLegacyCwMin() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:74:5: warning: function 'getLegacyCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual int getLegacyCwMax() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:75:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const char *getName() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:75:25: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 75 | virtual const char *getName() const = 0; + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:76:5: warning: function 'getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | virtual const IIeee80211PreambleMode *getPreambleMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:77:5: warning: function 'getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | virtual const IIeee80211HeaderMode *getHeaderMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:78:5: warning: function 'getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | virtual const IIeee80211DataMode *getDataMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:79:5: warning: function '_getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | IIeee80211PreambleMode *_getPreambleMode() const { return const_cast(getPreambleMode()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:79:29: warning: invalid case style for method '_getPreambleMode' [readability-identifier-naming] + 79 | IIeee80211PreambleMode *_getPreambleMode() const { return const_cast(getPreambleMode()); } + | ^~~~~~~~~~~~~~~~ + | getPreambleMode +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:80:5: warning: function '_getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | IIeee80211HeaderMode *_getHeaderMode() const { return const_cast(getHeaderMode()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:80:27: warning: invalid case style for method '_getHeaderMode' [readability-identifier-naming] + 80 | IIeee80211HeaderMode *_getHeaderMode() const { return const_cast(getHeaderMode()); } + | ^~~~~~~~~~~~~~ + | getHeaderMode +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:81:5: warning: function '_getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | IIeee80211DataMode *_getDataMode() const { return const_cast(getDataMode()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:81:25: warning: invalid case style for method '_getDataMode' [readability-identifier-naming] + 81 | IIeee80211DataMode *_getDataMode() const { return const_cast(getDataMode()); } + | ^~~~~~~~~~~~ + | getDataMode +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:82:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual const simtime_t getDuration(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:83:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 83 | virtual const simtime_t getSlotTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:84:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | virtual const simtime_t getSifsTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:85:5: warning: function 'getRifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const simtime_t getRifsTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:87:5: warning: function 'getSignalExtensionTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 87 | virtual const simtime_t getSignalExtensionTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:88:5: warning: function 'getCcaTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | virtual const simtime_t getCcaTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:89:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | virtual const simtime_t getPhyRxStartDelay() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:90:5: warning: function 'getRxTxTurnaroundTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const simtime_t getRxTxTurnaroundTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:91:5: warning: function 'getPreambleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const simtime_t getPreambleLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:92:5: warning: function 'getPlcpHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | virtual const simtime_t getPlcpHeaderLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:93:5: warning: function 'getMpduMaxLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 93 | virtual int getMpduMaxLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IIEEE80211MODE_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IIEEE80211MODE_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IIEE_E80211_MODE_M_H +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | + 35 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 36 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode_m.h:51:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 51 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 52 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 53 | + 54 | + 55 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 56 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211BAND_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211BAND_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_BAND_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:25:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override = 0; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:26:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const char *getName() const override = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:26:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual const char *getName() const override = 0; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:27:5: warning: function 'getNumChannels' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual int getNumChannels() const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:28:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual Hz getCenterFrequency(int channelNumber) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:29:5: warning: function 'getSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual Hz getSpacing() const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:30:5: warning: function 'getStandardChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual int getStandardChannelNumber(int channelIndex) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:31:5: warning: function 'getChannelIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual int getChannelIndex(int standardChannelNumber) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:32:5: warning: function 'isHt40OperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:67: note: the first parameter in the range is 'level' + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ^~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:78: note: the last parameter in the range is 'evFlags' + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ^~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:44:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const char *getName() const override { return name; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:44:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual const char *getName() const override { return name; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:45:5: warning: function 'getStandardChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:45:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:46:5: warning: function 'getChannelIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:46:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:47:5: warning: function 'isHt40OperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:47:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 47 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:61:5: warning: function 'getNumChannels' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | virtual int getNumChannels() const override { return centers.size(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:61:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual int getNumChannels() const override { return centers.size(); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:62:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:62:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:63:5: warning: function 'getSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual Hz getSpacing() const override { return Hz(NaN); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:63:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual Hz getSpacing() const override { return Hz(NaN); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:64:5: warning: function 'getStandardChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:64:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:65:5: warning: function 'getChannelIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:65:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:66:5: warning: function 'isHt40OperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:79:5: warning: function 'getNumChannels' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | virtual int getNumChannels() const override { return numChannels; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:79:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual int getNumChannels() const override { return numChannels; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:80:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:80:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:81:5: warning: function 'getSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual Hz getSpacing() const override { return spacing; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:81:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual Hz getSpacing() const override { return spacing; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:87:54: warning: invalid case style for global constant 'bands' [readability-identifier-naming] + 87 | static const std::vector bands; + | ^~~~~ + | BANDS +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:90:42: warning: invalid case style for global constant 'band2_4GHz' [readability-identifier-naming] + 90 | static const Ieee80211EnumeratedBand band2_4GHz; + | ^~~~~~~~~~ + | BAND2_4_G_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:91:44: warning: invalid case style for global constant 'band5GHz' [readability-identifier-naming] + 91 | static const Ieee80211ArithmeticalBand band5GHz; + | ^~~~~~~~ + | BAND5_G_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:92:44: warning: invalid case style for global constant 'band5GHz20MHz' [readability-identifier-naming] + 92 | static const Ieee80211ArithmeticalBand band5GHz20MHz; + | ^~~~~~~~~~~~~ + | BAND5_G_HZ20_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:94:42: warning: invalid case style for global constant 'band5GHzMapped20MHz' [readability-identifier-naming] + 94 | static const Ieee80211EnumeratedBand band5GHzMapped20MHz; + | ^~~~~~~~~~~~~~~~~~~ + | BAND5_G_HZ_MAPPED20_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:95:44: warning: invalid case style for global constant 'band5GHz40MHz' [readability-identifier-naming] + 95 | static const Ieee80211ArithmeticalBand band5GHz40MHz; + | ^~~~~~~~~~~~~ + | BAND5_G_HZ40_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:96:44: warning: invalid case style for global constant 'band5GHz80MHz' [readability-identifier-naming] + 96 | static const Ieee80211ArithmeticalBand band5GHz80MHz; + | ^~~~~~~~~~~~~ + | BAND5_G_HZ80_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:97:44: warning: invalid case style for global constant 'band5GHz160MHz' [readability-identifier-naming] + 97 | static const Ieee80211ArithmeticalBand band5GHz160MHz; + | ^~~~~~~~~~~~~~ + | BAND5_G_HZ160_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:98:44: warning: invalid case style for global constant 'band5_9GHz' [readability-identifier-naming] + 98 | static const Ieee80211ArithmeticalBand band5_9GHz; + | ^~~~~~~~~~ + | BAND5_9_G_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211CHANNEL_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211CHANNEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_CHANNEL_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:26:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:28:5: warning: function 'getBand' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual const IIeee80211Band *getBand() const { return band; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:29:5: warning: function 'getChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual int getChannelNumber() const { return channelNumber; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:30:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual Hz getCenterFrequency() const { return band->getCenterFrequency(channelNumber); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211CHANNEL_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211CHANNEL_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_CHANNEL_M_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | + 35 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 36 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel_m.h:48:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 48 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 49 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 50 | + 51 | + 52 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 53 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211HTCODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211HTCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTCODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:30:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | const Ieee80211ConvolutionalCode *getForwardErrorCorrection() const { return forwardErrorCorrection; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:31:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | const AdditiveScrambling *getScrambling() const { return scrambling; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:32:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const Ieee80211HtInterleaving *getInterleaving() const { return interleaving; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:34:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 34 | virtual ~Ieee80211HtCode(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:42:45: warning: invalid case style for global constant 'htConvolutionalCode5_6' [readability-identifier-naming] + 42 | static const Ieee80211ConvolutionalCode htConvolutionalCode5_6; + | ^~~~~~~~~~~~~~~~~~~~~~ + | HT_CONVOLUTIONAL_CODE5_6 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211HTMODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211HTMODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTMODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:24:5: warning: function 'getDFTPeriod' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | const simtime_t getDFTPeriod() const { return 3.2E-6; } // DFT + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:25:5: warning: function 'getGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | const simtime_t getGIDuration() const { return getDFTPeriod() / 4; } // GI + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:26:5: warning: function 'getShortGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | const simtime_t getShortGIDuration() const { return getDFTPeriod() / 8; } // GIS + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:27:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | const simtime_t getSymbolInterval() const { return getDFTPeriod() + getGIDuration(); } // SYM + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:28:5: warning: function 'getShortGISymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const simtime_t getShortGISymbolInterval() const { return getDFTPeriod() + getShortGIDuration(); } // SYMS + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:73:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bps computeGrossBitrate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:74:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bps computeNetBitrate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:79:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 79 | virtual ~Ieee80211HtSignalMode(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:104:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual const simtime_t getDuration() const override { return getHTSIGDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:105:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 105 | virtual b getLength() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:106:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual bps getNetBitrate() const override { return Ieee80211HtModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:107:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual bps getGrossBitrate() const override { return Ieee80211HtModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:108:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211HtTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:109:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:112:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 112 | virtual Ptr createHeader() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:134:5: warning: function 'computeNumberOfSpaceTimeStreams' should be marked [[nodiscard]] [modernize-use-nodiscard] + 134 | virtual unsigned int computeNumberOfSpaceTimeStreams(unsigned int numberOfSpatialStreams) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:135:5: warning: function 'computeNumberOfHTLongTrainings' should be marked [[nodiscard]] [modernize-use-nodiscard] + 135 | virtual unsigned int computeNumberOfHTLongTrainings(unsigned int numberOfSpaceTimeStreams) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:139:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 139 | virtual ~Ieee80211HtPreambleMode() { delete highThroughputSignalMode; } + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:141:5: warning: function 'getPreambleFormat' should be marked [[nodiscard]] [modernize-use-nodiscard] + 141 | HighTroughputPreambleFormat getPreambleFormat() const { return preambleFormat; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:142:5: warning: function 'getSignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 142 | virtual const Ieee80211HtSignalMode *getSignalMode() const { return highThroughputSignalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:143:5: warning: function 'getLegacySignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 143 | virtual const Ieee80211OfdmSignalMode *getLegacySignalMode() const { return legacySignalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:144:5: warning: function 'getHighThroughputSignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 144 | virtual const Ieee80211HtSignalMode *getHighThroughputSignalMode() const { return highThroughputSignalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:146:5: warning: function 'getDoubleGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 146 | virtual const simtime_t getDoubleGIDuration() const { return 2 * getGIDuration(); } // GI2 + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:147:5: warning: function 'getLSIGDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 147 | virtual const simtime_t getLSIGDuration() const { return getSymbolInterval(); } // L-SIG + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:148:5: warning: function 'getNonHTShortTrainingSequenceDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 148 | virtual const simtime_t getNonHTShortTrainingSequenceDuration() const { return 10 * getDFTPeriod() / 4; } // L-STF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:149:5: warning: function 'getHTGreenfieldShortTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 149 | virtual const simtime_t getHTGreenfieldShortTrainingFieldDuration() const { return 10 * getDFTPeriod() / 4; } // HT-GF-STF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:150:5: warning: function 'getNonHTLongTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 150 | virtual const simtime_t getNonHTLongTrainingFieldDuration() const { return 2 * getDFTPeriod() + getDoubleGIDuration(); } // L-LTF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:151:5: warning: function 'getHTShortTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 151 | virtual const simtime_t getHTShortTrainingFieldDuration() const { return 4E-6; } // HT-STF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:152:5: warning: function 'getFirstHTLongTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 152 | virtual const simtime_t getFirstHTLongTrainingFieldDuration() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:153:5: warning: function 'getSecondAndSubsequentHTLongTrainingFielDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 153 | virtual const simtime_t getSecondAndSubsequentHTLongTrainingFielDuration() const { return 4E-6; } // HT-LTFs, s = 2,3,..,n + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:154:5: warning: function 'getNumberOfHtLongTrainings' should be marked [[nodiscard]] [modernize-use-nodiscard] + 154 | virtual unsigned int getNumberOfHtLongTrainings() const { return numberOfHTLongTrainings; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:156:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 156 | virtual const simtime_t getDuration() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:156:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 156 | virtual const simtime_t getDuration() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:158:5: warning: function 'createPreamble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 158 | virtual Ptr createPreamble() const override { return makeShared(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:158:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 158 | virtual Ptr createPreamble() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:179:5: warning: function 'getCode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 179 | const Ieee80211HtCode *getCode() const { return code; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:180:5: warning: function 'getMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 180 | unsigned int getMcsIndex() const { return mcsIndex; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:181:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 181 | virtual const Ieee80211OfdmModulation *getModulation() const { return stream1Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:182:5: warning: function 'getStreamExtension1Modulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 182 | virtual const Ieee80211OfdmModulation *getStreamExtension1Modulation() const { return stream2Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:183:5: warning: function 'getStreamExtension2Modulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 183 | virtual const Ieee80211OfdmModulation *getStreamExtension2Modulation() const { return stream3Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:184:5: warning: function 'getStreamExtension3Modulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 184 | virtual const Ieee80211OfdmModulation *getStreamExtension3Modulation() const { return stream4Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:185:5: warning: function 'getBandwidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 185 | virtual Hz getBandwidth() const { return bandwidth; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:212:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 212 | virtual Hz getBandwidth() const override { return bandwidth; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:213:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 213 | virtual int getNumberOfSpatialStreams() const override { return Ieee80211HtModeBase::getNumberOfSpatialStreams(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:214:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 214 | virtual b getPaddingLength(b dataLength) const override { return b(0); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:215:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 215 | virtual b getCompleteLength(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:216:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 216 | virtual const simtime_t getDuration(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:217:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 217 | virtual bps getNetBitrate() const override { return Ieee80211HtModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:218:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 218 | virtual bps getGrossBitrate() const override { return Ieee80211HtModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:221:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 221 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211HtTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:222:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 222 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulationAndCodingScheme->getModulation(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:239:5: warning: function 'getLegacyCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 239 | virtual int getLegacyCwMin() const override { return 15; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:239:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 239 | virtual int getLegacyCwMin() const override { return 15; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:240:5: warning: function 'getLegacyCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 240 | virtual int getLegacyCwMax() const override { return 1023; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:240:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 240 | virtual int getLegacyCwMax() const override { return 1023; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:244:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 244 | virtual ~Ieee80211HtMode() { delete preambleMode; delete dataMode; } + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:246:5: warning: function 'getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 246 | virtual const Ieee80211HtDataMode *getDataMode() const override { return dataMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:246:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 246 | virtual const Ieee80211HtDataMode *getDataMode() const override { return dataMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:247:5: warning: function 'getHtMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 247 | virtual int getHtMcsIndex() const override { return dataMode->getMcsIndex(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:247:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 247 | virtual int getHtMcsIndex() const override { return dataMode->getMcsIndex(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:248:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 248 | virtual bps getNonHtReferenceRate() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:248:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 248 | virtual bps getNonHtReferenceRate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:249:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 249 | virtual ModulationClass getModulationClass() const override { return ModulationClass::HT; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:249:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 249 | virtual ModulationClass getModulationClass() const override { return ModulationClass::HT; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:250:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 250 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:250:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 250 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:251:5: warning: function 'isHtShortGuardInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 251 | virtual bool isHtShortGuardInterval() const override { return dataMode->getGuardIntervalType() == Ieee80211HtModeBase::HT_GUARD_INTERVAL_SHORT; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:251:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 251 | virtual bool isHtShortGuardInterval() const override { return dataMode->getGuardIntervalType() == Ieee80211HtModeBase::HT_GUARD_INTERVAL_SHORT; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:252:5: warning: function 'getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 252 | virtual const Ieee80211HtPreambleMode *getPreambleMode() const override { return preambleMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:252:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 252 | virtual const Ieee80211HtPreambleMode *getPreambleMode() const override { return preambleMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:253:5: warning: function 'getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 253 | virtual const Ieee80211HtSignalMode *getHeaderMode() const override { return preambleMode->getSignalMode(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:253:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 253 | virtual const Ieee80211HtSignalMode *getHeaderMode() const override { return preambleMode->getSignalMode(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:254:5: warning: function 'getLegacySignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 254 | virtual const Ieee80211OfdmSignalMode *getLegacySignalMode() const { return preambleMode->getLegacySignalMode(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:257:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 257 | virtual const simtime_t getSlotTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:257:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 257 | virtual const simtime_t getSlotTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:258:5: warning: function 'getShortSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 258 | virtual const simtime_t getShortSlotTime() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:259:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 259 | virtual const simtime_t getSifsTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:259:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 259 | virtual const simtime_t getSifsTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:260:5: warning: function 'getRifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 260 | virtual const simtime_t getRifsTime() const override { return 2E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:260:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 260 | virtual const simtime_t getRifsTime() const override { return 2E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:262:5: warning: function 'getSignalExtensionTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 262 | virtual const simtime_t getSignalExtensionTime() const override { return centerFrequencyMode == BAND_2_4GHZ ? SimTime(6, SIMTIME_US) : SIMTIME_ZERO; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:262:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 262 | virtual const simtime_t getSignalExtensionTime() const override { return centerFrequencyMode == BAND_2_4GHZ ? SimTime(6, SIMTIME_US) : SIMTIME_ZERO; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:263:5: warning: function 'getCcaTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 263 | virtual const simtime_t getCcaTime() const override { return 4E-6; } // < 4 + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:263:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 263 | virtual const simtime_t getCcaTime() const override { return 4E-6; } // < 4 + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:264:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 264 | virtual const simtime_t getPhyRxStartDelay() const override { return 24E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:264:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 264 | virtual const simtime_t getPhyRxStartDelay() const override { return 24E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:265:5: warning: function 'getRxTxTurnaroundTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 265 | virtual const simtime_t getRxTxTurnaroundTime() const override { return 2E-6; } // < 2 + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:265:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 265 | virtual const simtime_t getRxTxTurnaroundTime() const override { return 2E-6; } // < 2 + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:266:5: warning: function 'getPreambleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 266 | virtual const simtime_t getPreambleLength() const override { return 16E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:266:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 266 | virtual const simtime_t getPreambleLength() const override { return 16E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:267:5: warning: function 'getPlcpHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 267 | virtual const simtime_t getPlcpHeaderLength() const override { return 4E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:267:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 267 | virtual const simtime_t getPlcpHeaderLength() const override { return 4E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:268:5: warning: function 'getMpduMaxLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 268 | virtual int getMpduMaxLength() const override { return 65535; } // in octets + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:268:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 268 | virtual int getMpduMaxLength() const override { return 65535; } // in octets + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:269:5: warning: function 'getCenterFrequencyMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 269 | virtual BandMode getCenterFrequencyMode() const { return centerFrequencyMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:272:5: warning: function 'getMinimumMpduStartDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 272 | B getMinimumMpduStartDistance(int minimumMpduStartSpacing) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:274:5: warning: function 'getLSigLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 274 | int getLSigLength(b dataLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:276:5: warning: function 'isPpduDurationWithinLimit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 276 | bool isPpduDurationWithinLimit(b dataLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:278:5: warning: function 'isPpduDurationValid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 278 | bool isPpduDurationValid(b dataLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:280:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 280 | virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + dataMode->getDuration(dataLength) + getSignalExtensionTime(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:280:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 280 | virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + dataMode->getDuration(dataLength) + getSignalExtensionTime(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:291:37: warning: invalid case style for global constant 'htMcs0BW20MHz' [readability-identifier-naming] + 291 | static const DI htMcs0BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS0_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:292:37: warning: invalid case style for global constant 'htMcs1BW20MHz' [readability-identifier-naming] + 292 | static const DI htMcs1BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS1_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:293:37: warning: invalid case style for global constant 'htMcs2BW20MHz' [readability-identifier-naming] + 293 | static const DI htMcs2BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS2_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:294:37: warning: invalid case style for global constant 'htMcs3BW20MHz' [readability-identifier-naming] + 294 | static const DI htMcs3BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS3_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:295:37: warning: invalid case style for global constant 'htMcs4BW20MHz' [readability-identifier-naming] + 295 | static const DI htMcs4BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS4_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:296:37: warning: invalid case style for global constant 'htMcs5BW20MHz' [readability-identifier-naming] + 296 | static const DI htMcs5BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS5_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:297:37: warning: invalid case style for global constant 'htMcs6BW20MHz' [readability-identifier-naming] + 297 | static const DI htMcs6BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS6_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:298:37: warning: invalid case style for global constant 'htMcs7BW20MHz' [readability-identifier-naming] + 298 | static const DI htMcs7BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS7_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:301:37: warning: invalid case style for global constant 'htMcs8BW20MHz' [readability-identifier-naming] + 301 | static const DI htMcs8BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS8_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:302:37: warning: invalid case style for global constant 'htMcs9BW20MHz' [readability-identifier-naming] + 302 | static const DI htMcs9BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS9_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:303:37: warning: invalid case style for global constant 'htMcs10BW20MHz' [readability-identifier-naming] + 303 | static const DI htMcs10BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS10_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:304:37: warning: invalid case style for global constant 'htMcs11BW20MHz' [readability-identifier-naming] + 304 | static const DI htMcs11BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS11_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:305:37: warning: invalid case style for global constant 'htMcs12BW20MHz' [readability-identifier-naming] + 305 | static const DI htMcs12BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS12_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:306:37: warning: invalid case style for global constant 'htMcs13BW20MHz' [readability-identifier-naming] + 306 | static const DI htMcs13BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS13_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:307:37: warning: invalid case style for global constant 'htMcs14BW20MHz' [readability-identifier-naming] + 307 | static const DI htMcs14BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS14_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:308:37: warning: invalid case style for global constant 'htMcs15BW20MHz' [readability-identifier-naming] + 308 | static const DI htMcs15BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS15_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:311:37: warning: invalid case style for global constant 'htMcs16BW20MHz' [readability-identifier-naming] + 311 | static const DI htMcs16BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS16_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:312:37: warning: invalid case style for global constant 'htMcs17BW20MHz' [readability-identifier-naming] + 312 | static const DI htMcs17BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS17_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:313:37: warning: invalid case style for global constant 'htMcs18BW20MHz' [readability-identifier-naming] + 313 | static const DI htMcs18BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS18_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:314:37: warning: invalid case style for global constant 'htMcs19BW20MHz' [readability-identifier-naming] + 314 | static const DI htMcs19BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS19_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:315:37: warning: invalid case style for global constant 'htMcs20BW20MHz' [readability-identifier-naming] + 315 | static const DI htMcs20BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS20_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:316:37: warning: invalid case style for global constant 'htMcs21BW20MHz' [readability-identifier-naming] + 316 | static const DI htMcs21BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS21_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:317:37: warning: invalid case style for global constant 'htMcs22BW20MHz' [readability-identifier-naming] + 317 | static const DI htMcs22BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS22_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:318:37: warning: invalid case style for global constant 'htMcs23BW20MHz' [readability-identifier-naming] + 318 | static const DI htMcs23BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS23_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:321:37: warning: invalid case style for global constant 'htMcs24BW20MHz' [readability-identifier-naming] + 321 | static const DI htMcs24BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS24_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:322:37: warning: invalid case style for global constant 'htMcs25BW20MHz' [readability-identifier-naming] + 322 | static const DI htMcs25BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS25_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:323:37: warning: invalid case style for global constant 'htMcs26BW20MHz' [readability-identifier-naming] + 323 | static const DI htMcs26BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS26_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:324:37: warning: invalid case style for global constant 'htMcs27BW20MHz' [readability-identifier-naming] + 324 | static const DI htMcs27BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS27_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:325:37: warning: invalid case style for global constant 'htMcs28BW20MHz' [readability-identifier-naming] + 325 | static const DI htMcs28BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS28_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:326:37: warning: invalid case style for global constant 'htMcs29BW20MHz' [readability-identifier-naming] + 326 | static const DI htMcs29BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS29_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:327:37: warning: invalid case style for global constant 'htMcs30BW20MHz' [readability-identifier-naming] + 327 | static const DI htMcs30BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS30_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:328:37: warning: invalid case style for global constant 'htMcs31BW20MHz' [readability-identifier-naming] + 328 | static const DI htMcs31BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS31_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:331:37: warning: invalid case style for global constant 'htMcs0BW40MHz' [readability-identifier-naming] + 331 | static const DI htMcs0BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS0_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:332:37: warning: invalid case style for global constant 'htMcs1BW40MHz' [readability-identifier-naming] + 332 | static const DI htMcs1BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS1_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:333:37: warning: invalid case style for global constant 'htMcs2BW40MHz' [readability-identifier-naming] + 333 | static const DI htMcs2BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS2_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:334:37: warning: invalid case style for global constant 'htMcs3BW40MHz' [readability-identifier-naming] + 334 | static const DI htMcs3BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS3_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:335:37: warning: invalid case style for global constant 'htMcs4BW40MHz' [readability-identifier-naming] + 335 | static const DI htMcs4BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS4_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:336:37: warning: invalid case style for global constant 'htMcs5BW40MHz' [readability-identifier-naming] + 336 | static const DI htMcs5BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS5_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:337:37: warning: invalid case style for global constant 'htMcs6BW40MHz' [readability-identifier-naming] + 337 | static const DI htMcs6BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS6_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:338:37: warning: invalid case style for global constant 'htMcs7BW40MHz' [readability-identifier-naming] + 338 | static const DI htMcs7BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS7_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:341:37: warning: invalid case style for global constant 'htMcs8BW40MHz' [readability-identifier-naming] + 341 | static const DI htMcs8BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS8_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:342:37: warning: invalid case style for global constant 'htMcs9BW40MHz' [readability-identifier-naming] + 342 | static const DI htMcs9BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS9_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:343:37: warning: invalid case style for global constant 'htMcs10BW40MHz' [readability-identifier-naming] + 343 | static const DI htMcs10BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS10_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:344:37: warning: invalid case style for global constant 'htMcs11BW40MHz' [readability-identifier-naming] + 344 | static const DI htMcs11BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS11_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:345:37: warning: invalid case style for global constant 'htMcs12BW40MHz' [readability-identifier-naming] + 345 | static const DI htMcs12BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS12_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:346:37: warning: invalid case style for global constant 'htMcs13BW40MHz' [readability-identifier-naming] + 346 | static const DI htMcs13BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS13_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:347:37: warning: invalid case style for global constant 'htMcs14BW40MHz' [readability-identifier-naming] + 347 | static const DI htMcs14BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS14_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:348:37: warning: invalid case style for global constant 'htMcs15BW40MHz' [readability-identifier-naming] + 348 | static const DI htMcs15BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS15_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:351:37: warning: invalid case style for global constant 'htMcs16BW40MHz' [readability-identifier-naming] + 351 | static const DI htMcs16BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS16_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:352:37: warning: invalid case style for global constant 'htMcs17BW40MHz' [readability-identifier-naming] + 352 | static const DI htMcs17BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS17_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:353:37: warning: invalid case style for global constant 'htMcs18BW40MHz' [readability-identifier-naming] + 353 | static const DI htMcs18BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS18_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:354:37: warning: invalid case style for global constant 'htMcs19BW40MHz' [readability-identifier-naming] + 354 | static const DI htMcs19BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS19_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:355:37: warning: invalid case style for global constant 'htMcs20BW40MHz' [readability-identifier-naming] + 355 | static const DI htMcs20BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS20_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:356:37: warning: invalid case style for global constant 'htMcs21BW40MHz' [readability-identifier-naming] + 356 | static const DI htMcs21BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS21_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:357:37: warning: invalid case style for global constant 'htMcs22BW40MHz' [readability-identifier-naming] + 357 | static const DI htMcs22BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS22_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:358:37: warning: invalid case style for global constant 'htMcs23BW40MHz' [readability-identifier-naming] + 358 | static const DI htMcs23BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS23_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:361:37: warning: invalid case style for global constant 'htMcs24BW40MHz' [readability-identifier-naming] + 361 | static const DI htMcs24BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS24_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:362:37: warning: invalid case style for global constant 'htMcs25BW40MHz' [readability-identifier-naming] + 362 | static const DI htMcs25BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS25_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:363:37: warning: invalid case style for global constant 'htMcs26BW40MHz' [readability-identifier-naming] + 363 | static const DI htMcs26BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS26_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:364:37: warning: invalid case style for global constant 'htMcs27BW40MHz' [readability-identifier-naming] + 364 | static const DI htMcs27BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS27_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:365:37: warning: invalid case style for global constant 'htMcs28BW40MHz' [readability-identifier-naming] + 365 | static const DI htMcs28BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS28_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:366:37: warning: invalid case style for global constant 'htMcs29BW40MHz' [readability-identifier-naming] + 366 | static const DI htMcs29BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS29_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:367:37: warning: invalid case style for global constant 'htMcs30BW40MHz' [readability-identifier-naming] + 367 | static const DI htMcs30BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS30_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:368:37: warning: invalid case style for global constant 'htMcs31BW40MHz' [readability-identifier-naming] + 368 | static const DI htMcs31BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS31_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:371:37: warning: invalid case style for global constant 'htMcs32BW40MHz' [readability-identifier-naming] + 371 | static const DI htMcs32BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS32_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:374:37: warning: invalid case style for global constant 'htMcs33BW20MHz' [readability-identifier-naming] + 374 | static const DI htMcs33BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS33_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:375:37: warning: invalid case style for global constant 'htMcs34BW20MHz' [readability-identifier-naming] + 375 | static const DI htMcs34BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS34_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:376:37: warning: invalid case style for global constant 'htMcs35BW20MHz' [readability-identifier-naming] + 376 | static const DI htMcs35BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS35_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:377:37: warning: invalid case style for global constant 'htMcs36BW20MHz' [readability-identifier-naming] + 377 | static const DI htMcs36BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS36_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:378:37: warning: invalid case style for global constant 'htMcs37BW20MHz' [readability-identifier-naming] + 378 | static const DI htMcs37BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS37_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:379:37: warning: invalid case style for global constant 'htMcs38BW20MHz' [readability-identifier-naming] + 379 | static const DI htMcs38BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS38_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:382:37: warning: invalid case style for global constant 'htMcs39BW20MHz' [readability-identifier-naming] + 382 | static const DI htMcs39BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS39_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:383:37: warning: invalid case style for global constant 'htMcs40BW20MHz' [readability-identifier-naming] + 383 | static const DI htMcs40BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS40_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:384:37: warning: invalid case style for global constant 'htMcs41BW20MHz' [readability-identifier-naming] + 384 | static const DI htMcs41BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS41_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:385:37: warning: invalid case style for global constant 'htMcs42BW20MHz' [readability-identifier-naming] + 385 | static const DI htMcs42BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS42_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:386:37: warning: invalid case style for global constant 'htMcs43BW20MHz' [readability-identifier-naming] + 386 | static const DI htMcs43BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS43_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:387:37: warning: invalid case style for global constant 'htMcs44BW20MHz' [readability-identifier-naming] + 387 | static const DI htMcs44BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS44_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:388:37: warning: invalid case style for global constant 'htMcs45BW20MHz' [readability-identifier-naming] + 388 | static const DI htMcs45BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS45_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:389:37: warning: invalid case style for global constant 'htMcs46BW20MHz' [readability-identifier-naming] + 389 | static const DI htMcs46BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS46_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:390:37: warning: invalid case style for global constant 'htMcs47BW20MHz' [readability-identifier-naming] + 390 | static const DI htMcs47BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS47_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:391:37: warning: invalid case style for global constant 'htMcs48BW20MHz' [readability-identifier-naming] + 391 | static const DI htMcs48BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS48_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:392:37: warning: invalid case style for global constant 'htMcs49BW20MHz' [readability-identifier-naming] + 392 | static const DI htMcs49BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS49_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:393:37: warning: invalid case style for global constant 'htMcs50BW20MHz' [readability-identifier-naming] + 393 | static const DI htMcs50BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS50_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:394:37: warning: invalid case style for global constant 'htMcs51BW20MHz' [readability-identifier-naming] + 394 | static const DI htMcs51BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS51_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:395:37: warning: invalid case style for global constant 'htMcs52BW20MHz' [readability-identifier-naming] + 395 | static const DI htMcs52BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS52_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:398:37: warning: invalid case style for global constant 'htMcs53BW20MHz' [readability-identifier-naming] + 398 | static const DI htMcs53BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS53_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:399:37: warning: invalid case style for global constant 'htMcs54BW20MHz' [readability-identifier-naming] + 399 | static const DI htMcs54BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS54_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:400:37: warning: invalid case style for global constant 'htMcs55BW20MHz' [readability-identifier-naming] + 400 | static const DI htMcs55BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS55_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:401:37: warning: invalid case style for global constant 'htMcs56BW20MHz' [readability-identifier-naming] + 401 | static const DI htMcs56BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS56_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:402:37: warning: invalid case style for global constant 'htMcs57BW20MHz' [readability-identifier-naming] + 402 | static const DI htMcs57BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS57_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:403:37: warning: invalid case style for global constant 'htMcs58BW20MHz' [readability-identifier-naming] + 403 | static const DI htMcs58BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS58_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:404:37: warning: invalid case style for global constant 'htMcs59BW20MHz' [readability-identifier-naming] + 404 | static const DI htMcs59BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS59_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:405:37: warning: invalid case style for global constant 'htMcs60BW20MHz' [readability-identifier-naming] + 405 | static const DI htMcs60BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS60_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:406:37: warning: invalid case style for global constant 'htMcs61BW20MHz' [readability-identifier-naming] + 406 | static const DI htMcs61BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS61_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:407:37: warning: invalid case style for global constant 'htMcs62BW20MHz' [readability-identifier-naming] + 407 | static const DI htMcs62BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS62_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:408:37: warning: invalid case style for global constant 'htMcs63BW20MHz' [readability-identifier-naming] + 408 | static const DI htMcs63BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS63_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:409:37: warning: invalid case style for global constant 'htMcs64BW20MHz' [readability-identifier-naming] + 409 | static const DI htMcs64BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS64_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:410:37: warning: invalid case style for global constant 'htMcs65BW20MHz' [readability-identifier-naming] + 410 | static const DI htMcs65BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS65_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:411:37: warning: invalid case style for global constant 'htMcs66BW20MHz' [readability-identifier-naming] + 411 | static const DI htMcs66BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS66_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:412:37: warning: invalid case style for global constant 'htMcs67BW20MHz' [readability-identifier-naming] + 412 | static const DI htMcs67BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS67_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:413:37: warning: invalid case style for global constant 'htMcs68BW20MHz' [readability-identifier-naming] + 413 | static const DI htMcs68BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS68_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:414:37: warning: invalid case style for global constant 'htMcs69BW20MHz' [readability-identifier-naming] + 414 | static const DI htMcs69BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS69_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:415:37: warning: invalid case style for global constant 'htMcs70BW20MHz' [readability-identifier-naming] + 415 | static const DI htMcs70BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS70_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:416:37: warning: invalid case style for global constant 'htMcs71BW20MHz' [readability-identifier-naming] + 416 | static const DI htMcs71BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS71_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:417:37: warning: invalid case style for global constant 'htMcs72BW20MHz' [readability-identifier-naming] + 417 | static const DI htMcs72BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS72_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:418:37: warning: invalid case style for global constant 'htMcs73BW20MHz' [readability-identifier-naming] + 418 | static const DI htMcs73BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS73_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:419:37: warning: invalid case style for global constant 'htMcs74BW20MHz' [readability-identifier-naming] + 419 | static const DI htMcs74BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS74_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:420:37: warning: invalid case style for global constant 'htMcs75BW20MHz' [readability-identifier-naming] + 420 | static const DI htMcs75BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS75_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:421:37: warning: invalid case style for global constant 'htMcs76BW20MHz' [readability-identifier-naming] + 421 | static const DI htMcs76BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS76_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:424:37: warning: invalid case style for global constant 'htMcs33BW40MHz' [readability-identifier-naming] + 424 | static const DI htMcs33BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS33_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:425:37: warning: invalid case style for global constant 'htMcs34BW40MHz' [readability-identifier-naming] + 425 | static const DI htMcs34BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS34_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:426:37: warning: invalid case style for global constant 'htMcs35BW40MHz' [readability-identifier-naming] + 426 | static const DI htMcs35BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS35_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:427:37: warning: invalid case style for global constant 'htMcs36BW40MHz' [readability-identifier-naming] + 427 | static const DI htMcs36BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS36_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:428:37: warning: invalid case style for global constant 'htMcs37BW40MHz' [readability-identifier-naming] + 428 | static const DI htMcs37BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS37_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:429:37: warning: invalid case style for global constant 'htMcs38BW40MHz' [readability-identifier-naming] + 429 | static const DI htMcs38BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS38_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:432:37: warning: invalid case style for global constant 'htMcs39BW40MHz' [readability-identifier-naming] + 432 | static const DI htMcs39BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS39_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:433:37: warning: invalid case style for global constant 'htMcs40BW40MHz' [readability-identifier-naming] + 433 | static const DI htMcs40BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS40_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:434:37: warning: invalid case style for global constant 'htMcs41BW40MHz' [readability-identifier-naming] + 434 | static const DI htMcs41BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS41_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:435:37: warning: invalid case style for global constant 'htMcs42BW40MHz' [readability-identifier-naming] + 435 | static const DI htMcs42BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS42_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:436:37: warning: invalid case style for global constant 'htMcs43BW40MHz' [readability-identifier-naming] + 436 | static const DI htMcs43BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS43_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:437:37: warning: invalid case style for global constant 'htMcs44BW40MHz' [readability-identifier-naming] + 437 | static const DI htMcs44BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS44_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:438:37: warning: invalid case style for global constant 'htMcs45BW40MHz' [readability-identifier-naming] + 438 | static const DI htMcs45BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS45_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:439:37: warning: invalid case style for global constant 'htMcs46BW40MHz' [readability-identifier-naming] + 439 | static const DI htMcs46BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS46_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:440:37: warning: invalid case style for global constant 'htMcs47BW40MHz' [readability-identifier-naming] + 440 | static const DI htMcs47BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS47_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:441:37: warning: invalid case style for global constant 'htMcs48BW40MHz' [readability-identifier-naming] + 441 | static const DI htMcs48BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS48_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:442:37: warning: invalid case style for global constant 'htMcs49BW40MHz' [readability-identifier-naming] + 442 | static const DI htMcs49BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS49_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:443:37: warning: invalid case style for global constant 'htMcs50BW40MHz' [readability-identifier-naming] + 443 | static const DI htMcs50BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS50_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:444:37: warning: invalid case style for global constant 'htMcs51BW40MHz' [readability-identifier-naming] + 444 | static const DI htMcs51BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS51_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:445:37: warning: invalid case style for global constant 'htMcs52BW40MHz' [readability-identifier-naming] + 445 | static const DI htMcs52BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS52_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:448:37: warning: invalid case style for global constant 'htMcs53BW40MHz' [readability-identifier-naming] + 448 | static const DI htMcs53BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS53_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:449:37: warning: invalid case style for global constant 'htMcs54BW40MHz' [readability-identifier-naming] + 449 | static const DI htMcs54BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS54_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:450:37: warning: invalid case style for global constant 'htMcs55BW40MHz' [readability-identifier-naming] + 450 | static const DI htMcs55BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS55_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:451:37: warning: invalid case style for global constant 'htMcs56BW40MHz' [readability-identifier-naming] + 451 | static const DI htMcs56BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS56_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:452:37: warning: invalid case style for global constant 'htMcs57BW40MHz' [readability-identifier-naming] + 452 | static const DI htMcs57BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS57_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:453:37: warning: invalid case style for global constant 'htMcs58BW40MHz' [readability-identifier-naming] + 453 | static const DI htMcs58BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS58_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:454:37: warning: invalid case style for global constant 'htMcs59BW40MHz' [readability-identifier-naming] + 454 | static const DI htMcs59BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS59_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:455:37: warning: invalid case style for global constant 'htMcs60BW40MHz' [readability-identifier-naming] + 455 | static const DI htMcs60BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS60_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:456:37: warning: invalid case style for global constant 'htMcs61BW40MHz' [readability-identifier-naming] + 456 | static const DI htMcs61BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS61_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:457:37: warning: invalid case style for global constant 'htMcs62BW40MHz' [readability-identifier-naming] + 457 | static const DI htMcs62BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS62_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:458:37: warning: invalid case style for global constant 'htMcs63BW40MHz' [readability-identifier-naming] + 458 | static const DI htMcs63BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS63_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:459:37: warning: invalid case style for global constant 'htMcs64BW40MHz' [readability-identifier-naming] + 459 | static const DI htMcs64BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS64_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:460:37: warning: invalid case style for global constant 'htMcs65BW40MHz' [readability-identifier-naming] + 460 | static const DI htMcs65BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS65_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:461:37: warning: invalid case style for global constant 'htMcs66BW40MHz' [readability-identifier-naming] + 461 | static const DI htMcs66BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS66_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:462:37: warning: invalid case style for global constant 'htMcs67BW40MHz' [readability-identifier-naming] + 462 | static const DI htMcs67BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS67_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:463:37: warning: invalid case style for global constant 'htMcs68BW40MHz' [readability-identifier-naming] + 463 | static const DI htMcs68BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS68_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:464:37: warning: invalid case style for global constant 'htMcs69BW40MHz' [readability-identifier-naming] + 464 | static const DI htMcs69BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS69_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:465:37: warning: invalid case style for global constant 'htMcs70BW40MHz' [readability-identifier-naming] + 465 | static const DI htMcs70BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS70_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:466:37: warning: invalid case style for global constant 'htMcs71BW40MHz' [readability-identifier-naming] + 466 | static const DI htMcs71BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS71_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:467:37: warning: invalid case style for global constant 'htMcs72BW40MHz' [readability-identifier-naming] + 467 | static const DI htMcs72BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS72_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:468:37: warning: invalid case style for global constant 'htMcs73BW40MHz' [readability-identifier-naming] + 468 | static const DI htMcs73BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS73_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:469:37: warning: invalid case style for global constant 'htMcs74BW40MHz' [readability-identifier-naming] + 469 | static const DI htMcs74BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS74_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:470:37: warning: invalid case style for global constant 'htMcs75BW40MHz' [readability-identifier-naming] + 470 | static const DI htMcs75BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS75_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:471:37: warning: invalid case style for global constant 'htMcs76BW40MHz' [readability-identifier-naming] + 471 | static const DI htMcs76BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS76_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:477:61: warning: invalid case style for global constant 'singleton' [readability-identifier-naming] + 477 | static OPP_THREAD_LOCAL const Ieee80211HtCompliantModes singleton; + | ^~~~~~~~~ + | SINGLETON +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MODEBASE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MODEBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MODEBASE_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:27:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual bps getNonHtReferenceRate() const override { return bps(NaN); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:27:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual bps getNonHtReferenceRate() const override { return bps(NaN); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:28:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual ModulationClass getModulationClass() const override { return ModulationClass::UNKNOWN; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:28:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 28 | virtual ModulationClass getModulationClass() const override { return ModulationClass::UNKNOWN; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:29:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::UNKNOWN; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:29:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::UNKNOWN; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:30:5: warning: function 'getHtMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual int getHtMcsIndex() const override { return -1; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:30:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual int getHtMcsIndex() const override { return -1; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:31:5: warning: function 'isHtShortGuardInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual bool isHtShortGuardInterval() const override { return false; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual bool isHtShortGuardInterval() const override { return false; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:32:5: warning: function 'getSignalExtensionTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getSignalExtensionTime() const override { return SIMTIME_ZERO; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:32:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual const simtime_t getSignalExtensionTime() const override { return SIMTIME_ZERO; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:33:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const char *getName() const override { return name.c_str(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:33:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual const char *getName() const override { return name.c_str(); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MODESET_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MODESET_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MODESET_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:62:68: warning: invalid case style for global constant 'modeSets' [readability-identifier-naming] + 62 | static const DelayedInitializer> modeSets; + | ^~~~~~~~ + | MODE_SETS +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:67: note: the first parameter in the range is 'level' + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ^~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:78: note: the last parameter in the range is 'evFlags' + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ^~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:74:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | const char *getName() const override { return name.c_str(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:76:5: warning: function 'getNumModes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | int getNumModes() const { return entries.size(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:77:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | const IIeee80211Mode *getMode(int index) const { return entries[index].mode; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:78:5: warning: function 'isMandatory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | bool isMandatory(int index) const { return entries[index].isMandatory; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:79:5: warning: function 'isHtOperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | bool isHtOperationSupported() const { return htOperationSupported; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:80:5: warning: function 'getMaximumChannelWidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | Hz getMaximumChannelWidth() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:81:5: warning: function 'getMaximumNumberOfSpatialStreams' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | int getMaximumNumberOfSpatialStreams() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:85:5: warning: function 'getLegacyOperationalModes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | const std::vector& getLegacyOperationalModes() const { return legacyOperationalModes; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:86:5: warning: function 'getFastestLegacyOperationalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 86 | const IIeee80211Mode *getFastestLegacyOperationalMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:87:5: warning: function 'getHtMcsSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 87 | const std::array& getHtMcsSupported() const { return htMcsSupported; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:88:5: warning: function 'getHtMcsMandatory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | const std::array& getHtMcsMandatory() const { return htMcsMandatory; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:89:5: warning: function 'getHtSupportedChannelWidths' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | const std::set& getHtSupportedChannelWidths() const { return htSupportedChannelWidths; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:90:5: warning: function 'getHtShortGuardIntervalChannelWidths' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | const std::set& getHtShortGuardIntervalChannelWidths() const { return htShortGuardIntervalChannelWidths; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:91:5: warning: function 'isHtShortGuardIntervalSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | bool isHtShortGuardIntervalSupported(Hz bandwidth) const { return htShortGuardIntervalChannelWidths.count(bandwidth) != 0; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:96:5: warning: function 'findMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | const IIeee80211Mode *findMode(bps bitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:97:5: warning: function 'findMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | const IIeee80211Mode *findMode(bps minBitrate, bps maxBitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:98:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | const IIeee80211Mode *getMode(bps bitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:99:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 99 | const IIeee80211Mode *getMode(bps minBitrate, bps maxBitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:100:5: warning: function 'getSlowestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | const IIeee80211Mode *getSlowestMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:101:5: warning: function 'getFastestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | const IIeee80211Mode *getFastestMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:104:5: warning: function 'getSlowestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 104 | const IIeee80211Mode *getSlowestMandatoryMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:105:5: warning: function 'getFastestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 105 | const IIeee80211Mode *getFastestMandatoryMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:114:5: warning: function 'getPhyType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | PhyType getPhyType() const { return phyType; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:115:5: warning: function 'getReferenceMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | const IIeee80211Mode *getReferenceMode() const { return referenceMode; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:116:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | simtime_t getSifsTime() const { return referenceMode->getSifsTime(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:117:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 117 | simtime_t getSlotTime() const { return referenceMode->getSlotTime(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:118:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 118 | simtime_t getPhyRxStartDelay() const { return referenceMode->getPhyRxStartDelay(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:119:5: warning: function 'getCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 119 | int getCwMin() const { return referenceMode->getLegacyCwMin(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:120:5: warning: function 'getCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 120 | int getCwMax() const { return referenceMode->getLegacyCwMax(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:122:5: warning: function '_getSlowestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | IIeee80211Mode *_getSlowestMode() const { return const_cast(getSlowestMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:122:21: warning: invalid case style for method '_getSlowestMode' [readability-identifier-naming] + 122 | IIeee80211Mode *_getSlowestMode() const { return const_cast(getSlowestMode()); } + | ^~~~~~~~~~~~~~~ + | getSlowestMode +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:123:5: warning: function '_getFastestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | IIeee80211Mode *_getFastestMode() const { return const_cast(getFastestMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:123:21: warning: invalid case style for method '_getFastestMode' [readability-identifier-naming] + 123 | IIeee80211Mode *_getFastestMode() const { return const_cast(getFastestMode()); } + | ^~~~~~~~~~~~~~~ + | getFastestMode +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:124:5: warning: function '_getSlowestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | IIeee80211Mode *_getSlowestMandatoryMode() const { return const_cast(getSlowestMandatoryMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:124:21: warning: invalid case style for method '_getSlowestMandatoryMode' [readability-identifier-naming] + 124 | IIeee80211Mode *_getSlowestMandatoryMode() const { return const_cast(getSlowestMandatoryMode()); } + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | getSlowestMandatoryMode +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:125:5: warning: function '_getFastestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 125 | IIeee80211Mode *_getFastestMandatoryMode() const { return const_cast(getFastestMandatoryMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:125:21: warning: invalid case style for method '_getFastestMandatoryMode' [readability-identifier-naming] + 125 | IIeee80211Mode *_getFastestMandatoryMode() const { return const_cast(getFastestMandatoryMode()); } + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | getFastestMandatoryMode +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMCODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMCODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:29:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:31:5: warning: function 'getConvolutionalCode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | const ConvolutionalCode *getConvolutionalCode() const { return convolutionalCode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:32:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const Ieee80211OfdmInterleaving *getInterleaving() const { return interleaving; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:33:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | const AdditiveScrambling *getScrambling() const { return scrambling; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:40:45: warning: invalid case style for global constant 'ofdmConvolutionalCode1_2' [readability-identifier-naming] + 40 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode1_2; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE1_2 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:41:45: warning: invalid case style for global constant 'ofdmConvolutionalCode2_3' [readability-identifier-naming] + 41 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode2_3; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE2_3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:42:45: warning: invalid case style for global constant 'ofdmConvolutionalCode3_4' [readability-identifier-naming] + 42 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode3_4; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE3_4 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:43:45: warning: invalid case style for global constant 'ofdmConvolutionalCode5_6' [readability-identifier-naming] + 43 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode5_6; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE5_6 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:46:44: warning: invalid case style for global constant 'ofdmBPSKInterleaving' [readability-identifier-naming] + 46 | static const Ieee80211OfdmInterleaving ofdmBPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_BPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:47:44: warning: invalid case style for global constant 'ofdmQPSKInterleaving' [readability-identifier-naming] + 47 | static const Ieee80211OfdmInterleaving ofdmQPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_QPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:48:44: warning: invalid case style for global constant 'ofdmQAM16Interleaving' [readability-identifier-naming] + 48 | static const Ieee80211OfdmInterleaving ofdmQAM16Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M16_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:49:44: warning: invalid case style for global constant 'ofdmQAM64Interleaving' [readability-identifier-naming] + 49 | static const Ieee80211OfdmInterleaving ofdmQAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:50:44: warning: invalid case style for global constant 'ofdmQAM256Interleaving' [readability-identifier-naming] + 50 | static const Ieee80211OfdmInterleaving ofdmQAM256Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M256_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:51:44: warning: invalid case style for global constant 'ofdmQAM1024Interleaving' [readability-identifier-naming] + 51 | static const Ieee80211OfdmInterleaving ofdmQAM1024Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M1024_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:54:37: warning: invalid case style for global constant 'ofdmScrambling' [readability-identifier-naming] + 54 | static const AdditiveScrambling ofdmScrambling; + | ^~~~~~~~~~~~~~ + | OFDM_SCRAMBLING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:57:36: warning: invalid case style for global constant 'ofdmCC1_2BPSKInterleaving' [readability-identifier-naming] + 57 | static const Ieee80211OfdmCode ofdmCC1_2BPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_BPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:58:36: warning: invalid case style for global constant 'ofdmCC1_2BPSKInterleavingWithoutScrambling' [readability-identifier-naming] + 58 | static const Ieee80211OfdmCode ofdmCC1_2BPSKInterleavingWithoutScrambling; // For the SIGNAL field + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_BPSK_INTERLEAVING_WITHOUT_SCRAMBLING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:59:36: warning: invalid case style for global constant 'ofdmCC3_4BPSKInterleaving' [readability-identifier-naming] + 59 | static const Ieee80211OfdmCode ofdmCC3_4BPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_BPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:60:36: warning: invalid case style for global constant 'ofdmCC1_2QPSKInterleaving' [readability-identifier-naming] + 60 | static const Ieee80211OfdmCode ofdmCC1_2QPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_QPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:61:36: warning: invalid case style for global constant 'ofdmCC3_4QPSKInterleaving' [readability-identifier-naming] + 61 | static const Ieee80211OfdmCode ofdmCC3_4QPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:62:36: warning: invalid case style for global constant 'ofdmCC1_2QAM16Interleaving' [readability-identifier-naming] + 62 | static const Ieee80211OfdmCode ofdmCC1_2QAM16Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_QA_M16_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:63:36: warning: invalid case style for global constant 'ofdmCC3_4QAM16Interleaving' [readability-identifier-naming] + 63 | static const Ieee80211OfdmCode ofdmCC3_4QAM16Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M16_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:64:36: warning: invalid case style for global constant 'ofdmCC2_3QAM64Interleaving' [readability-identifier-naming] + 64 | static const Ieee80211OfdmCode ofdmCC2_3QAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C2_3_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:65:36: warning: invalid case style for global constant 'ofdmCC3_4QAM64Interleaving' [readability-identifier-naming] + 65 | static const Ieee80211OfdmCode ofdmCC3_4QAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:66:36: warning: invalid case style for global constant 'ofdmCC5_6QAM64Interleaving' [readability-identifier-naming] + 66 | static const Ieee80211OfdmCode ofdmCC5_6QAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C5_6_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:67:36: warning: invalid case style for global constant 'ofdmCC3_4QAM256Interleaving' [readability-identifier-naming] + 67 | static const Ieee80211OfdmCode ofdmCC3_4QAM256Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M256_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:68:36: warning: invalid case style for global constant 'ofdmCC5_6QAM256Interleaving' [readability-identifier-naming] + 68 | static const Ieee80211OfdmCode ofdmCC5_6QAM256Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C5_6_QA_M256_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:69:36: warning: invalid case style for global constant 'ofdmCC3_4QAM1024Interleaving' [readability-identifier-naming] + 69 | static const Ieee80211OfdmCode ofdmCC3_4QAM1024Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M1024_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:70:36: warning: invalid case style for global constant 'ofdmCC5_6QAM1024Interleaving' [readability-identifier-naming] + 70 | static const Ieee80211OfdmCode ofdmCC5_6QAM1024Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C5_6_QA_M1024_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMMODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMMODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMMODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:26:5: warning: function 'getSubcarrierFrequencySpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | Hz getSubcarrierFrequencySpacing() const { return channelSpacing / 64; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:27:5: warning: function 'getFFTTransformPeriod' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | const simtime_t getFFTTransformPeriod() const { return simtime_t(1 / getSubcarrierFrequencySpacing().get()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:28:5: warning: function 'getGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const simtime_t getGIDuration() const { return getFFTTransformPeriod() / 4; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:29:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | const simtime_t getSymbolInterval() const { return getGIDuration() + getFFTTransformPeriod(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:31:5: warning: function 'getChannelSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | const Hz getChannelSpacing() const { return channelSpacing; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:49:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 49 | virtual ~Ieee80211OfdmModeBase() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:68:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 68 | virtual ~Ieee80211OfdmPreambleMode() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:68:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 68 | virtual ~Ieee80211OfdmPreambleMode() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:70:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:72:5: warning: function 'getTrainingSymbolGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | const simtime_t getTrainingSymbolGIDuration() const { return getFFTTransformPeriod() / 2; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:73:5: warning: function 'getShortTrainingSequenceDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | const simtime_t getShortTrainingSequenceDuration() const { return 10 * getFFTTransformPeriod() / 4; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:74:5: warning: function 'getLongTrainingSequenceDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | const simtime_t getLongTrainingSequenceDuration() const { return getTrainingSymbolGIDuration() + 2 * getFFTTransformPeriod(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:75:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const simtime_t getDuration() const override { return getShortTrainingSequenceDuration() + getLongTrainingSequenceDuration(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:75:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual const simtime_t getDuration() const override { return getShortTrainingSequenceDuration() + getLongTrainingSequenceDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:77:5: warning: function 'createPreamble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | virtual Ptr createPreamble() const override { return makeShared(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:77:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual Ptr createPreamble() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:87:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 87 | virtual ~Ieee80211OfdmSignalMode() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:87:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 87 | virtual ~Ieee80211OfdmSignalMode() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:89:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:99:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual b getLength() const override { return getRateFieldLength() + getReservedFieldLength() + getLengthFieldLength() + getParityFieldLength() + getTailFieldLength() + getServiceFieldLength(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:100:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 100 | virtual const simtime_t getDuration() const override { return getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:103:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211OfdmTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:104:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:106:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual bps getGrossBitrate() const override { return Ieee80211OfdmModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:107:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual bps getNetBitrate() const override { return Ieee80211OfdmModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:109:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual Ptr createHeader() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:116:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 116 | virtual ~Ieee80211OfdmDataMode() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:116:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 116 | virtual ~Ieee80211OfdmDataMode() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:118:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 118 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:123:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 123 | virtual Hz getBandwidth() const override { return bandwidth; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:124:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 124 | virtual b getPaddingLength(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:125:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 125 | virtual b getCompleteLength(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:126:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 126 | virtual const simtime_t getDuration(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:129:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 129 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211OfdmTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:130:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 130 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:131:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 131 | virtual bps getGrossBitrate() const override { return Ieee80211OfdmModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:132:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 132 | virtual bps getNetBitrate() const override { return Ieee80211OfdmModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:133:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 133 | virtual int getNumberOfSpatialStreams() const override { return 1; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:144:5: warning: function 'getLegacyCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 144 | virtual int getLegacyCwMin() const override { return 15; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:144:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 144 | virtual int getLegacyCwMin() const override { return 15; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:145:5: warning: function 'getLegacyCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 145 | virtual int getLegacyCwMax() const override { return 1023; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:145:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 145 | virtual int getLegacyCwMax() const override { return 1023; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:150:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 150 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:152:5: warning: function 'getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 152 | virtual const Ieee80211OfdmPreambleMode *getPreambleMode() const override { return preambleMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:152:46: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 152 | virtual const Ieee80211OfdmPreambleMode *getPreambleMode() const override { return preambleMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:153:5: warning: function 'getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 153 | virtual const Ieee80211OfdmSignalMode *getHeaderMode() const override { return signalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:153:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 153 | virtual const Ieee80211OfdmSignalMode *getHeaderMode() const override { return signalMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:154:5: warning: function 'getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 154 | virtual const Ieee80211OfdmDataMode *getDataMode() const override { return dataMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:154:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 154 | virtual const Ieee80211OfdmDataMode *getDataMode() const override { return dataMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:155:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 155 | virtual bps getNonHtReferenceRate() const override { return dataMode->getNetBitrate(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:155:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 155 | virtual bps getNonHtReferenceRate() const override { return dataMode->getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:156:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 156 | virtual ModulationClass getModulationClass() const override { return ModulationClass::OFDM; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:156:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 156 | virtual ModulationClass getModulationClass() const override { return ModulationClass::OFDM; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:157:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 157 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:157:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 157 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:158:5: warning: function 'getSignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 158 | virtual const Ieee80211OfdmSignalMode *getSignalMode() const { return signalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:160:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 160 | virtual inline const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + signalMode->getDuration() + dataMode->getDuration(dataLength); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:160:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 160 | virtual inline const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + signalMode->getDuration() + dataMode->getDuration(dataLength); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:163:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 163 | virtual const simtime_t getSlotTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:163:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 163 | virtual const simtime_t getSlotTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:164:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 164 | virtual const simtime_t getSifsTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:164:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 164 | virtual const simtime_t getSifsTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:165:5: warning: function 'getRifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 165 | virtual const simtime_t getRifsTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:165:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 165 | virtual const simtime_t getRifsTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:166:5: warning: function 'getCcaTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 166 | virtual const simtime_t getCcaTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:166:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 166 | virtual const simtime_t getCcaTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:167:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 167 | virtual const simtime_t getPhyRxStartDelay() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:167:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 167 | virtual const simtime_t getPhyRxStartDelay() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:168:5: warning: function 'getRxTxTurnaroundTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 168 | virtual const simtime_t getRxTxTurnaroundTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:168:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 168 | virtual const simtime_t getRxTxTurnaroundTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:169:5: warning: function 'getPreambleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 169 | virtual inline const simtime_t getPreambleLength() const override { return preambleMode->getDuration(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:169:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual inline const simtime_t getPreambleLength() const override { return preambleMode->getDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:170:5: warning: function 'getPlcpHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 170 | virtual inline const simtime_t getPlcpHeaderLength() const override { return signalMode->getDuration(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:170:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual inline const simtime_t getPlcpHeaderLength() const override { return signalMode->getDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:171:5: warning: function 'getMpduMaxLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 171 | virtual inline int getMpduMaxLength() const override { return 4095; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:171:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 171 | virtual inline int getMpduMaxLength() const override { return 4095; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:178:44: warning: invalid case style for global constant 'ofdmPreambleModeCS5MHz' [readability-identifier-naming] + 178 | static const Ieee80211OfdmPreambleMode ofdmPreambleModeCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~ + | OFDM_PREAMBLE_MODE_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:179:44: warning: invalid case style for global constant 'ofdmPreambleModeCS10MHz' [readability-identifier-naming] + 179 | static const Ieee80211OfdmPreambleMode ofdmPreambleModeCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_PREAMBLE_MODE_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:180:44: warning: invalid case style for global constant 'ofdmPreambleModeCS20MHz' [readability-identifier-naming] + 180 | static const Ieee80211OfdmPreambleMode ofdmPreambleModeCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_PREAMBLE_MODE_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:183:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate13' [readability-identifier-naming] + 183 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate13; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE13 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:184:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate15' [readability-identifier-naming] + 184 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate15; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE15 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:185:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate5' [readability-identifier-naming] + 185 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate5; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE5 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:186:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate7' [readability-identifier-naming] + 186 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate7; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE7 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:187:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate9' [readability-identifier-naming] + 187 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate9; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE9 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:188:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate11' [readability-identifier-naming] + 188 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate11; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE11 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:189:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate1' [readability-identifier-naming] + 189 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate1; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE1 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:190:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate3' [readability-identifier-naming] + 190 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate3; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:192:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate13' [readability-identifier-naming] + 192 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate13; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE13 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:193:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate15' [readability-identifier-naming] + 193 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate15; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE15 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:194:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate5' [readability-identifier-naming] + 194 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate5; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE5 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:195:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate7' [readability-identifier-naming] + 195 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate7; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE7 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:196:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate9' [readability-identifier-naming] + 196 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate9; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE9 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:197:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate11' [readability-identifier-naming] + 197 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate11; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE11 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:198:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate1' [readability-identifier-naming] + 198 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate1; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE1 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:199:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate3' [readability-identifier-naming] + 199 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate3; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:201:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate13' [readability-identifier-naming] + 201 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate13; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE13 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:202:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate15' [readability-identifier-naming] + 202 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate15; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE15 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:203:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate5' [readability-identifier-naming] + 203 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate5; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE5 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:204:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate7' [readability-identifier-naming] + 204 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate7; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE7 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:205:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate9' [readability-identifier-naming] + 205 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate9; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE9 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:206:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate11' [readability-identifier-naming] + 206 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate11; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE11 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:207:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate1' [readability-identifier-naming] + 207 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate1; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE1 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:208:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate3' [readability-identifier-naming] + 208 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate3; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:211:40: warning: invalid case style for global constant 'ofdmDataMode1_5Mbps' [readability-identifier-naming] + 211 | static const Ieee80211OfdmDataMode ofdmDataMode1_5Mbps; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE1_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:212:40: warning: invalid case style for global constant 'ofdmDataMode2_25Mbps' [readability-identifier-naming] + 212 | static const Ieee80211OfdmDataMode ofdmDataMode2_25Mbps; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE2_25_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:213:40: warning: invalid case style for global constant 'ofdmDataMode3MbpsCS5MHz' [readability-identifier-naming] + 213 | static const Ieee80211OfdmDataMode ofdmDataMode3MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE3_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:214:40: warning: invalid case style for global constant 'ofdmDataMode3MbpsCS10MHz' [readability-identifier-naming] + 214 | static const Ieee80211OfdmDataMode ofdmDataMode3MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE3_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:215:40: warning: invalid case style for global constant 'ofdmDataMode4_5MbpsCS5MHz' [readability-identifier-naming] + 215 | static const Ieee80211OfdmDataMode ofdmDataMode4_5MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE4_5_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:216:40: warning: invalid case style for global constant 'ofdmDataMode4_5MbpsCS10MHz' [readability-identifier-naming] + 216 | static const Ieee80211OfdmDataMode ofdmDataMode4_5MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE4_5_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:217:40: warning: invalid case style for global constant 'ofdmDataMode6MbpsCS5MHz' [readability-identifier-naming] + 217 | static const Ieee80211OfdmDataMode ofdmDataMode6MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE6_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:218:40: warning: invalid case style for global constant 'ofdmDataMode6MbpsCS10MHz' [readability-identifier-naming] + 218 | static const Ieee80211OfdmDataMode ofdmDataMode6MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE6_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:219:40: warning: invalid case style for global constant 'ofdmDataMode6MbpsCS20MHz' [readability-identifier-naming] + 219 | static const Ieee80211OfdmDataMode ofdmDataMode6MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE6_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:220:40: warning: invalid case style for global constant 'ofdmDataMode9MbpsCS5MHz' [readability-identifier-naming] + 220 | static const Ieee80211OfdmDataMode ofdmDataMode9MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE9_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:221:40: warning: invalid case style for global constant 'ofdmDataMode9MbpsCS10MHz' [readability-identifier-naming] + 221 | static const Ieee80211OfdmDataMode ofdmDataMode9MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE9_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:222:40: warning: invalid case style for global constant 'ofdmDataMode9MbpsCS20MHz' [readability-identifier-naming] + 222 | static const Ieee80211OfdmDataMode ofdmDataMode9MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE9_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:223:40: warning: invalid case style for global constant 'ofdmDataMode12MbpsCS5MHz' [readability-identifier-naming] + 223 | static const Ieee80211OfdmDataMode ofdmDataMode12MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE12_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:224:40: warning: invalid case style for global constant 'ofdmDataMode12MbpsCS10MHz' [readability-identifier-naming] + 224 | static const Ieee80211OfdmDataMode ofdmDataMode12MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE12_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:225:40: warning: invalid case style for global constant 'ofdmDataMode12MbpsCS20MHz' [readability-identifier-naming] + 225 | static const Ieee80211OfdmDataMode ofdmDataMode12MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE12_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:226:40: warning: invalid case style for global constant 'ofdmDataMode13_5Mbps' [readability-identifier-naming] + 226 | static const Ieee80211OfdmDataMode ofdmDataMode13_5Mbps; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE13_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:227:40: warning: invalid case style for global constant 'ofdmDataMode18MbpsCS10MHz' [readability-identifier-naming] + 227 | static const Ieee80211OfdmDataMode ofdmDataMode18MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE18_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:228:40: warning: invalid case style for global constant 'ofdmDataMode18MbpsCS20MHz' [readability-identifier-naming] + 228 | static const Ieee80211OfdmDataMode ofdmDataMode18MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE18_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:229:40: warning: invalid case style for global constant 'ofdmDataMode24MbpsCS10MHz' [readability-identifier-naming] + 229 | static const Ieee80211OfdmDataMode ofdmDataMode24MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE24_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:230:40: warning: invalid case style for global constant 'ofdmDataMode24MbpsCS20MHz' [readability-identifier-naming] + 230 | static const Ieee80211OfdmDataMode ofdmDataMode24MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE24_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:231:40: warning: invalid case style for global constant 'ofdmDataMode27Mbps' [readability-identifier-naming] + 231 | static const Ieee80211OfdmDataMode ofdmDataMode27Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE27_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:232:40: warning: invalid case style for global constant 'ofdmDataMode36Mbps' [readability-identifier-naming] + 232 | static const Ieee80211OfdmDataMode ofdmDataMode36Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE36_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:233:40: warning: invalid case style for global constant 'ofdmDataMode48Mbps' [readability-identifier-naming] + 233 | static const Ieee80211OfdmDataMode ofdmDataMode48Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE48_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:234:40: warning: invalid case style for global constant 'ofdmDataMode54Mbps' [readability-identifier-naming] + 234 | static const Ieee80211OfdmDataMode ofdmDataMode54Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE54_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:237:36: warning: invalid case style for global constant 'ofdmMode1_5Mbps' [readability-identifier-naming] + 237 | static const Ieee80211OfdmMode ofdmMode1_5Mbps; + | ^~~~~~~~~~~~~~~ + | OFDM_MODE1_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:238:36: warning: invalid case style for global constant 'ofdmMode2_25Mbps' [readability-identifier-naming] + 238 | static const Ieee80211OfdmMode ofdmMode2_25Mbps; + | ^~~~~~~~~~~~~~~~ + | OFDM_MODE2_25_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:239:36: warning: invalid case style for global constant 'ofdmMode3MbpsCS5MHz' [readability-identifier-naming] + 239 | static const Ieee80211OfdmMode ofdmMode3MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_MODE3_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:240:36: warning: invalid case style for global constant 'ofdmMode3MbpsCS10MHz' [readability-identifier-naming] + 240 | static const Ieee80211OfdmMode ofdmMode3MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE3_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:241:36: warning: invalid case style for global constant 'ofdmMode4_5MbpsCS5MHz' [readability-identifier-naming] + 241 | static const Ieee80211OfdmMode ofdmMode4_5MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE4_5_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:242:36: warning: invalid case style for global constant 'ofdmMode4_5MbpsCS10MHz' [readability-identifier-naming] + 242 | static const Ieee80211OfdmMode ofdmMode4_5MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE4_5_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:243:36: warning: invalid case style for global constant 'ofdmMode6MbpsCS5MHz' [readability-identifier-naming] + 243 | static const Ieee80211OfdmMode ofdmMode6MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_MODE6_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:244:36: warning: invalid case style for global constant 'ofdmMode6MbpsCS10MHz' [readability-identifier-naming] + 244 | static const Ieee80211OfdmMode ofdmMode6MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE6_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:245:36: warning: invalid case style for global constant 'ofdmMode6MbpsCS20MHz' [readability-identifier-naming] + 245 | static const Ieee80211OfdmMode ofdmMode6MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE6_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:246:36: warning: invalid case style for global constant 'ofdmMode9MbpsCS5MHz' [readability-identifier-naming] + 246 | static const Ieee80211OfdmMode ofdmMode9MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_MODE9_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:247:36: warning: invalid case style for global constant 'ofdmMode9MbpsCS10MHz' [readability-identifier-naming] + 247 | static const Ieee80211OfdmMode ofdmMode9MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE9_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:248:36: warning: invalid case style for global constant 'ofdmMode9MbpsCS20MHz' [readability-identifier-naming] + 248 | static const Ieee80211OfdmMode ofdmMode9MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE9_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:249:36: warning: invalid case style for global constant 'ofdmMode12MbpsCS5MHz' [readability-identifier-naming] + 249 | static const Ieee80211OfdmMode ofdmMode12MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE12_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:250:36: warning: invalid case style for global constant 'ofdmMode12MbpsCS10MHz' [readability-identifier-naming] + 250 | static const Ieee80211OfdmMode ofdmMode12MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE12_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:251:36: warning: invalid case style for global constant 'ofdmMode12MbpsCS20MHz' [readability-identifier-naming] + 251 | static const Ieee80211OfdmMode ofdmMode12MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE12_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:252:36: warning: invalid case style for global constant 'ofdmMode13_5Mbps' [readability-identifier-naming] + 252 | static const Ieee80211OfdmMode ofdmMode13_5Mbps; + | ^~~~~~~~~~~~~~~~ + | OFDM_MODE13_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:253:36: warning: invalid case style for global constant 'ofdmMode18MbpsCS10MHz' [readability-identifier-naming] + 253 | static const Ieee80211OfdmMode ofdmMode18MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE18_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:254:36: warning: invalid case style for global constant 'ofdmMode18MbpsCS20MHz' [readability-identifier-naming] + 254 | static const Ieee80211OfdmMode ofdmMode18MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE18_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:255:36: warning: invalid case style for global constant 'ofdmMode24MbpsCS10MHz' [readability-identifier-naming] + 255 | static const Ieee80211OfdmMode ofdmMode24MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE24_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:256:36: warning: invalid case style for global constant 'ofdmMode24MbpsCS20MHz' [readability-identifier-naming] + 256 | static const Ieee80211OfdmMode ofdmMode24MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE24_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:257:36: warning: invalid case style for global constant 'ofdmMode27Mbps' [readability-identifier-naming] + 257 | static const Ieee80211OfdmMode ofdmMode27Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE27_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:258:36: warning: invalid case style for global constant 'ofdmMode36Mbps' [readability-identifier-naming] + 258 | static const Ieee80211OfdmMode ofdmMode36Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE36_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:259:36: warning: invalid case style for global constant 'ofdmMode48Mbps' [readability-identifier-naming] + 259 | static const Ieee80211OfdmMode ofdmMode48Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE48_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:260:36: warning: invalid case style for global constant 'ofdmMode54Mbps' [readability-identifier-naming] + 260 | static const Ieee80211OfdmMode ofdmMode54Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE54_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMMODULATION_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMMODULATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMMODULATION_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:25:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual cObject *dup() const override { return new Ieee80211OfdmModulation(numSubcarriers, subcarrierModulation); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:25:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual cObject *dup() const override { return new Ieee80211OfdmModulation(numSubcarriers, subcarrierModulation); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:27:5: warning: function 'getNumSubcarriers' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual int getNumSubcarriers() const { return numSubcarriers; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:28:5: warning: function 'getSubcarrierModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const ApskModulationBase *getSubcarrierModulation() const { return subcarrierModulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:31:5: warning: function 'calculateBER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual double calculateBER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateBER(snir, bandwidth, bitrate); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:31:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual double calculateBER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateBER(snir, bandwidth, bitrate); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:32:5: warning: function 'calculateSER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual double calculateSER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateSER(snir, bandwidth, bitrate); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:32:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual double calculateSER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateSER(snir, bandwidth, bitrate); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:34:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:42:42: warning: invalid case style for global constant 'subcarriers52QbpskModulation' [readability-identifier-naming] + 42 | static const Ieee80211OfdmModulation subcarriers52QbpskModulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QBPSK_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:43:42: warning: invalid case style for global constant 'subcarriers52BpskModulation' [readability-identifier-naming] + 43 | static const Ieee80211OfdmModulation subcarriers52BpskModulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_BPSK_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:44:42: warning: invalid case style for global constant 'subcarriers52QpskModulation' [readability-identifier-naming] + 44 | static const Ieee80211OfdmModulation subcarriers52QpskModulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QPSK_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:45:42: warning: invalid case style for global constant 'subcarriers52Qam16Modulation' [readability-identifier-naming] + 45 | static const Ieee80211OfdmModulation subcarriers52Qam16Modulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QAM16_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:46:42: warning: invalid case style for global constant 'subcarriers52Qam64Modulation' [readability-identifier-naming] + 46 | static const Ieee80211OfdmModulation subcarriers52Qam64Modulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QAM64_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:47:42: warning: invalid case style for global constant 'subcarriers52Qam256Modulation' [readability-identifier-naming] + 47 | static const Ieee80211OfdmModulation subcarriers52Qam256Modulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QAM256_MODULATION +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211CONTROLINFO_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211CONTROLINFO_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_CONTROLINFO_M_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | class Ieee80211ConfigureRadioCommand; + 35 | + 36 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:50:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 50 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 51 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:84:10: warning: deleted member function should be public [modernize-use-equals-delete] + 84 | bool operator==(const Ieee80211ConfigureRadioCommand&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:89:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 89 | virtual ~Ieee80211ConfigureRadioCommand(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:91:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual Ieee80211ConfigureRadioCommand *dup() const override {return new Ieee80211ConfigureRadioCommand(*this);} + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:91:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual Ieee80211ConfigureRadioCommand *dup() const override {return new Ieee80211ConfigureRadioCommand(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:95:5: warning: function 'getOpMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 95 | virtual const char * getOpMode() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:98:5: warning: function 'getModeSet' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual const Ieee80211ModeSet * getModeSet() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:101:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | virtual const IIeee80211Mode * getMode() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:104:5: warning: function 'getBand' should be marked [[nodiscard]] [modernize-use-nodiscard] + 104 | virtual const IIeee80211Band * getBand() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:108:5: warning: function 'getChannel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | virtual const Ieee80211Channel * getChannel() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:112:5: warning: function 'getChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 112 | virtual int getChannelNumber() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211PHYHEADER_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211PHYHEADER_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_PHYHEADER_M_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:65:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 65 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 66 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:84:10: warning: deleted member function should be public [modernize-use-equals-delete] + 84 | bool operator==(const Ieee80211PhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:89:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 89 | virtual ~Ieee80211PhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:91:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual Ieee80211PhyPreamble *dup() const override {return new Ieee80211PhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:118:10: warning: deleted member function should be public [modernize-use-equals-delete] + 118 | bool operator==(const Ieee80211PhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:123:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 123 | virtual ~Ieee80211PhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:125:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 125 | virtual Ieee80211PhyHeader *dup() const override {return new Ieee80211PhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:126:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 126 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:127:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 127 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:156:10: warning: deleted member function should be public [modernize-use-equals-delete] + 156 | bool operator==(const Ieee80211FhssPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:161:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 161 | virtual ~Ieee80211FhssPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:163:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 163 | virtual Ieee80211FhssPhyPreamble *dup() const override {return new Ieee80211FhssPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:164:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 164 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:165:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 165 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:196:10: warning: deleted member function should be public [modernize-use-equals-delete] + 196 | bool operator==(const Ieee80211FhssPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:201:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 201 | virtual ~Ieee80211FhssPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:203:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 203 | virtual Ieee80211FhssPhyHeader *dup() const override {return new Ieee80211FhssPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:204:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 204 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:205:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 205 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:242:10: warning: deleted member function should be public [modernize-use-equals-delete] + 242 | bool operator==(const Ieee80211IrPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:247:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 247 | virtual ~Ieee80211IrPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:249:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 249 | virtual Ieee80211IrPhyPreamble *dup() const override {return new Ieee80211IrPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:250:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 250 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:251:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 251 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:279:10: warning: deleted member function should be public [modernize-use-equals-delete] + 279 | bool operator==(const Ieee80211IrPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:284:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 284 | virtual ~Ieee80211IrPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:286:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 286 | virtual Ieee80211IrPhyHeader *dup() const override {return new Ieee80211IrPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:287:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 287 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:288:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 288 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:320:10: warning: deleted member function should be public [modernize-use-equals-delete] + 320 | bool operator==(const Ieee80211DsssPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:325:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 325 | virtual ~Ieee80211DsssPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:327:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 327 | virtual Ieee80211DsssPhyPreamble *dup() const override {return new Ieee80211DsssPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:328:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 328 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:329:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 329 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:361:10: warning: deleted member function should be public [modernize-use-equals-delete] + 361 | bool operator==(const Ieee80211DsssPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:366:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 366 | virtual ~Ieee80211DsssPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:368:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 368 | virtual Ieee80211DsssPhyHeader *dup() const override {return new Ieee80211DsssPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:369:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 369 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:370:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 370 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:407:10: warning: deleted member function should be public [modernize-use-equals-delete] + 407 | bool operator==(const Ieee80211HrDsssPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:412:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 412 | virtual ~Ieee80211HrDsssPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:414:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 414 | virtual Ieee80211HrDsssPhyPreamble *dup() const override {return new Ieee80211HrDsssPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:415:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 415 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:416:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 416 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:438:10: warning: deleted member function should be public [modernize-use-equals-delete] + 438 | bool operator==(const Ieee80211HrDsssPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:443:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 443 | virtual ~Ieee80211HrDsssPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:445:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 445 | virtual Ieee80211HrDsssPhyHeader *dup() const override {return new Ieee80211HrDsssPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:446:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 446 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:447:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 447 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:472:10: warning: deleted member function should be public [modernize-use-equals-delete] + 472 | bool operator==(const Ieee80211OfdmPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:477:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 477 | virtual ~Ieee80211OfdmPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:479:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 479 | virtual Ieee80211OfdmPhyPreamble *dup() const override {return new Ieee80211OfdmPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:480:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 480 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:481:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 481 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:533:10: warning: deleted member function should be public [modernize-use-equals-delete] + 533 | bool operator==(const Ieee80211OfdmPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:538:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 538 | virtual ~Ieee80211OfdmPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:540:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 540 | virtual Ieee80211OfdmPhyHeader *dup() const override {return new Ieee80211OfdmPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:541:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 541 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:542:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 542 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:582:10: warning: deleted member function should be public [modernize-use-equals-delete] + 582 | bool operator==(const Ieee80211ErpOfdmPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:587:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 587 | virtual ~Ieee80211ErpOfdmPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:589:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 589 | virtual Ieee80211ErpOfdmPhyPreamble *dup() const override {return new Ieee80211ErpOfdmPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:590:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 590 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:591:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 591 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:613:10: warning: deleted member function should be public [modernize-use-equals-delete] + 613 | bool operator==(const Ieee80211ErpOfdmPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:618:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 618 | virtual ~Ieee80211ErpOfdmPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:620:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 620 | virtual Ieee80211ErpOfdmPhyHeader *dup() const override {return new Ieee80211ErpOfdmPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:621:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 621 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:622:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 622 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:647:10: warning: deleted member function should be public [modernize-use-equals-delete] + 647 | bool operator==(const Ieee80211HtPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:652:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 652 | virtual ~Ieee80211HtPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:654:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 654 | virtual Ieee80211HtPhyPreamble *dup() const override {return new Ieee80211HtPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:655:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 655 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:656:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 656 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:704:10: warning: deleted member function should be public [modernize-use-equals-delete] + 704 | bool operator==(const Ieee80211HtPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:709:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 709 | virtual ~Ieee80211HtPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:711:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 711 | virtual Ieee80211HtPhyHeader *dup() const override {return new Ieee80211HtPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:712:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 712 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:713:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 713 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:773:10: warning: deleted member function should be public [modernize-use-equals-delete] + 773 | bool operator==(const Ieee80211VhtPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:778:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 778 | virtual ~Ieee80211VhtPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:780:38: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 780 | virtual Ieee80211VhtPhyPreamble *dup() const override {return new Ieee80211VhtPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:781:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 781 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:782:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 782 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:804:10: warning: deleted member function should be public [modernize-use-equals-delete] + 804 | bool operator==(const Ieee80211VhtPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:809:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 809 | virtual ~Ieee80211VhtPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:811:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 811 | virtual Ieee80211VhtPhyHeader *dup() const override {return new Ieee80211VhtPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:812:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 812 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:813:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 813 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211TAG_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211TAG_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_TAG_M_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | struct Ieee80211AmpduRange; + 35 | class Ieee80211AmpduInd; + 36 | class Ieee80211ModeTagBase; + 37 | class Ieee80211ModeReq; + 38 | class Ieee80211ModeInd; + 39 | class Ieee80211ChannelTagBase; + 40 | class Ieee80211ChannelReq; + 41 | class Ieee80211ChannelInd; + 42 | + 43 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 44 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:57:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 57 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 58 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:74:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 74 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211AmpduRange& a); + | ^~~~~~~~~~~ + | doPacking + 75 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211AmpduRange& a); + 76 | + 77 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211AmpduRange& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:75:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 75 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211AmpduRange& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 76 | + 77 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211AmpduRange& obj) { __doPacking(b, obj); } + 78 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211AmpduRange& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:100:12: warning: invalid case style for protected member 'ranges_arraysize' [readability-identifier-naming] + 100 | size_t ranges_arraysize = 0; + | ^~~~~~~~~~~~~~~~ + | rangesArraysize +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:106:10: warning: deleted member function should be public [modernize-use-equals-delete] + 106 | bool operator==(const Ieee80211AmpduInd&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:111:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 111 | virtual ~Ieee80211AmpduInd(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:113:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 113 | virtual Ieee80211AmpduInd *dup() const override {return new Ieee80211AmpduInd(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:114:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 114 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:115:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 115 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:161:10: warning: deleted member function should be public [modernize-use-equals-delete] + 161 | bool operator==(const Ieee80211ModeTagBase&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:166:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 166 | virtual ~Ieee80211ModeTagBase(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:168:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 168 | virtual Ieee80211ModeTagBase *dup() const override {return new Ieee80211ModeTagBase(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:169:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:170:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:199:10: warning: deleted member function should be public [modernize-use-equals-delete] + 199 | bool operator==(const Ieee80211ModeReq&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:204:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 204 | virtual ~Ieee80211ModeReq(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:206:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 206 | virtual Ieee80211ModeReq *dup() const override {return new Ieee80211ModeReq(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:207:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 207 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:208:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 208 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:234:10: warning: deleted member function should be public [modernize-use-equals-delete] + 234 | bool operator==(const Ieee80211ModeInd&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:239:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 239 | virtual ~Ieee80211ModeInd(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:241:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 241 | virtual Ieee80211ModeInd *dup() const override {return new Ieee80211ModeInd(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:242:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 242 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:243:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 243 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:270:10: warning: deleted member function should be public [modernize-use-equals-delete] + 270 | bool operator==(const Ieee80211ChannelTagBase&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:275:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 275 | virtual ~Ieee80211ChannelTagBase(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:277:38: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 277 | virtual Ieee80211ChannelTagBase *dup() const override {return new Ieee80211ChannelTagBase(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 278 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:279:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 279 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:308:10: warning: deleted member function should be public [modernize-use-equals-delete] + 308 | bool operator==(const Ieee80211ChannelReq&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:313:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 313 | virtual ~Ieee80211ChannelReq(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:315:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 315 | virtual Ieee80211ChannelReq *dup() const override {return new Ieee80211ChannelReq(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:316:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 316 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:317:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 317 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:343:10: warning: deleted member function should be public [modernize-use-equals-delete] + 343 | bool operator==(const Ieee80211ChannelInd&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:348:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 348 | virtual ~Ieee80211ChannelInd(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:350:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 350 | virtual Ieee80211ChannelInd *dup() const override {return new Ieee80211ChannelInd(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:351:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 351 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:352:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 352 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211TRANSMISSION_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211TRANSMISSION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_TRANSMISSION_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:31:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:33:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const IIeee80211Mode *getMode() const { return mode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:34:5: warning: function 'getChannel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual const Ieee80211Channel *getChannel() const { return channel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:37:5: warning: function 'getSignalExtensionDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | std::optional getSignalExtensionDuration() const; + | ^ + | [[nodiscard]] +./inet/queueing/base/PacketProcessorBase.h:9:9: warning: invalid case style for macro definition '__INET_PACKETPROCESSORBASE_H' [readability-identifier-naming] + 9 | #define __INET_PACKETPROCESSORBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PACKETPROCESSORBASE_H +./inet/queueing/base/PacketProcessorBase.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/base/PacketProcessorBase.h:32:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:33:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool supportsPacketSending(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool supportsPacketPassing(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool supportsPacketStreaming(const cGate *gate) const override { return false; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:78:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual std::string resolveDirective(char directive) const override; + | ~~~~~~~ ^ +./inet/queueing/common/PassivePacketSinkRef.h:9:9: warning: invalid case style for macro definition '__INET_PASSIVEPACKETSINKREF_H' [readability-identifier-naming] + 9 | #define __INET_PASSIVEPACKETSINKREF_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PASSIVEPACKETSINKREF_H +./inet/queueing/common/PassivePacketSinkRef.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/common/PassivePacketSinkRef.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~PassivePacketSinkRef() {} + | ^ ~~ + | = default; +./inet/queueing/common/PassivePacketSinkRef.h:22:5: warning: function 'canPushSomePacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool canPushSomePacket() const { + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:9:9: warning: invalid case style for macro definition '__INET_IPACKETCOLLECTION_H' [readability-identifier-naming] + 9 | #define __INET_IPACKETCOLLECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPACKETCOLLECTION_H +./inet/queueing/contract/IPacketCollection.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPacketCollection.h:26:5: warning: function 'getMaxNumPackets' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual int getMaxNumPackets() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:31:5: warning: function 'getNumPackets' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual int getNumPackets() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:37:5: warning: function 'getMaxTotalLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual b getMaxTotalLength() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:42:5: warning: function 'getTotalLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual b getTotalLength() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:47:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual Packet *getPacket(int index) const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:52:5: warning: function 'isEmpty' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual bool isEmpty() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketProcessor.h:9:9: warning: invalid case style for macro definition '__INET_IPACKETPROCESSOR_H' [readability-identifier-naming] + 9 | #define __INET_IPACKETPROCESSOR_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPACKETPROCESSOR_H +./inet/queueing/contract/IPacketProcessor.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPacketProcessor.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~IPacketProcessor() {} + | ^ ~~ + | = default; +./inet/queueing/contract/IPacketQueue.h:9:9: warning: invalid case style for macro definition '__INET_IPACKETQUEUE_H' [readability-identifier-naming] + 9 | #define __INET_IPACKETQUEUE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IPACKETQUEUE_H +./inet/queueing/contract/IPacketQueue.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPassivePacketSink.h:9:9: warning: invalid case style for macro definition '__INET_IPASSIVEPACKETSINK_H' [readability-identifier-naming] + 9 | #define __INET_IPASSIVEPACKETSINK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPASSIVEPACKETSINK_H +./inet/queueing/contract/IPassivePacketSink.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPassivePacketSink.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IPassivePacketSink() {} + | ^ ~~ + | = default; +./inet/queueing/contract/IPassivePacketSource.h:9:9: warning: invalid case style for macro definition '__INET_IPASSIVEPACKETSOURCE_H' [readability-identifier-naming] + 9 | #define __INET_IPASSIVEPACKETSOURCE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPASSIVEPACKETSOURCE_H +./inet/queueing/contract/IPassivePacketSource.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPassivePacketSource.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IPassivePacketSource() {} + | ^ ~~ + | = default; +./inet/queueing/contract/ISelectivePacketCollection.h:4:9: warning: invalid case style for macro definition '__INET_ISELECTIVEPACKETCOLLECTION_H' [readability-identifier-naming] + 4 | #define __INET_ISELECTIVEPACKETCOLLECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISELECTIVEPACKETCOLLECTION_H +./inet/queueing/contract/ISelectivePacketCollection.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/ISelectivePacketCollection.h:24:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 24 | virtual ~ISelectivePacketCollection() {} + | ^ ~~ + | = default; +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:36:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 36 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 37 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:57:33: warning: escaped string literal can be written as a raw string literal [modernize-raw-string-literal] + 57 | throw cRuntimeError("Unknown blockAckVariant \"%s\": expected \"basic\" or \"compressed\"", configuredVariant); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | R"(Unknown blockAckVariant "%s": expected "basic" or "compressed")" +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:584:31: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 584 | if (originator && request->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:588:32: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 588 | if (!originator && response->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:592:56: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 592 | if (delba->getInitiator() == originator && delba->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:632:101: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 632 | return data && data->getType() == ST_DATA_WITH_QOS && data->getReceiverAddress() == peer && data->getTid() == tid && + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:646:13: warning: empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether [bugprone-empty-catch] + 646 | catch (const queueing::UnsupportedPacketSelection&) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:664:63: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 664 | if (data && data->getReceiverAddress() == peer && data->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:743:72: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 743 | data->getReceiverAddress() == entry.first.first && data->getTid() == entry.first.second) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:775:57: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 775 | if (header->getReceiverAddress() == peer && header->getTid() == tid) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:799:63: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 799 | if (data && data->getReceiverAddress() == peer && data->getTid() == tid && + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:827:67: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 827 | if (data && data->getReceiverAddress() == peer && data->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:1996:9: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 1996 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:1996:10: note: end of the original + 1996 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2010:9: note: clone 1 starts here + 2010 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2012:9: note: clone 2 starts here + 2012 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2064:12: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 2064 | return SimTime(microseconds, SIMTIME_US); + | ^~~~~~~~ ~ + | { } +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2611:70: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 2611 | if (data && data->getReceiverAddress() == limits.receiver && data->getTid() == limits.tid && + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3015:99: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 3015 | if (dynamicPtrCast(header) && txop->getLimit() == 0) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3018:14: note: end of the original + 3018 | } + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3019:107: note: clone 1 starts here + 3019 | else if (pendingPacket && !channelOwner->getInProgressFrames()->containsFrame(pendingPacket)) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3194:6: warning: an exception may be thrown in function '~Hcf' which should not throw exceptions [bugprone-exception-escape] + 3194 | Hcf::~Hcf() + | ^ +/home/user/omnetpp-6.4.0aipre2/include/omnetpp/checkandcast.h:64:9: note: frame #0: unhandled exception of type 'omnetpp::cRuntimeError' may be thrown in function 'check_and_cast' here + 64 | throw cRuntimeError("check_and_cast(): Cannot cast nullptr to type '%s'", opp_typename(typeid(P))); + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3199:28: note: frame #1: function '~Hcf' calls function 'check_and_cast' here + 3199 | auto radioModule = check_and_cast(interframeRadio.get()); + | ^ +Suppressed 12155 warnings (12155 in non-user code). +Use -header-filter=.* to display errors from all non-system headers. Use -system-headers to display errors from system headers as well. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy.txt new file mode 100644 index 00000000000..a2e98d23fcd --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-tidy.txt @@ -0,0 +1,16335 @@ +[1/7] Processing file /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc. +16650 warnings generated. +[2/7] Processing file /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc. +27535 warnings generated. +[3/7] Processing file /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc. +39535 warnings generated. +[4/7] Processing file /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc. +51549 warnings generated. +[5/7] Processing file /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc. +64259 warnings generated. +[6/7] Processing file /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc. +75474 warnings generated. +[7/7] Processing file /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc. +87027 warnings generated. +./inet/common/BitVector.h:9:9: warning: invalid case style for macro definition '__INET_BITVECTOR_H' [readability-identifier-naming] + 9 | #define __INET_BITVECTOR_H + | ^~~~~~~~~~~~~~~~~~ + | INET_BITVECTOR_H +./inet/common/BitVector.h:24:5: warning: function 'containerSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | int containerSize() const { return bytes.size() * 8; } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:36:5: warning: function 'toDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | unsigned int toDecimal() const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:37:5: warning: function 'reverseToDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | unsigned int reverseToDecimal() const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:42:5: warning: function 'getBit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | bool getBit(int pos) const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:44:5: warning: function 'getSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | unsigned int getSize() const { return size; } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:45:5: warning: function 'getNumberOfBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | unsigned int getNumberOfBytes() const { return bytes.size(); } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:46:5: warning: function 'getBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | const std::vector& getBytes() const { return bytes; } + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:47:5: warning: function 'computeHammingDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | int computeHammingDistance(const BitVector& u) const; + | ^ + | [[nodiscard]] +./inet/common/BitVector.h:52:5: warning: function 'toString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | std::string toString() const; + | ^ + | [[nodiscard]] +./inet/common/Compat.h:9:9: warning: invalid case style for macro definition '__INET_COMPAT_H' [readability-identifier-naming] + 9 | #define __INET_COMPAT_H + | ^~~~~~~~~~~~~~~ + | INET_COMPAT_H +./inet/common/Compat.h:35:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 35 | typedef int sharedvarhandle_t; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sharedvarhandle_t = int +./inet/common/Compat.h:35:13: warning: invalid case style for typedef 'sharedvarhandle_t' [readability-identifier-naming] + 35 | typedef int sharedvarhandle_t; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Compat.h:43:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 43 | typedef int sharedcounterhandle_t; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sharedcounterhandle_t = int +./inet/common/Compat.h:43:13: warning: invalid case style for typedef 'sharedcounterhandle_t' [readability-identifier-naming] + 43 | typedef int sharedcounterhandle_t; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Compat.h:66:20: warning: invalid case style for private member 'INVALID' [readability-identifier-naming] + 66 | const uint64_t INVALID = (uint64_t)-1; + | ^~~~~~~ + | invalid +./inet/common/Compat.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void lifecycleEvent(omnetpp::SimulationLifecycleEventType eventType, omnetpp::cObject *details) override; + | ~~~~~~~ ^ +./inet/common/Compat.h:237:9: warning: invalid case style for macro definition 'cSimulationOrSharedDataManager' [readability-identifier-naming] + 237 | #define cSimulationOrSharedDataManager SharedDataManager + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | C_SIMULATION_OR_SHARED_DATA_MANAGER +./inet/common/DelayedInitializer.h:9:9: warning: invalid case style for macro definition '__INET_DELAYEDINITIALIZER_H' [readability-identifier-naming] + 9 | #define __INET_DELAYEDINITIALIZER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_DELAYEDINITIALIZER_H +./inet/common/DelayedInitializer.h:22:10: warning: use default member initializer for 'constructed' [modernize-use-default-member-init] + 22 | bool constructed; + | ^ + | {true} + 23 | const std::function initializer; + 24 | + 25 | public: + 26 | DelayedInitializer(const std::function initializer) : constructed(true), initializer(initializer) {} + | ~~~~~~~~~~~~~~~~~ +./inet/common/INETDefs.h:9:9: warning: invalid case style for macro definition '__INET_INETDEFS_H' [readability-identifier-naming] + 9 | #define __INET_INETDEFS_H + | ^~~~~~~~~~~~~~~~~ + | INET_INETDEFS_H +./inet/common/INETDefs.h:37:1: warning: replace macro with enum [modernize-macro-to-enum] + 37 | #define INET_VERSION 0x0407 + | ^~~~~~~ + | = , + 38 | #define INET_PATCH_LEVEL 0x00 + | ~~~~~~~ + | = + 39 | +./inet/common/INETDefs.h:37:9: warning: macro 'INET_VERSION' defines an integral constant; prefer an enum instead [modernize-macro-to-enum] + 37 | #define INET_VERSION 0x0407 + | ^ +./inet/common/INETDefs.h:38:9: warning: macro 'INET_PATCH_LEVEL' defines an integral constant; prefer an enum instead [modernize-macro-to-enum] + 38 | #define INET_PATCH_LEVEL 0x00 + | ^ +./inet/common/INETDefs.h:60:7: warning: invalid case style for type alias 'simtime_raw_t' [readability-identifier-naming] + 60 | using simtime_raw_t = int64_t; + | ^~~~~~~~~~~~~ + | SimtimeRawT +./inet/common/INETDefs.h:67:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 67 | typedef unsigned short ushort; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ushort = unsigned short +./inet/common/INETDefs.h:67:24: warning: invalid case style for typedef 'ushort' [readability-identifier-naming] + 67 | typedef unsigned short ushort; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/INETDefs.h:68:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 68 | typedef unsigned int uint; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using uint = unsigned int +./inet/common/INETDefs.h:68:22: warning: invalid case style for typedef 'uint' [readability-identifier-naming] + 68 | typedef unsigned int uint; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/INETDefs.h:69:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 69 | typedef unsigned long ulong; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ulong = unsigned long +./inet/common/INETDefs.h:69:23: warning: invalid case style for typedef 'ulong' [readability-identifier-naming] + 69 | typedef unsigned long ulong; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/INETDefs.h:75:7: warning: invalid case style for type alias 'void_t' [readability-identifier-naming] + 75 | using void_t = void; + | ^~~~~~ + | VoidT +./inet/common/INETDefs.h:86:4: warning: invalid case style for function '__checknull' [readability-identifier-naming] + 86 | T *__checknull(T *p, const char *expr, const char *file, int line) + | ^~~~~~~~~~~ + | checknull +./inet/common/INETDefs.h:114:99: warning: macro argument should be enclosed in parentheses [bugprone-macro-parentheses] + 114 | #define EV_FORMAT_STYLE(format) (evFlags & IPrintableObject::PRINT_FLAG_FORMATTED ? format : "") + | ^ + | ( ) +./inet/common/INETDefs_m.h:6:9: warning: invalid case style for macro definition '__INET_INETDEFS_M_H' [readability-identifier-naming] + 6 | #define __INET_INETDEFS_M_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_INETDEFS_M_H +./inet/common/INETMath.h:9:9: warning: invalid case style for macro definition '__INET_INETMATH_H' [readability-identifier-naming] + 9 | #define __INET_INETMATH_H + | ^~~~~~~~~~~~~~~~~ + | INET_INETMATH_H +./inet/common/INETMath.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | + 22 | /** + 23 | * @brief Support functions for mathematical operations. + 24 | * + 25 | * This namespace contains all kind of mathematical support functions + 26 | */ + 27 | namespace math { + | ~~~~~~~~~~~~~~ + | namespace inet::math +./inet/common/INETMath.h:90:9: warning: invalid case style for macro definition 'sNaN' [readability-identifier-naming] + 90 | #define sNaN std::numeric_limits::signaling_NaN() + | ^~~~ + | S_NA_N +./inet/common/INETMath.h:91:9: warning: invalid case style for macro definition 'NaN' [readability-identifier-naming] + 91 | #define NaN qNaN + | ^~~ + | NA_N +./inet/common/INETMath.h:194:15: warning: invalid case style for function 'n_choose_k' [readability-identifier-naming] + 194 | inline double n_choose_k(int n, int k) { + | ^~~~~~~~~~ + | nChooseK +./inet/common/INETMath.h:217:16: warning: use c++17 style variable templates [modernize-type-traits] + 217 | static_assert(!std::is_integral::value, "minnan() is only meant for doubles and double based units, use std::min() for integers"); + | ^ ~~~~~~~ + | _v +./inet/common/INETMath.h:219:9: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 219 | return a; + | ^ +./inet/common/INETMath.h:219:17: note: end of the original + 219 | return a; + | ^ +./inet/common/INETMath.h:223:9: note: clone 1 starts here + 223 | return a; + | ^ +./inet/common/INETMath.h:235:16: warning: use c++17 style variable templates [modernize-type-traits] + 235 | static_assert(!std::is_integral::value, "maxnan() is only meant for doubles and double based units, use std::max() for integers"); + | ^ ~~~~~~~ + | _v +./inet/common/INETMath.h:237:9: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 237 | return a; + | ^ +./inet/common/INETMath.h:237:17: note: end of the original + 237 | return a; + | ^ +./inet/common/INETMath.h:241:9: note: clone 1 starts here + 241 | return a; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:9:9: warning: invalid case style for macro definition '__INET_IPRINTABLEOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_IPRINTABLEOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPRINTABLEOBJECT_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:35:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 35 | virtual ~IPrintableObject() {} + | ^ ~~ + | = default; +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:40:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 40 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const { + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:40:67: note: the first parameter in the range is 'level' + 40 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const { + | ^~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:40:78: note: the last parameter in the range is 'evFlags' + 40 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const { + | ^~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:44:5: warning: function 'printToString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual std::string printToString() const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:48:5: warning: function 'printToString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual std::string printToString(int level, int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:54:5: warning: function 'getInfoStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual std::string getInfoStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:60:5: warning: function 'getDetailStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual std::string getDetailStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:66:5: warning: function 'getDebugStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual std::string getDebugStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:72:5: warning: function 'getTraceStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | virtual std::string getTraceStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:78:5: warning: function 'getCompleteStringRepresentation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | virtual std::string getCompleteStringRepresentation(int evFlags = 0) const { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:112:8: warning: invalid case style for struct 'has_print_to_string' [readability-identifier-naming] + 112 | struct has_print_to_string : std::false_type {}; + | ^~~~~~~~~~~~~~~~~~~ + | HasPrintToString + 113 | + 114 | template + 115 | struct has_print_to_string().printToString())>> + 116 | : std::true_type {}; + 117 | + 118 | template + 119 | struct has_str : std::false_type {}; + 120 | + 121 | template + 122 | struct has_str().str())>> + 123 | : std::true_type {}; + 124 | + 125 | template + 126 | std::enable_if_t::value, std::string> printToStringIfPossible(T *object, int evFlags) + | ~~~~~~~~~~~~~~~~~~~ + | HasPrintToString +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:119:8: warning: invalid case style for struct 'has_str' [readability-identifier-naming] + 119 | struct has_str : std::false_type {}; + | ^~~~~~~ + | HasStr +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:156:18: warning: use c++17 style variable templates [modernize-type-traits] + 156 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:172:18: warning: use c++17 style variable templates [modernize-type-traits] + 172 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:186:18: warning: use c++17 style variable templates [modernize-type-traits] + 186 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:202:18: warning: use c++17 style variable templates [modernize-type-traits] + 202 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:218:18: warning: use c++17 style variable templates [modernize-type-traits] + 218 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T *object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:234:18: warning: use c++17 style variable templates [modernize-type-traits] + 234 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:248:19: warning: use c++17 style variable templates [modernize-type-traits] + 248 | std::enable_if_t::value && has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/IPrintableObject.h:256:19: warning: use c++17 style variable templates [modernize-type-traits] + 256 | std::enable_if_t::value && !has_str::value && !has_print_to_string::value, std::string> printToStringIfPossible(const T& object, int evFlags) + | ^ ~~~~~~~ + | _v +./inet/common/IVisitor.h:9:9: warning: invalid case style for macro definition '__INET_IVISITOR_H' [readability-identifier-naming] + 9 | #define __INET_IVISITOR_H + | ^~~~~~~~~~~~~~~~~ + | INET_IVISITOR_H +./inet/common/IVisitor.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IVisitor() {} + | ^ ~~ + | = default; +./inet/common/InitStageRegistry.h:9:9: warning: invalid case style for macro definition '__INET_INITSTAGEREGISTRY_H' [readability-identifier-naming] + 9 | #define __INET_INITSTAGEREGISTRY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_INITSTAGEREGISTRY_H +./inet/common/InitStageRegistry.h:12:9: warning: invalid case style for macro definition '__INET_INITSTAGES_H' [readability-identifier-naming] + 12 | #define __INET_INITSTAGES_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_INITSTAGES_H +./inet/common/InitStageRegistry.h:40:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 40 | InitStageRegistry() {} + | ^ ~~ + | = default; +./inet/common/InitStageRegistry.h:63:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | const char *getName() const { return name; } + | ^ + | [[nodiscard]] +./inet/common/InitStageRegistry.h:67:9: warning: invalid case style for macro definition 'Define_InitStage' [readability-identifier-naming] + 67 | #define Define_InitStage(name) const inet::InitStage INITSTAGE_##name(#name); EXECUTE_PRE_NETWORK_SETUP(inet::InitStageRegistry::getInstance().addInitStage(&INITSTAGE_##name)) + | ^~~~~~~~~~~~~~~~ + | DEFINE_INIT_STAGE +./inet/common/InitStageRegistry.h:69:9: warning: invalid case style for macro definition 'Define_InitStage_Dependency' [readability-identifier-naming] + 69 | #define Define_InitStage_Dependency(source, target) EXECUTE_PRE_NETWORK_SETUP(inet::InitStageRegistry::getInstance().addInitStageDependency(#source, #target)) + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | DEFINE_INIT_STAGE_DEPENDENCY +./inet/common/InitStages.h:9:9: warning: invalid case style for macro definition '__INET_INITSTAGES_H' [readability-identifier-naming] + 9 | #define __INET_INITSTAGES_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_INITSTAGES_H +./inet/common/IntervalTree.h:38:9: warning: invalid case style for macro definition '__INET_INTERVALTREE_H' [readability-identifier-naming] + 38 | #define __INET_INTERVALTREE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_INTERVALTREE_H +./inet/common/IntervalTree.h:58:18: warning: 2 adjacent parameters of 'Interval' of similar type ('simtime_t') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 58 | Interval(simtime_t low, simtime_t high, void *value) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/IntervalTree.h:58:28: note: the first parameter in the range is 'low' + 58 | Interval(simtime_t low, simtime_t high, void *value) : + | ^~~ +./inet/common/IntervalTree.h:58:43: note: the last parameter in the range is 'high' + 58 | Interval(simtime_t low, simtime_t high, void *value) : + | ^~~~ +./inet/common/IntervalTree.h:61:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 61 | virtual ~Interval() + | ^ + 62 | { + | ~ + | = default; + 63 | } + | ~ +./inet/common/IntervalTree.h:89:30: warning: invalid case style for parameter 'new_interval' [readability-identifier-naming] + 89 | Node(const Interval *new_interval); + | ^~~~~~~~~~~~ + | newInterval +./inet/common/IntervalTree.h:95:25: warning: invalid case style for protected member 'stored_interval' [readability-identifier-naming] + 95 | const Interval *stored_interval = nullptr; + | ^~~~~~~~~~~~~~~ + | storedInterval +./inet/common/IntervalTree.h:101:19: warning: invalid case style for protected member 'max_high' [readability-identifier-naming] + 101 | simtime_t max_high; + | ^~~~~~~~ + | maxHigh +./inet/common/IntervalTree.h:116:12: warning: invalid case style for struct 'it_recursion_node' [readability-identifier-naming] + 116 | struct it_recursion_node { + | ^~~~~~~~~~~~~~~~~ + | ItRecursionNode +./inet/common/IntervalTree.h:118:15: warning: invalid case style for public member 'start_node' [readability-identifier-naming] + 118 | Node *start_node = nullptr; + | ^~~~~~~~~~ + | startNode +./inet/common/IntervalTree.h:120:22: warning: invalid case style for public member 'parent_index' [readability-identifier-naming] + 120 | unsigned int parent_index = 0; + | ^~~~~~~~~~~~ + | parentIndex +./inet/common/IntervalTree.h:122:14: warning: invalid case style for public member 'try_right_branch' [readability-identifier-naming] + 122 | bool try_right_branch = false; + | ^~~~~~~~~~~~~~~~ + | tryRightBranch +./inet/common/IntervalTree.h:139:34: warning: invalid case style for parameter 'new_interval' [readability-identifier-naming] + 139 | Node *insert(const Interval *new_interval); + | ^~~~~~~~~~~~ + | newInterval +./inet/common/IntervalTree.h:180:18: warning: invalid case style for private member 'recursion_node_stack_size' [readability-identifier-naming] + 180 | unsigned int recursion_node_stack_size = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | recursionNodeStackSize +./inet/common/IntervalTree.h:181:24: warning: invalid case style for private member 'recursion_node_stack' [readability-identifier-naming] + 181 | it_recursion_node *recursion_node_stack = nullptr; + | ^~~~~~~~~~~~~~~~~~~~ + | recursionNodeStack +./inet/common/IntervalTree.h:182:18: warning: invalid case style for private member 'current_parent' [readability-identifier-naming] + 182 | unsigned int current_parent = 0; + | ^~~~~~~~~~~~~~ + | currentParent +./inet/common/IntervalTree.h:183:18: warning: invalid case style for private member 'recursion_node_stack_top' [readability-identifier-naming] + 183 | unsigned int recursion_node_stack_top = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | recursionNodeStackTop +./inet/common/IntrusivePtr.h:9:9: warning: invalid case style for macro definition '__INET_INTRUSIVEPTR_H' [readability-identifier-naming] + 9 | #define __INET_INTRUSIVEPTR_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_INTRUSIVEPTR_H +./inet/common/IntrusivePtr.h:38:18: warning: use nullptr [modernize-use-nullptr] + 38 | if (p != 0) intrusivePtrCounterIncrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:43:18: warning: use nullptr [modernize-use-nullptr] + 43 | if (p != 0) intrusivePtrCounterIncrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:47:18: warning: use nullptr [modernize-use-nullptr] + 47 | if (p != 0) intrusivePtrCounterIncrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:51:18: warning: use nullptr [modernize-use-nullptr] + 51 | if (p != 0) intrusivePtrCounterDecrement(p); + | ^ + | nullptr +./inet/common/IntrusivePtr.h:73:17: warning: use nullptr [modernize-use-nullptr] + 73 | ptr.p = 0; + | ^ + | nullptr +./inet/common/IntrusivePtr.h:82:38: warning: operator=() does not handle self-assignment properly [bugprone-unhandled-self-assignment] + 82 | INET_ALWAYS_INLINE IntrusivePtr& operator=(IntrusivePtr const& ptr) { + | ^ +./inet/common/IntrusivePtr.h:100:48: warning: invalid case style for parameter 'add_ref' [readability-identifier-naming] + 100 | INET_ALWAYS_INLINE void reset(T *ptr, bool add_ref) { + | ^~~~~~~ + | addRef + 101 | IntrusivePtr(ptr, add_ref).swap(*this); + | ~~~~~~~ + | addRef +./inet/common/IntrusivePtr.h:104:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 104 | INET_ALWAYS_INLINE T *get() const noexcept { return p; } + | ^ + | [[nodiscard]] +./inet/common/IntrusivePtr.h:15:31: note: expanded from macro 'INET_ALWAYS_INLINE' + 15 | #define INET_ALWAYS_INLINE __attribute__((always_inline)) inline + | ^ +./inet/common/IntrusivePtr.h:116:78: warning: use nullptr [modernize-use-nullptr] + 116 | INET_ALWAYS_INLINE explicit operator bool() const noexcept { return p != 0; } + | ^ + | nullptr +./inet/common/IntrusivePtr.h:124:5: warning: function 'use_count' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | INET_ALWAYS_INLINE unsigned int use_count() const noexcept { return p->use_count(); } + | ^ + | [[nodiscard]] +./inet/common/IntrusivePtr.h:15:31: note: expanded from macro 'INET_ALWAYS_INLINE' + 15 | #define INET_ALWAYS_INLINE __attribute__((always_inline)) inline + | ^ +./inet/common/IntrusivePtr.h:124:37: warning: invalid case style for method 'use_count' [readability-identifier-naming] + 124 | INET_ALWAYS_INLINE unsigned int use_count() const noexcept { return p->use_count(); } + | ^~~~~~~~~ + | useCount +./inet/common/IntrusivePtr.h:166:23: warning: use nullptr [modernize-use-nullptr] + 166 | return p.get() == 0; + | ^ + | nullptr +./inet/common/IntrusivePtr.h:178:23: warning: use nullptr [modernize-use-nullptr] + 178 | return p.get() != 0; + | ^ + | nullptr +./inet/common/IntrusivePtr.h:200:23: warning: invalid case style for function 'get_pointer' [readability-identifier-naming] + 200 | INET_ALWAYS_INLINE T *get_pointer(IntrusivePtr const& p) noexcept + | ^~~~~~~~~~~ + | getPointer +./inet/common/IntrusivePtr.h:206:36: warning: invalid case style for function 'static_pointer_cast' [readability-identifier-naming] + 206 | INET_ALWAYS_INLINE IntrusivePtr static_pointer_cast(IntrusivePtr const& p) + | ^~~~~~~~~~~~~~~~~~~ + | staticPointerCast +./inet/common/IntrusivePtr.h:212:36: warning: invalid case style for function 'const_pointer_cast' [readability-identifier-naming] + 212 | INET_ALWAYS_INLINE IntrusivePtr const_pointer_cast(IntrusivePtr const& p) + | ^~~~~~~~~~~~~~~~~~ + | constPointerCast +./inet/common/IntrusivePtr.h:218:36: warning: invalid case style for function 'dynamic_pointer_cast' [readability-identifier-naming] + 218 | INET_ALWAYS_INLINE IntrusivePtr dynamic_pointer_cast(IntrusivePtr const& p) + | ^~~~~~~~~~~~~~~~~~~~ + | dynamicPointerCast +./inet/common/IntrusivePtr.h:242:26: warning: use default member initializer for 'c' [modernize-use-default-member-init] + 242 | mutable unsigned int c; + | ^ + | {0} + 243 | + 244 | public: + 245 | INET_ALWAYS_INLINE IntrusivePtrCounter() noexcept : c(0) {} + | ~~~~ +./inet/common/IntrusivePtr.h:245:24: warning: public constructor allows the CRTP to be constructed as a regular template class; consider making it private and declaring the derived class as friend [bugprone-crtp-constructor-accessibility] + 245 | INET_ALWAYS_INLINE IntrusivePtrCounter() noexcept : c(0) {} + | ^ +./inet/common/IntrusivePtr.h:246:24: warning: public constructor allows the CRTP to be constructed as a regular template class; consider making it private and declaring the derived class as friend [bugprone-crtp-constructor-accessibility] + 246 | INET_ALWAYS_INLINE IntrusivePtrCounter(IntrusivePtrCounter const&) noexcept : c(0) {} + | ^ +./inet/common/IntrusivePtr.h:248:37: warning: invalid case style for method 'use_count' [readability-identifier-naming] + 124 | INET_ALWAYS_INLINE unsigned int use_count() const noexcept { return c; } + | ^~~~~~~~~ + | useCount +./inet/common/IntrusivePtr.h:252:40: warning: invalid case style for method 'shared_from_this' [readability-identifier-naming] + 252 | INET_ALWAYS_INLINE IntrusivePtr shared_from_this() { return IntrusivePtr(static_cast(this)); } + | ^~~~~~~~~~~~~~~~ + | sharedFromThis +./inet/common/LayeredProtocolBase.h:9:9: warning: invalid case style for macro definition '__INET_LAYEREDPROTOCOLBASE_H' [readability-identifier-naming] + 9 | #define __INET_LAYEREDPROTOCOLBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_LAYEREDPROTOCOLBASE_H +./inet/common/LayeredProtocolBase.h:19:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 19 | virtual void handleMessageWhenUp(cMessage *message) override; + | ~~~~~~~ ^ +./inet/common/MemoryInputStream.h:9:9: warning: invalid case style for macro definition '__INET_MEMORYINPUTSTREAM_H' [readability-identifier-naming] + 9 | #define __INET_MEMORYINPUTSTREAM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MEMORYINPUTSTREAM_H +./inet/common/MemoryInputStream.h:52:10: warning: invalid case style for protected member 'isReadBeyondEnd_' [readability-identifier-naming] + 52 | bool isReadBeyondEnd_ = false; + | ^~~~~~~~~~~~~~~~ + | isReadBeyondEnd +./inet/common/MemoryInputStream.h:55:5: warning: function 'isByteAligned' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | bool isByteAligned() const { + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:60:57: warning: 2 adjacent parameters of 'MemoryInputStream' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 60 | MemoryInputStream(const std::vector& data, b length = b(-1), b position = b(0)) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryInputStream.h:60:59: note: the first parameter in the range is 'length' + 60 | MemoryInputStream(const std::vector& data, b length = b(-1), b position = b(0)) : + | ^~~~~~ +./inet/common/MemoryInputStream.h:60:77: note: the last parameter in the range is 'position' + 60 | MemoryInputStream(const std::vector& data, b length = b(-1), b position = b(0)) : + | ^~~~~~~~ +./inet/common/MemoryInputStream.h:69:46: warning: 2 adjacent parameters of 'MemoryInputStream' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 69 | MemoryInputStream(const uint8_t *buffer, b length, b position = b(0)) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryInputStream.h:69:48: note: the first parameter in the range is 'length' + 69 | MemoryInputStream(const uint8_t *buffer, b length, b position = b(0)) : + | ^~~~~~ +./inet/common/MemoryInputStream.h:69:58: note: the last parameter in the range is 'position' + 69 | MemoryInputStream(const uint8_t *buffer, b length, b position = b(0)) : + | ^~~~~~~~ +./inet/common/MemoryInputStream.h:83:5: warning: function 'isReadBeyondEnd' should be marked [[nodiscard]] [modernize-use-nodiscard] + 83 | bool isReadBeyondEnd() const { return isReadBeyondEnd_; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:88:5: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | b getLength() const { return length; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:93:5: warning: function 'getRemainingLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 93 | b getRemainingLength() const { return length - position; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:98:5: warning: function 'getPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | b getPosition() const { return position; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:100:5: warning: function 'getData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | const std::vector& getData() const { return data; } + | ^ + | [[nodiscard]] +./inet/common/MemoryInputStream.h:176:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 176 | return b(i); + | ^ +./inet/common/MemoryInputStream.h:210:29: warning: 2 adjacent parameters of 'readByteRepeatedly' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryInputStream.h:210:37: note: the first parameter in the range is 'value' + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryInputStream.h:210:51: note: the last parameter in the range is 'count' + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryInputStream.h:210:29: note: + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryInputStream.h:210:44: note: 'uint8_t' and 'size_t' may be implicitly converted: 'uint8_t' (as 'unsigned char') -> 'size_t' (as 'unsigned long'), 'size_t' (as 'unsigned long') -> 'uint8_t' (as 'unsigned char') + 210 | bool readByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryInputStream.h:459:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 459 | return Ipv6Address(d[0], d[1], d[2], d[3]); + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/MemoryOutputStream.h:9:9: warning: invalid case style for macro definition '__INET_MEMORYOUTPUTSTREAM_H' [readability-identifier-naming] + 9 | #define __INET_MEMORYOUTPUTSTREAM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MEMORYOUTPUTSTREAM_H +./inet/common/MemoryOutputStream.h:46:5: warning: function 'isByteAligned' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | bool isByteAligned() const { + | ^ + | [[nodiscard]] +./inet/common/MemoryOutputStream.h:64:5: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | b getLength() const { return length; } + | ^ + | [[nodiscard]] +./inet/common/MemoryOutputStream.h:70:5: warning: function 'getData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | const std::vector& getData() const { return data; } + | ^ + | [[nodiscard]] +./inet/common/MemoryOutputStream.h:166:30: warning: 2 adjacent parameters of 'writeByteRepeatedly' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryOutputStream.h:166:38: note: the first parameter in the range is 'value' + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryOutputStream.h:166:52: note: the last parameter in the range is 'count' + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^~~~~ +./inet/common/MemoryOutputStream.h:166:30: note: + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryOutputStream.h:166:45: note: 'uint8_t' and 'size_t' may be implicitly converted: 'uint8_t' (as 'unsigned char') -> 'size_t' (as 'unsigned long'), 'size_t' (as 'unsigned long') -> 'uint8_t' (as 'unsigned char') + 166 | void writeByteRepeatedly(uint8_t value, size_t count) { + | ^ +./inet/common/MemoryOutputStream.h:398:31: warning: 2 adjacent parameters of 'writeNBitsOfUint64Be' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/MemoryOutputStream.h:398:40: note: the first parameter in the range is 'value' + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^~~~~ +./inet/common/MemoryOutputStream.h:398:55: note: the last parameter in the range is 'n' + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^ +./inet/common/MemoryOutputStream.h:398:31: note: + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^ +./inet/common/MemoryOutputStream.h:398:47: note: 'uint64_t' and 'uint8_t' may be implicitly converted: 'uint64_t' (as 'unsigned long') -> 'uint8_t' (as 'unsigned char'), 'uint8_t' (as 'unsigned char') -> 'uint64_t' (as 'unsigned long') + 398 | void writeNBitsOfUint64Be(uint64_t value, uint8_t n) { + | ^ +./inet/common/ModuleAccess.h:9:9: warning: invalid case style for macro definition '__INET_MODULEACCESS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEACCESS_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEACCESS_H +./inet/common/ModuleMixin.h:9:9: warning: invalid case style for macro definition '__INET_MODULEMIXIN_H' [readability-identifier-naming] + 9 | #define __INET_MODULEMIXIN_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_MODULEMIXIN_H +./inet/common/ModuleMixin.h:35:17: warning: use c++17 style variable templates [modernize-type-traits] + 35 | static_assert(std::is_base_of::value, "Type parameter of ModuleMixin must be a subclass of cModule"); + | ^ ~~~~~~~ + | _v +./inet/common/ModuleMixin.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void initialize() override { T::initialize(); } + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void initialize(int stage) override { T::initialize(stage); } + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void refreshDisplay() const override + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:51:5: warning: function 'resolveDirective' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual std::string resolveDirective(char directive) const override + | ^ + | [[nodiscard]] +./inet/common/ModuleMixin.h:51:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual std::string resolveDirective(char directive) const override + | ~~~~~~~ ^ +./inet/common/ModuleMixin.h:56:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual std::string resolveExpression(const char *expression) const override + | ~~~~~~~ ^ +./inet/common/ModuleRefByGate.h:9:9: warning: invalid case style for macro definition '__INET_MODULEREFBYGATE_H' [readability-identifier-naming] + 9 | #define __INET_MODULEREFBYGATE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEREFBYGATE_H +./inet/common/ModuleRefByGate.h:67:5: warning: function 'getNullable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 67 | const T *getNullable() const { return referencedModule.getNullable(); } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByGate.h:70:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | const T *get() const { checkReference(); return referencedModule.get(); } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByGate.h:74:5: warning: function 'getReferencingGate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | const cGate *getReferencingGate() const { return referencingGate; } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByGate.h:78:5: warning: function 'getReferencedGate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | const cGate *getReferencedGate() const { return referencedGate; } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByPar.h:9:9: warning: invalid case style for macro definition '__INET_MODULEREFBYPAR_H' [readability-identifier-naming] + 9 | #define __INET_MODULEREFBYPAR_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEREFBYPAR_H +./inet/common/ModuleRefByPar.h:70:5: warning: function 'getNullable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | const T *getNullable() const { return referencedModule.getNullable(); } + | ^ + | [[nodiscard]] +./inet/common/ModuleRefByPar.h:73:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | const T *get() const { checkReference(); return referencedModule.get(); } + | ^ + | [[nodiscard]] +./inet/common/ParsimPacking.h:8:9: warning: invalid case style for macro definition '__INET_PARSIMPACKING_H' [readability-identifier-naming] + 8 | #define __INET_PARSIMPACKING_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_PARSIMPACKING_H +./inet/common/ParsimPacking.h:28:31: warning: use c++14 style type templates [modernize-type-traits] + 28 | template::value, int>::type = 0> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/ParsimPacking.h:28:46: warning: use c++17 style variable templates [modernize-type-traits] + 28 | template::value, int>::type = 0> + | ^ ~~~~~~~ + | _v +./inet/common/ParsimPacking.h:39:31: warning: use c++14 style type templates [modernize-type-traits] + 39 | template::value && !std::is_const::value, int>::type = 0> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/ParsimPacking.h:39:46: warning: use c++17 style variable templates [modernize-type-traits] + 39 | template::value && !std::is_const::value, int>::type = 0> + | ^ ~~~~~~~ + | _v +./inet/common/ParsimPacking.h:39:85: warning: use c++17 style variable templates [modernize-type-traits] + 39 | template::value && !std::is_const::value, int>::type = 0> + | ^ ~~~~~~~ + | _v +./inet/common/Protocol.h:9:9: warning: invalid case style for macro definition '__INET_PROTOCOL_H' [readability-identifier-naming] + 9 | #define __INET_PROTOCOL_H + | ^~~~~~~~~~~~~~~~~ + | INET_PROTOCOL_H +./inet/common/Protocol.h:23:18: warning: invalid case style for enum constant 'PhysicalLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~~ + | PHYSICAL_LAYER +./inet/common/Protocol.h:23:33: warning: invalid case style for enum constant 'LinkLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~ + | LINK_LAYER +./inet/common/Protocol.h:23:44: warning: invalid case style for enum constant 'NetworkLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~ + | NETWORK_LAYER +./inet/common/Protocol.h:23:58: warning: invalid case style for enum constant 'TransportLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~~~ + | TRANSPORT_LAYER +./inet/common/Protocol.h:23:74: warning: invalid case style for enum constant 'UnspecifiedLayer' [readability-identifier-naming] + 23 | enum Layer { PhysicalLayer, LinkLayer, NetworkLayer, TransportLayer, UnspecifiedLayer }; + | ^~~~~~~~~~~~~~~~ + | UNSPECIFIED_LAYER + 24 | + 25 | protected: + 26 | const int id; + 27 | const std::string name; + 28 | const std::string descriptiveName; + 29 | const Layer layer; + 30 | + 31 | public: + 32 | Protocol(const char *name, const char *descriptiveName, Layer layer = UnspecifiedLayer); + | ~~~~~~~~~~~~~~~~ + | UNSPECIFIED_LAYER +./inet/common/Protocol.h:37:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | int getId() const { return id; } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:38:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | const char *getName() const { return name.c_str(); } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:39:5: warning: function 'getDescriptiveName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | const char *getDescriptiveName() const { return descriptiveName.c_str(); } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:40:5: warning: function 'getLayer' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | Layer getLayer() const { return layer; } + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:42:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/Protocol.h:52:27: warning: invalid case style for global constant 'aodv' [readability-identifier-naming] + 52 | static const Protocol aodv; + | ^~~~ + | AODV +./inet/common/Protocol.h:53:27: warning: invalid case style for global constant 'arp' [readability-identifier-naming] + 53 | static const Protocol arp; + | ^~~ + | ARP +./inet/common/Protocol.h:54:27: warning: invalid case style for global constant 'babel' [readability-identifier-naming] + 54 | static const Protocol babel; + | ^~~~~ + | BABEL +./inet/common/Protocol.h:55:27: warning: invalid case style for global constant 'bgp' [readability-identifier-naming] + 55 | static const Protocol bgp; + | ^~~ + | BGP +./inet/common/Protocol.h:56:27: warning: invalid case style for global constant 'bmac' [readability-identifier-naming] + 56 | static const Protocol bmac; + | ^~~~ + | BMAC +./inet/common/Protocol.h:57:27: warning: invalid case style for global constant 'cdp' [readability-identifier-naming] + 57 | static const Protocol cdp; + | ^~~ + | CDP +./inet/common/Protocol.h:58:27: warning: invalid case style for global constant 'clns' [readability-identifier-naming] + 58 | static const Protocol clns; + | ^~~~ + | CLNS +./inet/common/Protocol.h:59:27: warning: invalid case style for global constant 'dhcp' [readability-identifier-naming] + 59 | static const Protocol dhcp; + | ^~~~ + | DHCP +./inet/common/Protocol.h:60:27: warning: invalid case style for global constant 'dsdv2' [readability-identifier-naming] + 60 | static const Protocol dsdv2; + | ^~~~~ + | DSDV2 +./inet/common/Protocol.h:61:27: warning: invalid case style for global constant 'dsr' [readability-identifier-naming] + 61 | static const Protocol dsr; + | ^~~ + | DSR +./inet/common/Protocol.h:62:27: warning: invalid case style for global constant 'dymo' [readability-identifier-naming] + 62 | static const Protocol dymo; + | ^~~~ + | DYMO +./inet/common/Protocol.h:63:27: warning: invalid case style for global constant 'egp' [readability-identifier-naming] + 63 | static const Protocol egp; + | ^~~ + | EGP +./inet/common/Protocol.h:64:27: warning: invalid case style for global constant 'eigrp' [readability-identifier-naming] + 64 | static const Protocol eigrp; + | ^~~~~ + | EIGRP +./inet/common/Protocol.h:65:27: warning: invalid case style for global constant 'ethernetFlowCtrl' [readability-identifier-naming] + 65 | static const Protocol ethernetFlowCtrl; + | ^~~~~~~~~~~~~~~~ + | ETHERNET_FLOW_CTRL +./inet/common/Protocol.h:66:27: warning: invalid case style for global constant 'ethernetMac' [readability-identifier-naming] + 66 | static const Protocol ethernetMac; + | ^~~~~~~~~~~ + | ETHERNET_MAC +./inet/common/Protocol.h:67:27: warning: invalid case style for global constant 'ethernetPhy' [readability-identifier-naming] + 67 | static const Protocol ethernetPhy; + | ^~~~~~~~~~~ + | ETHERNET_PHY +./inet/common/Protocol.h:68:27: warning: invalid case style for global constant 'ftp' [readability-identifier-naming] + 68 | static const Protocol ftp; + | ^~~ + | FTP +./inet/common/Protocol.h:69:27: warning: invalid case style for global constant 'gpsr' [readability-identifier-naming] + 69 | static const Protocol gpsr; + | ^~~~ + | GPSR +./inet/common/Protocol.h:70:27: warning: invalid case style for global constant 'gptp' [readability-identifier-naming] + 70 | static const Protocol gptp; + | ^~~~ + | GPTP +./inet/common/Protocol.h:71:27: warning: invalid case style for global constant 'http' [readability-identifier-naming] + 71 | static const Protocol http; + | ^~~~ + | HTTP +./inet/common/Protocol.h:72:27: warning: invalid case style for global constant 'icmpv4' [readability-identifier-naming] + 72 | static const Protocol icmpv4; + | ^~~~~~ + | ICMPV4 +./inet/common/Protocol.h:73:27: warning: invalid case style for global constant 'icmpv6' [readability-identifier-naming] + 73 | static const Protocol icmpv6; + | ^~~~~~ + | ICMPV6 +./inet/common/Protocol.h:74:27: warning: invalid case style for global constant 'ieee80211DsssPhy' [readability-identifier-naming] + 74 | static const Protocol ieee80211DsssPhy; + | ^~~~~~~~~~~~~~~~ + | IEEE80211_DSSS_PHY +./inet/common/Protocol.h:75:27: warning: invalid case style for global constant 'ieee80211ErpOfdmPhy' [readability-identifier-naming] + 75 | static const Protocol ieee80211ErpOfdmPhy; + | ^~~~~~~~~~~~~~~~~~~ + | IEEE80211_ERP_OFDM_PHY +./inet/common/Protocol.h:76:27: warning: invalid case style for global constant 'ieee80211FhssPhy' [readability-identifier-naming] + 76 | static const Protocol ieee80211FhssPhy; + | ^~~~~~~~~~~~~~~~ + | IEEE80211_FHSS_PHY +./inet/common/Protocol.h:77:27: warning: invalid case style for global constant 'ieee80211HrDsssPhy' [readability-identifier-naming] + 77 | static const Protocol ieee80211HrDsssPhy; + | ^~~~~~~~~~~~~~~~~~ + | IEEE80211_HR_DSSS_PHY +./inet/common/Protocol.h:78:27: warning: invalid case style for global constant 'ieee80211HtPhy' [readability-identifier-naming] + 78 | static const Protocol ieee80211HtPhy; + | ^~~~~~~~~~~~~~ + | IEEE80211_HT_PHY +./inet/common/Protocol.h:79:27: warning: invalid case style for global constant 'ieee80211IrPhy' [readability-identifier-naming] + 79 | static const Protocol ieee80211IrPhy; + | ^~~~~~~~~~~~~~ + | IEEE80211_IR_PHY +./inet/common/Protocol.h:80:27: warning: invalid case style for global constant 'ieee80211Mac' [readability-identifier-naming] + 80 | static const Protocol ieee80211Mac; + | ^~~~~~~~~~~~ + | IEEE80211_MAC +./inet/common/Protocol.h:81:27: warning: invalid case style for global constant 'ieee80211Mgmt' [readability-identifier-naming] + 81 | static const Protocol ieee80211Mgmt; + | ^~~~~~~~~~~~~ + | IEEE80211_MGMT +./inet/common/Protocol.h:82:27: warning: invalid case style for global constant 'ieee80211OfdmPhy' [readability-identifier-naming] + 82 | static const Protocol ieee80211OfdmPhy; + | ^~~~~~~~~~~~~~~~ + | IEEE80211_OFDM_PHY +./inet/common/Protocol.h:83:27: warning: invalid case style for global constant 'ieee80211VhtPhy' [readability-identifier-naming] + 83 | static const Protocol ieee80211VhtPhy; + | ^~~~~~~~~~~~~~~ + | IEEE80211_VHT_PHY +./inet/common/Protocol.h:84:27: warning: invalid case style for global constant 'ieee802154' [readability-identifier-naming] + 84 | static const Protocol ieee802154; + | ^~~~~~~~~~ + | IEEE802154 +./inet/common/Protocol.h:85:27: warning: invalid case style for global constant 'ieee8021ae' [readability-identifier-naming] + 85 | static const Protocol ieee8021ae; + | ^~~~~~~~~~ + | IEEE8021AE +./inet/common/Protocol.h:86:27: warning: invalid case style for global constant 'ieee8021qCTag' [readability-identifier-naming] + 86 | static const Protocol ieee8021qCTag; + | ^~~~~~~~~~~~~ + | IEEE8021Q_C_TAG +./inet/common/Protocol.h:87:27: warning: invalid case style for global constant 'ieee8021qCFM' [readability-identifier-naming] + 87 | static const Protocol ieee8021qCFM; + | ^~~~~~~~~~~~ + | IEEE8021Q_CFM +./inet/common/Protocol.h:88:27: warning: invalid case style for global constant 'ieee8021qSTag' [readability-identifier-naming] + 88 | static const Protocol ieee8021qSTag; + | ^~~~~~~~~~~~~ + | IEEE8021Q_S_TAG +./inet/common/Protocol.h:89:27: warning: invalid case style for global constant 'ieee8021rTag' [readability-identifier-naming] + 89 | static const Protocol ieee8021rTag; + | ^~~~~~~~~~~~ + | IEEE8021R_TAG +./inet/common/Protocol.h:90:27: warning: invalid case style for global constant 'ieee8022llc' [readability-identifier-naming] + 90 | static const Protocol ieee8022llc; + | ^~~~~~~~~~~ + | IEEE8022LLC +./inet/common/Protocol.h:91:27: warning: invalid case style for global constant 'ieee8022snap' [readability-identifier-naming] + 91 | static const Protocol ieee8022snap; + | ^~~~~~~~~~~~ + | IEEE8022SNAP +./inet/common/Protocol.h:92:27: warning: invalid case style for global constant 'ieee802epd' [readability-identifier-naming] + 92 | static const Protocol ieee802epd; + | ^~~~~~~~~~ + | IEEE802EPD +./inet/common/Protocol.h:93:27: warning: invalid case style for global constant 'igmp' [readability-identifier-naming] + 93 | static const Protocol igmp; + | ^~~~ + | IGMP +./inet/common/Protocol.h:94:27: warning: invalid case style for global constant 'igp' [readability-identifier-naming] + 94 | static const Protocol igp; + | ^~~ + | IGP +./inet/common/Protocol.h:95:27: warning: invalid case style for global constant 'ipv4' [readability-identifier-naming] + 95 | static const Protocol ipv4; + | ^~~~ + | IPV4 +./inet/common/Protocol.h:96:27: warning: invalid case style for global constant 'ipv6' [readability-identifier-naming] + 96 | static const Protocol ipv6; + | ^~~~ + | IPV6 +./inet/common/Protocol.h:97:27: warning: invalid case style for global constant 'ipsecAh' [readability-identifier-naming] + 97 | static const Protocol ipsecAh; + | ^~~~~~~ + | IPSEC_AH +./inet/common/Protocol.h:98:27: warning: invalid case style for global constant 'ipsecEsp' [readability-identifier-naming] + 98 | static const Protocol ipsecEsp; + | ^~~~~~~~ + | IPSEC_ESP +./inet/common/Protocol.h:99:27: warning: invalid case style for global constant 'isis' [readability-identifier-naming] + 99 | static const Protocol isis; + | ^~~~ + | ISIS +./inet/common/Protocol.h:100:27: warning: invalid case style for global constant 'l2isis' [readability-identifier-naming] + 100 | static const Protocol l2isis; + | ^~~~~~ + | L2ISIS +./inet/common/Protocol.h:101:27: warning: invalid case style for global constant 'lldp' [readability-identifier-naming] + 101 | static const Protocol lldp; + | ^~~~ + | LLDP +./inet/common/Protocol.h:102:27: warning: invalid case style for global constant 'lmac' [readability-identifier-naming] + 102 | static const Protocol lmac; + | ^~~~ + | LMAC +./inet/common/Protocol.h:103:27: warning: invalid case style for global constant 'manet' [readability-identifier-naming] + 103 | static const Protocol manet; + | ^~~~~ + | MANET +./inet/common/Protocol.h:104:27: warning: invalid case style for global constant 'mld' [readability-identifier-naming] + 104 | static const Protocol mld; + | ^~~ + | MLD +./inet/common/Protocol.h:105:27: warning: invalid case style for global constant 'mobileipv6' [readability-identifier-naming] + 105 | static const Protocol mobileipv6; + | ^~~~~~~~~~ + | MOBILEIPV6 +./inet/common/Protocol.h:106:27: warning: invalid case style for global constant 'mpls' [readability-identifier-naming] + 106 | static const Protocol mpls; + | ^~~~ + | MPLS +./inet/common/Protocol.h:107:27: warning: invalid case style for global constant 'mrp' [readability-identifier-naming] + 107 | static const Protocol mrp; + | ^~~ + | MRP +./inet/common/Protocol.h:108:27: warning: invalid case style for global constant 'ospf' [readability-identifier-naming] + 108 | static const Protocol ospf; + | ^~~~ + | OSPF +./inet/common/Protocol.h:109:27: warning: invalid case style for global constant 'pim' [readability-identifier-naming] + 109 | static const Protocol pim; + | ^~~ + | PIM +./inet/common/Protocol.h:110:27: warning: invalid case style for global constant 'ppp' [readability-identifier-naming] + 110 | static const Protocol ppp; + | ^~~ + | PPP +./inet/common/Protocol.h:111:27: warning: invalid case style for global constant 'quic' [readability-identifier-naming] + 111 | static const Protocol quic; + | ^~~~ + | QUIC +./inet/common/Protocol.h:112:27: warning: invalid case style for global constant 'rip' [readability-identifier-naming] + 112 | static const Protocol rip; + | ^~~ + | RIP +./inet/common/Protocol.h:113:27: warning: invalid case style for global constant 'rtcp' [readability-identifier-naming] + 113 | static const Protocol rtcp; + | ^~~~ + | RTCP +./inet/common/Protocol.h:114:27: warning: invalid case style for global constant 'rtp' [readability-identifier-naming] + 114 | static const Protocol rtp; + | ^~~ + | RTP +./inet/common/Protocol.h:115:27: warning: invalid case style for global constant 'rsvpTe' [readability-identifier-naming] + 115 | static const Protocol rsvpTe; + | ^~~~~~ + | RSVP_TE +./inet/common/Protocol.h:116:27: warning: invalid case style for global constant 'rtsp' [readability-identifier-naming] + 116 | static const Protocol rtsp; + | ^~~~ + | RTSP +./inet/common/Protocol.h:117:27: warning: invalid case style for global constant 'sctp' [readability-identifier-naming] + 117 | static const Protocol sctp; + | ^~~~ + | SCTP +./inet/common/Protocol.h:118:27: warning: invalid case style for global constant 'srp' [readability-identifier-naming] + 118 | static const Protocol srp; + | ^~~ + | SRP +./inet/common/Protocol.h:119:27: warning: invalid case style for global constant 'ssh' [readability-identifier-naming] + 119 | static const Protocol ssh; + | ^~~ + | SSH +./inet/common/Protocol.h:120:27: warning: invalid case style for global constant 'stp' [readability-identifier-naming] + 120 | static const Protocol stp; + | ^~~ + | STP +./inet/common/Protocol.h:121:27: warning: invalid case style for global constant 'tcp' [readability-identifier-naming] + 121 | static const Protocol tcp; + | ^~~ + | TCP +./inet/common/Protocol.h:122:27: warning: invalid case style for global constant 'telnet' [readability-identifier-naming] + 122 | static const Protocol telnet; + | ^~~~~~ + | TELNET +./inet/common/Protocol.h:123:27: warning: invalid case style for global constant 'trill' [readability-identifier-naming] + 123 | static const Protocol trill; + | ^~~~~ + | TRILL +./inet/common/Protocol.h:124:27: warning: invalid case style for global constant 'tsn' [readability-identifier-naming] + 124 | static const Protocol tsn; // ieee1722, AVB, TSN + | ^~~ + | TSN +./inet/common/Protocol.h:125:27: warning: invalid case style for global constant 'tteth' [readability-identifier-naming] + 125 | static const Protocol tteth; // SAE AS6802, TTEthernet + | ^~~~~ + | TTETH +./inet/common/Protocol.h:126:27: warning: invalid case style for global constant 'udp' [readability-identifier-naming] + 126 | static const Protocol udp; + | ^~~ + | UDP +./inet/common/Protocol.h:127:27: warning: invalid case style for global constant 'xmac' [readability-identifier-naming] + 127 | static const Protocol xmac; + | ^~~~ + | XMAC +./inet/common/Protocol.h:128:27: warning: invalid case style for global constant 'xtp' [readability-identifier-naming] + 128 | static const Protocol xtp; + | ^~~ + | XTP +./inet/common/Protocol.h:131:27: warning: invalid case style for global constant 'ackingMac' [readability-identifier-naming] + 131 | static const Protocol ackingMac; + | ^~~~~~~~~ + | ACKING_MAC +./inet/common/Protocol.h:132:27: warning: invalid case style for global constant 'apskPhy' [readability-identifier-naming] + 132 | static const Protocol apskPhy; + | ^~~~~~~ + | APSK_PHY +./inet/common/Protocol.h:133:27: warning: invalid case style for global constant 'csmaCaMac' [readability-identifier-naming] + 133 | static const Protocol csmaCaMac; + | ^~~~~~~~~ + | CSMA_CA_MAC +./inet/common/Protocol.h:134:27: warning: invalid case style for global constant 'echo' [readability-identifier-naming] + 134 | static const Protocol echo; + | ^~~~ + | ECHO +./inet/common/Protocol.h:135:27: warning: invalid case style for global constant 'flooding' [readability-identifier-naming] + 135 | static const Protocol flooding; + | ^~~~~~~~ + | FLOODING +./inet/common/Protocol.h:136:27: warning: invalid case style for global constant 'linkStateRouting' [readability-identifier-naming] + 136 | static const Protocol linkStateRouting; + | ^~~~~~~~~~~~~~~~ + | LINK_STATE_ROUTING +./inet/common/Protocol.h:137:27: warning: invalid case style for global constant 'nextHopForwarding' [readability-identifier-naming] + 137 | static const Protocol nextHopForwarding; + | ^~~~~~~~~~~~~~~~~ + | NEXT_HOP_FORWARDING +./inet/common/Protocol.h:138:27: warning: invalid case style for global constant 'probabilistic' [readability-identifier-naming] + 138 | static const Protocol probabilistic; + | ^~~~~~~~~~~~~ + | PROBABILISTIC +./inet/common/Protocol.h:139:27: warning: invalid case style for global constant 'shortcutMac' [readability-identifier-naming] + 139 | static const Protocol shortcutMac; + | ^~~~~~~~~~~ + | SHORTCUT_MAC +./inet/common/Protocol.h:140:27: warning: invalid case style for global constant 'shortcutPhy' [readability-identifier-naming] + 140 | static const Protocol shortcutPhy; + | ^~~~~~~~~~~ + | SHORTCUT_PHY +./inet/common/Protocol.h:141:27: warning: invalid case style for global constant 'genericPhy' [readability-identifier-naming] + 141 | static const Protocol genericPhy; + | ^~~~~~~~~~ + | GENERIC_PHY +./inet/common/Protocol.h:142:27: warning: invalid case style for global constant 'unknown' [readability-identifier-naming] + 142 | static const Protocol unknown; + | ^~~~~~~ + | UNKNOWN +./inet/common/Protocol.h:143:27: warning: invalid case style for global constant 'wiseRoute' [readability-identifier-naming] + 143 | static const Protocol wiseRoute; + | ^~~~~~~~~ + | WISE_ROUTE +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/Ptr.h:9:9: warning: invalid case style for macro definition '__INET_PTR_H' [readability-identifier-naming] + 9 | #define __INET_PTR_H + | ^~~~~~~~~~~~ + | INET_PTR_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/Ptr.h:104:8: warning: invalid case style for function '__checknull' [readability-identifier-naming] + 104 | Ptr __checknull(const Ptr& p, const char *expr, const char *file, int line) + | ^~~~~~~~~~~ + | checknull +./inet/common/ShortBitVector.h:9:9: warning: invalid case style for macro definition '__INET_SHORTBITVECTOR_H' [readability-identifier-naming] + 9 | #define __INET_SHORTBITVECTOR_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_SHORTBITVECTOR_H +./inet/common/ShortBitVector.h:38:5: warning: function 'toDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | inline unsigned int toDecimal() const { return bits; } + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:40:5: warning: function 'reverseToDecimal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | inline unsigned int reverseToDecimal() const + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:60:5: warning: function 'getBit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | inline bool getBit(unsigned int pos) const + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:92:5: warning: function 'isEmpty' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | inline bool isEmpty() const { return size == 0; } + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:94:5: warning: function 'getSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 94 | inline unsigned int getSize() const { return size; } + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:96:5: warning: function 'computeHammingDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | inline unsigned int computeHammingDistance(const ShortBitVector& u) const + | ^ + | [[nodiscard]] +./inet/common/ShortBitVector.h:122:5: warning: function 'toString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | std::string toString() const; + | ^ + | [[nodiscard]] +./inet/common/SimpleModule.h:9:9: warning: invalid case style for macro definition '__INET_SIMPLEMODULE_H' [readability-identifier-naming] + 9 | #define __INET_SIMPLEMODULE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_SIMPLEMODULE_H +./inet/common/SimpleModule.h:20:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 20 | virtual void initialize() override; + | ~~~~~~~ ^ +./inet/common/SimpleModule.h:21:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 21 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/common/Simsignals.h:9:9: warning: invalid case style for macro definition '__INET_SIMSIGNALS_H' [readability-identifier-naming] + 9 | #define __INET_SIMSIGNALS_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_SIMSIGNALS_H +./inet/common/Simsignals_m.h:6:9: warning: invalid case style for macro definition '__INET_SIMSIGNALS_M_H' [readability-identifier-naming] + 6 | #define __INET_SIMSIGNALS_M_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_SIMSIGNALS_M_H +./inet/common/Simsignals_m.h:110:10: warning: deleted member function should be public [modernize-use-equals-delete] + 110 | bool operator==(const PacketDropDetails&) = delete; + | ^ +./inet/common/Simsignals_m.h:115:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 115 | virtual ~PacketDropDetails(); + | ~~~~~~~ ^ + | override +./inet/common/Simsignals_m.h:117:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 117 | virtual PacketDropDetails *dup() const override {return new PacketDropDetails(*this);} + | ^ + | [[nodiscard]] +./inet/common/Simsignals_m.h:117:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 117 | virtual PacketDropDetails *dup() const override {return new PacketDropDetails(*this);} + | ~~~~~~~ ^ +./inet/common/Simsignals_m.h:118:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 118 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/common/Simsignals_m.h:119:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 119 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/common/Simsignals_m.h:121:5: warning: function 'getReason' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | virtual PacketDropReason getReason() const; + | ^ + | [[nodiscard]] +./inet/common/Simsignals_m.h:124:5: warning: function 'getLimit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | virtual int getLimit() const; + | ^ + | [[nodiscard]] +./inet/common/StringFormat.h:9:9: warning: invalid case style for macro definition '__INET_STRINGFORMAT_H' [readability-identifier-naming] + 9 | #define __INET_STRINGFORMAT_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_STRINGFORMAT_H +./inet/common/StringFormat.h:22:9: warning: function 'resolveDirective' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual std::string resolveDirective(char directive) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:9:9: warning: invalid case style for macro definition '__INET_TAGBASE_H' [readability-identifier-naming] + 9 | #define __INET_TAGBASE_H + | ^~~~~~~~~~~~~~~~ + | INET_TAGBASE_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:24:45: warning: 2 adjacent parameters of 'changeRegion' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 24 | virtual const Ptr changeRegion(b offsetDelta, b lengthDelta) const { return const_cast(this)->shared_from_this(); } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:24:47: note: the first parameter in the range is 'offsetDelta' + 24 | virtual const Ptr changeRegion(b offsetDelta, b lengthDelta) const { return const_cast(this)->shared_from_this(); } + | ^~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:24:62: note: the last parameter in the range is 'lengthDelta' + 24 | virtual const Ptr changeRegion(b offsetDelta, b lengthDelta) const { return const_cast(this)->shared_from_this(); } + | ^~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:26:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual void parsimPack(cCommBuffer *buffer) const override {} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:27:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual void parsimUnpack(cCommBuffer *buffer) override {} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:29:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual std::ostream& printToStream(std::ostream &stream, int level, int evFlags) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/TagBase.h:33:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/common/TagBase_m.h:6:9: warning: invalid case style for macro definition '__INET_TAGBASE_M_H' [readability-identifier-naming] + 6 | #define __INET_TAGBASE_M_H + | ^~~~~~~~~~~~~~~~~~ + | INET_TAGBASE_M_H +./inet/common/TemporarySharedPtr.h:9:9: warning: invalid case style for macro definition '__INET_TEMPORARYSHAREDPTR_H' [readability-identifier-naming] + 9 | #define __INET_TEMPORARYSHAREDPTR_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_TEMPORARYSHAREDPTR_H +./inet/common/TemporarySharedPtr.h:29:5: warning: function 'getObjectPointer' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | any_ptr getObjectPointer(any_ptr object) const { return toAnyPtr(const_cast(getSharedPtr(object).get())); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:34:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual bool doesSupport(cObject *object) const override { return classDescriptor->doesSupport(fromAnyPtr(getObjectPointer(toAnyPtr(object)))); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:35:5: warning: function 'getBaseClassDescriptor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual cClassDescriptor *getBaseClassDescriptor() const override { return classDescriptor->getBaseClassDescriptor(); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:35:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual cClassDescriptor *getBaseClassDescriptor() const override { return classDescriptor->getBaseClassDescriptor(); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:36:5: warning: function 'getPropertyNames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const char **getPropertyNames() const override { return classDescriptor->getPropertyNames(); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:36:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual const char **getPropertyNames() const override { return classDescriptor->getPropertyNames(); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:37:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual const char *getProperty(const char *propertyname) const override { return classDescriptor->getProperty(propertyname); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:38:5: warning: function 'getFieldCount' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getFieldCount() const override { return classDescriptor->getFieldCount(); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:38:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual int getFieldCount() const override { return classDescriptor->getFieldCount(); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:39:5: warning: function 'getFieldName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual const char *getFieldName(int field) const override { return classDescriptor->getFieldName(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:39:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual const char *getFieldName(int field) const override { return classDescriptor->getFieldName(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:40:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual int findField(const char *fieldName) const override { return classDescriptor->findField(fieldName); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:41:5: warning: function 'getFieldTypeFlags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual unsigned int getFieldTypeFlags(int field) const override { return classDescriptor->getFieldTypeFlags(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:41:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual unsigned int getFieldTypeFlags(int field) const override { return classDescriptor->getFieldTypeFlags(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:42:5: warning: function 'getFieldDeclaredOn' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual const char *getFieldDeclaredOn(int field) const override { return classDescriptor->getFieldDeclaredOn(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:42:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual const char *getFieldDeclaredOn(int field) const override { return classDescriptor->getFieldDeclaredOn(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:43:5: warning: function 'getFieldTypeString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual const char *getFieldTypeString(int field) const override { return classDescriptor->getFieldTypeString(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:43:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual const char *getFieldTypeString(int field) const override { return classDescriptor->getFieldTypeString(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:44:5: warning: function 'getFieldPropertyNames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const char **getFieldPropertyNames(int field) const override { return classDescriptor->getFieldPropertyNames(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:44:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual const char **getFieldPropertyNames(int field) const override { return classDescriptor->getFieldPropertyNames(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:45:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual const char *getFieldProperty(int field, const char *propertyname) const override { return classDescriptor->getFieldProperty(field, propertyname); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:46:5: warning: function 'getFieldArraySize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual int getFieldArraySize(any_ptr object, int field) const override { return classDescriptor->getFieldArraySize(getObjectPointer(object), field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:46:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual int getFieldArraySize(any_ptr object, int field) const override { return classDescriptor->getFieldArraySize(getObjectPointer(object), field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:47:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 47 | virtual void setFieldArraySize(any_ptr object, int field, int size) const override { classDescriptor->setFieldArraySize(getObjectPointer(object), field, size); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:48:5: warning: function 'getFieldDynamicTypeString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual const char *getFieldDynamicTypeString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldDynamicTypeString(getObjectPointer(object), field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:48:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual const char *getFieldDynamicTypeString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldDynamicTypeString(getObjectPointer(object), field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:49:5: warning: function 'getFieldValueAsString' should be marked [[nodiscard]] [modernize-use-nodiscard] + 49 | virtual std::string getFieldValueAsString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValueAsString(getObjectPointer(object), field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:49:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual std::string getFieldValueAsString(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValueAsString(getObjectPointer(object), field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void setFieldValueAsString(any_ptr object, int field, int i, const char *value) const override { classDescriptor->setFieldValueAsString(getObjectPointer(object), field, i, value); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:51:5: warning: function 'getFieldStructName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual const char *getFieldStructName(int field) const override { return classDescriptor->getFieldStructName(field); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:51:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const char *getFieldStructName(int field) const override { return classDescriptor->getFieldStructName(field); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:52:5: warning: function 'getFieldStructValuePointer' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual any_ptr getFieldStructValuePointer(any_ptr object, int field, int i) const override { return classDescriptor->getFieldStructValuePointer(getObjectPointer(object), field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:52:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual any_ptr getFieldStructValuePointer(any_ptr object, int field, int i) const override { return classDescriptor->getFieldStructValuePointer(getObjectPointer(object), field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void setFieldStructValuePointer(any_ptr object, int field, int i, any_ptr ptr) const override { classDescriptor->setFieldStructValuePointer(getObjectPointer(object), field, i, ptr); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:54:5: warning: function 'getFieldValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual cValue getFieldValue(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValue(object, field, i); } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:54:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual cValue getFieldValue(any_ptr object, int field, int i) const override { return classDescriptor->getFieldValue(object, field, i); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void setFieldValue(any_ptr object, int field, int i, const cValue& value) const override { classDescriptor->setFieldValue(object, field, i, value); } + | ~~~~~~~ ^ +./inet/common/TemporarySharedPtr.h:71:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 71 | virtual ~TemporarySharedPtr() { delete classDescriptor; } + | ~~~~~~~ ^ + | override +./inet/common/TemporarySharedPtr.h:73:5: warning: function 'getObject' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | const Ptr& getObject() const { return object; } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:74:5: warning: function 'getDescriptor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual cClassDescriptor *getDescriptor() const override { return classDescriptor; } + | ^ + | [[nodiscard]] +./inet/common/TemporarySharedPtr.h:74:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual cClassDescriptor *getDescriptor() const override { return classDescriptor; } + | ~~~~~~~ ^ +./inet/common/Units.h:23:9: warning: invalid case style for macro definition '__INET_UNITS_H' [readability-identifier-naming] + 23 | #define __INET_UNITS_H + | ^~~~~~~~~~~~~~ + | INET_UNITS_H +./inet/common/Units.h:40:43: warning: invalid case style for struct 'convert' [readability-identifier-naming] + 40 | template struct convert; + | ^~~~~~~ + | Convert +./inet/common/Units.h:47:8: warning: invalid case style for struct 'fixed_power' [readability-identifier-naming] + 47 | struct fixed_power; + | ^~~~~~~~~~~ + | FixedPower +./inet/common/Units.h:76:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 76 | typedef pow unit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using unit = pow +./inet/common/Units.h:76:32: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 76 | typedef pow unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:82:7: warning: invalid case style for class 'value' [readability-identifier-naming] + 82 | class value + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:88:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 88 | typedef Value value_type; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using value_type = Value +./inet/common/Units.h:88:19: warning: invalid case style for typedef 'value_type' [readability-identifier-naming] + 88 | typedef Value value_type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:89:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 89 | typedef Units unit; + | ^~~~~~~~~~~~~~~~~~ + | using unit = Units +./inet/common/Units.h:89:19: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 89 | typedef Units unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:108:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | std::string str() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get>>' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get>>' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:116:5: warning: function 'get>' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | value_type get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:121:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | const value_type& get() const + | ^ + | [[nodiscard]] +./inet/common/Units.h:139:88: warning: use c++14 style type templates [modernize-type-traits] + 139 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:159:88: warning: use c++14 style type templates [modernize-type-traits] + 159 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:170:88: warning: use c++14 style type templates [modernize-type-traits] + 170 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:189:88: warning: use c++14 style type templates [modernize-type-traits] + 189 | template::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/Units.h:270:16: warning: invalid case style for private member 'm_rep' [readability-identifier-naming] + 91 | --m_rep; + | ~~~~~ + | mRep + 92 | return *this; + 93 | } + 94 | + 95 | value operator--(int) + 96 | { + 97 | value v = *this; + 98 | --m_rep; + | ~~~~~ + | mRep + 99 | return v; + 100 | } + 101 | + 102 | private: + 103 | value_type m_rep; + | ^~~~~ + | mRep +./inet/common/Units.h:316:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 316 | namespace units { + | ^~~~~~~~~~~~~~~~~ + 317 | + 318 | namespace internal { + | ~~~~~~~~~~~~~~~~~~ + | namespace units::internal +./inet/common/Units.h:326:8: warning: invalid case style for struct 'convertible' [readability-identifier-naming] + 326 | struct convertible; + | ^~~~~~~~~~~ + | Convertible +./inet/common/Units.h:330:8: warning: invalid case style for struct 'scaling_factor' [readability-identifier-naming] + 330 | struct scaling_factor; + | ^~~~~~~~~~~~~~ + | ScalingFactor + 331 | + 332 | // Converts T1 to T2. + 333 | // Stage 3 - performed after Stage 1 and Stage 2. + 334 | // The reason we perform convert in stages is so that the compiler + 335 | // can resolve templates in the order we want it to. + 336 | template + 337 | struct convert3 + 338 | { + 339 | // The default implementation assumes that the two quantities are in compatible + 340 | // units up to some scaling factor. Find the scaling factor and apply it. + 341 | template + 342 | static V fn(const V& v) + 343 | { + 344 | return v * scaling_factor::template fn() / scaling_factor::template fn(); + | ~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~ + | ScalingFactor ScalingFactor +./inet/common/Units.h:337:8: warning: invalid case style for struct 'convert3' [readability-identifier-naming] + 337 | struct convert3 + | ^~~~~~~~ + | Convert3 +./inet/common/Units.h:352:8: warning: invalid case style for struct 'convert2' [readability-identifier-naming] + 352 | struct convert2 + | ^~~~~~~~ + | Convert2 +./inet/common/Units.h:369:54: warning: invalid case style for public member 'check_convertible' [readability-identifier-naming] + 369 | legacy_static_assert::value> check_convertible; + | ^~~~~~~~~~~~~~~~~ + | checkConvertible +./inet/common/Units.h:384:45: warning: returning a constant reference parameter may cause use-after-free when the parameter is constructed from a temporary [bugprone-return-const-ref-from-parameter] + 384 | static const U& fn(const U& u) { return u; } + | ^ +./inet/common/Units.h:392:45: warning: returning a constant reference parameter may cause use-after-free when the parameter is constructed from a temporary [bugprone-return-const-ref-from-parameter] + 392 | static const U& fn(const U& u) { return u; } + | ^ +./inet/common/Units.h:495:8: warning: invalid case style for struct 'count_terms' [readability-identifier-naming] + 495 | struct count_terms + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:497:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 497 | static const int num = 0; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:498:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 498 | static const int den = 1; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:504:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 504 | static const int num = 1; + | ^~~ + | NUM + 505 | static const int den = 1; + 506 | }; + 507 | + 508 | // count_terms ignores scaling factors - that is taken care of by scaling_factor. + 509 | template + 510 | struct count_terms> + 511 | { + 512 | typedef count_terms result; + 513 | static const int num = result::num; + | ~~~ + | NUM +./inet/common/Units.h:505:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 505 | static const int den = 1; + | ^~~ + | DEN + 506 | }; + 507 | + 508 | // count_terms ignores scaling factors - that is taken care of by scaling_factor. + 509 | template + 510 | struct count_terms> + 511 | { + 512 | typedef count_terms result; + 513 | static const int num = result::num; + 514 | static const int den = result::den; + | ~~~ + | DEN +./inet/common/Units.h:512:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 512 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:512:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 512 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:513:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 513 | static const int num = result::num; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:514:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 514 | static const int den = result::den; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:520:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 520 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:520:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 520 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:521:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 521 | static const int num = result::num; + | ^~~ + | NUM +./inet/common/Units.h:522:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 522 | static const int den = result::den; + | ^~~ + | DEN +./inet/common/Units.h:529:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 529 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:529:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 529 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:530:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 530 | static const int num = result::num; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:531:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 531 | static const int den = result::den; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:538:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 538 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:538:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 538 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:539:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 539 | static const int num = result::num; + | ^~~ + | NUM +./inet/common/Units.h:540:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 540 | static const int den = result::den; + | ^~~ + | DEN +./inet/common/Units.h:547:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 547 | typedef count_terms result1; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result1 = count_terms +./inet/common/Units.h:547:35: warning: invalid case style for typedef 'result1' [readability-identifier-naming] + 547 | typedef count_terms result1; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:548:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 548 | typedef count_terms result2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result2 = count_terms +./inet/common/Units.h:548:35: warning: invalid case style for typedef 'result2' [readability-identifier-naming] + 548 | typedef count_terms result2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:549:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 549 | static const int num = + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:551:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 551 | static const int den = + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:559:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 559 | typedef count_terms result; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using result = count_terms +./inet/common/Units.h:559:37: warning: invalid case style for typedef 'result' [readability-identifier-naming] + 559 | typedef count_terms result; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:560:22: warning: invalid case style for global constant 'num' [readability-identifier-naming] + 560 | static const int num = N * result::num; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:561:22: warning: invalid case style for global constant 'den' [readability-identifier-naming] + 561 | static const int den = D * result::den; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:569:8: warning: invalid case style for struct 'check_terms_equal' [readability-identifier-naming] + 569 | struct check_terms_equal + | ^~~~~~~~~~~~~~~~~ + | CheckTermsEqual + 570 | { + 571 | typedef count_terms count1; + 572 | typedef count_terms count2; + 573 | + 574 | static const bool value = + 575 | count1::num * count2::den == + 576 | count1::den * count2::num; + 577 | }; + 578 | + 579 | template + 580 | struct check_terms_equal, T1, T2> + 581 | { + 582 | static const bool value = check_terms_equal::value; + | ~~~~~~~~~~~~~~~~~ + | CheckTermsEqual +./inet/common/Units.h:571:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 571 | typedef count_terms count1; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using count1 = count_terms +./inet/common/Units.h:571:35: warning: invalid case style for typedef 'count1' [readability-identifier-naming] + 571 | typedef count_terms count1; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:572:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 572 | typedef count_terms count2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using count2 = count_terms +./inet/common/Units.h:572:35: warning: invalid case style for typedef 'count2' [readability-identifier-naming] + 572 | typedef count_terms count2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:574:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 574 | static const bool value = + | ^~~~~ + | VALUE + 575 | count1::num * count2::den == + 576 | count1::den * count2::num; + 577 | }; + 578 | + 579 | template + 580 | struct check_terms_equal, T1, T2> + 581 | { + 582 | static const bool value = check_terms_equal::value; + | ~~~~~ + | VALUE + 583 | }; + 584 | + 585 | template + 586 | struct check_terms_equal, T1, T2> + 587 | { + 588 | static const bool value = check_terms_equal::value; + | ~~~~~ + | VALUE +./inet/common/Units.h:582:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 582 | static const bool value = check_terms_equal::value; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:588:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 588 | static const bool value = check_terms_equal::value; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:594:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 594 | static const bool value = check_terms_equal::value; + | ^~~~~ + | VALUE +./inet/common/Units.h:600:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 600 | static const bool value = check_terms_equal::value; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:606:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 606 | static const bool value = check_terms_equal::value; + | ^~~~~ + | VALUE +./inet/common/Units.h:612:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 612 | static const bool value = + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:622:23: warning: invalid case style for global constant 'value' [readability-identifier-naming] + 369 | static const bool value = + | ^~~~~ + | VALUE +./inet/common/Units.h:644:16: warning: returning a constant reference parameter may cause use-after-free when the parameter is constructed from a temporary [bugprone-return-const-ref-from-parameter] + 644 | return t; + | ^ +./inet/common/Units.h:786:71: warning: macro argument should be enclosed in parentheses [bugprone-macro-parentheses] + 786 | template static void fn(Stream & os) { os << string; } \ + | ^ + | ( ) +./inet/common/Units.h:798:8: warning: invalid case style for struct 'output_unit2' [readability-identifier-naming] + 798 | struct output_unit2 + | ^~~~~~~~~~~~ + | OutputUnit2 + 799 | { + 800 | template + 801 | static void fn(Stream& os) { os << "units"; } + 802 | }; + 803 | + 804 | } // namespace internal + 805 | + 806 | // Functor to write unit text to stream + 807 | template + 808 | struct output_unit + 809 | { + 810 | template + 811 | static void fn(Stream& os) { internal::output_unit2::fn(os); } + | ~~~~~~~~~~~~ + | OutputUnit2 +./inet/common/Units.h:808:8: warning: invalid case style for struct 'output_unit' [readability-identifier-naming] + 808 | struct output_unit + | ^~~~~~~~~~~ + | OutputUnit +./inet/common/Units.h:920:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 920 | typedef ::inet::units::unit unit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using unit = ::inet::units::unit +./inet/common/Units.h:920:29: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 920 | typedef ::inet::units::unit unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:948:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 948 | typedef compose, pow> sr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sr = compose, pow> +./inet/common/Units.h:948:40: warning: invalid case style for typedef 'sr' [readability-identifier-naming] + 948 | typedef compose, pow> sr; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:949:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 949 | typedef pow Hz; + | ^~~~~~~~~~~~~~~~~~~~~ + | using Hz = pow +./inet/common/Units.h:950:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 950 | typedef compose>> N; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using N = compose>> +./inet/common/Units.h:951:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 951 | typedef compose> Pa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Pa = compose> +./inet/common/Units.h:952:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 952 | typedef compose J; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | using J = compose +./inet/common/Units.h:953:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 953 | typedef compose> W; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using W = compose> +./inet/common/Units.h:954:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 954 | typedef compose> WpHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using WpHz = compose> +./inet/common/Units.h:955:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 955 | typedef compose C; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | using C = compose +./inet/common/Units.h:956:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 956 | typedef compose> V; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using V = compose> +./inet/common/Units.h:957:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 957 | typedef compose> F; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using F = compose> +./inet/common/Units.h:958:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 958 | typedef compose> Ohm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohm = compose> +./inet/common/Units.h:959:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 959 | typedef compose Ohmm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohmm = compose +./inet/common/Units.h:960:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 960 | typedef compose As; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using As = compose +./inet/common/Units.h:961:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 961 | typedef compose> Ah; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ah = compose> +./inet/common/Units.h:962:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 962 | typedef compose> S; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using S = compose> +./inet/common/Units.h:963:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 963 | typedef compose> Spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Spm = compose> +./inet/common/Units.h:964:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 964 | typedef compose Wb; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using Wb = compose +./inet/common/Units.h:965:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 965 | typedef compose> T; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using T = compose> +./inet/common/Units.h:966:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 966 | typedef compose> H; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using H = compose> +./inet/common/Units.h:967:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 967 | typedef cd lm; + | ^~~~~~~~~~~~~ + | using lm = cd +./inet/common/Units.h:967:12: warning: invalid case style for typedef 'lm' [readability-identifier-naming] + 967 | typedef cd lm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:968:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 968 | typedef compose> lx; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lx = compose> +./inet/common/Units.h:968:33: warning: invalid case style for typedef 'lx' [readability-identifier-naming] + 968 | typedef compose> lx; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:969:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 969 | typedef pow Bq; + | ^~~~~~~~~~~~~~~~~~~~~ + | using Bq = pow +./inet/common/Units.h:970:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 970 | typedef compose> Gy; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gy = compose> +./inet/common/Units.h:971:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 971 | typedef Gy Sv; + | ^~~~~~~~~~~~~ + | using Sv = Gy +./inet/common/Units.h:972:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 972 | typedef compose, mol> kat; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kat = compose, mol> +./inet/common/Units.h:972:34: warning: invalid case style for typedef 'kat' [readability-identifier-naming] + 972 | typedef compose, mol> kat; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:999:32: warning: invalid case style for struct 'deca' [readability-identifier-naming] + 999 | template struct deca + | ^~~~ + | Deca +./inet/common/Units.h:1001:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1001 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1001:32: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1001 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1003:32: warning: invalid case style for struct 'hecto' [readability-identifier-naming] + 1003 | template struct hecto + | ^~~~~ + | Hecto +./inet/common/Units.h:1005:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1005 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1005:33: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1005 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1007:32: warning: invalid case style for struct 'kilo' [readability-identifier-naming] + 1007 | template struct kilo + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1009:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1009 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1009:34: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1009 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1011:32: warning: invalid case style for struct 'mega' [readability-identifier-naming] + 1011 | template struct mega + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1013:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1013 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1013:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1013 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1015:32: warning: invalid case style for struct 'giga' [readability-identifier-naming] + 1015 | template struct giga + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1017:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1017 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1017:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1017 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1019:32: warning: invalid case style for struct 'tera' [readability-identifier-naming] + 1019 | template struct tera + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1021:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1021 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1021:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1021 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1023:32: warning: invalid case style for struct 'peta' [readability-identifier-naming] + 1023 | template struct peta + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1025:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1025 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1025:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1025 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1027:32: warning: invalid case style for struct 'exa' [readability-identifier-naming] + 1027 | template struct exa + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1029:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1029 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1029:55: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1029 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1031:32: warning: invalid case style for struct 'zetta' [readability-identifier-naming] + 1031 | template struct zetta + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1033:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1033 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1033:54: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1033 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1035:32: warning: invalid case style for struct 'yotta' [readability-identifier-naming] + 1035 | template struct yotta + | ^~~~~ + | Yotta +./inet/common/Units.h:1037:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1037 | typedef scale::type, 1, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1, 1000> +./inet/common/Units.h:1037:56: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1037 | typedef scale::type, 1, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1040:32: warning: invalid case style for struct 'deci' [readability-identifier-naming] + 1040 | template struct deci + | ^~~~ + | Deci +./inet/common/Units.h:1042:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1042 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1042:29: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1042 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1044:32: warning: invalid case style for struct 'centi' [readability-identifier-naming] + 1044 | template struct centi + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1046:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1046 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1046:30: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1046 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1048:32: warning: invalid case style for struct 'milli' [readability-identifier-naming] + 1048 | template struct milli + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1050:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1050 | typedef scale type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale +./inet/common/Units.h:1050:31: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1050 | typedef scale type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1052:32: warning: invalid case style for struct 'micro' [readability-identifier-naming] + 1052 | template struct micro + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1054:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1054 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1054:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1054 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1056:32: warning: invalid case style for struct 'nano' [readability-identifier-naming] + 1056 | template struct nano + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1058:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1058 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1058:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1058 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1060:32: warning: invalid case style for struct 'pico' [readability-identifier-naming] + 1060 | template struct pico + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1062:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1062 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1062:52: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1062 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1064:32: warning: invalid case style for struct 'femto' [readability-identifier-naming] + 1064 | template struct femto + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1066:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1066 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1066:52: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1066 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1068:32: warning: invalid case style for struct 'atto' [readability-identifier-naming] + 1068 | template struct atto + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1070:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1070 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1070:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1070 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1072:32: warning: invalid case style for struct 'zepto' [readability-identifier-naming] + 1072 | template struct zepto + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1074:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1074 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1074:52: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1074 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1076:32: warning: invalid case style for struct 'yocto' [readability-identifier-naming] + 1076 | template struct yocto + | ^~~~~ + | Yocto +./inet/common/Units.h:1078:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1078 | typedef scale::type, 1000> type; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using type = scale::type, 1000> +./inet/common/Units.h:1078:53: warning: invalid case style for typedef 'type' [readability-identifier-naming] + 1078 | typedef scale::type, 1000> type; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1082:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1082 | typedef centi::type cm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using cm = centi::type +./inet/common/Units.h:1082:24: warning: invalid case style for typedef 'cm' [readability-identifier-naming] + 1082 | typedef centi::type cm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1083:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1083 | typedef milli::type mm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using mm = milli::type +./inet/common/Units.h:1083:24: warning: invalid case style for typedef 'mm' [readability-identifier-naming] + 1083 | typedef milli::type mm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1084:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1084 | typedef kilo::type km; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using km = kilo::type +./inet/common/Units.h:1084:23: warning: invalid case style for typedef 'km' [readability-identifier-naming] + 1084 | typedef kilo::type km; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1085:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1085 | typedef milli::type g; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using g = milli::type +./inet/common/Units.h:1085:25: warning: invalid case style for typedef 'g' [readability-identifier-naming] + 1085 | typedef milli::type g; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1086:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1086 | typedef milli::type mg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using mg = milli::type +./inet/common/Units.h:1086:24: warning: invalid case style for typedef 'mg' [readability-identifier-naming] + 1086 | typedef milli::type mg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1087:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1087 | typedef pico::type ps; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using ps = pico::type +./inet/common/Units.h:1087:23: warning: invalid case style for typedef 'ps' [readability-identifier-naming] + 1087 | typedef pico::type ps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1088:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1088 | typedef nano::type ns; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using ns = nano::type +./inet/common/Units.h:1088:23: warning: invalid case style for typedef 'ns' [readability-identifier-naming] + 1088 | typedef nano::type ns; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1089:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1089 | typedef micro::type us; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using us = micro::type +./inet/common/Units.h:1089:24: warning: invalid case style for typedef 'us' [readability-identifier-naming] + 1089 | typedef micro::type us; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1090:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1090 | typedef milli::type ms; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using ms = milli::type +./inet/common/Units.h:1090:24: warning: invalid case style for typedef 'ms' [readability-identifier-naming] + 1090 | typedef milli::type ms; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1091:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1091 | typedef pico::type pW; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using pW = pico::type +./inet/common/Units.h:1091:23: warning: invalid case style for typedef 'pW' [readability-identifier-naming] + 1091 | typedef pico::type pW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1092:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1092 | typedef nano::type nW; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using nW = nano::type +./inet/common/Units.h:1092:23: warning: invalid case style for typedef 'nW' [readability-identifier-naming] + 1092 | typedef nano::type nW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1093:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1093 | typedef micro::type uW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using uW = micro::type +./inet/common/Units.h:1093:24: warning: invalid case style for typedef 'uW' [readability-identifier-naming] + 1093 | typedef micro::type uW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1094:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1094 | typedef milli::type mW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using mW = milli::type +./inet/common/Units.h:1094:24: warning: invalid case style for typedef 'mW' [readability-identifier-naming] + 1094 | typedef milli::type mW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1095:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1095 | typedef milli::type mAh; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mAh = milli::type +./inet/common/Units.h:1095:25: warning: invalid case style for typedef 'mAh' [readability-identifier-naming] + 1095 | typedef milli::type mAh; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1096:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1096 | typedef kilo::type kHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kHz = kilo::type +./inet/common/Units.h:1096:24: warning: invalid case style for typedef 'kHz' [readability-identifier-naming] + 1096 | typedef kilo::type kHz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1097:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1097 | typedef mega::type MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using MHz = mega::type +./inet/common/Units.h:1098:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1098 | typedef giga::type GHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using GHz = giga::type +./inet/common/Units.h:1122:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1122 | typedef scale lb; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lb = scale +./inet/common/Units.h:1122:39: warning: invalid case style for typedef 'lb' [readability-identifier-naming] + 1122 | typedef scale lb; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1123:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1123 | typedef scale oz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | using oz = scale +./inet/common/Units.h:1123:23: warning: invalid case style for typedef 'oz' [readability-identifier-naming] + 1123 | typedef scale oz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1124:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1124 | typedef scale tonne; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using tonne = scale +./inet/common/Units.h:1124:28: warning: invalid case style for typedef 'tonne' [readability-identifier-naming] + 1124 | typedef scale tonne; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1127:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1127 | typedef translate Celsius; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Celsius = translate +./inet/common/Units.h:1128:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1128 | typedef translate, 32> Fahrenheit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fahrenheit = translate, 32> +./inet/common/Units.h:1131:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1131 | typedef scale minute; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using minute = scale +./inet/common/Units.h:1131:25: warning: invalid case style for typedef 'minute' [readability-identifier-naming] + 1131 | typedef scale minute; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1132:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1132 | typedef scale hour; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hour = scale +./inet/common/Units.h:1132:30: warning: invalid case style for typedef 'hour' [readability-identifier-naming] + 1132 | typedef scale hour; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1133:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1133 | typedef scale day; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using day = scale +./inet/common/Units.h:1133:28: warning: invalid case style for typedef 'day' [readability-identifier-naming] + 1133 | typedef scale day; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1134:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1134 | typedef scale week; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using week = scale +./inet/common/Units.h:1134:26: warning: invalid case style for typedef 'week' [readability-identifier-naming] + 1134 | typedef scale week; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1136:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1136 | typedef scale year; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using year = scale +./inet/common/Units.h:1136:29: warning: invalid case style for typedef 'year' [readability-identifier-naming] + 1136 | typedef scale year; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1137:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1137 | typedef scale century; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using century = scale +./inet/common/Units.h:1137:29: warning: invalid case style for typedef 'century' [readability-identifier-naming] + 1137 | typedef scale century; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1138:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1138 | typedef scale millennium; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millennium = scale +./inet/common/Units.h:1138:30: warning: invalid case style for typedef 'millennium' [readability-identifier-naming] + 1138 | typedef scale millennium; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1141:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1141 | typedef scale inch; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch = scale +./inet/common/Units.h:1141:29: warning: invalid case style for typedef 'inch' [readability-identifier-naming] + 1141 | typedef scale inch; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1142:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1142 | typedef scale foot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using foot = scale +./inet/common/Units.h:1142:28: warning: invalid case style for typedef 'foot' [readability-identifier-naming] + 1142 | typedef scale foot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1143:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1143 | typedef scale yard; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using yard = scale +./inet/common/Units.h:1143:28: warning: invalid case style for typedef 'yard' [readability-identifier-naming] + 1143 | typedef scale yard; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1144:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1144 | typedef scale mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mile = scale +./inet/common/Units.h:1144:30: warning: invalid case style for typedef 'mile' [readability-identifier-naming] + 1144 | typedef scale mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1145:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1145 | typedef scale nautical_mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nautical_mile = scale +./inet/common/Units.h:1145:27: warning: invalid case style for typedef 'nautical_mile' [readability-identifier-naming] + 1145 | typedef scale nautical_mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1148:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1148 | typedef pow m2; + | ^~~~~~~~~~~~~~~~~~~~ + | using m2 = pow +./inet/common/Units.h:1148:19: warning: invalid case style for typedef 'm2' [readability-identifier-naming] + 1148 | typedef pow m2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1149:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1149 | typedef scale hectare; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hectare = scale +./inet/common/Units.h:1149:29: warning: invalid case style for typedef 'hectare' [readability-identifier-naming] + 1149 | typedef scale hectare; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1150:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1150 | typedef scale are; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using are = scale +./inet/common/Units.h:1150:27: warning: invalid case style for typedef 'are' [readability-identifier-naming] + 1150 | typedef scale are; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1151:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1151 | typedef pow inch2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch2 = pow +./inet/common/Units.h:1151:22: warning: invalid case style for typedef 'inch2' [readability-identifier-naming] + 1151 | typedef pow inch2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1152:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1152 | typedef scale acre; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using acre = scale +./inet/common/Units.h:1152:44: warning: invalid case style for typedef 'acre' [readability-identifier-naming] + 1152 | typedef scale acre; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1155:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1155 | typedef pow cm3; + | ^~~~~~~~~~~~~~~~~~~~~~ + | using cm3 = pow +./inet/common/Units.h:1155:20: warning: invalid case style for typedef 'cm3' [readability-identifier-naming] + 1155 | typedef pow cm3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1156:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1156 | typedef cm3 ml; + | ^~~~~~~~~~~~~~ + | using ml = cm3 +./inet/common/Units.h:1156:13: warning: invalid case style for typedef 'ml' [readability-identifier-naming] + 1156 | typedef cm3 ml; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1157:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1157 | typedef scale liter; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using liter = scale +./inet/common/Units.h:1157:28: warning: invalid case style for typedef 'liter' [readability-identifier-naming] + 1157 | typedef scale liter; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1158:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1158 | typedef scale dl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dl = scale +./inet/common/Units.h:1158:26: warning: invalid case style for typedef 'dl' [readability-identifier-naming] + 1158 | typedef scale dl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1159:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1159 | typedef scale cl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cl = scale +./inet/common/Units.h:1159:27: warning: invalid case style for typedef 'cl' [readability-identifier-naming] + 1159 | typedef scale cl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1160:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1160 | typedef pow m3; + | ^~~~~~~~~~~~~~~~~~~~ + | using m3 = pow +./inet/common/Units.h:1160:19: warning: invalid case style for typedef 'm3' [readability-identifier-naming] + 1160 | typedef pow m3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1163:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1163 | typedef compose> mph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mph = compose> +./inet/common/Units.h:1163:38: warning: invalid case style for typedef 'mph' [readability-identifier-naming] + 1163 | typedef compose> mph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1164:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1164 | typedef compose> kph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kph = compose> +./inet/common/Units.h:1164:36: warning: invalid case style for typedef 'kph' [readability-identifier-naming] + 1164 | typedef compose> kph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1165:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1165 | typedef compose> mps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mps = compose> +./inet/common/Units.h:1165:32: warning: invalid case style for typedef 'mps' [readability-identifier-naming] + 1165 | typedef compose> mps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1166:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1166 | typedef compose> spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using spm = compose> +./inet/common/Units.h:1166:32: warning: invalid case style for typedef 'spm' [readability-identifier-naming] + 1166 | typedef compose> spm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1167:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1167 | typedef compose> knot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using knot = compose> +./inet/common/Units.h:1167:47: warning: invalid case style for typedef 'knot' [readability-identifier-naming] + 1167 | typedef compose> knot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1168:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1168 | typedef scale mach; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mach = scale +./inet/common/Units.h:1168:32: warning: invalid case style for typedef 'mach' [readability-identifier-naming] + 1168 | typedef scale mach; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1172:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1172 | typedef fscale deg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg = fscale +./inet/common/Units.h:1172:35: warning: invalid case style for typedef 'deg' [readability-identifier-naming] + 1172 | typedef fscale deg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1173:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1173 | typedef scale deg_min; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_min = scale +./inet/common/Units.h:1173:24: warning: invalid case style for typedef 'deg_min' [readability-identifier-naming] + 1173 | typedef scale deg_min; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1174:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1174 | typedef scale deg_sec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_sec = scale +./inet/common/Units.h:1174:28: warning: invalid case style for typedef 'deg_sec' [readability-identifier-naming] + 1174 | typedef scale deg_sec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1177:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1177 | typedef scale kPa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kPa = scale +./inet/common/Units.h:1177:28: warning: invalid case style for typedef 'kPa' [readability-identifier-naming] + 1177 | typedef scale kPa; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1178:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1178 | typedef scale psi; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using psi = scale +./inet/common/Units.h:1178:39: warning: invalid case style for typedef 'psi' [readability-identifier-naming] + 1178 | typedef scale psi; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1179:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1179 | typedef scale millibar; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millibar = scale +./inet/common/Units.h:1179:24: warning: invalid case style for typedef 'millibar' [readability-identifier-naming] + 1179 | typedef scale millibar; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1182:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1182 | typedef intscale B; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using B = intscale +./inet/common/Units.h:1183:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1183 | typedef compose> bps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bps = compose> +./inet/common/Units.h:1183:32: warning: invalid case style for typedef 'bps' [readability-identifier-naming] + 1183 | typedef compose> bps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1184:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1184 | typedef kilo::type kbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kbps = kilo::type +./inet/common/Units.h:1184:25: warning: invalid case style for typedef 'kbps' [readability-identifier-naming] + 1184 | typedef kilo::type kbps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1185:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1185 | typedef mega::type Mbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Mbps = mega::type +./inet/common/Units.h:1186:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1186 | typedef giga::type Gbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gbps = giga::type +./inet/common/Units.h:1189:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1189 | typedef scale rpm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | using rpm = scale +./inet/common/Units.h:1189:23: warning: invalid case style for typedef 'rpm' [readability-identifier-naming] + 1189 | typedef scale rpm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1190:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1190 | typedef scale percent; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using percent = scale +./inet/common/Units.h:1190:26: warning: invalid case style for typedef 'percent' [readability-identifier-naming] + 1190 | typedef scale percent; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1191:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1191 | typedef scale dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dozen = scale +./inet/common/Units.h:1191:28: warning: invalid case style for typedef 'dozen' [readability-identifier-naming] + 1191 | typedef scale dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1192:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1192 | typedef scale bakers_dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bakers_dozen = scale +./inet/common/Units.h:1192:28: warning: invalid case style for typedef 'bakers_dozen' [readability-identifier-naming] + 1192 | typedef scale bakers_dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1193:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1193 | typedef scale ppm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ppm = scale +./inet/common/Units.h:1193:30: warning: invalid case style for typedef 'ppm' [readability-identifier-naming] + 1193 | typedef scale ppm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1246:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1246 | typedef value unit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using unit = value +./inet/common/Units.h:1246:36: warning: invalid case style for typedef 'unit' [readability-identifier-naming] + 1246 | typedef value unit; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1249:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1249 | typedef value m; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using m = value +./inet/common/Units.h:1249:33: warning: invalid case style for typedef 'm' [readability-identifier-naming] + 1249 | typedef value m; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1250:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1250 | typedef value kg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kg = value +./inet/common/Units.h:1250:34: warning: invalid case style for typedef 'kg' [readability-identifier-naming] + 1250 | typedef value kg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1251:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1251 | typedef value s; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using s = value +./inet/common/Units.h:1251:33: warning: invalid case style for typedef 's' [readability-identifier-naming] + 1251 | typedef value s; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1252:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1252 | typedef value simsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using simsec = value +./inet/common/Units.h:1252:36: warning: invalid case style for typedef 'simsec' [readability-identifier-naming] + 1252 | typedef value simsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1253:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1253 | typedef value K; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using K = value +./inet/common/Units.h:1254:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1254 | typedef value A; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using A = value +./inet/common/Units.h:1255:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1255 | typedef value mol; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mol = value +./inet/common/Units.h:1255:35: warning: invalid case style for typedef 'mol' [readability-identifier-naming] + 1255 | typedef value mol; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1256:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1256 | typedef value cd; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cd = value +./inet/common/Units.h:1256:34: warning: invalid case style for typedef 'cd' [readability-identifier-naming] + 1256 | typedef value cd; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1257:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1257 | typedef value b; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using b = value +./inet/common/Units.h:1257:34: warning: invalid case style for typedef 'b' [readability-identifier-naming] + 1257 | typedef value b; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1258:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1258 | typedef value B; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using B = value +./inet/common/Units.h:1261:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1261 | typedef value rad; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using rad = value +./inet/common/Units.h:1261:35: warning: invalid case style for typedef 'rad' [readability-identifier-naming] + 1261 | typedef value rad; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1262:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1262 | typedef value sr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using sr = value +./inet/common/Units.h:1262:34: warning: invalid case style for typedef 'sr' [readability-identifier-naming] + 1262 | typedef value sr; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1263:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1263 | typedef value Hz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Hz = value +./inet/common/Units.h:1264:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1264 | typedef value N; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using N = value +./inet/common/Units.h:1265:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1265 | typedef value Pa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Pa = value +./inet/common/Units.h:1266:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1266 | typedef value J; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using J = value +./inet/common/Units.h:1267:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1267 | typedef value W; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using W = value +./inet/common/Units.h:1268:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1268 | typedef value WpHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using WpHz = value +./inet/common/Units.h:1269:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1269 | typedef value C; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using C = value +./inet/common/Units.h:1270:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1270 | typedef value V; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using V = value +./inet/common/Units.h:1271:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1271 | typedef value F; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using F = value +./inet/common/Units.h:1272:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1272 | typedef value Ohm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohm = value +./inet/common/Units.h:1273:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1273 | typedef value Ohmm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ohmm = value +./inet/common/Units.h:1274:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1274 | typedef value As; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using As = value +./inet/common/Units.h:1275:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1275 | typedef value Ah; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Ah = value +./inet/common/Units.h:1276:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1276 | typedef value S; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using S = value +./inet/common/Units.h:1277:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1277 | typedef value Spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Spm = value +./inet/common/Units.h:1278:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1278 | typedef value Wb; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Wb = value +./inet/common/Units.h:1279:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1279 | typedef value T; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using T = value +./inet/common/Units.h:1280:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1280 | typedef value H; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using H = value +./inet/common/Units.h:1281:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1281 | typedef value lm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lm = value +./inet/common/Units.h:1281:34: warning: invalid case style for typedef 'lm' [readability-identifier-naming] + 1281 | typedef value lm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1282:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1282 | typedef value lx; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lx = value +./inet/common/Units.h:1282:34: warning: invalid case style for typedef 'lx' [readability-identifier-naming] + 1282 | typedef value lx; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1283:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1283 | typedef value Bq; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Bq = value +./inet/common/Units.h:1284:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1284 | typedef value Gy; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gy = value +./inet/common/Units.h:1285:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1285 | typedef value Sv; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Sv = value +./inet/common/Units.h:1286:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1286 | typedef value kat; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kat = value +./inet/common/Units.h:1286:35: warning: invalid case style for typedef 'kat' [readability-identifier-naming] + 1286 | typedef value kat; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1289:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1289 | typedef value cm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cm = value +./inet/common/Units.h:1289:34: warning: invalid case style for typedef 'cm' [readability-identifier-naming] + 1289 | typedef value cm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1290:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1290 | typedef value mm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mm = value +./inet/common/Units.h:1290:34: warning: invalid case style for typedef 'mm' [readability-identifier-naming] + 1290 | typedef value mm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1291:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1291 | typedef value km; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using km = value +./inet/common/Units.h:1291:34: warning: invalid case style for typedef 'km' [readability-identifier-naming] + 1291 | typedef value km; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1292:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1292 | typedef value g; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using g = value +./inet/common/Units.h:1292:33: warning: invalid case style for typedef 'g' [readability-identifier-naming] + 1292 | typedef value g; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1293:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1293 | typedef value mg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mg = value +./inet/common/Units.h:1293:34: warning: invalid case style for typedef 'mg' [readability-identifier-naming] + 1293 | typedef value mg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1294:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1294 | typedef value ms; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ms = value +./inet/common/Units.h:1294:34: warning: invalid case style for typedef 'ms' [readability-identifier-naming] + 1294 | typedef value ms; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1295:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1295 | typedef value pW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using pW = value +./inet/common/Units.h:1295:34: warning: invalid case style for typedef 'pW' [readability-identifier-naming] + 1295 | typedef value pW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1296:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1296 | typedef value nW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nW = value +./inet/common/Units.h:1296:34: warning: invalid case style for typedef 'nW' [readability-identifier-naming] + 1296 | typedef value nW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1297:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1297 | typedef value uW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using uW = value +./inet/common/Units.h:1297:34: warning: invalid case style for typedef 'uW' [readability-identifier-naming] + 1297 | typedef value uW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1298:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1298 | typedef value mW; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mW = value +./inet/common/Units.h:1298:34: warning: invalid case style for typedef 'mW' [readability-identifier-naming] + 1298 | typedef value mW; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1299:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1299 | typedef value mAh; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mAh = value +./inet/common/Units.h:1299:35: warning: invalid case style for typedef 'mAh' [readability-identifier-naming] + 1299 | typedef value mAh; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1300:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1300 | typedef value kHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kHz = value +./inet/common/Units.h:1300:35: warning: invalid case style for typedef 'kHz' [readability-identifier-naming] + 1300 | typedef value kHz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1301:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1301 | typedef value MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using MHz = value +./inet/common/Units.h:1302:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1302 | typedef value GHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using GHz = value +./inet/common/Units.h:1303:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1303 | typedef value ps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ps = value +./inet/common/Units.h:1303:34: warning: invalid case style for typedef 'ps' [readability-identifier-naming] + 1303 | typedef value ps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1304:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1304 | typedef value ns; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ns = value +./inet/common/Units.h:1304:34: warning: invalid case style for typedef 'ns' [readability-identifier-naming] + 1304 | typedef value ns; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1305:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1305 | typedef value us; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using us = value +./inet/common/Units.h:1305:34: warning: invalid case style for typedef 'us' [readability-identifier-naming] + 1305 | typedef value us; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1306:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1306 | typedef value ms; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ms = value +./inet/common/Units.h:1307:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1307 | typedef value psimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using psimsec = value +./inet/common/Units.h:1307:37: warning: invalid case style for typedef 'psimsec' [readability-identifier-naming] + 1307 | typedef value psimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1308:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1308 | typedef value nsimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nsimsec = value +./inet/common/Units.h:1308:37: warning: invalid case style for typedef 'nsimsec' [readability-identifier-naming] + 1308 | typedef value nsimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1309:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1309 | typedef value usimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using usimsec = value +./inet/common/Units.h:1309:37: warning: invalid case style for typedef 'usimsec' [readability-identifier-naming] + 1309 | typedef value usimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1310:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1310 | typedef value msimsec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using msimsec = value +./inet/common/Units.h:1310:37: warning: invalid case style for typedef 'msimsec' [readability-identifier-naming] + 1310 | typedef value msimsec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1313:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1313 | typedef value lb; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using lb = value +./inet/common/Units.h:1313:34: warning: invalid case style for typedef 'lb' [readability-identifier-naming] + 1313 | typedef value lb; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1314:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1314 | typedef value oz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using oz = value +./inet/common/Units.h:1314:34: warning: invalid case style for typedef 'oz' [readability-identifier-naming] + 1314 | typedef value oz; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1315:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1315 | typedef value tonne; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using tonne = value +./inet/common/Units.h:1315:37: warning: invalid case style for typedef 'tonne' [readability-identifier-naming] + 1315 | typedef value tonne; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1317:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1317 | typedef value Celsius; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Celsius = value +./inet/common/Units.h:1318:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1318 | typedef value Fahrenheit; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fahrenheit = value +./inet/common/Units.h:1320:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1320 | typedef value minute; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using minute = value +./inet/common/Units.h:1320:38: warning: invalid case style for typedef 'minute' [readability-identifier-naming] + 1320 | typedef value minute; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1321:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1321 | typedef value hour; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hour = value +./inet/common/Units.h:1321:36: warning: invalid case style for typedef 'hour' [readability-identifier-naming] + 1321 | typedef value hour; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1322:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1322 | typedef value day; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using day = value +./inet/common/Units.h:1322:35: warning: invalid case style for typedef 'day' [readability-identifier-naming] + 1322 | typedef value day; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1323:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1323 | typedef value week; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using week = value +./inet/common/Units.h:1323:36: warning: invalid case style for typedef 'week' [readability-identifier-naming] + 1323 | typedef value week; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1324:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1324 | typedef value month; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using month = value +./inet/common/Units.h:1324:37: warning: invalid case style for typedef 'month' [readability-identifier-naming] + 1324 | typedef value month; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1325:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1325 | typedef value year; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using year = value +./inet/common/Units.h:1325:36: warning: invalid case style for typedef 'year' [readability-identifier-naming] + 1325 | typedef value year; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1326:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1326 | typedef value century; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using century = value +./inet/common/Units.h:1326:39: warning: invalid case style for typedef 'century' [readability-identifier-naming] + 1326 | typedef value century; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1327:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1327 | typedef value millennium; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millennium = value +./inet/common/Units.h:1327:42: warning: invalid case style for typedef 'millennium' [readability-identifier-naming] + 1327 | typedef value millennium; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1329:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1329 | typedef value inch; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch = value +./inet/common/Units.h:1329:36: warning: invalid case style for typedef 'inch' [readability-identifier-naming] + 1329 | typedef value inch; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1330:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1330 | typedef value foot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using foot = value +./inet/common/Units.h:1330:36: warning: invalid case style for typedef 'foot' [readability-identifier-naming] + 1330 | typedef value foot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1331:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1331 | typedef value yard; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using yard = value +./inet/common/Units.h:1331:36: warning: invalid case style for typedef 'yard' [readability-identifier-naming] + 1331 | typedef value yard; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1332:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1332 | typedef value mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mile = value +./inet/common/Units.h:1332:36: warning: invalid case style for typedef 'mile' [readability-identifier-naming] + 1332 | typedef value mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1333:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1333 | typedef value nautical_mile; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using nautical_mile = value +./inet/common/Units.h:1333:45: warning: invalid case style for typedef 'nautical_mile' [readability-identifier-naming] + 1333 | typedef value nautical_mile; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1335:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1335 | typedef value m2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using m2 = value +./inet/common/Units.h:1335:34: warning: invalid case style for typedef 'm2' [readability-identifier-naming] + 1335 | typedef value m2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1336:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1336 | typedef value hectare; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using hectare = value +./inet/common/Units.h:1336:39: warning: invalid case style for typedef 'hectare' [readability-identifier-naming] + 1336 | typedef value hectare; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1337:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1337 | typedef value are; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using are = value +./inet/common/Units.h:1337:35: warning: invalid case style for typedef 'are' [readability-identifier-naming] + 1337 | typedef value are; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1338:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1338 | typedef value inch2; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using inch2 = value +./inet/common/Units.h:1338:37: warning: invalid case style for typedef 'inch2' [readability-identifier-naming] + 1338 | typedef value inch2; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1339:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1339 | typedef value acre; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using acre = value +./inet/common/Units.h:1339:36: warning: invalid case style for typedef 'acre' [readability-identifier-naming] + 1339 | typedef value acre; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1341:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1341 | typedef value cm3; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cm3 = value +./inet/common/Units.h:1341:35: warning: invalid case style for typedef 'cm3' [readability-identifier-naming] + 1341 | typedef value cm3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1342:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1342 | typedef value ml; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ml = value +./inet/common/Units.h:1342:34: warning: invalid case style for typedef 'ml' [readability-identifier-naming] + 1342 | typedef value ml; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1343:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1343 | typedef value cl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using cl = value +./inet/common/Units.h:1343:34: warning: invalid case style for typedef 'cl' [readability-identifier-naming] + 1343 | typedef value cl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1344:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1344 | typedef value liter; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using liter = value +./inet/common/Units.h:1344:37: warning: invalid case style for typedef 'liter' [readability-identifier-naming] + 1344 | typedef value liter; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1345:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1345 | typedef value dl; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dl = value +./inet/common/Units.h:1345:34: warning: invalid case style for typedef 'dl' [readability-identifier-naming] + 1345 | typedef value dl; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1346:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1346 | typedef value m3; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using m3 = value +./inet/common/Units.h:1346:34: warning: invalid case style for typedef 'm3' [readability-identifier-naming] + 1346 | typedef value m3; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1348:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1348 | typedef value mph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mph = value +./inet/common/Units.h:1348:35: warning: invalid case style for typedef 'mph' [readability-identifier-naming] + 1348 | typedef value mph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1349:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1349 | typedef value kph; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kph = value +./inet/common/Units.h:1349:35: warning: invalid case style for typedef 'kph' [readability-identifier-naming] + 1349 | typedef value kph; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1350:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1350 | typedef value mps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mps = value +./inet/common/Units.h:1350:35: warning: invalid case style for typedef 'mps' [readability-identifier-naming] + 1350 | typedef value mps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1351:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1351 | typedef value spm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using spm = value +./inet/common/Units.h:1351:35: warning: invalid case style for typedef 'spm' [readability-identifier-naming] + 1351 | typedef value spm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1352:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1352 | typedef value knot; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using knot = value +./inet/common/Units.h:1352:36: warning: invalid case style for typedef 'knot' [readability-identifier-naming] + 1352 | typedef value knot; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1353:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1353 | typedef value mach; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using mach = value +./inet/common/Units.h:1353:36: warning: invalid case style for typedef 'mach' [readability-identifier-naming] + 1353 | typedef value mach; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1355:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1355 | typedef value deg; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg = value +./inet/common/Units.h:1355:35: warning: invalid case style for typedef 'deg' [readability-identifier-naming] + 1355 | typedef value deg; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1356:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1356 | typedef value deg_min; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_min = value +./inet/common/Units.h:1356:39: warning: invalid case style for typedef 'deg_min' [readability-identifier-naming] + 1356 | typedef value deg_min; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1357:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1357 | typedef value deg_sec; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using deg_sec = value +./inet/common/Units.h:1357:39: warning: invalid case style for typedef 'deg_sec' [readability-identifier-naming] + 1357 | typedef value deg_sec; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1359:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1359 | typedef value kPa; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kPa = value +./inet/common/Units.h:1359:35: warning: invalid case style for typedef 'kPa' [readability-identifier-naming] + 1359 | typedef value kPa; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1360:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1360 | typedef value psi; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using psi = value +./inet/common/Units.h:1360:35: warning: invalid case style for typedef 'psi' [readability-identifier-naming] + 1360 | typedef value psi; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1361:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1361 | typedef value millibar; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using millibar = value +./inet/common/Units.h:1361:40: warning: invalid case style for typedef 'millibar' [readability-identifier-naming] + 1361 | typedef value millibar; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1363:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1363 | typedef value bps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bps = value +./inet/common/Units.h:1363:35: warning: invalid case style for typedef 'bps' [readability-identifier-naming] + 1363 | typedef value bps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1364:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1364 | typedef value kbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using kbps = value +./inet/common/Units.h:1364:36: warning: invalid case style for typedef 'kbps' [readability-identifier-naming] + 1364 | typedef value kbps; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1365:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1365 | typedef value Mbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Mbps = value +./inet/common/Units.h:1366:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1366 | typedef value Gbps; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Gbps = value +./inet/common/Units.h:1368:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1368 | typedef value percent; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using percent = value +./inet/common/Units.h:1368:39: warning: invalid case style for typedef 'percent' [readability-identifier-naming] + 1368 | typedef value percent; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1369:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1369 | typedef value rpm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using rpm = value +./inet/common/Units.h:1369:35: warning: invalid case style for typedef 'rpm' [readability-identifier-naming] + 1369 | typedef value rpm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1370:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1370 | typedef value dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using dozen = value +./inet/common/Units.h:1370:37: warning: invalid case style for typedef 'dozen' [readability-identifier-naming] + 1370 | typedef value dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1371:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1371 | typedef value bakers_dozen; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using bakers_dozen = value +./inet/common/Units.h:1371:44: warning: invalid case style for typedef 'bakers_dozen' [readability-identifier-naming] + 1371 | typedef value bakers_dozen; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1372:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 1372 | typedef value ppm; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ppm = value +./inet/common/Units.h:1372:35: warning: invalid case style for typedef 'ppm' [readability-identifier-naming] + 1372 | typedef value ppm; + | ^ +note: this fix will not be applied because it overlaps with another fix +./inet/common/Units.h:1508:59: warning: invalid case style for global constant 'k' [readability-identifier-naming] + 1508 | const value>> k(1.3806504e-23); + | ^ + | K +./inet/common/Units.h:1509:32: warning: invalid case style for global constant 'mu' [readability-identifier-naming] + 1509 | const value mu(1.660538782e-27); + | ^~ + | MU +./inet/common/Units.h:1512:59: warning: invalid case style for global constant 'e0' [readability-identifier-naming] + 1512 | const value>> e0(8.854187817e-12); + | ^~ + | E0 +./inet/common/Units.h:1513:32: warning: invalid case style for global constant 'me' [readability-identifier-naming] + 1513 | const value me(9.10938215e-31); + | ^~ + | ME +./inet/common/Units.h:1514:31: warning: invalid case style for global constant 'eV' [readability-identifier-naming] + 1514 | const value eV(1.602176487e-19); + | ^~ + | E_V +./inet/common/Units.h:1515:31: warning: invalid case style for global constant 'e' [readability-identifier-naming] + 1515 | const value e(1.602176487e-19); + | ^ + | E +./inet/common/Units.h:1517:34: warning: invalid case style for global constant 'alpha' [readability-identifier-naming] + 1517 | const value alpha(7.2973525376e-3); + | ^~~~~ + | ALPHA +./inet/common/Units.h:1518:34: warning: invalid case style for global constant 'inv_alpha' [readability-identifier-naming] + 1518 | const value inv_alpha(137.035999679); + | ^~~~~~~~~ + | INV_ALPHA +./inet/common/Units.h:1519:59: warning: invalid case style for global constant 'u0' [readability-identifier-naming] + 1519 | const value>> u0(12.566370614e-7); + | ^~ + | U0 +./inet/common/Units.h:1520:32: warning: invalid case style for global constant 'phi0' [readability-identifier-naming] + 1520 | const value phi0(2.067833667e-15); // ?? + | ^~~~ + | PHI0 +./inet/common/Units.h:1523:50: warning: invalid case style for global constant 'h' [readability-identifier-naming] + 1523 | const value> h(6.62606896e-34); + | ^ + | H +./inet/common/Units.h:1524:50: warning: invalid case style for global constant 'h_bar' [readability-identifier-naming] + 1524 | const value> h_bar(1.054571628e-34); + | ^~~~~ + | H_BAR +./inet/common/Units.h:1525:32: warning: invalid case style for global constant 'mp' [readability-identifier-naming] + 1525 | const value mp(1.672621637e-27); + | ^~ + | MP +./inet/common/Units.h:1526:27: warning: invalid case style for global constant 'mpme' [readability-identifier-naming] + 1526 | const value mpme(1836.15267247); + | ^~~~ + | MPME +./inet/common/Units.h:1527:40: warning: invalid case style for global constant 'Rinf' [readability-identifier-naming] + 1527 | const value> Rinf(10973731.568527); + | ^~~~ + | RINF +./inet/common/Units.h:1528:59: warning: invalid case style for global constant 'c' [readability-identifier-naming] + 1528 | const value>> c(299792458); + | ^ + | C +./inet/common/Units.h:1529:87: warning: invalid case style for global constant 'rho' [readability-identifier-naming] + 1529 | const value, pow>>> rho(5.6704e-8); + | ^~~ + | RHO +./inet/common/Units.h:1532:33: warning: invalid case style for global constant 'pi' [readability-identifier-naming] + 1532 | const value pi(3.141592653589793); + | ^~ + | PI +./inet/common/Units.h:1533:31: warning: invalid case style for global constant 'lightyear' [readability-identifier-naming] + 1533 | const value lightyear(9.4605284e15); + | ^~~~~~~~~ + | LIGHTYEAR +./inet/common/Units.h:1534:59: warning: invalid case style for global constant 'g' [readability-identifier-naming] + 1534 | const value>> g(9.80665); + | ^ + | G +./inet/common/Units_m.h:6:9: warning: invalid case style for macro definition '__INET_UNITS_M_H' [readability-identifier-naming] + 6 | #define __INET_UNITS_M_H + | ^~~~~~~~~~~~~~~~ + | INET_UNITS_M_H +./inet/common/checksum/ChecksumMode_m.h:6:9: warning: invalid case style for macro definition '__INET_CHECKSUMMODE_M_H' [readability-identifier-naming] + 6 | #define __INET_CHECKSUMMODE_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_CHECKSUMMODE_M_H +./inet/common/geometry/base/GeometricObjectBase.h:9:9: warning: invalid case style for macro definition '__INET_GEOMETRICOBJECTBASE_H' [readability-identifier-naming] + 9 | #define __INET_GEOMETRICOBJECTBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_GEOMETRICOBJECTBASE_H +./inet/common/geometry/base/GeometricObjectBase.h:22:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 22 | GeometricObjectBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/GeometricObjectBase.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~GeometricObjectBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/GeometricObjectBase.h:29:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual bool isNil() const = 0; + | ^ + | [[nodiscard]] +./inet/common/geometry/base/GeometricObjectBase.h:34:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual bool isUnspecified() const = 0; + | ^ + | [[nodiscard]] +./inet/common/geometry/base/ShapeBase.h:9:9: warning: invalid case style for macro definition '__INET_SHAPEBASE_H' [readability-identifier-naming] + 9 | #define __INET_SHAPEBASE_H + | ^~~~~~~~~~~~~~~~~~ + | INET_SHAPEBASE_H +./inet/common/geometry/base/ShapeBase.h:23:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 23 | ShapeBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/ShapeBase.h:24:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 24 | virtual ~ShapeBase() {} + | ^ ~~ + | = default; +./inet/common/geometry/base/ShapeBase.h:29:5: warning: function 'computeBoundingBoxSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual Coord computeBoundingBoxSize() const = 0; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:9:9: warning: invalid case style for macro definition '__INET_COORD_H' [readability-identifier-naming] + 9 | #define __INET_COORD_H + | ^~~~~~~~~~~~~~ + | INET_COORD_H +./inet/common/geometry/common/Coord.h:49:11: warning: 3 adjacent parameters of 'Coord' of similar type ('double') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 49 | Coord(double x, double y, double z = 0.0) : x(x), y(y), z(z) {} + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/geometry/common/Coord.h:49:18: note: the first parameter in the range is 'x' + 49 | Coord(double x, double y, double z = 0.0) : x(x), y(y), z(z) {} + | ^ +./inet/common/geometry/common/Coord.h:49:38: note: the last parameter in the range is 'z' + 49 | Coord(double x, double y, double z = 0.0) : x(x), y(y), z(z) {} + | ^ +./inet/common/geometry/common/Coord.h:54:5: warning: function 'xyz' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | Coord xyz() const { return *this; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:55:5: warning: function 'getXyz' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | Coord getXyz() const { return Coord(*this).xyz(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:58:5: warning: function 'getYzx' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | Coord getYzx() const { return Coord(*this).yzx(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:61:5: warning: function 'getZxy' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | Coord getZxy() const { return Coord(*this).zxy(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:63:5: warning: function 'getX' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | double getX() const { return x; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:66:5: warning: function 'getY' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | double getY() const { return y; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:69:5: warning: function 'getZ' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | double getZ() const { return z; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:73:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | inline std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:76:38: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 76 | Coord operator-() const { return Coord(-x, -y, -z); } + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:139:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 139 | return Coord(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:189:5: warning: function 'getClamped' should be marked [[nodiscard]] [modernize-use-nodiscard] + 189 | Coord getClamped(double l, double u) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:200:5: warning: function 'getSign' should be marked [[nodiscard]] [modernize-use-nodiscard] + 200 | Coord getSign() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:211:5: warning: function 'getAbs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 211 | Coord getAbs() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:222:5: warning: function 'getStep' should be marked [[nodiscard]] [modernize-use-nodiscard] + 222 | Coord getStep(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:233:5: warning: function 'getDividedElementwise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 233 | Coord getDividedElementwise(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:244:5: warning: function 'getMultipliedElementwise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 244 | Coord getMultipliedElementwise(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:251:5: warning: function 'distance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 251 | double distance(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:258:5: warning: function 'sqrdist' should be marked [[nodiscard]] [modernize-use-nodiscard] + 258 | double sqrdist(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:265:5: warning: function 'sqrTorusDist' should be marked [[nodiscard]] [modernize-use-nodiscard] + 265 | double sqrTorusDist(const Coord& b, const Coord& size) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:270:5: warning: function 'squareLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 270 | double squareLength() const { return x * x + y * y + z * z; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:275:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 275 | double length() const { return sqrt(squareLength()); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:282:5: warning: function 'getNormalized' should be marked [[nodiscard]] [modernize-use-nodiscard] + 282 | Coord getNormalized() const { return Coord(*this).normalize(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:290:5: warning: function 'isInBoundary' should be marked [[nodiscard]] [modernize-use-nodiscard] + 290 | bool isInBoundary(const Coord& lowerBound, const Coord& upperBound) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:296:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 296 | bool isNil() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:303:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 303 | bool isUnspecified() const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:310:5: warning: function 'min' should be marked [[nodiscard]] [modernize-use-nodiscard] + 310 | Coord min(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:311:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 311 | return Coord(x < a.x ? x : a.x, y < a.y ? y : a.y, z < a.z ? z : a.z); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:317:5: warning: function 'max' should be marked [[nodiscard]] [modernize-use-nodiscard] + 317 | Coord max(const Coord& a) const { + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Coord.h:318:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 318 | return Coord(x > a.x ? x : a.x, y > a.y ? y : a.y, z > a.z ? z : a.z); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/Coord.h:346:20: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 346 | return Coord(x, y, z); + | ^~~~~~ ~ + | { } +./inet/common/geometry/common/EulerAngles.h:2:9: warning: invalid case style for macro definition '__INET_EULERANGLES_H' [readability-identifier-naming] + 2 | #define __INET_EULERANGLES_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_EULERANGLES_H +./inet/common/geometry/common/EulerAngles.h:41:17: warning: 3 adjacent parameters of 'EulerAngles' of similar type ('rad') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 41 | EulerAngles(rad alpha, rad beta, rad gamma) + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/geometry/common/EulerAngles.h:41:21: note: the first parameter in the range is 'alpha' + 41 | EulerAngles(rad alpha, rad beta, rad gamma) + | ^~~~~ +./inet/common/geometry/common/EulerAngles.h:41:42: note: the last parameter in the range is 'gamma' + 41 | EulerAngles(rad alpha, rad beta, rad gamma) + | ^~~~~ +./inet/common/geometry/common/EulerAngles.h:44:5: warning: function 'getAlpha' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | rad getAlpha() const { return alpha; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:47:5: warning: function 'getBeta' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | rad getBeta() const { return beta; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:50:5: warning: function 'getGamma' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | rad getGamma() const { return gamma; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:53:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | inline std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:55:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | bool isNil() const + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:60:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | bool isUnspecified() const + | ^ + | [[nodiscard]] +./inet/common/geometry/common/EulerAngles.h:73:63: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 73 | EulerAngles operator+(const EulerAngles a) const { return EulerAngles(alpha + a.alpha, beta + a.beta, gamma + a.gamma); } + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/EulerAngles.h:75:63: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 75 | EulerAngles operator-(const EulerAngles a) const { return EulerAngles(alpha - a.alpha, beta - a.beta, gamma - a.gamma); } + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/EulerAngles.h:77:52: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 77 | EulerAngles operator*(double f) const { return EulerAngles(alpha * f, beta * f, gamma * f); } + | ^~~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/Quaternion.h:9:9: warning: invalid case style for macro definition '__INET_QUATERNION_H' [readability-identifier-naming] + 9 | #define __INET_QUATERNION_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_QUATERNION_H +./inet/common/geometry/common/Quaternion.h:28:5: warning: use '= default' to define a trivial default constructor [modernize-use-equals-default] + 28 | Quaternion() {} + | ^ ~~ + | = default; +./inet/common/geometry/common/Quaternion.h:29:16: warning: 2 adjacent parameters of 'Quaternion' of similar type ('double') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 29 | Quaternion(double real, double i, double j, double k) : s(real), v(i, j, k) {} + | ^~~~~~~~~~~~~~~~~~~~~ +./inet/common/geometry/common/Quaternion.h:29:23: note: the first parameter in the range is 'real' + 29 | Quaternion(double real, double i, double j, double k) : s(real), v(i, j, k) {} + | ^~~~ +./inet/common/geometry/common/Quaternion.h:29:36: note: the last parameter in the range is 'i' + 29 | Quaternion(double real, double i, double j, double k) : s(real), v(i, j, k) {} + | ^ +./inet/common/geometry/common/Quaternion.h:38:5: warning: function 'getS' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | double getS() const { return s; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:41:5: warning: function 'getV' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | const Coord& getV() const { return v; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:48:17: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 48 | Quaternion& operator=(const Quaternion& q) { s = q.s; v = q.v; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/common/geometry/common/Quaternion.h:68:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 68 | double length() const { return std::sqrt(s * s + v * v); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:71:5: warning: function 'lengthSquared' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | double lengthSquared() const { return s * s + v * v; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:77:5: warning: function 'normalized' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | Quaternion normalized() const { return (*this) / length(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:82:5: warning: function 'conjugated' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | Quaternion conjugated() const { return Quaternion(s, -v.x, -v.y, -v.z); } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:82:44: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 82 | Quaternion conjugated() const { return Quaternion(s, -v.x, -v.y, -v.z); } + | ^~~~~~~~~~~ ~ + | { } +./inet/common/geometry/common/Quaternion.h:88:5: warning: function 'inverse' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | Quaternion inverse() const { Quaternion q(*this); q.invert(); return q; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:100:5: warning: function 'getRotationAxis' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | Coord getRotationAxis() const { Coord axis; double angle; getRotationAxisAndAngle(axis, angle); return axis; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:101:5: warning: function 'getRotationAngle' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | double getRotationAngle() const { return std::acos(s) * 2; } + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:105:5: warning: function 'rotate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 105 | Coord rotate(const Coord& v) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:108:5: warning: function 'toEulerAngles' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | EulerAngles toEulerAngles(bool homogenous = false) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/Quaternion.h:125:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 125 | inline std::string str() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:9:9: warning: invalid case style for macro definition '__INET_ROTATIONMATRIX_H' [readability-identifier-naming] + 9 | #define __INET_ROTATIONMATRIX_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ROTATIONMATRIX_H +./inet/common/geometry/common/RotationMatrix.h:27:5: warning: function 'computeDeterminant' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | double computeDeterminant() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:34:5: warning: function 'rotateVector' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | Coord rotateVector(const Coord& vector) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:35:5: warning: function 'rotateVectorInverse' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | Coord rotateVectorInverse(const Coord& vector) const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:37:5: warning: function 'toEulerAngles' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | EulerAngles toEulerAngles() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/common/RotationMatrix.h:38:5: warning: function 'toQuaternion' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | Quaternion toQuaternion() const; + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:9:9: warning: invalid case style for macro definition '__INET_LINESEGMENT_H' [readability-identifier-naming] + 9 | #define __INET_LINESEGMENT_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_LINESEGMENT_H +./inet/common/geometry/object/LineSegment.h:32:5: warning: function 'getPoint1' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const Coord& getPoint1() const { return point1; } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:34:5: warning: function 'getPoint2' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | const Coord& getPoint2() const { return point2; } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:36:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | double length() const { return point2.distance(point1); } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:38:5: warning: function 'isNil' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual bool isNil() const override { return this == &NIL; } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:38:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual bool isNil() const override { return this == &NIL; } + | ~~~~~~~ ^ +./inet/common/geometry/object/LineSegment.h:39:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual bool isUnspecified() const override { return point1.isUnspecified() || point2.isUnspecified(); } + | ^ + | [[nodiscard]] +./inet/common/geometry/object/LineSegment.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual bool isUnspecified() const override { return point1.isUnspecified() || point2.isUnspecified(); } + | ~~~~~~~ ^ +./inet/common/lifecycle/ILifecycle.h:9:9: warning: invalid case style for macro definition '__INET_ILIFECYCLE_H' [readability-identifier-naming] + 9 | #define __INET_ILIFECYCLE_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ILIFECYCLE_H +./inet/common/lifecycle/ILifecycle.h:25:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 25 | virtual ~IDoneCallback() {} + | ^ ~~ + | = default; +./inet/common/lifecycle/ILifecycle.h:38:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 38 | virtual ~ILifecycle() {} + | ^ ~~ + | = default; +./inet/common/lifecycle/LifecycleOperation.h:9:9: warning: invalid case style for macro definition '__INET_LIFECYCLEOPERATION_H' [readability-identifier-naming] + 9 | #define __INET_LIFECYCLEOPERATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_LIFECYCLEOPERATION_H +./inet/common/lifecycle/LifecycleOperation.h:28:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 28 | typedef std::map StringMap; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using StringMap = std::map +./inet/common/lifecycle/LifecycleOperation.h:39:9: warning: member initializer for 'rootModule' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:39:30: warning: member initializer for 'currentStage' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:39:47: warning: member initializer for 'insideInitiateOperation' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:39:79: warning: member initializer for 'operationCompletionCallback' is redundant [modernize-use-default-member-init] + 39 | rootModule(nullptr), currentStage(0), insideInitiateOperation(false), operationCompletionCallback(nullptr) {} + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/lifecycle/LifecycleOperation.h:41:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 41 | virtual ~LifecycleOperation() { + | ~~~~~~~ ^ + | override +./inet/common/lifecycle/LifecycleOperation.h:66:5: warning: function 'getRootModule' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | cModule *getRootModule() const { return rootModule; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/LifecycleOperation.h:71:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | virtual int getNumStages() const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/LifecycleOperation.h:76:5: warning: function 'getCurrentStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | int getCurrentStage() const { return currentStage; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:9:9: warning: invalid case style for macro definition '__INET_MODULEOPERATIONS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEOPERATIONS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEOPERATIONS_H +./inet/common/lifecycle/ModuleOperations.h:38:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:38:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ~~~~~~~ ^ +./inet/common/lifecycle/ModuleOperations.h:62:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:62:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ~~~~~~~ ^ +./inet/common/lifecycle/ModuleOperations.h:83:5: warning: function 'getNumStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 83 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/ModuleOperations.h:83:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual int getNumStages() const override { return STAGE_LAST + 1; } + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalBase.h:9:9: warning: invalid case style for macro definition '__INET_OPERATIONALBASE_H' [readability-identifier-naming] + 9 | #define __INET_OPERATIONALBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_OPERATIONALBASE_H +./inet/common/lifecycle/OperationalMixin.h:9:9: warning: invalid case style for macro definition '__INET_OPERATIONALMIXIN_H' [readability-identifier-naming] + 9 | #define __INET_OPERATIONALMIXIN_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_OPERATIONALMIXIN_H +./inet/common/lifecycle/OperationalMixin.h:32:38: warning: invalid case style for parameter 'operation_' [readability-identifier-naming] + 32 | void set(LifecycleOperation *operation_, IDoneCallback *doneCallback_, State endState_) { operation = operation_; doneCallback = doneCallback_; endState = endState_; isDelayedFinish = false; } + | ^~~~~~~~~~ ~~~~~~~~~~ + | operation operation +./inet/common/lifecycle/OperationalMixin.h:32:65: warning: invalid case style for parameter 'doneCallback_' [readability-identifier-naming] + 32 | void set(LifecycleOperation *operation_, IDoneCallback *doneCallback_, State endState_) { operation = operation_; doneCallback = doneCallback_; endState = endState_; isDelayedFinish = false; } + | ^~~~~~~~~~~~~ ~~~~~~~~~~~~~ + | doneCallback doneCallback +./inet/common/lifecycle/OperationalMixin.h:32:86: warning: invalid case style for parameter 'endState_' [readability-identifier-naming] + 32 | void set(LifecycleOperation *operation_, IDoneCallback *doneCallback_, State endState_) { operation = operation_; doneCallback = doneCallback_; endState = endState_; isDelayedFinish = false; } + | ^~~~~~~~~ ~~~~~~~~~ + | endState endState +./inet/common/lifecycle/OperationalMixin.h:41:5: warning: function 'numInitStages' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:41:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void refreshDisplay() const override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:45:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual void handleMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual bool handleOperationStage(LifecycleOperation *operation, IDoneCallback *doneCallback) override; + | ~~~~~~~ ^ +./inet/common/lifecycle/OperationalMixin.h:59:5: warning: function 'isInitializeStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual bool isInitializeStage(int stage) const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:60:5: warning: function 'isModuleStartStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual bool isModuleStartStage(int stage) const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:61:5: warning: function 'isModuleStopStage' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | virtual bool isModuleStopStage(int stage) const = 0; + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:66:5: warning: function 'isUp' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual bool isUp() const { return operationalState != NOT_OPERATING /* && operationalState != OPERATION_SUSPENDED */; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:67:5: warning: function 'isDown' should be marked [[nodiscard]] [modernize-use-nodiscard] + 67 | virtual bool isDown() const { return operationalState == NOT_OPERATING /* || operationalState == OPERATION_SUSPENDED */; } + | ^ + | [[nodiscard]] +./inet/common/lifecycle/OperationalMixin.h:79:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 79 | virtual ~OperationalMixin(); + | ~~~~~~~ ^ + | override +./inet/common/packet/Packet.h:9:9: warning: invalid case style for macro definition '__INET_PACKET_H' [readability-identifier-naming] + 9 | #define __INET_PACKET_H + | ^~~~~~~~~~~~~~~ + | INET_PACKET_H +./inet/common/packet/Packet.h:136:5: warning: function 'getContent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 136 | const Chunk *getContent() const { return content.get(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:137:5: warning: function 'getDissection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 137 | const ChunkTemporarySharedPtr *getDissection() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:138:5: warning: function 'getFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 138 | const ChunkTemporarySharedPtr *getFront() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:139:5: warning: function 'getData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 139 | const ChunkTemporarySharedPtr *getData() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:140:5: warning: function 'getBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 140 | const ChunkTemporarySharedPtr *getBack() const; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:141:20: warning: invalid case style for method '_getTag' [readability-identifier-naming] + 141 | const TagBase *_getTag(int index) { return tags.getTag(index).get(); } + | ^~~~~~~ + | getTag +./inet/common/packet/Packet.h:142:52: warning: invalid case style for method '_getRegionTag' [readability-identifier-naming] + 142 | const SharingRegionTagSet::RegionTag& _getRegionTag(int index) { return regionTags.getRegionTag(index); } + | ^~~~~~~~~~~~~ + | getRegionTag +./inet/common/packet/Packet.h:179:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 179 | virtual Packet *dup() const override { return new Packet(*this); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:179:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 179 | virtual Packet *dup() const override { return new Packet(*this); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:180:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 180 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:181:5: warning: function 'hasBitError' should be marked [[nodiscard]] [modernize-use-nodiscard] + 181 | virtual bool hasBitError() const override { return cPacket::hasBitError() || content->isIncorrect(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:181:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 181 | virtual bool hasBitError() const override { return cPacket::hasBitError() || content->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:182:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 182 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:183:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 183 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:189:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 189 | virtual void encapsulate(cPacket *packet) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:190:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 190 | virtual cPacket *decapsulate() override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:191:5: warning: function 'getEncapsulatedPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 191 | virtual cPacket *getEncapsulatedPacket() const override { return nullptr; } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:191:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 191 | virtual cPacket *getEncapsulatedPacket() const override { return nullptr; } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:192:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 192 | virtual void setControlInfo(cObject *p) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:193:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 193 | virtual void setBitLength(int64_t value) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:203:5: warning: function 'getTotalLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 203 | b getTotalLength() const { return totalLength; } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:209:5: warning: function 'getBitLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 209 | virtual int64_t getBitLength() const override { return getDataLength().get(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:209:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 209 | virtual int64_t getBitLength() const override { return getDataLength().get(); } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:216:5: warning: function 'getDataLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 216 | b getDataLength() const { return getTotalLength() - frontIterator.getPosition() - backIterator.getPosition(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:225:5: warning: function 'getFrontOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 225 | b getFrontOffset() const { return frontIterator.getPosition(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:237:5: warning: function 'getBackOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 237 | b getBackOffset() const { return getTotalLength() - backIterator.getPosition(); } + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:255:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 255 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:266:5: warning: function 'peekAtBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 266 | const Ptr peekAtBack(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:276:5: warning: function 'peekData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 276 | const Ptr peekData(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:287:5: warning: function 'peekDataAsBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 287 | const Ptr peekDataAsBits(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:298:5: warning: function 'peekDataAsBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 298 | const Ptr peekDataAsBytes(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:309:5: warning: function 'peekAll' should be marked [[nodiscard]] [modernize-use-nodiscard] + 309 | const Ptr peekAll(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:320:5: warning: function 'peekAllAsBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 320 | const Ptr peekAllAsBits(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:331:5: warning: function 'peekAllAsBytes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 331 | const Ptr peekAllAsBytes(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:342:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 342 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:353:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 353 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:366:5: warning: function 'peekAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 366 | const Ptr peekAtFront(b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:381:5: warning: function 'peekAtBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 381 | const Ptr peekAtBack(b length, int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:381:5: warning: function 'peekAtBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 381 | const Ptr peekAtBack(b length, int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:397:5: warning: function 'peekData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 397 | const Ptr peekData(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:409:5: warning: function 'peekAll' should be marked [[nodiscard]] [modernize-use-nodiscard] + 409 | const Ptr peekAll(int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:421:5: warning: function 'peekDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 421 | const Ptr peekDataAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:436:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 436 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:436:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 436 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:436:5: warning: function 'peekAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 436 | const Ptr peekAt(b offset, b length = b(-1), int flags = 0) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:519:5: warning: function 'hasAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 519 | bool hasAtFront(b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:519:5: warning: function 'hasAtFront' should be marked [[nodiscard]] [modernize-use-nodiscard] + 519 | bool hasAtFront(b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:531:5: warning: function 'hasAtBack' should be marked [[nodiscard]] [modernize-use-nodiscard] + 531 | bool hasAtBack(b length) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:542:5: warning: function 'hasData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 542 | bool hasData() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:552:5: warning: function 'hasAll' should be marked [[nodiscard]] [modernize-use-nodiscard] + 552 | bool hasAll() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:563:5: warning: function 'hasDataAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 563 | bool hasDataAt(b offset, b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:577:5: warning: function 'hasAt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 577 | bool hasAt(b offset, b length = b(-1)) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1259:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1259 | virtual SharingTagSet& getTags() override { return tags; } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1264:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1264 | int getNumTags() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1271:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1271 | const Ptr getTag(int index) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1292:26: warning: function 'hasTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1292 | template bool hasTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1299:26: warning: function 'findTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1299 | template const Ptr findTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1313:26: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1313 | template const Ptr getTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1313:26: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1313 | template const Ptr getTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1313:26: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1313 | template const Ptr getTag() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1359:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1359 | virtual SharingRegionTagSet& getRegionTags() override { return regionTags; } + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1364:5: warning: function 'getNumRegionTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1364 | int getNumRegionTags() const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1371:5: warning: function 'getRegionTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1371 | const Ptr getRegionTag(int index) const { + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1480:5: warning: function 'getFullName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1480 | virtual const char *getFullName() const override; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1480:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1480 | virtual const char *getFullName() const override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1487:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1487 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/Packet.h:1492:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 1492 | virtual std::string str() const override; + | ^ + | [[nodiscard]] +./inet/common/packet/Packet.h:1492:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1492 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:9:9: warning: invalid case style for macro definition '__INET_BITCOUNTCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BITCOUNTCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_BITCOUNTCHUNK_H +./inet/common/packet/chunk/BitCountChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:50:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual BitCountChunk *dup() const override { return new BitCountChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:51:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:68:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual ChunkType getChunkType() const override { return CT_BITCOUNT; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:69:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= b(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:71:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual bool canRemoveAtFront(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool canRemoveAtBack(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitCountChunk.h:79:30: warning: 2 adjacent parameters of 'canRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~~~~~~~~~~~~~ +./inet/common/packet/chunk/BitCountChunk.h:79:32: note: the first parameter in the range is 'offset' + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitCountChunk.h:79:42: note: the last parameter in the range is 'length' + 79 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitCountChunk.h:81:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:9:9: warning: invalid case style for macro definition '__INET_BITSCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BITSCHUNK_H + | ^~~~~~~~~~~~~~~~~~ + | INET_BITSCHUNK_H +./inet/common/packet/chunk/BitsChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:50:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual BitsChunk *dup() const override { return new BitsChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:51:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:69:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual ChunkType getChunkType() const override { return CT_BITS; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:70:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual b getChunkLength() const override { return b(bits.size()); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:72:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool canRemoveAtFront(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool canRemoveAtBack(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:80:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BitsChunk.h:80:30: warning: 2 adjacent parameters of 'canRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~~~~~~~~~~~~~ +./inet/common/packet/chunk/BitsChunk.h:80:32: note: the first parameter in the range is 'offset' + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitsChunk.h:80:42: note: the last parameter in the range is 'length' + 80 | virtual bool canRemoveAt(b offset, b length) const override { return true; } + | ^~~~~~ +./inet/common/packet/chunk/BitsChunk.h:82:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:9:9: warning: invalid case style for macro definition '__INET_BYTECOUNTCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BYTECOUNTCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_BYTECOUNTCHUNK_H +./inet/common/packet/chunk/ByteCountChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:50:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual ByteCountChunk *dup() const override { return new ByteCountChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:51:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:68:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual ChunkType getChunkType() const override { return CT_BYTECOUNT; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:69:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= B(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:71:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual bool canRemoveAtFront(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool canRemoveAtBack(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool canRemoveAt(b offset, b length) const override { return offset.get() % 8 == 0 && length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/ByteCountChunk.h:81:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:9:9: warning: invalid case style for macro definition '__INET_BYTESCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_BYTESCHUNK_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_BYTESCHUNK_H +./inet/common/packet/chunk/BytesChunk.h:31:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void doInsertAt(const Ptr& chunk, b offset) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void doRemoveAt(b offset, b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:51:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual BytesChunk *dup() const override { return new BytesChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:52:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:76:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual ChunkType getChunkType() const override { return CT_BYTES; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:77:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual b getChunkLength() const override { return B(bytes.size()); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:81:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:82:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:83:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual bool canInsertAt(const Ptr& chunk, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual bool canRemoveAtFront(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:86:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual bool canRemoveAtBack(b length) const override { return length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:87:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual bool canRemoveAt(b offset, b length) const override { return offset.get() % 8 == 0 && length.get() % 8 == 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/BytesChunk.h:89:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:9:9: warning: invalid case style for macro definition '__INET_CHUNK_H' [readability-identifier-naming] + 9 | #define __INET_CHUNK_H + | ^~~~~~~~~~~~~~ + | INET_CHUNK_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:294:20: warning: invalid case style for global constant 'unspecifiedLength' [readability-identifier-naming] + 294 | static const b unspecifiedLength; + | ^~~~~~~~~~~~~~~~~ + | UNSPECIFIED_LENGTH +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:298:20: warning: invalid case style for protected member 'isForward_' [readability-identifier-naming] + 298 | const bool isForward_; + | ^~~~~~~~~~ + | isForward + 299 | b position; + 300 | int index; + 301 | + 302 | public: + 303 | Iterator(b position) : isForward_(true), position(position), index(position == b(0) ? 0 : -1) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ + | isForward + 304 | Iterator(B position) : isForward_(true), position(position), index(position == b(0) ? 0 : -1) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ + | isForward + 305 | explicit Iterator(bool isForward, b position, int index) : isForward_(isForward), position(position), index(index) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ + | isForward + 306 | Iterator(const Iterator& other) : isForward_(other.isForward_), position(other.position), index(other.index) { CHUNK_CHECK_IMPLEMENTATION(isCorrect()); } + | ~~~~~~~~~~ ~~~~~~~~~~ + | isForward isForward + 307 | + 308 | bool isCorrect() { return position >= b(0) && index >= -1; } + 309 | + 310 | bool isForward() const { return isForward_; } + | ~~~~~~~~~~ + | isForward + 311 | bool isBackward() const { return !isForward_; } + | ~~~~~~~~~~ + | isForward +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:310:9: warning: function 'isForward' should be marked [[nodiscard]] [modernize-use-nodiscard] + 310 | bool isForward() const { return isForward_; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:311:9: warning: function 'isBackward' should be marked [[nodiscard]] [modernize-use-nodiscard] + 311 | bool isBackward() const { return !isForward_; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:313:9: warning: function 'getPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 313 | b getPosition() const { return position; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:316:9: warning: function 'getIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 316 | int getIndex() const { return index; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:363:52: warning: invalid case style for method '_getTag' [readability-identifier-naming] + 363 | const SharingRegionTagSet::RegionTag& _getTag(int index) const { return regionTags.getRegionTag(index); } + | ^~~~~~~ + | getTag +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:380:29: warning: 2 adjacent parameters of 'doRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 380 | virtual void doRemoveAt(b offset, b length) { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:380:31: note: the first parameter in the range is 'offset' + 380 | virtual void doRemoveAt(b offset, b length) { throw cRuntimeError("Invalid operation"); } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:380:41: note: the last parameter in the range is 'length' + 380 | virtual void doRemoveAt(b offset, b length) { throw cRuntimeError("Invalid operation"); } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:391:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 391 | typedef bool (*PeekPredicate)(const Ptr&); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using PeekPredicate = bool (*)(const Ptr&) +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:392:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 392 | typedef const Ptr (*PeekConverter)(const Ptr& chunk, const Chunk::Iterator& iterator, b length, int flags); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using PeekConverter = Ptr (*)(const Ptr& chunk, const Chunk::Iterator& iterator, b length, int flags) +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:438:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 438 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:440:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 440 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:441:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 441 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:555:30: warning: 2 adjacent parameters of 'canRemoveAt' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 555 | virtual bool canRemoveAt(b offset, b length) const { return false; } + | ^~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:555:32: note: the first parameter in the range is 'offset' + 555 | virtual bool canRemoveAt(b offset, b length) const { return false; } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:555:42: note: the last parameter in the range is 'length' + 555 | virtual bool canRemoveAt(b offset, b length) const { return false; } + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:670:13: warning: use c++17 style variable templates [modernize-type-traits] + 670 | if (std::is_same::value) + | ^ ~~~~~~~ + | _v +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:691:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 691 | virtual SharingRegionTagSet& getRegionTags() override { return regionTags; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:822:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 822 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:834:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 834 | virtual std::string str() const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/chunk/Chunk.h:870:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 870 | typedef TemporarySharedPtr ChunkTemporarySharedPtr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ChunkTemporarySharedPtr = TemporarySharedPtr +./inet/common/packet/chunk/Chunk_m.h:6:9: warning: invalid case style for macro definition '__INET_CHUNK_M_H' [readability-identifier-naming] + 6 | #define __INET_CHUNK_M_H + | ^~~~~~~~~~~~~~~~ + | INET_CHUNK_M_H +./inet/common/packet/chunk/Chunk_m.h:59:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 59 | typedef Ptr ChunkPtr; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ChunkPtr = Ptr +./inet/common/packet/chunk/EmptyChunk.h:9:9: warning: invalid case style for macro definition '__INET_EMPTYCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_EMPTYCHUNK_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_EMPTYCHUNK_H +./inet/common/packet/chunk/EmptyChunk.h:23:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:33:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual EmptyChunk *dup() const override { return new EmptyChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:34:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:39:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual ChunkType getChunkType() const override { return CT_EMPTY; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:40:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual b getChunkLength() const override { return b(0); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:42:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EmptyChunk.h:42:69: warning: 2 adjacent parameters of 'printFieldsToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/common/packet/chunk/EmptyChunk.h:42:73: note: the first parameter in the range is 'level' + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ^~~~~ +./inet/common/packet/chunk/EmptyChunk.h:42:84: note: the last parameter in the range is 'evFlags' + 42 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream; } + | ^~~~~~~ +./inet/common/packet/chunk/EncryptedChunk.h:9:9: warning: invalid case style for macro definition '__INET_ENCRYPTEDCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_ENCRYPTEDCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ENCRYPTEDCHUNK_H +./inet/common/packet/chunk/EncryptedChunk.h:35:12: warning: invalid case style for method '_getChunk' [readability-identifier-naming] + 35 | Chunk *_getChunk() const { return chunk.get(); } // only for class descriptor + | ^~~~~~~~~ + | getChunk +./inet/common/packet/chunk/EncryptedChunk.h:37:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:46:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual EncryptedChunk *dup() const override { return new EncryptedChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:47:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 47 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool isMutable() const override { return Chunk::isMutable() || chunk->isMutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:67:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual bool isImmutable() const override { return Chunk::isImmutable() && chunk->isImmutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:69:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual bool isComplete() const override { return Chunk::isComplete() && chunk->isComplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual bool isIncomplete() const override { return Chunk::isIncomplete() || chunk->isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:72:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual bool isCorrect() const override { return Chunk::isCorrect() && chunk->isCorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool isIncorrect() const override { return Chunk::isIncorrect() || chunk->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool isProperlyRepresented() const override { return Chunk::isProperlyRepresented() && chunk->isProperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool isImproperlyRepresented() const override { return Chunk::isImproperlyRepresented() || chunk->isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:81:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual ChunkType getChunkType() const override { return CT_ENCRYPTED; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:82:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= b(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:84:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/EncryptedChunk.h:86:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:9:9: warning: invalid case style for macro definition '__INET_FIELDSCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_FIELDSCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_FIELDSCHUNK_H +./inet/common/packet/chunk/FieldsChunk.h:43:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:54:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 54 | virtual ~FieldsChunk(); + | ~~~~~~~ ^ + | override +./inet/common/packet/chunk/FieldsChunk.h:56:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void handleChange() override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:64:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual ChunkType getChunkType() const override { return CT_FIELDS; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:68:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(chunkLength >= b(0)); return chunkLength; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/FieldsChunk.h:72:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:9:9: warning: invalid case style for macro definition '__INET_SEQUENCECHUNK_H' [readability-identifier-naming] + 9 | #define __INET_SEQUENCECHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_SEQUENCECHUNK_H +./inet/common/packet/chunk/SequenceChunk.h:50:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:58:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:67:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual SequenceChunk *dup() const override { return new SequenceChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:68:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:71:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual bool isComplete() const override { return !isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:86:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual bool isIncomplete() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual bool isCorrect() const override { return !isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:89:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual bool isIncorrect() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual bool isProperlyRepresented() const override { return !isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual bool isImproperlyRepresented() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:97:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 97 | virtual void moveIterator(Iterator& iterator, b length) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:98:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 98 | virtual void seekIterator(Iterator& iterator, b offset) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual bool canInsertAtFront(const Ptr& chunk) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:104:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual bool canInsertAtBack(const Ptr& chunk) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:109:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual bool canRemoveAtFront(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:110:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual bool canRemoveAtBack(b length) const override { return true; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:115:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 115 | virtual ChunkType getChunkType() const override { return CT_SEQUENCE; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:116:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 116 | virtual b getChunkLength() const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:117:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 117 | virtual bool isEmpty() const override { return chunks.size() != 0; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SequenceChunk.h:120:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 120 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:9:9: warning: invalid case style for macro definition '__INET_SLICECHUNK_H' [readability-identifier-naming] + 9 | #define __INET_SLICECHUNK_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_SLICECHUNK_H +./inet/common/packet/chunk/SliceChunk.h:42:12: warning: invalid case style for method '_getChunk' [readability-identifier-naming] + 42 | Chunk *_getChunk() const { return chunk.get(); } // only for class descriptor + | ^~~~~~~~~ + | getChunk +./inet/common/packet/chunk/SliceChunk.h:44:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual void doInsertAtFront(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual void doInsertAtBack(const Ptr& chunk) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void doRemoveAtFront(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void doRemoveAtBack(b length) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:61:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual SliceChunk *dup() const override { return new SliceChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:62:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:65:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:68:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:84:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual bool isMutable() const override { return Chunk::isMutable() || chunk->isMutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual bool isImmutable() const override { return Chunk::isImmutable() && chunk->isImmutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:87:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual bool isComplete() const override { return Chunk::isComplete() && chunk->isComplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual bool isIncomplete() const override { return Chunk::isIncomplete() || chunk->isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:90:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual bool isCorrect() const override { return Chunk::isCorrect() && chunk->isCorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual bool isIncorrect() const override { return Chunk::isIncorrect() || chunk->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual bool isProperlyRepresented() const override { return Chunk::isProperlyRepresented() && chunk->isProperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:94:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 94 | virtual bool isImproperlyRepresented() const override { return Chunk::isImproperlyRepresented() || chunk->isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:99:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual ChunkType getChunkType() const override { return CT_SLICE; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:100:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 100 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(length >= b(0)); return length; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:102:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 102 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:104:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual bool canInsertAtFront(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:105:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 105 | virtual bool canInsertAtBack(const Ptr& chunk) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:107:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual bool canRemoveAtFront(b length) const override { return false; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:108:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual bool canRemoveAtBack(b length) const override { return false; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/SliceChunk.h:110:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:9:9: warning: invalid case style for macro definition '__INET_STREAMBUFFERCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_STREAMBUFFERCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_STREAMBUFFERCHUNK_H +./inet/common/packet/chunk/StreamBufferChunk.h:38:12: warning: invalid case style for method '_getStreamData' [readability-identifier-naming] + 38 | Chunk *_getStreamData() const { return streamData.get(); } // only for class descriptor + | ^~~~~~~~~~~~~~ + | getStreamData +./inet/common/packet/chunk/StreamBufferChunk.h:40:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:49:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual StreamBufferChunk *dup() const override { return new StreamBufferChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:50:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:56:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:72:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual bool isMutable() const override { return Chunk::isMutable() || streamData->isMutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bool isImmutable() const override { return Chunk::isImmutable() && streamData->isImmutable(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool isComplete() const override { return Chunk::isComplete() && streamData->isComplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool isIncomplete() const override { return Chunk::isIncomplete() || streamData->isIncomplete(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual bool isCorrect() const override { return Chunk::isCorrect() && streamData->isCorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool isIncorrect() const override { return Chunk::isIncorrect() || streamData->isIncorrect(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:81:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual bool isProperlyRepresented() const override { return Chunk::isProperlyRepresented() && streamData->isProperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:82:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual bool isImproperlyRepresented() const override { return Chunk::isImproperlyRepresented() || streamData->isImproperlyRepresented(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:87:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual ChunkType getChunkType() const override { return CT_STREAM; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:89:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual b getChunkLength() const override { return streamData->getChunkLength(); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/StreamBufferChunk.h:93:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:9:9: warning: invalid case style for macro definition '__INET_CPACKETCHUNK_H' [readability-identifier-naming] + 9 | #define __INET_CPACKETCHUNK_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_CPACKETCHUNK_H +./inet/common/packet/chunk/cPacketChunk.h:21:16: warning: invalid case style for class 'cPacketChunk' [readability-identifier-naming] + 21 | class INET_API cPacketChunk : public Chunk + | ^~~~~~~~~~~~ + | CPacketChunk + 22 | { + 23 | protected: + 24 | cPacket *packet; + 25 | + 26 | protected: + 27 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + 28 | + 29 | public: + 30 | /** @name Constructors, destructors and duplication related functions */ + 31 | //@{ + 32 | cPacketChunk(cPacket *packet = nullptr); + | ~~~~~~~~~~~~ + | CPacketChunk + 33 | cPacketChunk(const cPacketChunk& other); + | ~~~~~~~~~~~~ ~~~~~~~~~~~~ + | CPacketChunk CPacketChunk + 34 | ~cPacketChunk(); + | ~~~~~~~~~~~~ + | CPacketChunk + 35 | + 36 | virtual cPacketChunk *dup() const override { return new cPacketChunk(*this); } + | ~~~~~~~~~~~~ ~~~~~~~~~~~~ + | CPacketChunk CPacketChunk +./inet/common/packet/chunk/cPacketChunk.h:27:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual const Ptr peekUnchecked(PeekPredicate predicate, PeekConverter converter, const Iterator& iterator, b length, int flags) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:34:5: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + 34 | ~cPacketChunk(); + | ^ + | override +./inet/common/packet/chunk/cPacketChunk.h:36:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual cPacketChunk *dup() const override { return new cPacketChunk(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:37:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual const Ptr dupShared() const override { return makeShared(*this); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:51:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual ChunkType getChunkType() const override { return CT_CPACKET; } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:52:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual b getChunkLength() const override { CHUNK_CHECK_IMPLEMENTATION(packet->getBitLength() >= 0); return b(packet->getBitLength()); } + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual bool containsSameData(const Chunk& other) const override; + | ~~~~~~~ ^ +./inet/common/packet/chunk/cPacketChunk.h:56:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual std::ostream& printFieldsToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/common/packet/tag/IRegionTaggedObject.h:9:9: warning: invalid case style for macro definition '__INET_IREGIONTAGGEDOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_IREGIONTAGGEDOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IREGIONTAGGEDOBJECT_H +./inet/common/packet/tag/ITaggedObject.h:9:9: warning: invalid case style for macro definition '__INET_ITAGGEDOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_ITAGGEDOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_ITAGGEDOBJECT_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:9:9: warning: invalid case style for macro definition '__INET_SHARINGREGIONTAGSET_H' [readability-identifier-naming] + 9 | #define __INET_SHARINGREGIONTAGSET_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_SHARINGREGIONTAGSET_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:56:9: warning: function '_getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | const T *_getTag() const { return tag.get(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:56:18: warning: invalid case style for method '_getTag' [readability-identifier-naming] + 56 | const T *_getTag() const { return tag.get(); } + | ^~~~~~~ + | getTag +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:59:19: warning: 2 adjacent parameters of 'RegionTag' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 59 | RegionTag(b offset, b length, const Ptr& tag) : offset(offset), length(length), tag(tag) { + | ^~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:59:21: note: the first parameter in the range is 'offset' + 59 | RegionTag(b offset, b length, const Ptr& tag) : offset(offset), length(length), tag(tag) { + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:59:31: note: the last parameter in the range is 'length' + 59 | RegionTag(b offset, b length, const Ptr& tag) : offset(offset), length(length), tag(tag) { + | ^~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:88:9: warning: function 'getOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | b getOffset() const { return offset; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:97:9: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | b getLength() const { return length; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:106:9: warning: function 'getStartOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 106 | b getStartOffset() const { return offset; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:107:9: warning: function 'getEndOffset' should be marked [[nodiscard]] [modernize-use-nodiscard] + 107 | b getEndOffset() const { return offset + length; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:109:9: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | const Ptr& getTag() const { return tag; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:112:9: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 112 | virtual std::string str() const override { + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:112:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 112 | virtual std::string str() const override { + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:120:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 120 | typedef RegionTag TagBaseRegionTag; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using TagBaseRegionTag = RegionTag +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:137:5: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 137 | int getTagIndex(const std::type_info& typeInfo, b offset, b length) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:138:26: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 138 | template int getTagIndex(b offset, b length) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:154:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 154 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:155:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 155 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:163:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 163 | inline int getNumTags() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:168:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 168 | inline const Ptr& getTag(int index) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingRegionTagSet.h:178:5: warning: function 'getRegionTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 178 | inline const RegionTag& getRegionTag(int index) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:9:9: warning: invalid case style for macro definition '__INET_SHARINGTAGSET_H' [readability-identifier-naming] + 9 | #define __INET_SHARINGTAGSET_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_SHARINGTAGSET_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:47:5: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | int getTagIndex(const std::type_info& typeInfo) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:48:26: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | template int getTagIndex() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:63:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual void parsimPack(cCommBuffer *buffer) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual void parsimUnpack(cCommBuffer *buffer) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:72:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | inline int getNumTags() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:77:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | inline const Ptr& getTag(int index) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/common/packet/tag/SharingTagSet.h:100:26: warning: function 'hasTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | template bool hasTag() const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:9:9: warning: invalid case style for macro definition '__INET_TAGSET_H' [readability-identifier-naming] + 9 | #define __INET_TAGSET_H + | ^~~~~~~~~~~~~~~ + | INET_TAGSET_H +./inet/common/packet/tag/TagSet.h:40:5: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | int getTagIndex(const std::type_info& typeInfo) const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:41:26: warning: function 'getTagIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | template int getTagIndex() const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:47:5: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + 47 | ~TagSet(); + | ^ + | override +./inet/common/packet/tag/TagSet.h:55:5: warning: function 'getNumTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | inline int getNumTags() const; + | ^ + | [[nodiscard]] +./inet/common/packet/tag/TagSet.h:60:5: warning: function 'getTag' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | inline cObject *getTag(int index) const; + | ^ + | [[nodiscard]] +./inet/common/precompiled.h:9:9: warning: invalid case style for macro definition '__INET_PRECOMPILED_H' [readability-identifier-naming] + 9 | #define __INET_PRECOMPILED_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_PRECOMPILED_H +./inet/common/stlutils.h:9:9: warning: invalid case style for macro definition '__INET_STLUTILS_H' [readability-identifier-naming] + 9 | #define __INET_STLUTILS_H + | ^~~~~~~~~~~~~~~~~ + | INET_STLUTILS_H +./inet/common/stlutils.h:31:31: warning: invalid case style for type template parameter '_C' [readability-identifier-naming] + 31 | template + | ^~ + | C + 32 | typename std::set& addAll(std::set& s, const std::set& t) { + | ~~ ~~ + | C C +./inet/common/stlutils.h:31:44: warning: invalid case style for type template parameter '_C2' [readability-identifier-naming] + 31 | template + | ^~~ + | C2 + 32 | typename std::set& addAll(std::set& s, const std::set& t) { + | ~~~ + | C2 +./inet/common/stlutils.h:37:43: warning: invalid case style for type template parameter '_C' [readability-identifier-naming] + 37 | template + | ^~ + | C + 38 | inline std::map& addAll(std::map& m, const std::map& n) { + | ~~ ~~ + | C C +./inet/common/stlutils.h:37:56: warning: invalid case style for type template parameter '_C2' [readability-identifier-naming] + 37 | template + | ^~~ + | C2 + 38 | inline std::map& addAll(std::map& m, const std::map& n) { + | ~~~ + | C2 +./inet/common/stlutils.h:43:55: warning: use c++14 style type templates [modernize-type-traits] + 43 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:43:70: warning: use c++17 style variable templates [modernize-type-traits] + 43 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:48:55: warning: use c++14 style type templates [modernize-type-traits] + 48 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:48:70: warning: use c++17 style variable templates [modernize-type-traits] + 48 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:53:55: warning: use c++14 style type templates [modernize-type-traits] + 53 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:53:70: warning: use c++17 style variable templates [modernize-type-traits] + 53 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:58:55: warning: use c++14 style type templates [modernize-type-traits] + 58 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:58:70: warning: use c++17 style variable templates [modernize-type-traits] + 58 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:64:55: warning: use c++14 style type templates [modernize-type-traits] + 64 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:64:70: warning: use c++17 style variable templates [modernize-type-traits] + 64 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:69:31: warning: invalid case style for type template parameter '_C' [readability-identifier-naming] + 69 | template::value>::type> + | ^~ + | C + 70 | inline bool contains(const std::set& s, const Tk& a) { + | ~~ + | C +./inet/common/stlutils.h:69:68: warning: use c++14 style type templates [modernize-type-traits] + 69 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:69:83: warning: use c++17 style variable templates [modernize-type-traits] + 69 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:74:31: warning: invalid case style for type template parameter '_H' [readability-identifier-naming] + 74 | template::value>::type> + | ^~ + | H + 75 | inline bool contains(const std::unordered_set& s, const Tk& a) { + | ~~ + | H +./inet/common/stlutils.h:74:44: warning: invalid case style for type template parameter '_P' [readability-identifier-naming] + 74 | template::value>::type> + | ^~ + | P + 75 | inline bool contains(const std::unordered_set& s, const Tk& a) { + | ~~ + | P +./inet/common/stlutils.h:74:81: warning: use c++14 style type templates [modernize-type-traits] + 74 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:74:96: warning: use c++17 style variable templates [modernize-type-traits] + 74 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:79:43: warning: invalid case style for type template parameter '_C' [readability-identifier-naming] + 79 | template::value>::type> + | ^~ + | C + 80 | inline bool containsKey(const std::map& m, const Tk& a) { + | ~~ + | C +./inet/common/stlutils.h:79:80: warning: use c++14 style type templates [modernize-type-traits] + 79 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:79:95: warning: use c++17 style variable templates [modernize-type-traits] + 79 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:84:43: warning: invalid case style for type template parameter '_C' [readability-identifier-naming] + 84 | template::value>::type> + | ^~ + | C + 85 | inline bool containsKey(const std::multimap& m, const Tk& a) { + | ~~ + | C +./inet/common/stlutils.h:84:80: warning: use c++14 style type templates [modernize-type-traits] + 84 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:84:95: warning: use c++17 style variable templates [modernize-type-traits] + 84 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:89:43: warning: invalid case style for type template parameter '_H' [readability-identifier-naming] + 89 | template::value>::type> + | ^~ + | H + 90 | inline bool containsKey(const std::unordered_map& m, const Tk& a) { + | ~~ + | H +./inet/common/stlutils.h:89:56: warning: invalid case style for type template parameter '_P' [readability-identifier-naming] + 89 | template::value>::type> + | ^~ + | P + 90 | inline bool containsKey(const std::unordered_map& m, const Tk& a) { + | ~~ + | P +./inet/common/stlutils.h:89:93: warning: use c++14 style type templates [modernize-type-traits] + 89 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:89:108: warning: use c++17 style variable templates [modernize-type-traits] + 89 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:94:55: warning: use c++14 style type templates [modernize-type-traits] + 94 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:94:70: warning: use c++17 style variable templates [modernize-type-traits] + 94 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:106:55: warning: use c++14 style type templates [modernize-type-traits] + 106 | template::value>::type> + | ~~~~~~~~ ^ ~~~~~~ + | _t +./inet/common/stlutils.h:106:70: warning: use c++17 style variable templates [modernize-type-traits] + 106 | template::value>::type> + | ^ ~~~~~~~ + | _v +./inet/common/stlutils.h:141:13: warning: invalid case style for function 'to_str' [readability-identifier-naming] + 141 | std::string to_str(const std::vector& v) { + | ^~~~~~ + | toStr +./inet/common/stlutils.h:153:44: warning: invalid case style for type template parameter '_C' [readability-identifier-naming] + 153 | template + | ^~ + | C + 154 | std::string to_str(const std::map& m) { + | ~~ + | C +./inet/common/stlutils.h:154:13: warning: invalid case style for function 'to_str' [readability-identifier-naming] + 154 | std::string to_str(const std::map& m) { + | ^~~~~~ + | toStr +./inet/common/stlutils.h:167:13: warning: invalid case style for function 'hash_combine' [readability-identifier-naming] + 167 | inline void hash_combine(std::size_t& seed, const T& v) // from boost + | ^~~~~~~~~~~~ + | hashCombine +./inet/common/stlutils.h:173:8: warning: invalid case style for struct 'pair_hash' [readability-identifier-naming] + 173 | struct pair_hash + | ^~~~~~~~~ + | PairHash +./inet/environment/common/Material.h:9:9: warning: invalid case style for macro definition '__INET_MATERIAL_H' [readability-identifier-naming] + 9 | #define __INET_MATERIAL_H + | ^~~~~~~~~~~~~~~~~ + | INET_MATERIAL_H +./inet/environment/common/Material.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/common/Material.h:31:5: warning: function 'getResistivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual Ohmm getResistivity() const override { return resistivity; } + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual Ohmm getResistivity() const override { return resistivity; } + | ~~~~~~~ ^ +./inet/environment/common/Material.h:32:5: warning: function 'getRelativePermittivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual double getRelativePermittivity() const override { return relativePermittivity; } + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:32:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual double getRelativePermittivity() const override { return relativePermittivity; } + | ~~~~~~~ ^ +./inet/environment/common/Material.h:33:5: warning: function 'getRelativePermeability' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual double getRelativePermeability() const override { return relativePermeability; } + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:33:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual double getRelativePermeability() const override { return relativePermeability; } + | ~~~~~~~ ^ +./inet/environment/common/Material.h:34:5: warning: function 'getDielectricLossTangent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual double getDielectricLossTangent(Hz frequency) const override; + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:34:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual double getDielectricLossTangent(Hz frequency) const override; + | ~~~~~~~ ^ +./inet/environment/common/Material.h:35:5: warning: function 'getRefractiveIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual double getRefractiveIndex() const override; + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:35:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual double getRefractiveIndex() const override; + | ~~~~~~~ ^ +./inet/environment/common/Material.h:36:5: warning: function 'getPropagationSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual mps getPropagationSpeed() const override; + | ^ + | [[nodiscard]] +./inet/environment/common/Material.h:36:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual mps getPropagationSpeed() const override; + | ~~~~~~~ ^ +./inet/environment/contract/IGround.h:9:9: warning: invalid case style for macro definition '__INET_IGROUND_H' [readability-identifier-naming] + 9 | #define __INET_IGROUND_H + | ^~~~~~~~~~~~~~~~ + | INET_IGROUND_H +./inet/environment/contract/IGround.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IGround.h:26:5: warning: function 'computeGroundProjection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual Coord computeGroundProjection(const Coord& position) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IGround.h:34:5: warning: function 'computeGroundNormal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual Coord computeGroundNormal(const Coord& position) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:9:9: warning: invalid case style for macro definition '__INET_IMATERIAL_H' [readability-identifier-naming] + 9 | #define __INET_IMATERIAL_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IMATERIAL_H +./inet/environment/contract/IMaterial.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IMaterial.h:23:5: warning: function 'getResistivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual Ohmm getResistivity() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:24:5: warning: function 'getRelativePermittivity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual double getRelativePermittivity() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:25:5: warning: function 'getRelativePermeability' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual double getRelativePermeability() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:26:5: warning: function 'getDielectricLossTangent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual double getDielectricLossTangent(Hz frequency) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:27:5: warning: function 'getRefractiveIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual double getRefractiveIndex() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterial.h:28:5: warning: function 'getPropagationSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual mps getPropagationSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IMaterialRegistry.h:9:9: warning: invalid case style for macro definition '__INET_IMATERIALREGISTRY_H' [readability-identifier-naming] + 9 | #define __INET_IMATERIALREGISTRY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMATERIALREGISTRY_H +./inet/environment/contract/IMaterialRegistry.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment + 16 | + 17 | class INET_API IMaterialRegistry + 18 | { + 19 | public: + 20 | virtual const Material *getMaterial(const char *name) const = 0; + 21 | }; + 22 | + 23 | } // namespace physicalenvironment + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicalenvironment + 24 | + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/environment/contract/IObjectCache.h:9:9: warning: invalid case style for macro definition '__INET_IOBJECTCACHE_H' [readability-identifier-naming] + 9 | #define __INET_IOBJECTCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IOBJECTCACHE_H +./inet/environment/contract/IObjectCache.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IPhysicalEnvironment.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALENVIRONMENT_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALENVIRONMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALENVIRONMENT_H +./inet/environment/contract/IPhysicalEnvironment.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | + 22 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IPhysicalEnvironment.h:27:5: warning: function 'getObjectCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual IObjectCache *getObjectCache() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:28:5: warning: function 'getGround' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual IGround *getGround() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:30:5: warning: function 'getSpaceMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const Coord& getSpaceMin() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:31:5: warning: function 'getSpaceMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const Coord& getSpaceMax() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:32:5: warning: function 'getMaterialRegistry' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const IMaterialRegistry *getMaterialRegistry() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:34:5: warning: function 'getNumObjects' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual int getNumObjects() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:35:5: warning: function 'getObject' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const IPhysicalObject *getObject(int index) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalEnvironment.h:36:5: warning: function 'getObjectById' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const IPhysicalObject *getObjectById(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALOBJECT_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALOBJECT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALOBJECT_H +./inet/environment/contract/IPhysicalObject.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicalenvironment { + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicalenvironment +./inet/environment/contract/IPhysicalObject.h:22:5: warning: function 'getPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual const Coord& getPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:23:5: warning: function 'getOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual const Quaternion& getOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:25:5: warning: function 'getShape' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual const ShapeBase *getShape() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:26:5: warning: function 'getMaterial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const IMaterial *getMaterial() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:28:5: warning: function 'getLineWidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual double getLineWidth() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:29:5: warning: function 'getLineColor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const cFigure::Color& getLineColor() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:30:5: warning: function 'getFillColor' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const cFigure::Color& getFillColor() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:31:5: warning: function 'getOpacity' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual double getOpacity() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:32:5: warning: function 'getTexture' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const char *getTexture() const = 0; + | ^ + | [[nodiscard]] +./inet/environment/contract/IPhysicalObject.h:33:5: warning: function 'getTags' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const char *getTags() const = 0; + | ^ + | [[nodiscard]] +./inet/features.h:21:9: warning: invalid case style for macro definition 'INET_WITH_BGPv4' [readability-identifier-naming] + 21 | #define INET_WITH_BGPv4 + | ^~~~~~~~~~~~~~~ + | INET_WITH_BG_PV4 +./inet/features.h:105:9: warning: invalid case style for macro definition 'INET_WITH_IPv4' [readability-identifier-naming] + 105 | #define INET_WITH_IPv4 + | ^~~~~~~~~~~~~~ + | INET_WITH_I_PV4 +./inet/features.h:109:9: warning: invalid case style for macro definition 'INET_WITH_IPv6' [readability-identifier-naming] + 109 | #define INET_WITH_IPv6 + | ^~~~~~~~~~~~~~ + | INET_WITH_I_PV6 +./inet/features.h:133:9: warning: invalid case style for macro definition 'INET_WITH_OSPFv2' [readability-identifier-naming] + 133 | #define INET_WITH_OSPFv2 + | ^~~~~~~~~~~~~~~~ + | INET_WITH_OSP_FV2 +./inet/features.h:137:9: warning: invalid case style for macro definition 'INET_WITH_OSPFv3' [readability-identifier-naming] + 137 | #define INET_WITH_OSPFv3 + | ^~~~~~~~~~~~~~~~ + | INET_WITH_OSP_FV3 +./inet/linklayer/base/MacProtocolBase.h:9:9: warning: invalid case style for macro definition '__INET_MACPROTOCOLBASE_H' [readability-identifier-naming] + 9 | #define __INET_MACPROTOCOLBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MACPROTOCOLBASE_H +./inet/linklayer/base/MacProtocolBase.h:42:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 42 | virtual ~MacProtocolBase(); + | ~~~~~~~ ^ + | override +./inet/linklayer/base/MacProtocolBase.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void handleMessageWhenDown(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:59:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual bool isUpperMessage(cMessage *message) const override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual bool isLowerMessage(cMessage *message) const override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:62:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual bool isInitializeStage(int stage) const override { return stage == INITSTAGE_LINK_LAYER; } + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:63:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual bool isModuleStartStage(int stage) const override { return stage == ModuleStartOperation::STAGE_LINK_LAYER; } + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual bool isModuleStopStage(int stage) const override { return stage == ModuleStopOperation::STAGE_LINK_LAYER; } + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual void handleStartOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual void handleStopOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/base/MacProtocolBase.h:80:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual void handleCrashOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/common/FcsMode_m.h:6:9: warning: invalid case style for macro definition '__INET_FCSMODE_M_H' [readability-identifier-naming] + 6 | #define __INET_FCSMODE_M_H + | ^~~~~~~~~~~~~~~~~~ + | INET_FCSMODE_M_H +./inet/linklayer/common/FcsMode_m.h:46:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 46 | typedef ChecksumMode FcsMode; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using FcsMode = ChecksumMode +./inet/linklayer/common/MacAddress.h:8:9: warning: invalid case style for macro definition '__INET_MACADDRESS_H' [readability-identifier-naming] + 8 | #define __INET_MACADDRESS_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_MACADDRESS_H +./inet/linklayer/common/MacAddress.h:75:17: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 75 | MacAddress& operator=(const MacAddress& other) { address = other.address; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/linklayer/common/MacAddress.h:80:5: warning: function 'getAddressSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | unsigned int getAddressSize() const { return MAC_ADDRESS_SIZE; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:85:5: warning: function 'getAddressByte' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | unsigned char getAddressByte(unsigned int k) const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:124:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | bool isBroadcast() const { return address == MAC_ADDRESS_MASK; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:129:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 129 | bool isMulticast() const { return getAddressByte(0) & 0x01; }; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:134:5: warning: function 'isLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 134 | bool isLocal() const { return getAddressByte(0) & 0x02; }; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:139:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 139 | bool isUnspecified() const { return address == 0; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:144:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 144 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:149:5: warning: function 'getInt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 149 | uint64_t getInt() const { return address; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:154:5: warning: function 'equals' should be marked [[nodiscard]] [modernize-use-nodiscard] + 154 | bool equals(const MacAddress& other) const { return address == other.address; } + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:169:5: warning: function 'compareTo' should be marked [[nodiscard]] [modernize-use-nodiscard] + 169 | int compareTo(const MacAddress& other) const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress.h:175:5: warning: function 'formInterfaceIdentifier' should be marked [[nodiscard]] [modernize-use-nodiscard] + 175 | InterfaceToken formInterfaceIdentifier() const; + | ^ + | [[nodiscard]] +./inet/linklayer/common/MacAddress_m.h:6:9: warning: invalid case style for macro definition '__INET_MACADDRESS_M_H' [readability-identifier-naming] + 6 | #define __INET_MACADDRESS_M_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_MACADDRESS_M_H +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_IEEE80211DATASEQUENCETAG_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_IEEE80211DATASEQUENCETAG_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_IEE_E80211_DATASEQUENCETAG_M_H +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 33 | + 34 | class Ieee80211DataSequenceTag; + 35 | + 36 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:44:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 44 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 45 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:67:10: warning: deleted member function should be public [modernize-use-equals-delete] + 67 | bool operator==(const Ieee80211DataSequenceTag&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:72:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 72 | virtual ~Ieee80211DataSequenceTag(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:74:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual Ieee80211DataSequenceTag *dup() const override {return new Ieee80211DataSequenceTag(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211DataSequenceTag_m.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:6:9: warning: invalid case style for macro definition '__INET_IEEE80211FRAME_M_H' [readability-identifier-naming] + 6 | #define __INET_IEEE80211FRAME_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_FRAME_M_H +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:37:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 37 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 38 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:91:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 91 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 92 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:106:36: warning: performing an implicit widening conversion to type 'const value_type' (aka 'const long') of a multiplication performed in type 'int' [bugprone-implicit-widening-of-multiplication-result] + 106 | const b QOSCONTROL_PART_LENGTH = b(2 * 8); // QoS Control field length (bits) + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:106:36: note: make conversion explicit to silence this warning + 12 | const b QOSCONTROL_PART_LENGTH = b(2 * 8); // QoS Control field length (bits) + | ^~~~~ + | static_cast( ) +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:106:36: note: perform multiplication in a wider type + 106 | const b QOSCONTROL_PART_LENGTH = b(2 * 8); // QoS Control field length (bits) + | ^ + | static_cast( ) +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:228:10: warning: deleted member function should be public [modernize-use-equals-delete] + 228 | bool operator==(const Ieee80211MacTrailer&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:233:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 233 | virtual ~Ieee80211MacTrailer(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:235:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 235 | virtual Ieee80211MacTrailer *dup() const override {return new Ieee80211MacTrailer(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:236:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 236 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:237:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 237 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:292:11: warning: invalid case style for protected member 'AID' [readability-identifier-naming] + 292 | short AID = -1; + | ^~~ + | aid +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:294:26: warning: invalid case style for protected member 'MACArrive' [readability-identifier-naming] + 294 | ::omnetpp::simtime_t MACArrive = SIMTIME_ZERO; + | ^~~~~~~~~ + | macArrive +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:300:10: warning: deleted member function should be public [modernize-use-equals-delete] + 300 | bool operator==(const Ieee80211MacHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:305:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 305 | virtual ~Ieee80211MacHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:307:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 307 | virtual Ieee80211MacHeader *dup() const override {return new Ieee80211MacHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:308:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 308 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:309:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 309 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:342:31: warning: invalid case style for parameter 'AID' [readability-identifier-naming] + 342 | virtual void setAID(short AID); + | ^~~ + | aid +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:349:52: warning: invalid case style for parameter 'MACArrive' [readability-identifier-naming] + 349 | virtual void setMACArrive(::omnetpp::simtime_t MACArrive); + | ^~~~~~~~~ + | macArrive +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:382:10: warning: deleted member function should be public [modernize-use-equals-delete] + 382 | bool operator==(const Ieee80211OneAddressHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:387:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 387 | virtual ~Ieee80211OneAddressHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:389:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 389 | virtual Ieee80211OneAddressHeader *dup() const override {return new Ieee80211OneAddressHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:390:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 390 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:391:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 391 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:418:10: warning: deleted member function should be public [modernize-use-equals-delete] + 418 | bool operator==(const Ieee80211AckFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:423:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 423 | virtual ~Ieee80211AckFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:425:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 425 | virtual Ieee80211AckFrame *dup() const override {return new Ieee80211AckFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:426:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 426 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:427:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 427 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:455:10: warning: deleted member function should be public [modernize-use-equals-delete] + 455 | bool operator==(const Ieee80211TwoAddressHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:460:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 460 | virtual ~Ieee80211TwoAddressHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:462:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 462 | virtual Ieee80211TwoAddressHeader *dup() const override {return new Ieee80211TwoAddressHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:463:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 463 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:464:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 464 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:495:10: warning: deleted member function should be public [modernize-use-equals-delete] + 495 | bool operator==(const Ieee80211RtsFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:500:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 500 | virtual ~Ieee80211RtsFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:502:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 502 | virtual Ieee80211RtsFrame *dup() const override {return new Ieee80211RtsFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:503:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 503 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:504:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 504 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:531:10: warning: deleted member function should be public [modernize-use-equals-delete] + 531 | bool operator==(const Ieee80211CtsFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:536:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 536 | virtual ~Ieee80211CtsFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:538:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 538 | virtual Ieee80211CtsFrame *dup() const override {return new Ieee80211CtsFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:539:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 539 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:540:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 540 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:572:10: warning: deleted member function should be public [modernize-use-equals-delete] + 572 | bool operator==(const Ieee80211DataOrMgmtHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:577:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 577 | virtual ~Ieee80211DataOrMgmtHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:579:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 579 | virtual Ieee80211DataOrMgmtHeader *dup() const override {return new Ieee80211DataOrMgmtHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:580:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 580 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:581:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 581 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:646:10: warning: deleted member function should be public [modernize-use-equals-delete] + 646 | bool operator==(const Ieee80211DataHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:651:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 651 | virtual ~Ieee80211DataHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:653:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 653 | virtual Ieee80211DataHeader *dup() const override {return new Ieee80211DataHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:654:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 654 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:655:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 655 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:657:5: warning: method 'inet::ieee80211::Ieee80211DataHeader::getAddress4' has a similar name and the same signature as virtual method 'inet::ieee80211::Ieee80211DataOrMgmtHeader::getAddress3'; did you mean to override it? [bugprone-virtual-near-miss] + 657 | virtual const ::inet::MacAddress& getAddress4() const; + | ^ ~~~~~~~~~~~ + | getAddress3 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:658:5: warning: method 'inet::ieee80211::Ieee80211DataHeader::getAddress4ForUpdate' has a similar name and the same signature as virtual method 'inet::ieee80211::Ieee80211DataOrMgmtHeader::getAddress3ForUpdate'; did you mean to override it? [bugprone-virtual-near-miss] + 658 | virtual ::inet::MacAddress& getAddress4ForUpdate() { handleChange();return const_cast<::inet::MacAddress&>(const_cast(this)->getAddress4());} + | ^ ~~~~~~~~~~~~~~~~~~~~ + | getAddress3ForUpdate +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:659:5: warning: method 'inet::ieee80211::Ieee80211DataHeader::setAddress4' has a similar name and the same signature as virtual method 'inet::ieee80211::Ieee80211DataOrMgmtHeader::setAddress3'; did you mean to override it? [bugprone-virtual-near-miss] + 659 | virtual void setAddress4(const ::inet::MacAddress& address4); + | ^ ~~~~~~~~~~~ + | setAddress3 +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:696:10: warning: deleted member function should be public [modernize-use-equals-delete] + 696 | bool operator==(const Ieee80211MgmtHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:701:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 701 | virtual ~Ieee80211MgmtHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:703:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 703 | virtual Ieee80211MgmtHeader *dup() const override {return new Ieee80211MgmtHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:704:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 704 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:705:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 705 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:735:10: warning: deleted member function should be public [modernize-use-equals-delete] + 735 | bool operator==(const Ieee80211ActionFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:740:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 740 | virtual ~Ieee80211ActionFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:742:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 742 | virtual Ieee80211ActionFrame *dup() const override {return new Ieee80211ActionFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:743:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 743 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:744:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 744 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:773:12: warning: invalid case style for protected member 'actionBody_arraysize' [readability-identifier-naming] + 773 | size_t actionBody_arraysize = 0; + | ^~~~~~~~~~~~~~~~~~~~ + | actionBodyArraysize +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:779:10: warning: deleted member function should be public [modernize-use-equals-delete] + 779 | bool operator==(const Ieee80211ActionFrameOther&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:784:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 784 | virtual ~Ieee80211ActionFrameOther(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:786:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 786 | virtual Ieee80211ActionFrameOther *dup() const override {return new Ieee80211ActionFrameOther(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:787:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 787 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:788:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 788 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:826:10: warning: deleted member function should be public [modernize-use-equals-delete] + 826 | bool operator==(const Ieee80211MsduSubframeHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:831:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 831 | virtual ~Ieee80211MsduSubframeHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:833:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 833 | virtual Ieee80211MsduSubframeHeader *dup() const override {return new Ieee80211MsduSubframeHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:834:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 834 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:835:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 835 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:871:10: warning: deleted member function should be public [modernize-use-equals-delete] + 871 | bool operator==(const Ieee80211MpduSubframeHeader&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:876:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 876 | virtual ~Ieee80211MpduSubframeHeader(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:878:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 878 | virtual Ieee80211MpduSubframeHeader *dup() const override {return new Ieee80211MpduSubframeHeader(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:879:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 879 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:880:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 880 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:931:13: warning: invalid case style for protected member '_fragmentNumber' [readability-identifier-naming] + 931 | uint8_t _fragmentNumber = 0; + | ^~~~~~~~~~~~~~~ + | fragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:938:10: warning: deleted member function should be public [modernize-use-equals-delete] + 938 | bool operator==(const Ieee80211AddbaRequest&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:943:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 943 | virtual ~Ieee80211AddbaRequest(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:945:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 945 | virtual Ieee80211AddbaRequest *dup() const override {return new Ieee80211AddbaRequest(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:946:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 946 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:947:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 947 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:967:21: warning: invalid case style for method 'get_fragmentNumber' [readability-identifier-naming] + 967 | virtual uint8_t get_fragmentNumber() const; + | ^~~~~~~~~~~~~~~~~~ + | getFragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:968:18: warning: invalid case style for method 'set_fragmentNumber' [readability-identifier-naming] + 968 | virtual void set_fragmentNumber(uint8_t _fragmentNumber); + | ^~~~~~~~~~~~~~~~~~ + | setFragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:968:45: warning: invalid case style for parameter '_fragmentNumber' [readability-identifier-naming] + 968 | virtual void set_fragmentNumber(uint8_t _fragmentNumber); + | ^~~~~~~~~~~~~~~ + | fragmentNumber +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1021:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1021 | bool operator==(const Ieee80211AddbaResponse&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1026:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1026 | virtual ~Ieee80211AddbaResponse(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1028:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1028 | virtual Ieee80211AddbaResponse *dup() const override {return new Ieee80211AddbaResponse(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1029:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1029 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1030:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1030 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1094:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1094 | bool operator==(const Ieee80211Delba&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1099:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1099 | virtual ~Ieee80211Delba(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1101:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1101 | virtual Ieee80211Delba *dup() const override {return new Ieee80211Delba(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1102:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1102 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1103 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1152:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1152 | bool operator==(const Ieee80211BlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1157:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1157 | virtual ~Ieee80211BlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1159:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1159 | virtual Ieee80211BlockAckReq *dup() const override {return new Ieee80211BlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1160:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1160 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1161:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1161 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1211:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1211 | bool operator==(const Ieee80211BasicBlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1216:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1216 | virtual ~Ieee80211BasicBlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1218:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1218 | virtual Ieee80211BasicBlockAckReq *dup() const override {return new Ieee80211BasicBlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1219:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1219 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1220:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1220 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1269:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1269 | bool operator==(const Ieee80211CompressedBlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1274:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1274 | virtual ~Ieee80211CompressedBlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1276:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1276 | virtual Ieee80211CompressedBlockAckReq *dup() const override {return new Ieee80211CompressedBlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1277:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1277 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1278 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1314:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1314 | bool operator==(const Ieee80211MultiTidBlockAckReq&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1319:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1319 | virtual ~Ieee80211MultiTidBlockAckReq(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1321:43: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1321 | virtual Ieee80211MultiTidBlockAckReq *dup() const override {return new Ieee80211MultiTidBlockAckReq(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1322:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1322 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1323:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1323 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1363:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1363 | bool operator==(const Ieee80211BlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1368:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1368 | virtual ~Ieee80211BlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1370:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1370 | virtual Ieee80211BlockAck *dup() const override {return new Ieee80211BlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1371:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1371 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1372:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1372 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1434:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1434 | bool operator==(const Ieee80211BasicBlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1439:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1439 | virtual ~Ieee80211BasicBlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1441:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1441 | virtual Ieee80211BasicBlockAck *dup() const override {return new Ieee80211BasicBlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1442:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1442 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1443:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1443 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1501:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1501 | bool operator==(const Ieee80211CompressedBlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1506:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1506 | virtual ~Ieee80211CompressedBlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1508:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1508 | virtual Ieee80211CompressedBlockAck *dup() const override {return new Ieee80211CompressedBlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1509:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1509 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1510:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1510 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1554:10: warning: deleted member function should be public [modernize-use-equals-delete] + 1554 | bool operator==(const Ieee80211MultiTidBlockAck&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1559:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 1559 | virtual ~Ieee80211MultiTidBlockAck(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1561:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1561 | virtual Ieee80211MultiTidBlockAck *dup() const override {return new Ieee80211MultiTidBlockAck(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1562:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1562 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Frame_m.h:1563:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 1563 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MAC_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MAC_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MAC_H +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:26:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 26 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 27 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:66:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:67:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual void initialize(int) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, intval_t value, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:73:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual void configureNetworkInterface() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual void handleMessageWhenUp(cMessage *message) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual void handleUpperCommand(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:82:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual void handleSelfMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual void handleUpperPacket(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual void handleLowerPacket(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual void handleStartOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:94:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 94 | virtual void handleStopOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:95:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 95 | virtual void handleCrashOperation(LifecycleOperation *operation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:102:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 102 | virtual ~Ieee80211Mac(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:106:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual void sendUp(cMessage *message) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/Ieee80211Mac.h:110:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual void resetPeerAgreements(const MacAddress& peer) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h:9:9: warning: invalid case style for macro definition '__INET_MPDUAGGREGATION_H' [readability-identifier-naming] + 9 | #define __INET_MPDUAGGREGATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MPDUAGGREGATION_H +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h:19:5: warning: function 'buildAggregate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 19 | Packet *buildAggregate(const std::vector& frames, B minimumStartDistance) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h:22:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 22 | virtual Packet *aggregateFrames(std::vector *frames) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h:23:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual B computeAggregateLength(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregation.h:25:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual Packet *aggregateFrames(const std::vector& frames, const physicallayer::IIeee80211Mode *mode, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h:4:9: warning: invalid case style for macro definition '__INET_MPDUAGGREGATIONUTILS_H' [readability-identifier-naming] + 4 | #define __INET_MPDUAGGREGATIONUTILS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MPDUAGGREGATIONUTILS_H +./inet/linklayer/ieee80211/mac/aggregation/MpduAggregationUtils.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/aggregation/MsduAggregation.h:9:9: warning: invalid case style for macro definition '__INET_MSDUAGGREGATION_H' [readability-identifier-naming] + 9 | #define __INET_MSDUAGGREGATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MSDUAGGREGATION_H +./inet/linklayer/ieee80211/mac/aggregation/MsduAggregation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API MsduAggregation : public IMsduAggregation, public cObject + 17 | { + 18 | protected: + 19 | virtual void setSubframeAddress(const Ptr& subframe, const Ptr& header); + 20 | + 21 | public: + 22 | virtual Packet *aggregateFrames(std::vector *frames) override; + 23 | }; + 24 | + 25 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/aggregation/MsduAggregation.h:22:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 22 | virtual Packet *aggregateFrames(std::vector *frames) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:9:9: warning: invalid case style for macro definition '__INET_BLOCKACKRECORD_H' [readability-identifier-naming] + 9 | #define __INET_BLOCKACKRECORD_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_BLOCKACKRECORD_H +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:34:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 34 | virtual ~BlockAckRecord() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:42:5: warning: function 'getCompressedAckState' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | bool getCompressedAckState(SequenceNumberCyclic sequenceNumber) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:43:5: warning: function 'hasCompleteReceipt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | bool hasCompleteReceipt(SequenceNumberCyclic sequenceNumber) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/BlockAckRecord.h:44:5: warning: function 'getWindowStart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | SequenceNumberCyclic getWindowStart() const { return windowStart; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORBLOCKACKAGREEMENT_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORBLOCKACKAGREEMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORBLOCKACKAGREEMENT_H +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:40:5: warning: function 'hasPendingProbe' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | bool hasPendingProbe() const { return pendingProbe; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:52:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 52 | virtual ~OriginatorBlockAckAgreement() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:52:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 52 | virtual ~OriginatorBlockAckAgreement() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:54:5: warning: function 'getBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual int getBufferSize() const { return bufferSize; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:55:5: warning: function 'getWindowSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | int getWindowSize() const { return std::min(bufferSize, 64); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:60:5: warning: function 'containsSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | bool containsSequence(SequenceNumberCyclic sequence) const + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:80:5: warning: function 'getIsAddbaResponseReceived' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual bool getIsAddbaResponseReceived() const { return isAddbaResponseReceived; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:81:5: warning: function 'getIsAddbaRequestSent' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual bool getIsAddbaRequestSent() const { return isAddbaRequestSent; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:82:5: warning: function 'getIsAMsduSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual bool getIsAMsduSupported() const { return isAMsduSupported; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:84:5: warning: function 'isAMsduPermitted' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | bool isAMsduPermitted() const { return isAMsduSupported && responseAMsduSupported; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:85:5: warning: function 'getDialogToken' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | int getDialogToken() const { return dialogToken; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:88:5: warning: function 'getFirstDataTransmitted' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | bool getFirstDataTransmitted() const { return highestTransmittedDataIndex >= 0; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:89:5: warning: function 'getHighestTransmittedDataIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | int64_t getHighestTransmittedDataIndex() const { return highestTransmittedDataIndex; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:96:5: warning: function 'getIsDelayedBlockAckPolicySupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | virtual bool getIsDelayedBlockAckPolicySupported() const { return isDelayedBlockAckPolicySupported; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:97:5: warning: function 'getReceiverAddr' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual MacAddress getReceiverAddr() const { return receiverAddr; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:98:5: warning: function 'getTid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual Tid getTid() const { return tid; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:99:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 99 | virtual const simtime_t getBlockAckTimeoutValue() const { return blockAckTimeoutValue; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreement.h:100:5: warning: function 'getNumSentBaPolicyFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | virtual int getNumSentBaPolicyFrames() const { return numSentBaPolicyFrames; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:36:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual simtime_t computeEarliestExpirationTime() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:37:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | const std::map& getAgreements() const override { return blockAckAgreements; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:38:5: warning: function 'getProcedures' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | const std::map& getProcedures() const override { return procedures; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void noteEligibleDataTransmission(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void beginSetupIntent(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual void beginTeardown(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual void failTeardown(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void finishProcedure(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void markRequestAttempted(MacAddress peer, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:45:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual void acknowledgeRequest(MacAddress peer, Tid tid, simtime_t timeout) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:49:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 49 | virtual ~OriginatorBlockAckAgreementHandler(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void processTransmittedAddbaReq(const Ptr& addbaReq) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void processTransmittedDataFrame(Packet *packet, const Ptr& dataHeader, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void processReceivedBlockAck(const Ptr& blockAck, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void processReceivedAddbaResp(const Ptr& addbaResp, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void processReceivedDelba(const Ptr& delba, IOriginatorBlockAckAgreementPolicy *blockAckAgreementPolicy) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:55:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual void processTransmittedDelba(const Ptr& delba) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:56:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual void blockAckAgreementExpired(IProcedureCallback *procedureCallback, IBlockAckAgreementHandlerCallback *agreementHandlerCallback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckAgreementHandler.h:58:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual OriginatorBlockAckAgreement *getAgreement(MacAddress receiverAddr, Tid tid) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API OriginatorBlockAckProcedure : public IOriginatorBlockAckProcedure + 17 | { + 18 | public: + 19 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + 20 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + 21 | }; + 22 | + 23 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 24 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:19:5: warning: function 'buildCompressedBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 19 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:19:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 19 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:20:5: warning: function 'buildBasicBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 20 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/OriginatorBlockAckProcedure.h:20:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 20 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTBLOCKACKAGREEMENT_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTBLOCKACKAGREEMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTBLOCKACKAGREEMENT_H +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:33:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 33 | virtual ~RecipientBlockAckAgreement() { delete blockAckRecord; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:37:5: warning: function 'getBlockAckRecord' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual BlockAckRecord *getBlockAckRecord() const { return blockAckRecord; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:38:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual simtime_t getBlockAckTimeoutValue() const { return blockAckTimeoutValue; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:39:5: warning: function 'getBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual int getBufferSize() const { return bufferSize; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:40:5: warning: function 'getVariant' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | BlockAckVariant getVariant() const { return variant; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:55:5: warning: function 'getHighestReceivedSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | const SequenceNumberCyclic& getHighestReceivedSequence() const { return highestReceivedSequence; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:56:5: warning: function 'getHighestReceivedFragment' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | int getHighestReceivedFragment() const { return highestReceivedFragment; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreement.h:57:5: warning: function 'getStartingSequenceNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual SequenceNumberCyclic getStartingSequenceNumber() const { return startingSequenceNumber; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:40:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual simtime_t computeEarliestExpirationTime() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:41:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | const std::map, RecipientBlockAckAgreement *>& getAgreements() const override { return blockAckAgreements; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:42:5: warning: function 'isTeardownPending' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | bool isTeardownPending(MacAddress peer, Tid tid) const override { return pendingTeardowns.count({peer, tid}) != 0; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:47:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 47 | virtual ~RecipientBlockAckAgreementHandler(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual void processTransmittedAddbaResp(const Ptr& addbaResp, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual void processReceivedAddbaRequest(const Ptr& addbaRequest, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void processReceivedDelba(const Ptr& delba, IRecipientBlockAckAgreementPolicy *blockAckAgreementPolicy) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void qosFrameReceived(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:52:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual void implicitBlockAckRequested(const Ptr& qosHeader, IBlockAckAgreementHandlerCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void processTransmittedDelba(const Ptr& delba) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void blockAckAgreementExpired(IProcedureCallback *procedureCallback, IBlockAckAgreementHandlerCallback *agreementHandlerCallback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckAgreementHandler.h:56:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual RecipientBlockAckAgreement *getAgreement(Tid tid, MacAddress originatorAddr) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void processReceivedBlockAckReq(Packet *blockAckPacket, const Ptr& blockAckReq, IRecipientQosAckPolicy *ackPolicy, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockack/RecipientBlockAckProcedure.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual void processTransmittedBlockAck(const Ptr& blockAck) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:9:9: warning: invalid case style for macro definition '__INET_BLOCKACKREORDERING_H' [readability-identifier-naming] + 9 | #define __INET_BLOCKACKREORDERING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_BLOCKACKREORDERING_H +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:27:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 27 | typedef std::vector Fragments; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fragments = std::vector +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:28:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 28 | typedef std::map ReorderBuffer; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ReorderBuffer = std::map +./inet/linklayer/ieee80211/mac/blockackreordering/BlockAckReordering.h:30:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 30 | typedef std::vector> ReleasedFrames; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ReleasedFrames = std::vector> +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:9:9: warning: invalid case style for macro definition '__INET_RECEIVEBUFFER_H' [readability-identifier-naming] + 9 | #define __INET_RECEIVEBUFFER_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_RECEIVEBUFFER_H +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:21:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 21 | typedef std::vector Fragments; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Fragments = std::vector +./inet/linklayer/ieee80211/mac/blockackreordering/ReceiveBuffer.h:22:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 22 | typedef std::map ReorderBuffer; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ReorderBuffer = std::map +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:9:9: warning: invalid case style for macro definition '__INET_DCAF_H' [readability-identifier-naming] + 9 | #define __INET_DCAF_H + | ^~~~~~~~~~~~~ + | INET_DCAF_H +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:42:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:46:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual void requestChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void releaseChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void channelAccessGranted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:58:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual void expectedChannelAccess(simtime_t time) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:61:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual void incrementCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:62:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual void resetCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Dcaf.h:63:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual int getCw() override { return cw; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:9:9: warning: invalid case style for macro definition '__INET_EDCA_H' [readability-identifier-naming] + 9 | #define __INET_EDCA_H + | ^~~~~~~~~~~~~ + | INET_EDCA_H +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:30:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edca.h:34:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 34 | virtual ~Edca(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:9:9: warning: invalid case style for macro definition '__INET_EDCAF_H' [readability-identifier-naming] + 9 | #define __INET_EDCAF_H + | ^~~~~~~~~~~~~~ + | INET_EDCAF_H +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:26:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 26 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 27 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:65:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:67:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:78:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 78 | virtual ~Edcaf(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:91:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual void requestChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual void releaseChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:95:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 95 | virtual void channelAccessGranted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:96:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 96 | virtual void expectedChannelAccess(simtime_t time) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:99:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual void incrementCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:100:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 100 | virtual void resetCw() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Edcaf.h:101:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 101 | virtual int getCw() override { return cw; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:9:9: warning: invalid case style for macro definition '__INET_HCCA_H' [readability-identifier-naming] + 9 | #define __INET_HCCA_H + | ^~~~~~~~~~~~~ + | INET_HCCA_H +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:23:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:24:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 24 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void requestChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/channelaccess/Hcca.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void releaseChannel(IChannelAccess::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/AccessCategory.h:9:9: warning: invalid case style for macro definition '__INET_ACCESSCATEGORY_H' [readability-identifier-naming] + 9 | #define __INET_ACCESSCATEGORY_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ACCESSCATEGORY_H +./inet/linklayer/ieee80211/mac/common/AccessCategory.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211DEFS_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211DEFS_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_DEFS_H +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:16:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 16 | typedef int8_t FragmentNumber; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using FragmentNumber = int8_t +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:17:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 17 | typedef int8_t Tid; + | ^~~~~~~~~~~~~~~~~~ + | using Tid = int8_t +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:18:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 18 | typedef int16_t SequenceNumber; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using SequenceNumber = int16_t +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:30:5: warning: function 'modulo4096' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | SequenceNumber modulo4096(SequenceNumber value) const { return (value % 4096 + 4096) % 4096; } // always returns positive result + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:31:5: warning: function 'distance4096' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | SequenceNumber distance4096(SequenceNumber other) const { ASSERT(0 <= other && other < 4096); return (value - other + 4096) % 4096; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:38:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | SequenceNumber get() const { ASSERT(value != -1); return value; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:40:5: warning: function 'isSpecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | bool isSpecified() const { return value != -1; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/Ieee80211Defs.h:42:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | std::string str() const { return value == -1 ? std::string("unspecified") : std::to_string(value); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:9:9: warning: invalid case style for macro definition '__INET_MODESETLISTENER_H' [readability-identifier-naming] + 9 | #define __INET_MODESETLISTENER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODESETLISTENER_H +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API ModeSetListener : public SimpleModule, public cListener + 18 | { + 19 | protected: + 20 | physicallayer::Ieee80211ModeSet *modeSet = nullptr; + 21 | + 22 | protected: + 23 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + 24 | virtual void initialize(int stage) override; + 25 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + 26 | }; + 27 | + 28 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 29 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:23:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:24:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 24 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/ModeSetListener.h:25:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:9:9: warning: invalid case style for macro definition '__INET_SEQUENCECONTROLFIELD_H' [readability-identifier-naming] + 9 | #define __INET_SEQUENCECONTROLFIELD_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_SEQUENCECONTROLFIELD_H +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:26: warning: 2 adjacent parameters of 'SequenceControlField' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:41: note: the first parameter in the range is 'sequenceNumber' + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:72: note: the last parameter in the range is 'fragmentNumber' + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:26: note: + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:28:57: note: 'SequenceNumber' and 'FragmentNumber' may be implicitly converted: 'SequenceNumber' (as 'short') -> 'FragmentNumber' (as 'signed char'), 'FragmentNumber' (as 'signed char') -> 'SequenceNumber' (as 'short') + 28 | SequenceControlField(SequenceNumber sequenceNumber, FragmentNumber fragmentNumber) : + | ^ +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:35:5: warning: function 'getSequenceNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | SequenceNumber getSequenceNumber() const { return sequenceNumber; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/SequenceControlField.h:36:5: warning: function 'getFragmentNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | FragmentNumber getFragmentNumber() const { return fragmentNumber; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:9:9: warning: invalid case style for macro definition '__INET_STATIONRETRYCOUNTERS_H' [readability-identifier-naming] + 9 | #define __INET_STATIONRETRYCOUNTERS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_STATIONRETRYCOUNTERS_H +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:23:5: warning: function 'getStationLongRetryCount' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | int getStationLongRetryCount() const { return stationLongRetryCount; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/common/StationRetryCounters.h:24:5: warning: function 'getStationShortRetryCount' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | int getStationShortRetryCount() const { return stationShortRetryCount; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/AmpduReception.h:4:9: warning: invalid case style for macro definition '__INET_AMPDURECEPTION_H' [readability-identifier-naming] + 4 | #define __INET_AMPDURECEPTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_AMPDURECEPTION_H +./inet/linklayer/ieee80211/mac/contract/AmpduReception.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h:4:9: warning: invalid case style for macro definition '__INET_BLOCKACKVARIANT_H' [readability-identifier-naming] + 4 | #define __INET_BLOCKACKVARIANT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_BLOCKACKVARIANT_H +./inet/linklayer/ieee80211/mac/contract/BlockAckVariant.h:6:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 6 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 7 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 8 | + 9 | enum class BlockAckVariant { BASIC, COMPRESSED }; + 10 | + 11 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 12 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_FRAMETRANSMISSIONDETAILS_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_FRAMETRANSMISSIONDETAILS_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_FRAMETRANSMISSIONDETAILS_M_H +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 33 | + 34 | class FrameTransmissionDetails; + 35 | + 36 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:42:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 42 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 43 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:90:10: warning: deleted member function should be public [modernize-use-equals-delete] + 90 | bool operator==(const FrameTransmissionDetails&) = delete; + | ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:95:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 95 | virtual ~FrameTransmissionDetails(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:97:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual FrameTransmissionDetails *dup() const override {return new FrameTransmissionDetails(*this);} + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:97:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 97 | virtual FrameTransmissionDetails *dup() const override {return new FrameTransmissionDetails(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:98:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 98 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:99:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/FrameTransmissionDetails_m.h:101:5: warning: function 'getStatus' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | virtual FrameTransmissionStatus getStatus() const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IAckHandler.h:9:9: warning: invalid case style for macro definition '__INET_IACKHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IACKHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IACKHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IAckHandler.h:11:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 11 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 12 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IAckHandler.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~IAckHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h:9:9: warning: invalid case style for macro definition '__INET_IBLOCKACKAGREEMENTHANDLERCALLBACK_H' [readability-identifier-naming] + 9 | #define __INET_IBLOCKACKAGREEMENTHANDLERCALLBACK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IBLOCKACKAGREEMENTHANDLERCALLBACK_H +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API IBlockAckAgreementHandlerCallback + 17 | { + 18 | public: + 19 | virtual ~IBlockAckAgreementHandlerCallback() {} + 20 | + 21 | // The coordinator recomputes the earliest absolute deadline across both agreement roles. + 22 | virtual void scheduleInactivityTimer() = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementHandlerCallback.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~IBlockAckAgreementHandlerCallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h:4:9: warning: invalid case style for macro definition '__INET_IBLOCKACKAGREEMENTLIFECYCLE_H' [readability-identifier-naming] + 4 | #define __INET_IBLOCKACKAGREEMENTLIFECYCLE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IBLOCKACKAGREEMENTLIFECYCLE_H +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h:8:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 8 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 9 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 10 | + 11 | // Management supplies the old peer identity before association replacement or loss. + 12 | class INET_API IBlockAckAgreementLifecycle + 13 | { + 14 | public: + 15 | virtual ~IBlockAckAgreementLifecycle() {} + 16 | virtual void resetPeerAgreements(const MacAddress& peer) = 0; + 17 | }; + 18 | + 19 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 20 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IBlockAckAgreementLifecycle.h:15:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 15 | virtual ~IBlockAckAgreementLifecycle() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:9:9: warning: invalid case style for macro definition '__INET_ICHANNELACCESS_H' [readability-identifier-naming] + 9 | #define __INET_ICHANNELACCESS_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_ICHANNELACCESS_H +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:24:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 24 | virtual ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IChannelAccess.h:30:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 30 | virtual ~IChannelAccess() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IContention.h:9:9: warning: invalid case style for macro definition '__INET_ICONTENTION_H' [readability-identifier-naming] + 9 | #define __INET_ICONTENTION_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_ICONTENTION_H +./inet/linklayer/ieee80211/mac/contract/IContention.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IContention.h:40:9: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 40 | ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IContention.h:46:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 46 | virtual ~IContention() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h:9:9: warning: invalid case style for macro definition '__INET_ICOORDINATIONFUNCTION_H' [readability-identifier-naming] + 9 | #define __INET_ICOORDINATIONFUNCTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ICOORDINATIONFUNCTION_H +./inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/ICoordinationFunction.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~ICoordinationFunction() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:9:9: warning: invalid case style for macro definition '__INET_ICTSPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_ICTSPOLICY_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ICTSPOLICY_H +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API ICtsPolicy + 18 | { + 19 | public: + 20 | virtual ~ICtsPolicy() {} + 21 | + 22 | virtual bool isCtsNeeded(const Ptr& rtsFrame) const = 0; + 23 | virtual simtime_t computeCtsDurationField(Packet *packet, const Ptr& rtsFrame) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~ICtsPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ICtsPolicy.h:22:5: warning: function 'isCtsNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isCtsNeeded(const Ptr& rtsFrame) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/ICtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_ICTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_ICTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_ICTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/ICtsProcedure.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 18 | + 19 | class INET_API ICtsProcedure + 20 | { + 21 | public: + 22 | virtual ~ICtsProcedure() {} + 23 | + 24 | virtual void processReceivedRts(Packet *rtsPacket, const Ptr& rtsFrame, ICtsPolicy *ctsPolicy, IProcedureCallback *callback) = 0; + 25 | virtual void processTransmittedCts(const Ptr& ctsFrame) = 0; + 26 | }; + 27 | + 28 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 29 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ICtsProcedure.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~ICtsProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IDs.h:9:9: warning: invalid case style for macro definition '__INET_IDS_H' [readability-identifier-naming] + 9 | #define __INET_IDS_H + | ^~~~~~~~~~~~ + | INET_IDS_H +./inet/linklayer/ieee80211/mac/contract/IDs.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | /** + 18 | * Abstract interface for distribution service. + 19 | */ + 20 | class INET_API IDs + 21 | { + 22 | public: + 23 | virtual ~IDs() {} + 24 | + 25 | virtual void processDataFrame(Packet *packet, const Ptr& header) = 0; + 26 | }; + 27 | + 28 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 29 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IDs.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IDs() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IEdcaCollisionController.h:9:9: warning: invalid case style for macro definition '__INET_IEDCACOLLISIONCONTROLLER_H' [readability-identifier-naming] + 9 | #define __INET_IEDCACOLLISIONCONTROLLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEDCACOLLISIONCONTROLLER_H +./inet/linklayer/ieee80211/mac/contract/IEdcaCollisionController.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class Edcaf; + 17 | + 18 | class INET_API IEdcaCollisionController + 19 | { + 20 | public: + 21 | virtual ~IEdcaCollisionController() {} + 22 | + 23 | virtual void expectedChannelAccess(Edcaf *channelAccess, simtime_t time) = 0; + 24 | virtual bool isInternalCollision(Edcaf *channelAccess) = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IEdcaCollisionController.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IEdcaCollisionController() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFragmentation.h:9:9: warning: invalid case style for macro definition '__INET_IFRAGMENTATION_H' [readability-identifier-naming] + 9 | #define __INET_IFRAGMENTATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAGMENTATION_H +./inet/linklayer/ieee80211/mac/contract/IFragmentation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class Ieee80211DataOrMgmtHeader; + 17 | + 18 | class INET_API IFragmentation + 19 | { + 20 | public: + 21 | virtual ~IFragmentation() {} + 22 | + 23 | virtual std::vector *fragmentFrame(Packet *frame, const std::vector& fragmentSizes) = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IFragmentation.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IFragmentation() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IFRAGMENTATIONPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IFRAGMENTATIONPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAGMENTATIONPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IFragmentationPolicy.h:29:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 29 | virtual ~IFragmentationPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:9:9: warning: invalid case style for macro definition '__INET_IFRAMESEQUENCE_H' [readability-identifier-naming] + 9 | #define __INET_IFRAMESEQUENCE_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAMESEQUENCE_H +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:34:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 34 | virtual ~IFrameSequenceStep() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual Type getType() override { return Type::TRANSMIT; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:53:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 53 | virtual Type getType() override { return Type::RECEIVE; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:63:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 63 | virtual ~IFrameSequence() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequence.h:69:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual std::string getHistory() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:9:9: warning: invalid case style for macro definition '__INET_IFRAMESEQUENCEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IFRAMESEQUENCEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IFRAMESEQUENCEHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:27:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 27 | virtual ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:42:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 42 | virtual ~IFrameSequenceHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:44:5: warning: function 'getContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const FrameSequenceContext *getContext() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IFrameSequenceHandler.h:45:5: warning: function 'getFrameSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual const IFrameSequence *getFrameSequence() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h:9:9: warning: invalid case style for macro definition '__INET_IMPDUAGGREGATION_H' [readability-identifier-naming] + 9 | #define __INET_IMPDUAGGREGATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMPDUAGGREGATION_H +./inet/linklayer/ieee80211/mac/contract/IMpduAggregation.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IMpduAggregation() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IMPDUAGGREGATIONPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IMPDUAGGREGATIONPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMPDUAGGREGATIONPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:33:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 33 | virtual ~IMpduAggregationPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:36:5: warning: function 'isEnabled' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual bool isEnabled() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IMpduAggregationPolicy.h:38:5: warning: function 'selectFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual std::vector selectFrames(const std::vector& candidates, const MpduAggregationLimits& limits) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IMsduAggregation.h:9:9: warning: invalid case style for macro definition '__INET_IMSDUAGGREGATION_H' [readability-identifier-naming] + 9 | #define __INET_IMSDUAGGREGATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMSDUAGGREGATION_H +./inet/linklayer/ieee80211/mac/contract/IMsduAggregation.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IMsduAggregation + 18 | { + 19 | public: + 20 | virtual ~IMsduAggregation() {} + 21 | + 22 | virtual Packet *aggregateFrames(std::vector *frames) = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IMsduAggregation.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IMsduAggregation() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IMsduAggregationPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IMSDUAGGREGATIONPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IMSDUAGGREGATIONPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMSDUAGGREGATIONPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IMsduAggregationPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IMsduAggregationPolicy + 18 | { + 19 | public: + 20 | virtual ~IMsduAggregationPolicy() {} + 21 | + 22 | virtual std::vector *computeAggregateFrames(queueing::IPacketQueue *queue) = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IMsduAggregationPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IMsduAggregationPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IOriginatorAckPolicy + 18 | { + 19 | public: + 20 | virtual ~IOriginatorAckPolicy() {} + 21 | + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + 23 | virtual simtime_t getAckTimeout(Packet *packet, const Ptr& header) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IOriginatorAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorAckPolicy.h:22:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:25:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 25 | typedef std::pair AgreementId; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using AgreementId = std::pair +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:32:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 32 | virtual ~IOriginatorBlockAckAgreementHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:33:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const std::map& getAgreements() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementHandler.h:34:5: warning: function 'getProcedures' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual const std::map& getProcedures() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORBLOCKACKAGREEMENTPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORBLOCKACKAGREEMENTPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORBLOCKACKAGREEMENTPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IOriginatorBlockAckAgreementPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:25:5: warning: function 'isProfileAllowed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:31:5: warning: function 'isMsduSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual bool isMsduSupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:32:5: warning: function 'computeAddbaFailureTimeout' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual simtime_t computeAddbaFailureTimeout() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:33:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual simtime_t getBlockAckTimeoutValue() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:34:5: warning: function 'isDelayedAckPolicySupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual bool isDelayedAckPolicySupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckAgreementPolicy.h:35:5: warning: function 'getMaximumAllowedBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual int getMaximumAllowedBufferSize() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IOriginatorBlockAckProcedure + 18 | { + 19 | public: + 20 | virtual ~IOriginatorBlockAckProcedure() {} + 21 | + 22 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + 23 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IOriginatorBlockAckProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:22:5: warning: function 'buildCompressedBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual const Ptr buildCompressedBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorBlockAckProcedure.h:23:5: warning: function 'buildBasicBlockAckReqFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual const Ptr buildBasicBlockAckReqFrame(const MacAddress& receiverAddress, Tid tid, SequenceNumberCyclic startingSequenceNumber) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API IOriginatorMacDataService + 17 | { + 18 | public: + 19 | static simsignal_t packetFragmentedSignal; + 20 | static simsignal_t packetAggregatedSignal; + 21 | + 22 | public: + 23 | virtual ~IOriginatorMacDataService() {} + 24 | + 25 | virtual std::vector *extractFramesToTransmit(queueing::IPacketQueue *pendingQueue) = 0; + 26 | }; + 27 | + 28 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorMacDataService.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IOriginatorMacDataService() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IORIGINATORQOSACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IORIGINATORQOSACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORQOSACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IOriginatorQoSAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IOriginatorQoSAckPolicy.h:27:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:8:9: warning: invalid case style for macro definition '__INET_IORIGINATORQOSMACDATASERVICE_H' [readability-identifier-naming] + 8 | #define __INET_IORIGINATORQOSMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IORIGINATORQOSMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:58:5: warning: function 'getNextSequenceNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:59:5: warning: function 'hasAMsduAggregation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual bool hasAMsduAggregation() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:60:5: warning: function 'hasAMpduAggregation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual bool hasAMpduAggregation() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:63:5: warning: function 'isBatchValid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual bool isBatchValid(const PreparedQosBatch& batch, simtime_t start) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:66:5: warning: function 'buildAggregate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual Packet *buildAggregate(const PreparedQosBatch& batch, const MpduAggregationLimits& limits) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IOriginatorQosMacDataService.h:69:5: warning: function 'isPreparationValid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IProcedureCallback.h:9:9: warning: invalid case style for macro definition '__INET_IPROCEDURECALLBACK_H' [readability-identifier-naming] + 9 | #define __INET_IPROCEDURECALLBACK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPROCEDURECALLBACK_H +./inet/linklayer/ieee80211/mac/contract/IProcedureCallback.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IProcedureCallback + 18 | { + 19 | public: + 20 | virtual ~IProcedureCallback() {} + 21 | + 22 | virtual void transmitControlResponseFrame(Packet *responsePacket, const Ptr& responseHeader, Packet *receivedPacket, const Ptr& receivedHeader) = 0; + 23 | virtual void processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IProcedureCallback.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IProcedureCallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h:9:9: warning: invalid case style for macro definition '__INET_IQOSRATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_IQOSRATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IQOSRATESELECTION_H +./inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IQosRateSelection.h:28:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 28 | virtual ~IQosRateSelection() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRateControl.h:9:9: warning: invalid case style for macro definition '__INET_IRATECONTROL_H' [readability-identifier-naming] + 9 | #define __INET_IRATECONTROL_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IRATECONTROL_H +./inet/linklayer/ieee80211/mac/contract/IRateControl.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRateControl.h:27:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 27 | virtual ~IRateControl() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRateSelection.h:9:9: warning: invalid case style for macro definition '__INET_IRATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_IRATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRATESELECTION_H +./inet/linklayer/ieee80211/mac/contract/IRateSelection.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRateSelection.h:31:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 31 | virtual ~IRateSelection() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IRecipientAckPolicy + 18 | { + 19 | public: + 20 | virtual ~IRecipientAckPolicy() {} + 21 | + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + 23 | virtual simtime_t computeAckDurationField(Packet *packet, const Ptr& header) const = 0; + 24 | }; + 25 | + 26 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IRecipientAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientAckPolicy.h:22:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientAckProcedure.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 17 | + 18 | class INET_API IRecipientAckProcedure + 19 | { + 20 | public: + 21 | virtual ~IRecipientAckProcedure() {} + 22 | + 23 | virtual void processReceivedFrame(Packet *packet, const Ptr& dataOrMgmtHeader, IRecipientAckPolicy *ackPolicy, IProcedureCallback *callback) = 0; + 24 | virtual void processTransmittedAck(const Ptr& ack) = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRecipientAckProcedure.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IRecipientAckProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTBLOCKACKAGREEMENTHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTBLOCKACKAGREEMENTHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTBLOCKACKAGREEMENTHANDLER_H +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:25:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 25 | virtual ~IRecipientBlockAckAgreementHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:27:5: warning: function 'getAgreements' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual const std::map, RecipientBlockAckAgreement *>& getAgreements() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementHandler.h:30:5: warning: function 'isTeardownPending' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual bool isTeardownPending(MacAddress peer, Tid tid) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTBLOCKACKAGREEMENTPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTBLOCKACKAGREEMENTPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTBLOCKACKAGREEMENTPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IRecipientBlockAckAgreementPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:22:5: warning: function 'isProfileAllowed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool isProfileAllowed(BlockAckVariant variant, bool localHt, bool peerHt) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:27:5: warning: function 'getBlockAckTimeoutValue' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual simtime_t getBlockAckTimeoutValue() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:28:5: warning: function 'aMsduSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual bool aMsduSupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:29:5: warning: function 'delayedBlockAckPolicySupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual bool delayedBlockAckPolicySupported() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckAgreementPolicy.h:30:5: warning: function 'getMaximumAllowedBufferSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual int getMaximumAllowedBufferSize() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h:14:9: warning: invalid case style for macro definition '__INET_IRECIPIENTBLOCKACKPROCEDURE_H' [readability-identifier-naming] + 14 | #define __INET_IRECIPIENTBLOCKACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTBLOCKACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 18 | + 19 | class INET_API IRecipientBlockAckProcedure + 20 | { + 21 | public: + 22 | virtual ~IRecipientBlockAckProcedure() {} + 23 | + 24 | virtual void processReceivedBlockAckReq(Packet *packet, const Ptr& blockAckReq, IRecipientQosAckPolicy *ackPolicy, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler, IProcedureCallback *callback) = 0; + 25 | virtual void processTransmittedBlockAck(const Ptr& blockAck) = 0; + 26 | virtual Ptr buildCompressedBlockAck(MacAddress peer, Tid tid, RecipientBlockAckAgreement *agreement) = 0; + 27 | }; + 28 | + 29 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 30 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRecipientBlockAckProcedure.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~IRecipientBlockAckProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientMacDataService.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientMacDataService.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IRecipientMacDataService() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTQOSACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTQOSACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTQOSACKPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~IRecipientQosAckPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecipientQosAckPolicy.h:24:5: warning: function 'isAckNeeded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual bool isAckNeeded(const Ptr& header) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_IRECIPIENTQOSMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_IRECIPIENTQOSMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECIPIENTQOSMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecipientQosMacDataService.h:26:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 26 | virtual ~IRecipientQosMacDataService() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IRECOVERYPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IRECOVERYPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECOVERYPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:25:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 25 | virtual ~ICwCalculator() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRecoveryProcedure.h:33:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 33 | virtual ~IRecoveryProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:9:9: warning: invalid case style for macro definition '__INET_IRTSPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_IRTSPOLICY_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_IRTSPOLICY_H +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API IRtsPolicy + 18 | { + 19 | public: + 20 | virtual ~IRtsPolicy() {} + 21 | + 22 | virtual bool isRtsNeeded(Packet *packet, const Ptr& protectedHeader) const = 0; + 23 | virtual simtime_t getCtsTimeout(Packet *packet, const Ptr& rtsFrame) const = 0; + 24 | virtual int getRtsThreshold() const = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~IRtsPolicy() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRtsPolicy.h:24:5: warning: function 'getRtsThreshold' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual int getRtsThreshold() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_IRTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_IRTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IRTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API IRtsProcedure + 17 | { + 18 | public: + 19 | virtual ~IRtsProcedure() {} + 20 | + 21 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const = 0; + 22 | virtual void processTransmittedRts(const Ptr& rtsFrame) = 0; + 23 | }; + 24 | + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 26 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~IRtsProcedure() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRtsProcedure.h:21:5: warning: function 'buildRtsFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRx.h:9:9: warning: invalid case style for macro definition '__INET_IRX_H' [readability-identifier-naming] + 9 | #define __INET_IRX_H + | ^~~~~~~~~~~~ + | INET_IRX_H +./inet/linklayer/ieee80211/mac/contract/IRx.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/IRx.h:33:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 33 | virtual ~IRx() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/IRx.h:35:5: warning: function 'isReceptionInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual bool isReceptionInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRx.h:38:5: warning: function 'isMediumFree' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual bool isMediumFree() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/IRx.h:41:5: warning: function 'getTxnavRemaining' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual simtime_t getTxnavRemaining() const = 0; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/contract/ISequenceNumberAssignment.h:9:9: warning: invalid case style for macro definition '__INET_ISEQUENCENUMBERASSIGNMENT_H' [readability-identifier-naming] + 9 | #define __INET_ISEQUENCENUMBERASSIGNMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISEQUENCENUMBERASSIGNMENT_H +./inet/linklayer/ieee80211/mac/contract/ISequenceNumberAssignment.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API ISequenceNumberAssignment + 17 | { + 18 | public: + 19 | virtual ~ISequenceNumberAssignment() {} + 20 | + 21 | virtual void assignSequenceNumber(const Ptr& header) = 0; + 22 | }; + 23 | + 24 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ISequenceNumberAssignment.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~ISequenceNumberAssignment() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ITransmitLifetimeHandler.h:9:9: warning: invalid case style for macro definition '__INET_ITRANSMITLIFETIMEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_ITRANSMITLIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ITRANSMITLIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/contract/ITransmitLifetimeHandler.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API ITransmitLifetimeHandler + 17 | { + 18 | public: + 19 | virtual ~ITransmitLifetimeHandler() {} + 20 | + 21 | virtual void frameGotInProgess(const Ptr& header) = 0; + 22 | virtual void frameTransmitted(const Ptr& header) = 0; + 23 | + 24 | virtual bool isLifetimeExpired(const Ptr& header) = 0; + 25 | }; + 26 | + 27 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/contract/ITransmitLifetimeHandler.h:19:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 19 | virtual ~ITransmitLifetimeHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ITx.h:9:9: warning: invalid case style for macro definition '__INET_ITX_H' [readability-identifier-naming] + 9 | #define __INET_ITX_H + | ^~~~~~~~~~~~ + | INET_ITX_H +./inet/linklayer/ieee80211/mac/contract/ITx.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/contract/ITx.h:26:17: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 26 | virtual ~ICallback() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/contract/ITx.h:40:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 40 | virtual ~ITx() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:9:9: warning: invalid case style for macro definition '__INET_DCF_H' [readability-identifier-naming] + 9 | #define __INET_DCF_H + | ^~~~~~~~~~~~ + | INET_DCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:32:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 32 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 33 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:86:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:87:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:89:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual void handleMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:90:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual void channelGranted(IChannelAccess *channelAccess) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:106:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual bool transmitFrame(Packet *packet, simtime_t ifs) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:107:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual void frameSequenceStarted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:108:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual void originatorProcessRtsProtectionFailed(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:109:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual void originatorProcessTransmittedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:110:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual void originatorProcessReceivedFrame(Packet *packet, Packet *lastTransmittedPacket) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:111:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 111 | virtual void originatorProcessFailedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:112:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 112 | virtual void frameSequenceFinished() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:113:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 113 | virtual void scheduleStartRxTimer(simtime_t timeout) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:116:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 116 | virtual void frameTransmissionStarted(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:117:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 117 | virtual void transmissionComplete(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:120:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 120 | virtual void transmitControlResponseFrame(Packet *responsePacket, const Ptr& responseHeader, Packet *receivedPacket, const Ptr& receivedHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:121:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 121 | virtual void processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:127:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 127 | virtual ~Dcf(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:130:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 130 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:131:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 131 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Dcf.h:132:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 132 | virtual void corruptedFrameReceived() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:9:9: warning: invalid case style for macro definition '__INET_HCF_H' [readability-identifier-naming] + 9 | #define __INET_HCF_H + | ^~~~~~~~~~~~ + | INET_HCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:46:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 46 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 47 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:169:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:170:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:171:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 171 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:172:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 172 | virtual void handleMessage(cMessage *msg) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:173:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 173 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:174:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 174 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, bool value, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:175:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 175 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, intval_t value, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:176:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 176 | virtual void refreshDisplay() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:261:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 261 | virtual void originatorProcessRtsProtectionFailed(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:262:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 262 | virtual void originatorProcessTransmittedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:263:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 263 | virtual void originatorProcessReceivedFrame(Packet *packet, Packet *lastTransmittedPacket) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:264:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 264 | virtual void originatorProcessFailedFrame(Packet *packet) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:265:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 265 | virtual void frameSequenceStarted() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:266:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 266 | virtual void frameSequenceFinished() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:267:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 267 | virtual bool transmitFrame(Packet *packet, simtime_t ifs) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:268:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 268 | virtual void scheduleStartRxTimer(simtime_t timeout) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:271:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 271 | virtual void channelGranted(IChannelAccess *channelAccess) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:274:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 274 | virtual void transmissionComplete(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:277:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 277 | virtual void transmitControlResponseFrame(Packet *responsePacket, const Ptr& responseHeader, Packet *receivedPacket, const Ptr& receivedHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 278 | virtual void processMgmtFrame(Packet *mgmtPacket, const Ptr& mgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:281:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 281 | virtual void scheduleInactivityTimer() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:286:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 286 | virtual ~Hcf(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:290:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 290 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:291:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 291 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.h:293:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 293 | virtual void corruptedFrameReceived() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:9:9: warning: invalid case style for macro definition '__INET_MCF_H' [readability-identifier-naming] + 9 | #define __INET_MCF_H + | ^~~~~~~~~~~~ + | INET_MCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:25:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:28:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 28 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Mcf.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void corruptedFrameReceived() override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:9:9: warning: invalid case style for macro definition '__INET_PCF_H' [readability-identifier-naming] + 9 | #define __INET_PCF_H + | ^~~~~~~~~~~~ + | INET_PCF_H +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:28:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 28 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual void processUpperFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:32:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual void processLowerFrame(Packet *packet, const Ptr& header) override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/coordinationfunction/Pcf.h:33:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual void corruptedFrameReceived() override { throw cRuntimeError("Unimplemented!"); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h:9:9: warning: invalid case style for macro definition '__INET_BASICFRAGMENTATIONPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_BASICFRAGMENTATIONPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_BASICFRAGMENTATIONPOLICY_H +./inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h:24:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 24 | virtual void initialize() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h:27:30: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual std::vector computeFragmentSizes(Packet *frame) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.h:28:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 28 | virtual FragmentPartition computeBoundedFragmentSizes(Packet *frame, int maxMpduBytes) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/fragmentation/Fragmentation.h:9:9: warning: invalid case style for macro definition '__INET_FRAGMENTATION_H' [readability-identifier-naming] + 9 | #define __INET_FRAGMENTATION_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_FRAGMENTATION_H +./inet/linklayer/ieee80211/mac/fragmentation/Fragmentation.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 16 | + 17 | class INET_API Fragmentation : public IFragmentation, public cObject + 18 | { + 19 | public: + 20 | virtual std::vector *fragmentFrame(Packet *frame, const std::vector& fragmentSizes) override; + 21 | }; + 22 | + 23 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 24 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/fragmentation/Fragmentation.h:20:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 20 | virtual std::vector *fragmentFrame(Packet *frame, const std::vector& fragmentSizes) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:9:9: warning: invalid case style for macro definition '__INET_FRAMESEQUENCECONTEXT_H' [readability-identifier-naming] + 9 | #define __INET_FRAMESEQUENCECONTEXT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_FRAMESEQUENCECONTEXT_H +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:29:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 29 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 30 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:108:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 108 | virtual ~FrameSequenceContext(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:110:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 110 | virtual simtime_t getDuration() const { return simTime() - startTime; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:114:5: warning: function 'getNumSteps' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | virtual int getNumSteps() const { return steps.size(); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:115:5: warning: function 'getStep' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | virtual IFrameSequenceStep *getStep(int i) const { return steps[i]; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:116:5: warning: function 'getLastStep' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | virtual IFrameSequenceStep *getLastStep() const { return steps.size() > 0 ? steps.back() : nullptr; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:117:5: warning: function 'getStepBeforeLast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 117 | virtual IFrameSequenceStep *getStepBeforeLast() const { return steps.size() > 1 ? steps[steps.size() - 2] : nullptr; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:119:5: warning: function 'getInProgressFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 119 | virtual InProgressFrames *getInProgressFrames() const { return inProgressFrames; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:121:5: warning: function 'getDataFrameToTransmit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | Packet *getDataFrameToTransmit() const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:122:5: warning: function 'getRtsProcedure' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | virtual IRtsProcedure *getRtsProcedure() const { return rtsProcedure; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:123:5: warning: function 'getRtsPolicy' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | virtual IRtsPolicy *getRtsPolicy() const { return rtsPolicy; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:125:5: warning: function 'getNonQoSContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 125 | virtual NonQoSContext *getNonQoSContext() const { return nonQoSContext; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:126:5: warning: function 'getQoSContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 126 | virtual QoSContext *getQoSContext() const { return qosContext; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:130:5: warning: function 'getIfs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 130 | virtual simtime_t getIfs() const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:132:5: warning: function 'isForUs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 132 | virtual bool isForUs(const Ptr& header) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:133:5: warning: function 'isSentByUs' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual bool isSentByUs(const Ptr& header) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:139:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 139 | virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceContext.h:146:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 146 | virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:9:9: warning: invalid case style for macro definition '__INET_FRAMESEQUENCEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_FRAMESEQUENCEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_FRAMESEQUENCEHANDLER_H +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:33:5: warning: function 'getContext' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const FrameSequenceContext *getContext() const override { return context; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:33:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual const FrameSequenceContext *getContext() const override { return context; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:34:5: warning: function 'getFrameSequence' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual const IFrameSequence *getFrameSequence() const override { return frameSequence; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:34:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual const IFrameSequence *getFrameSequence() const override { return frameSequence; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void startFrameSequence(IFrameSequence *frameSequence, FrameSequenceContext *context, IFrameSequenceHandler::ICallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:36:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual void processResponse(Packet *frame) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void transmissionComplete() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:38:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual void handleStartRxTimeout() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void interruptFrameSequence() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual bool isSequenceRunning() override { return frameSequence != nullptr; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceHandler.h:42:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 42 | virtual ~FrameSequenceHandler(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:9:9: warning: invalid case style for macro definition '__INET_FRAMESEQUENCESTEP_H' [readability-identifier-naming] + 9 | #define __INET_FRAMESEQUENCESTEP_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_FRAMESEQUENCESTEP_H +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:36:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 36 | virtual ~TransmitStep() { if (owner) delete frameToTransmit; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:38:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual Completion getCompletion() override { return completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual void setCompletion(Completion completion) override { this->completion = completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:40:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual Packet *getFrameToTransmit() override { return frameToTransmit; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:41:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual simtime_t getIfs() override { return ifs; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:42:5: warning: function 'getPpduEnd' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | simtime_t getPpduEnd() const { return ppduEnd; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:52:21: warning: 2 adjacent parameters of 'RtsTransmitStep' of similar type ('Packet *') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 52 | RtsTransmitStep(Packet *protectedFrame, Packet *frame, simtime_t ifs) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:52:29: note: the first parameter in the range is 'protectedFrame' + 52 | RtsTransmitStep(Packet *protectedFrame, Packet *frame, simtime_t ifs) : + | ^~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:52:53: note: the last parameter in the range is 'frame' + 52 | RtsTransmitStep(Packet *protectedFrame, Packet *frame, simtime_t ifs) : + | ^~~~~ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:66:5: warning: function 'getPreparedData' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | const PreparedDataTransmission *getPreparedData() const { return prepared.get(); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:80:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 80 | virtual ~ReceiveStep() { delete receivedFrame; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:82:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual Completion getCompletion() override { return completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:83:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual void setCompletion(Completion completion) override { this->completion = completion; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:84:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual simtime_t getTimeout() override { return timeout; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:85:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual Packet *getReceivedFrame() override { return receivedFrame; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/FrameSequenceStep.h:86:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual void setFrameToReceive(Packet *frame) override { this->receivedFrame = frame; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:9:9: warning: invalid case style for macro definition '__INET_GENERICFRAMESEQUENCES_H' [readability-identifier-naming] + 9 | #define __INET_GENERICFRAMESEQUENCES_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_GENERICFRAMESEQUENCES_H +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:34:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 34 | virtual ~SequentialFs(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:37:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:38:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:41:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:41:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:54:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 54 | virtual ~OptionalFs() { delete element; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:61:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:62:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:64:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:64:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:79:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 79 | virtual ~RepeatingFs() { delete element; } + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:85:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:87:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:88:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:90:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:90:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:103:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 103 | virtual ~AlternativesFs(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:109:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:110:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:111:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 111 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:113:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 113 | virtual std::string getHistory() const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/GenericFrameSequences.h:113:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 113 | virtual std::string getHistory() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:8:9: warning: invalid case style for macro definition '__INET_HCFFS_H' [readability-identifier-naming] + 8 | #define __INET_HCFFS_H + | ^~~~~~~~~~~~~~ + | INET_HCFFS_H +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 12 | + 13 | class INET_API HcfFs : public AlternativesFs + 14 | { + 15 | public: + 16 | HcfFs(); + 17 | virtual ~HcfFs() {} + 18 | + 19 | virtual int selectHcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 20 | virtual int selectDataOrManagementSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 21 | virtual bool isSelfCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *context); + 22 | virtual bool hasMoreTxOps(RepeatingFs *frameSequence, FrameSequenceContext *context); + 23 | virtual bool hasMoreTxOpsAndMulticast(RepeatingFs *frameSequence, FrameSequenceContext *context); + 24 | }; + 25 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:17:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 17 | virtual ~HcfFs() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/framesequence/HcfFs.h:17:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 17 | virtual ~HcfFs() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/framesequence/McfFs.h:9:9: warning: invalid case style for macro definition '__INET_MCFFS_H' [readability-identifier-naming] + 9 | #define __INET_MCFFS_H + | ^~~~~~~~~~~~~~ + | INET_MCFFS_H +./inet/linklayer/ieee80211/mac/framesequence/McfFs.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API McfFs : public AlternativesFs + 17 | { + 18 | public: + 19 | McfFs(); + 20 | + 21 | virtual int selectMcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 22 | }; + 23 | + 24 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/framesequence/PcfFs.h:9:9: warning: invalid case style for macro definition '__INET_PCFFS_H' [readability-identifier-naming] + 9 | #define __INET_PCFFS_H + | ^~~~~~~~~~~~~~ + | INET_PCFFS_H +./inet/linklayer/ieee80211/mac/framesequence/PcfFs.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API PcfFs : public AlternativesFs + 17 | { + 18 | public: + 19 | PcfFs(); + 20 | + 21 | virtual int selectPcfSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 22 | }; + 23 | + 24 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:9:9: warning: invalid case style for macro definition '__INET_PRIMITIVEFRAMESEQUENCES_H' [readability-identifier-naming] + 9 | #define __INET_PRIMITIVEFRAMESEQUENCES_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PRIMITIVEFRAMESEQUENCES_H +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:25:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:26:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:27:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:29:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual std::string getHistory() const override { return "CTS + self"; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:29:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual std::string getHistory() const override { return "CTS + self"; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:41:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:44:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual std::string getHistory() const override { return "DATA"; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:44:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual std::string getHistory() const override { return "DATA"; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:54:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:55:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 55 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:56:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:58:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual std::string getHistory() const override { return "MANAGEMENT"; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:58:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual std::string getHistory() const override { return "MANAGEMENT"; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:68:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:69:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:72:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | virtual std::string getHistory() const override { return "MANAGEMENT"; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:72:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual std::string getHistory() const override { return "MANAGEMENT"; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:82:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:83:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:84:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:86:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 86 | virtual std::string getHistory() const override { return "ACK"; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:86:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual std::string getHistory() const override { return "ACK"; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:96:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 96 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:97:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 97 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:98:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 98 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:100:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | virtual std::string getHistory() const override { return std::string("RTS") + (step == 2 ? " CTS" : ""); } // TODO completeStep = true? + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:100:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 100 | virtual std::string getHistory() const override { return std::string("RTS") + (step == 2 ? " CTS" : ""); } // TODO completeStep = true? + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:110:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 110 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:111:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 111 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:112:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 112 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:114:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | virtual std::string getHistory() const override { return "RTS"; } // TODO completeStep = true? + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:114:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 114 | virtual std::string getHistory() const override { return "RTS"; } // TODO completeStep = true? + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:124:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 124 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:125:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 125 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:126:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 126 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:128:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 128 | virtual std::string getHistory() const override { return "CTS"; } // TODO completeStep = true? + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:128:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 128 | virtual std::string getHistory() const override { return "CTS"; } // TODO completeStep = true? + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:138:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 138 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:139:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 139 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:140:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 140 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:142:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 142 | virtual std::string getHistory() const override { return std::string("FRAG-FRAME") + (step == 2 ? " ACK" : ""); } // TODO completeStep = true? + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:142:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 142 | virtual std::string getHistory() const override { return std::string("FRAG-FRAME") + (step == 2 ? " ACK" : ""); } // TODO completeStep = true? + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:152:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 152 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:153:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 153 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:154:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 154 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:156:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 156 | virtual std::string getHistory() const override { return std::string("LAST-FRAME") + (step == 2 ? " ACK" : ""); } // TODO completeStep = true? + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:156:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 156 | virtual std::string getHistory() const override { return std::string("LAST-FRAME") + (step == 2 ? " ACK" : ""); } // TODO completeStep = true? + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:166:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 166 | std::string getHistory() const override { return "A-MPDU BLOCKACK"; } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:178:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 178 | virtual void startSequence(FrameSequenceContext *context, int firstStep) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:179:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 179 | virtual IFrameSequenceStep *prepareStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:180:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 180 | virtual bool completeStep(FrameSequenceContext *context) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:182:5: warning: function 'getHistory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 182 | virtual std::string getHistory() const override { return std::string("BLOCKACKREQ") + (step == 2 ? " BLOCKACK" : ""); } // TODO completeStep = true? + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/framesequence/PrimitiveFrameSequences.h:182:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 182 | virtual std::string getHistory() const override { return std::string("BLOCKACKREQ") + (step == 2 ? " BLOCKACK" : ""); } // TODO completeStep = true? + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/framesequence/TxOpFs.h:8:9: warning: invalid case style for macro definition '__INET_TXOPFS_H' [readability-identifier-naming] + 8 | #define __INET_TXOPFS_H + | ^~~~~~~~~~~~~~~ + | INET_TXOPFS_H +./inet/linklayer/ieee80211/mac/framesequence/TxOpFs.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API TxOpFs : public AlternativesFs + 17 | { + 18 | + 19 | public: + 20 | TxOpFs(); + 21 | virtual ~TxOpFs() {} + 22 | + 23 | virtual int selectTxOpSequence(AlternativesFs *frameSequence, FrameSequenceContext *context); + 24 | virtual bool isRtsCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *context); + 25 | virtual bool isBlockAckReqRtsCtsNeeded(OptionalFs *frameSequence, FrameSequenceContext *context); + 26 | virtual int selectMgmtOrDataQap(AlternativesFs *frameSequence, FrameSequenceContext *context); + 27 | }; + 28 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/framesequence/TxOpFs.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~TxOpFs() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/framesequence/TxOpFs.h:21:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 21 | virtual ~TxOpFs() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/lifetime/DcfReceiveLifetimeHandler.h:8:9: warning: invalid case style for macro definition '__INET_DCFRECEIVELIFETIMEHANDLER_H' [readability-identifier-naming] + 8 | #define __INET_DCFRECEIVELIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_DCFRECEIVELIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/lifetime/DcfReceiveLifetimeHandler.h:12:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 12 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 13 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 14 | + 15 | class INET_API DcfReceiveLifetimeHandler + 16 | { + 17 | protected: + 18 | simtime_t maxReceiveLifetime; + 19 | }; + 20 | + 21 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 22 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:9:9: warning: invalid case style for macro definition '__INET_DCFTRANSMITLIFETIMEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_DCFTRANSMITLIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_DCFTRANSMITLIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:28:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 28 | virtual void frameGotInProgess(const Ptr& header); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:29:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 29 | virtual void frameTransmitted(const Ptr& header); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/lifetime/DcfTransmitLifetimeHandler.h:31:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 31 | virtual bool isLifetimeExpired(const Ptr& header); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:9:9: warning: invalid case style for macro definition '__INET_EDCATRANSMITLIFETIMEHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_EDCATRANSMITLIFETIMEHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_EDCATRANSMITLIFETIMEHANDLER_H +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:53:5: warning: function 'getEarliestDeadline' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | simtime_t getEarliestDeadline(const std::set& referencedFrames) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:54:5: warning: function 'getExpiredFrameIds' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | std::vector getExpiredFrameIds(const std::set& referencedFrames) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:56:5: warning: function 'findFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | Packet *findFrame(int64_t packetId) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/lifetime/EdcaTransmitLifetimeHandler.h:57:5: warning: function 'getNumFrames' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | size_t getNumFrames() const { return frames.size(); } + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:9:9: warning: invalid case style for macro definition '__INET_ACKHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_ACKHANDLER_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ACKHANDLER_H +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:35:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:40:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 40 | virtual ~AckHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:40:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 40 | virtual ~AckHandler() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) override; // TODO rename + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual bool isEligibleToTransmit(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:49:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 49 | virtual bool isOutstandingFrame(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/AckHandler.h:51:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 51 | virtual void dropFrame(const Ptr& dataOrMgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:9:9: warning: invalid case style for macro definition '__INET_NONQOSRECOVERYPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_NONQOSRECOVERYPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_NONQOSRECOVERYPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:41:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/NonQosRecoveryProcedure.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORQOSACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORQOSACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORQOSACKPOLICY_H +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:31:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:32:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:39:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual bool isAckNeeded(const Ptr& header) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:40:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual AckPolicy computeAckPolicy(Packet *packet, const Ptr& header, OriginatorBlockAckAgreement *agreement) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:41:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 41 | virtual bool isBlockAckPolicyEligibleFrame(Packet *packet, const Ptr& header) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:42:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual bool isBlockAckReqNeeded(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure, IOriginatorBlockAckAgreementHandler *agreements) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:43:63: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual std::tuple computeBlockAckReqParameters(InProgressFrames *inProgressFrames, TxopProcedure *txopProcedure, IOriginatorBlockAckAgreementHandler *agreements) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:45:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual simtime_t getAckTimeout(Packet *packet, const Ptr& dataOrMgmtHeader) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosAckPolicy.h:46:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual simtime_t getBlockAckTimeout(Packet *packet, const Ptr& blockAckReq) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORQOSMACDATASERVICE_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORQOSMACDATASERVICE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORQOSMACDATASERVICE_H +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:23:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 23 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 24 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:50:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 50 | virtual void initialize() override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:62:51: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual std::unique_ptr prepareFragments(queueing::IPacketQueue *queue, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual bool isFragmentPreparationValid(const PreparedQosFragments& preparation, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool commitPreparedFragments(PreparedQosFragments& preparation, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:73:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual Packet *peekEligibleFrame(queueing::IPacketQueue *queue) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:74:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool hasAMsduAggregation() const override { return aMsduAggregationPolicy != nullptr; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool hasAMpduAggregation() const override { return aMpduAggregationPolicy && aMpduAggregationPolicy->isEnabled(); } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:77:47: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual std::unique_ptr prepareBatch(queueing::IPacketQueue *queue, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:79:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual bool isBatchValid(const PreparedQosBatch& batch, simtime_t start) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:80:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual bool commitPreparedBatch(PreparedQosBatch& batch, std::vector& committed) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:81:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual Packet *buildAggregate(const PreparedQosBatch& batch, const MpduAggregationLimits& limits) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:82:46: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual std::unique_ptr prepareFrame(queueing::IPacketQueue *queue, bool allowAggregation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:83:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 83 | virtual bool isPreparationValid(const PreparedQosData& preparation, simtime_t start) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:84:21: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual Packet *commitPreparedFrame(PreparedQosData& preparation) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:85:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 85 | virtual ~OriginatorQosMacDataService(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.h:91:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual std::vector *extractFramesToTransmit(queueing::IPacketQueue *pendingQueue) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:9:9: warning: invalid case style for macro definition '__INET_QOSACKHANDLER_H' [readability-identifier-naming] + 9 | #define __INET_QOSACKHANDLER_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_QOSACKHANDLER_H +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:42:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 42 | typedef std::pair> QoSKey; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using QoSKey = std::pair> +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:43:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 43 | typedef std::pair Key; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Key = std::pair +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:48:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 48 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:56:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 56 | virtual ~QosAckHandler() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:56:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 56 | virtual ~QosAckHandler() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:64:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual void frameGotInProgress(const Ptr& dataOrMgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:70:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual void dropFrame(const Ptr& dataOrMgmtHeader) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool isEligibleToTransmit(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosAckHandler.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual bool isOutstandingFrame(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:9:9: warning: invalid case style for macro definition '__INET_QOSRECOVERYPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_QOSRECOVERYPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_QOSRECOVERYPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:59:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_RTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_RTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_RTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 15 | + 16 | class INET_API RtsProcedure : public IRtsProcedure + 17 | { + 18 | protected: + 19 | int numSentRts = 0; + 20 | + 21 | public: + 22 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const override; + 23 | virtual void processTransmittedRts(const Ptr& rtsFrame) override; + 24 | }; + 25 | + 26 | } /* namespace ieee80211 */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 27 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:22:5: warning: function 'buildRtsFrame' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const override; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:22:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 22 | virtual const Ptr buildRtsFrame(const Ptr& dataOrMgmtHeader) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/RtsProcedure.h:23:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 23 | virtual void processTransmittedRts(const Ptr& rtsFrame) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:9:9: warning: invalid case style for macro definition '__INET_TXOPPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_TXOPPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_TXOPPROCEDURE_H +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:42:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 42 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:43:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/originator/TxopProcedure.h:69:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual void receiveSignal(cResultFilter *prev, simtime_t_cref t, cObject *object, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:9:9: warning: invalid case style for macro definition '__INET_ORIGINATORPROTECTIONMECHANISM_H' [readability-identifier-naming] + 9 | #define __INET_ORIGINATORPROTECTIONMECHANISM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ORIGINATORPROTECTIONMECHANISM_H +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:24:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 24 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:25:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:32:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 32 | virtual ~OriginatorProtectionMechanism() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/protectionmechanism/OriginatorProtectionMechanism.h:32:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 32 | virtual ~OriginatorProtectionMechanism() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:8:9: warning: invalid case style for macro definition '__INET_SINGLEPROTECTIONMECHANISM_H' [readability-identifier-naming] + 8 | #define __INET_SINGLEPROTECTIONMECHANISM_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_SINGLEPROTECTIONMECHANISM_H +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:33:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:34:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:43:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 43 | virtual ~SingleProtectionMechanism() {} + | ^ ~~ + | = default; +./inet/linklayer/ieee80211/mac/protectionmechanism/SingleProtectionMechanism.h:43:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 43 | virtual ~SingleProtectionMechanism() {} + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:9:9: warning: invalid case style for macro definition '__INET_INPROGRESSFRAMES_H' [readability-identifier-naming] + 9 | #define __INET_INPROGRESSFRAMES_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_INPROGRESSFRAMES_H +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:44:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:51:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 51 | virtual ~InProgressFrames(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:56:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/queue/InProgressFrames.h:57:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual void forEachChild(cVisitor *v) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211PEERMODESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211PEERMODESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_PEERMODESELECTION_H +./inet/linklayer/ieee80211/mac/rateselection/Ieee80211PeerModeSelection.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:9:9: warning: invalid case style for macro definition '__INET_QOSRATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_QOSRATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_QOSRATESELECTION_H +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:59:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:61:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:85:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& rtsFrame, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:86:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 86 | virtual const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& dataOrMgmtHeader, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:87:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual const physicallayer::IIeee80211Mode *computeResponseBlockAckFrameMode(Packet *packet, const Ptr& blockAckReq, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:88:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual const physicallayer::IIeee80211Mode *computeCompressedBlockAckReqMode(Packet *packet, + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/QosRateSelection.h:91:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header, TxopProcedure *txopProcedure) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:9:9: warning: invalid case style for macro definition '__INET_RATESELECTION_H' [readability-identifier-naming] + 9 | #define __INET_RATESELECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_RATESELECTION_H +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:59:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:60:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:61:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual void receiveSignal(cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:93:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual const physicallayer::IIeee80211Mode *computeResponseCtsFrameMode(Packet *packet, const Ptr& rtsFrame, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:94:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 94 | virtual const physicallayer::IIeee80211Mode *computeResponseAckFrameMode(Packet *packet, const Ptr& dataOrMgmtHeader, ResponseQueryRole role) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/rateselection/RateSelection.h:96:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 96 | virtual const physicallayer::IIeee80211Mode *computeMode(Packet *packet, const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:9:9: warning: invalid case style for macro definition '__INET_CTSPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_CTSPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_CTSPROCEDURE_H +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:26:5: warning: function 'buildCts' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const Ptr buildCts(const Ptr& rtsFrame) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void processReceivedRts(Packet *rtsPacket, const Ptr& rtsFrame, ICtsPolicy *ctsPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/CtsProcedure.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void processTransmittedCts(const Ptr& ctsFrame) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTACKPROCEDURE_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTACKPROCEDURE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTACKPROCEDURE_H +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:26:5: warning: function 'buildAck' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const Ptr buildAck(const Ptr& dataOrMgmtHeader) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:29:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual void processReceivedFrame(Packet *packet, const Ptr& dataOrMgmtHeader, IRecipientAckPolicy *ackPolicy, IProcedureCallback *callback) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientAckProcedure.h:30:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual void processTransmittedAck(const Ptr& ack) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:9:9: warning: invalid case style for macro definition '__INET_RECIPIENTQOSACKPOLICY_H' [readability-identifier-naming] + 9 | #define __INET_RECIPIENTQOSACKPOLICY_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_RECIPIENTQOSACKPOLICY_H +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:25:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:26:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:32:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual bool isAckNeeded(const Ptr& header) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:33:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual bool isBlockAckNeeded(const Ptr& blockAckReq, RecipientBlockAckAgreement *agreement) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:35:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 35 | virtual simtime_t computeAckDurationField(Packet *packet, const Ptr& header) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:36:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual simtime_t computeBasicBlockAckDurationField(Packet *packet, const Ptr& basicBlockAckReq) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/recipient/RecipientQosAckPolicy.h:37:23: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual simtime_t computeCompressedBlockAckDurationField(Packet *packet, const Ptr& blockAckReq) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h:9:9: warning: invalid case style for macro definition '__INET_QOSSEQUENCENUMBERASSIGNMENT_H' [readability-identifier-naming] + 9 | #define __INET_QOSSEQUENCENUMBERASSIGNMENT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_QOSSEQUENCENUMBERASSIGNMENT_H +./inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h:28:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 28 | typedef std::pair Key; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using Key = std::pair +./inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h:39:5: warning: function 'getNextSequenceNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | SequenceNumberCyclic getNextSequenceNumber(MacAddress peer, Tid tid) const; + | ^ + | [[nodiscard]] +./inet/linklayer/ieee80211/mac/sequencenumberassignment/QoSSequenceNumberAssignment.h:40:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual void assignSequenceNumber(const Ptr& header) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_IEEE80211MGMTFRAME_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_IEEE80211MGMTFRAME_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_IEE_E80211_MGMTFRAME_M_H +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:64:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 64 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 65 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:73:10: warning: invalid case style for public member 'ESS' [readability-identifier-naming] + 73 | bool ESS = false; + | ^~~ + | ess +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:74:10: warning: invalid case style for public member 'IBSS' [readability-identifier-naming] + 74 | bool IBSS = false; + | ^~~~ + | ibss +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:75:10: warning: invalid case style for public member 'CFPollable' [readability-identifier-naming] + 75 | bool CFPollable = false; + | ^~~~~~~~~~ + | cfPollable +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:76:10: warning: invalid case style for public member 'CFPollRequest' [readability-identifier-naming] + 76 | bool CFPollRequest = false; + | ^~~~~~~~~~~~~ + | cfPollRequest +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:78:10: warning: invalid case style for public member 'DelayedBlockAck' [readability-identifier-naming] + 78 | bool DelayedBlockAck = false; + | ^~~~~~~~~~~~~~~ + | delayedBlockAck +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:79:10: warning: invalid case style for public member 'InmediateBlockAck' [readability-identifier-naming] + 79 | bool InmediateBlockAck = false; + | ^~~~~~~~~~~~~~~~~ + | inmediateBlockAck +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:83:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 83 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211CapabilityInformation& a); + | ^~~~~~~~~~~ + | doPacking + 84 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211CapabilityInformation& a); + 85 | + 86 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211CapabilityInformation& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:84:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 84 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211CapabilityInformation& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 85 | + 86 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211CapabilityInformation& obj) { __doPacking(b, obj); } + 87 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211CapabilityInformation& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:102:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 102 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211HandoverParameters& a); + | ^~~~~~~~~~~ + | doPacking + 103 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HandoverParameters& a); + 104 | + 105 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HandoverParameters& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:103:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 103 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HandoverParameters& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 104 | + 105 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HandoverParameters& obj) { __doPacking(b, obj); } + 106 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211HandoverParameters& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:254:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 254 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211SupportedRatesElement& a); + | ^~~~~~~~~~~ + | doPacking + 255 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211SupportedRatesElement& a); + 256 | + 257 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211SupportedRatesElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:255:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 255 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211SupportedRatesElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 256 | + 257 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211SupportedRatesElement& obj) { __doPacking(b, obj); } + 258 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211SupportedRatesElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:272:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 272 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211ExtendedSupportedRatesElement& a); + | ^~~~~~~~~~~ + | doPacking + 273 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211ExtendedSupportedRatesElement& a); + 274 | + 275 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211ExtendedSupportedRatesElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:273:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 273 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211ExtendedSupportedRatesElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 274 | + 275 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211ExtendedSupportedRatesElement& obj) { __doPacking(b, obj); } + 276 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211ExtendedSupportedRatesElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:312:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 312 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211HtCapabilitiesElement& a); + | ^~~~~~~~~~~ + | doPacking + 313 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtCapabilitiesElement& a); + 314 | + 315 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtCapabilitiesElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:313:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 313 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtCapabilitiesElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 314 | + 315 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtCapabilitiesElement& obj) { __doPacking(b, obj); } + 316 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtCapabilitiesElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:339:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 339 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211HtOperationElement& a); + | ^~~~~~~~~~~ + | doPacking + 340 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtOperationElement& a); + 341 | + 342 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtOperationElement& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:340:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 340 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtOperationElement& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 341 | + 342 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211HtOperationElement& obj) { __doPacking(b, obj); } + 343 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211HtOperationElement& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:381:12: warning: invalid case style for protected member 'unmodelledElements_arraysize' [readability-identifier-naming] + 381 | size_t unmodelledElements_arraysize = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | unmodelledElementsArraysize +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:383:12: warning: invalid case style for protected member 'unmodelledElementPositions_arraysize' [readability-identifier-naming] + 383 | size_t unmodelledElementPositions_arraysize = 0; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | unmodelledElementPositionsArraysize +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:389:10: warning: deleted member function should be public [modernize-use-equals-delete] + 389 | bool operator==(const Ieee80211MgmtFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:394:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 394 | virtual ~Ieee80211MgmtFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:396:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 396 | virtual Ieee80211MgmtFrame *dup() const override {return new Ieee80211MgmtFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:397:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 397 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:398:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 398 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:470:10: warning: invalid case style for protected member 'isLast_' [readability-identifier-naming] + 470 | bool isLast_ = false; + | ^~~~~~~ + | isLast +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:476:10: warning: deleted member function should be public [modernize-use-equals-delete] + 476 | bool operator==(const Ieee80211AuthenticationFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:481:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 481 | virtual ~Ieee80211AuthenticationFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:483:43: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 483 | virtual Ieee80211AuthenticationFrame *dup() const override {return new Ieee80211AuthenticationFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:484:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 484 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:485:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 485 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:522:10: warning: deleted member function should be public [modernize-use-equals-delete] + 522 | bool operator==(const Ieee80211DeauthenticationFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:527:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 527 | virtual ~Ieee80211DeauthenticationFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:529:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 529 | virtual Ieee80211DeauthenticationFrame *dup() const override {return new Ieee80211DeauthenticationFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:530:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 530 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:531:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 531 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:562:10: warning: deleted member function should be public [modernize-use-equals-delete] + 562 | bool operator==(const Ieee80211DisassociationFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:567:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 567 | virtual ~Ieee80211DisassociationFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:569:43: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 569 | virtual Ieee80211DisassociationFrame *dup() const override {return new Ieee80211DisassociationFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:570:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 570 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:571:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 571 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:596:27: warning: invalid case style for protected member 'SSID' [readability-identifier-naming] + 596 | ::omnetpp::opp_string SSID; + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:603:10: warning: deleted member function should be public [modernize-use-equals-delete] + 603 | bool operator==(const Ieee80211ProbeRequestFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:608:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 608 | virtual ~Ieee80211ProbeRequestFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:610:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 610 | virtual Ieee80211ProbeRequestFrame *dup() const override {return new Ieee80211ProbeRequestFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:611:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 611 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:612:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 612 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:615:39: warning: invalid case style for parameter 'SSID' [readability-identifier-naming] + 615 | virtual void setSSID(const char * SSID); + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:645:27: warning: invalid case style for protected member 'SSID' [readability-identifier-naming] + 645 | ::omnetpp::opp_string SSID; + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:652:10: warning: deleted member function should be public [modernize-use-equals-delete] + 652 | bool operator==(const Ieee80211AssociationRequestFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:657:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 657 | virtual ~Ieee80211AssociationRequestFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:659:47: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 659 | virtual Ieee80211AssociationRequestFrame *dup() const override {return new Ieee80211AssociationRequestFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:660:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 660 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:661:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 661 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:670:39: warning: invalid case style for parameter 'SSID' [readability-identifier-naming] + 670 | virtual void setSSID(const char * SSID); + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:701:10: warning: deleted member function should be public [modernize-use-equals-delete] + 701 | bool operator==(const Ieee80211ReassociationRequestFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:706:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 706 | virtual ~Ieee80211ReassociationRequestFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:708:49: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 708 | virtual Ieee80211ReassociationRequestFrame *dup() const override {return new Ieee80211ReassociationRequestFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:709:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 709 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:710:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 710 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:747:10: warning: deleted member function should be public [modernize-use-equals-delete] + 747 | bool operator==(const Ieee80211AssociationResponseFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:752:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 752 | virtual ~Ieee80211AssociationResponseFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:754:48: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 754 | virtual Ieee80211AssociationResponseFrame *dup() const override {return new Ieee80211AssociationResponseFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:755:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 755 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:756:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 756 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:794:10: warning: deleted member function should be public [modernize-use-equals-delete] + 794 | bool operator==(const Ieee80211ReassociationResponseFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:799:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 799 | virtual ~Ieee80211ReassociationResponseFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:801:50: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 801 | virtual Ieee80211ReassociationResponseFrame *dup() const override {return new Ieee80211ReassociationResponseFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:802:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 802 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:803:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 803 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:834:27: warning: invalid case style for protected member 'SSID' [readability-identifier-naming] + 834 | ::omnetpp::opp_string SSID; + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:844:10: warning: deleted member function should be public [modernize-use-equals-delete] + 844 | bool operator==(const Ieee80211BeaconFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:849:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 849 | virtual ~Ieee80211BeaconFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:851:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 851 | virtual Ieee80211BeaconFrame *dup() const override {return new Ieee80211BeaconFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:852:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 852 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:853:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 853 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:865:39: warning: invalid case style for parameter 'SSID' [readability-identifier-naming] + 865 | virtual void setSSID(const char * SSID); + | ^~~~ + | ssid +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:904:10: warning: deleted member function should be public [modernize-use-equals-delete] + 904 | bool operator==(const Ieee80211ProbeResponseFrame&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:909:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 909 | virtual ~Ieee80211ProbeResponseFrame(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:911:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 911 | virtual Ieee80211ProbeResponseFrame *dup() const override {return new Ieee80211ProbeResponseFrame(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:912:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 912 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrame_m.h:913:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 913 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:6:9: warning: invalid case style for macro definition '__INET__IEEE80211_IEEE80211MGMTTRANSACTIONTAG_M_H' [readability-identifier-naming] + 6 | #define __INET__IEEE80211_IEEE80211MGMTTRANSACTIONTAG_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_IEE_E80211_MGMTTRANSACTIONTAG_M_H +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 + 33 | + 34 | class Ieee80211MgmtTransactionTag; + 35 | + 36 | } // namespace ieee80211 + | ~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::ieee80211 + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:44:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 44 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 45 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:69:10: warning: deleted member function should be public [modernize-use-equals-delete] + 69 | bool operator==(const Ieee80211MgmtTransactionTag&) = delete; + | ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:74:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 74 | virtual ~Ieee80211MgmtTransactionTag(); + | ~~~~~~~ ^ + | override +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:76:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual Ieee80211MgmtTransactionTag *dup() const override {return new Ieee80211MgmtTransactionTag(*this);} + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:77:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mgmt/Ieee80211MgmtTransactionTag_m.h:78:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h:8:9: warning: invalid case style for macro definition '__INET_IEEE80211HTCAPABILITIES_H' [readability-identifier-naming] + 8 | #define __INET_IEEE80211HTCAPABILITIES_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTCAPABILITIES_H +./inet/linklayer/ieee80211/mib/Ieee80211HtCapabilities.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/linklayer/ieee80211/mib/Ieee80211Mib.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MIB_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MIB_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MIB_H +./inet/linklayer/ieee80211/mib/Ieee80211Mib.h:103:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/linklayer/ieee80211/mib/Ieee80211RateSet.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211RATESET_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211RATESET_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_RATESET_H +./inet/linklayer/ieee80211/mib/Ieee80211RateSet.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +./inet/mobility/contract/IMobility.h:9:9: warning: invalid case style for macro definition '__INET_IMOBILITY_H' [readability-identifier-naming] + 9 | #define __INET_IMOBILITY_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IMOBILITY_H +./inet/mobility/contract/IMobility.h:43:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 43 | virtual ~IMobility() {} + | ^ ~~ + | = default; +./inet/mobility/contract/IMobility.h:45:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual int getId() const = 0; + | ^ + | [[nodiscard]] +./inet/mobility/contract/IMobility.h:50:5: warning: function 'getMaxSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual double getMaxSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/mobility/contract/IMobility.h:85:5: warning: function 'getConstraintAreaMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const Coord& getConstraintAreaMax() const = 0; + | ^ + | [[nodiscard]] +./inet/mobility/contract/IMobility.h:90:5: warning: function 'getConstraintAreaMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const Coord& getConstraintAreaMin() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/common/InterfaceToken.h:9:9: warning: invalid case style for macro definition '__INET_INTERFACETOKEN_H' [readability-identifier-naming] + 9 | #define __INET_INTERFACETOKEN_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_INTERFACETOKEN_H +./inet/networklayer/common/InterfaceToken.h:24:14: warning: invalid case style for private member '_normal' [readability-identifier-naming] + 24 | uint32_t _normal, _low; + | ^~~~~~~ + | normal + 25 | short _len; // in bits, 1..64 + 26 | + 27 | private: + 28 | void copy(const InterfaceToken& t) { _normal = t._normal; _low = t._low; _len = t._len; } + | ~~~~~~~ ~~~~~~~ + | normal normal + 29 | + 30 | public: + 31 | InterfaceToken() { _normal = _low = _len = 0; } + | ~~~~~~~ + | normal + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ~~~~~~~ + | normal + 33 | InterfaceToken(const InterfaceToken& t) { copy(t); } + 34 | InterfaceToken& operator=(const InterfaceToken& t) { copy(t); return *this; } + 35 | int length() const { return _len; } + 36 | uint32_t low() const { return _low; } + 37 | uint32_t normal() const { return _normal; } + | ~~~~~~~ + | normal +./inet/networklayer/common/InterfaceToken.h:24:23: warning: invalid case style for private member '_low' [readability-identifier-naming] + 24 | uint32_t _normal, _low; + | ^~~~ + | low + 25 | short _len; // in bits, 1..64 + 26 | + 27 | private: + 28 | void copy(const InterfaceToken& t) { _normal = t._normal; _low = t._low; _len = t._len; } + | ~~~~ ~~~~ + | low low + 29 | + 30 | public: + 31 | InterfaceToken() { _normal = _low = _len = 0; } + | ~~~~ + | low + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ~~~~ + | low + 33 | InterfaceToken(const InterfaceToken& t) { copy(t); } + 34 | InterfaceToken& operator=(const InterfaceToken& t) { copy(t); return *this; } + 35 | int length() const { return _len; } + 36 | uint32_t low() const { return _low; } + | ~~~~ + | low +./inet/networklayer/common/InterfaceToken.h:25:11: warning: invalid case style for private member '_len' [readability-identifier-naming] + 25 | short _len; // in bits, 1..64 + | ^~~~ + | len + 26 | + 27 | private: + 28 | void copy(const InterfaceToken& t) { _normal = t._normal; _low = t._low; _len = t._len; } + | ~~~~ ~~~~ + | len len + 29 | + 30 | public: + 31 | InterfaceToken() { _normal = _low = _len = 0; } + | ~~~~ + | len + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ~~~~ + | len + 33 | InterfaceToken(const InterfaceToken& t) { copy(t); } + 34 | InterfaceToken& operator=(const InterfaceToken& t) { copy(t); return *this; } + 35 | int length() const { return _len; } + | ~~~~ + | len +./inet/networklayer/common/InterfaceToken.h:32:20: warning: 3 adjacent parameters of 'InterfaceToken' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/common/InterfaceToken.h:32:29: note: the first parameter in the range is 'low' + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^~~ +./inet/networklayer/common/InterfaceToken.h:32:55: note: the last parameter in the range is 'len' + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^~~ +./inet/networklayer/common/InterfaceToken.h:32:20: note: + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^ +./inet/networklayer/common/InterfaceToken.h:32:51: note: 'uint32_t' and 'int' may be implicitly converted: 'uint32_t' (as 'unsigned int') -> 'int', 'int' -> 'uint32_t' (as 'unsigned int') + 32 | InterfaceToken(uint32_t low, uint32_t normal, int len) { _normal = normal; _low = low; _len = len; } + | ^ +./inet/networklayer/common/InterfaceToken.h:35:5: warning: function 'length' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | int length() const { return _len; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/InterfaceToken.h:36:5: warning: function 'low' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | uint32_t low() const { return _low; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/InterfaceToken.h:37:5: warning: function 'normal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | uint32_t normal() const { return _normal; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:9:9: warning: invalid case style for macro definition '__INET_L3ADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_L3ADDRESS_H + | ^~~~~~~~~~~~~~~~~~ + | INET_L3_ADDRESS_H +./inet/networklayer/common/L3Address.h:35:9: warning: invalid case style for enum constant 'IPv4' [readability-identifier-naming] + 35 | IPv4, + | ^~~~ + | I_PV4 +./inet/networklayer/common/L3Address.h:36:9: warning: invalid case style for enum constant 'IPv6' [readability-identifier-naming] + 36 | IPv6, + | ^~~~ + | I_PV6 +./inet/networklayer/common/L3Address.h:48:5: warning: function 'get' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | uint64_t get(AddressType type) const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:53:5: warning: use '= default' to define a trivial copy constructor [modernize-use-equals-default] + 53 | L3Address(const L3Address& other) : hi(other.hi), lo(other.lo) {} + | ^ ~~~~~~~~~~~~ ~~~~~~~~~~~~~~~ + | = default; +./inet/networklayer/common/L3Address.h:70:5: warning: function 'toIpv4' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | Ipv4Address toIpv4() const { return getType() == NONE ? Ipv4Address() : Ipv4Address(get(IPv4)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:71:5: warning: function 'toIpv6' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | Ipv6Address toIpv6() const { return getType() == NONE ? Ipv6Address() : Ipv6Address(hi, get(IPv6)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:72:5: warning: function 'toMac' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | MacAddress toMac() const { return getType() == NONE ? MacAddress() : MacAddress(get(MAC)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:73:5: warning: function 'toModuleId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | ModuleIdAddress toModuleId() const { return getType() == NONE ? ModuleIdAddress() : ModuleIdAddress(get(MODULEID)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:74:5: warning: function 'toModulePath' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | ModulePathAddress toModulePath() const { return getType() == NONE ? ModulePathAddress() : ModulePathAddress(get(MODULEPATH)); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:75:5: warning: function 'toClns' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | ClnsAddress toClns() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:77:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:78:5: warning: function 'getType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | AddressType getType() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:79:5: warning: function 'getAddressType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | const IL3AddressType *getAddressType() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:84:5: warning: function 'getPrefix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | L3Address getPrefix(int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:88:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | bool isUnspecified() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:89:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | bool isUnicast() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:90:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | bool isMulticast() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:91:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | bool isBroadcast() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:92:5: warning: function 'isLinkLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | bool isLinkLocal() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:94:16: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 94 | L3Address& operator=(const L3Address& other) { hi = other.hi; lo = other.lo; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/networklayer/common/L3Address.h:101:5: warning: function 'matches' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | bool matches(const L3Address& other, int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/L3Address.h:103:5: warning: function 'mapToMulticastMacAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | MacAddress mapToMulticastMacAddress() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:9:9: warning: invalid case style for macro definition '__INET_MODULEIDADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEIDADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEIDADDRESS_H +./inet/networklayer/common/ModuleIdAddress.h:32:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | int getId() const { return id; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:35:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | bool isUnspecified() const { return id == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:36:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | bool isUnicast() const { return id > 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:37:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | bool isMulticast() const { return id < -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:38:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | bool isBroadcast() const { return id == -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModuleIdAddress.h:58:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | std::string str() const { std::ostringstream s; s << id; return s.str(); } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:9:9: warning: invalid case style for macro definition '__INET_MODULEPATHADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_MODULEPATHADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_MODULEPATHADDRESS_H +./inet/networklayer/common/ModulePathAddress.h:32:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | int getId() const { return id; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:35:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | bool isUnspecified() const { return id == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:36:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | bool isUnicast() const { return id > 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:37:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | bool isMulticast() const { return id < -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:38:5: warning: function 'isBroadcast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | bool isBroadcast() const { return id == -1; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/ModulePathAddress.h:59:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:9:9: warning: invalid case style for macro definition '__INET_NETWORKINTERFACE_H' [readability-identifier-naming] + 9 | #define __INET_NETWORKINTERFACE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_NETWORKINTERFACE_H +./inet/networklayer/common/NetworkInterface.h:38:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 38 | virtual ~MacEstimateCostProcess() {} + | ^ ~~ + | = default; +./inet/networklayer/common/NetworkInterface.h:79:5: warning: function 'getNetworkInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | NetworkInterface *getNetworkInterface() const { return ie; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:80:5: warning: function 'getFieldId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | int getFieldId() const { return field; } + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:81:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual std::string str() const override; + | ^ + | [[nodiscard]] +./inet/networklayer/common/NetworkInterface.h:81:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:140:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 140 | virtual bool deliver(cMessage *msg, const SendOptions &options, simtime_t t) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:165:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 165 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:166:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 166 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:167:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 167 | virtual void handleParameterChange(const char *name) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:168:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 168 | virtual std::string resolveDirective(char directive) const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:169:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual void receiveSignal(cComponent *source, simsignal_t signal, cObject *obj, cObject *details) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:170:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual cGate *createGateObject(cGate::Type type) override { + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:183:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 183 | virtual std::string getFullPath() const override { return cModule::getFullPath(); } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:184:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 184 | virtual const char *getName() const override { return cModule::getName(); } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:186:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 186 | virtual void arrived(cMessage *message, cGate *gate, const SendOptions& options, simtime_t time) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:190:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 190 | virtual ~NetworkInterface(); + | ~~~~~~~ ^ + | override +./inet/networklayer/common/NetworkInterface.h:191:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 191 | virtual std::string str() const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:194:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 194 | virtual bool supportsPacketSending(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:195:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 195 | virtual bool supportsPacketPushing(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:196:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 196 | virtual bool supportsPacketPulling(const cGate *gate) const override { return false; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:197:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 197 | virtual bool supportsPacketPassing(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:198:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 198 | virtual bool supportsPacketStreaming(const cGate *gate) const override { return false; } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:199:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 199 | virtual bool canPushSomePacket(const cGate *gate) const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:200:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 200 | virtual bool canPushPacket(Packet *packet, const cGate *gate) const override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:201:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 201 | virtual void pushPacket(Packet *packet, const cGate *gate) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:202:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 202 | virtual void pushPacketStart(Packet *packet, const cGate *gate, bps datarate) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:203:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 203 | virtual void pushPacketEnd(Packet *packet, const cGate *gate) override; + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:204:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ~~~~~~~ ^ +./inet/networklayer/common/NetworkInterface.h:204:86: warning: 2 adjacent parameters of 'pushPacketProgress' of similar type ('b') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/common/NetworkInterface.h:204:88: note: the first parameter in the range is 'position' + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~ +./inet/networklayer/common/NetworkInterface.h:204:100: note: the last parameter in the range is 'extraProcessableLength' + 204 | virtual void pushPacketProgress(Packet *packet, const cGate *gate, bps datarate, b position, b extraProcessableLength = b(0)) override { throw cRuntimeError("Invalid operation"); } + | ^~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/common/NetworkInterface.h:390:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 390 | virtual bool handleOperationStage(LifecycleOperation *operation, IDoneCallback *doneCallback) override; + | ~~~~~~~ ^ +./inet/networklayer/contract/IInterfaceTable.h:9:9: warning: invalid case style for macro definition '__INET_IINTERFACETABLE_H' [readability-identifier-naming] + 9 | #define __INET_IINTERFACETABLE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IINTERFACETABLE_H +./inet/networklayer/contract/IInterfaceTable.h:26:1: warning: use 'using' instead of 'typedef' [modernize-use-using] + 26 | typedef std::vector MulticastGroupList; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using MulticastGroupList = std::vector +./inet/networklayer/contract/IInterfaceTable.h:45:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 45 | virtual ~IInterfaceTable() {} + | ^ ~~ + | = default; +./inet/networklayer/contract/IInterfaceTable.h:50:5: warning: function 'getFullPath' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual std::string getFullPath() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:55:5: warning: function 'getHostModule' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual cModule *getHostModule() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:60:5: warning: function 'isLocalAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual bool isLocalAddress(const L3Address& address) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:66:5: warning: function 'isNeighborAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual bool isNeighborAddress(const L3Address& address) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:71:5: warning: function 'findInterfaceByAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | virtual NetworkInterface *findInterfaceByAddress(const L3Address& address) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:91:5: warning: function 'getNumInterfaces' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual int getNumInterfaces() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:102:5: warning: function 'getInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 102 | virtual NetworkInterface *getInterface(int pos) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:109:5: warning: function 'findInterfaceById' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | virtual NetworkInterface *findInterfaceById(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:116:5: warning: function 'getInterfaceById' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | virtual NetworkInterface *getInterfaceById(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:121:5: warning: function 'getBiggestInterfaceId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | virtual int getBiggestInterfaceId() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:127:5: warning: function 'findInterfaceByNodeOutputGateId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 127 | virtual NetworkInterface *findInterfaceByNodeOutputGateId(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:133:5: warning: function 'findInterfaceByNodeInputGateId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual NetworkInterface *findInterfaceByNodeInputGateId(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:150:5: warning: function 'findFirstLoopbackInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 150 | virtual NetworkInterface *findFirstLoopbackInterface() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:157:5: warning: function 'findFirstNonLoopbackInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 157 | virtual NetworkInterface *findFirstNonLoopbackInterface() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:162:5: warning: function 'findFirstMulticastInterface' should be marked [[nodiscard]] [modernize-use-nodiscard] + 162 | virtual NetworkInterface *findFirstMulticastInterface() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/IInterfaceTable.h:167:5: warning: function 'collectMulticastGroups' should be marked [[nodiscard]] [modernize-use-nodiscard] + 167 | virtual MulticastGroupList collectMulticastGroups() const = 0; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:17:9: warning: invalid case style for macro definition '__INET_CLNSADDRESS_H' [readability-identifier-naming] + 17 | #define __INET_CLNSADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_CLNSADDRESS_H +./inet/networklayer/contract/clns/ClnsAddress.h:46:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | bool isUnspecified() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:52:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | std::string str(bool printUnspec = true) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:57:5: warning: function 'equals' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | bool equals(const ClnsAddress& toCmp) const { return systemID == toCmp.systemID && areaID == toCmp.areaID; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:59:5: warning: function 'getAreaId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | uint64_t getAreaId() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:60:5: warning: function 'getSystemId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | uint64_t getSystemId() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/clns/ClnsAddress.h:61:5: warning: function 'getNsel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | uint8_t getNsel() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:16:9: warning: invalid case style for macro definition '__INET_IPV4ADDRESS_H' [readability-identifier-naming] + 16 | #define __INET_IPV4ADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IP_V4_ADDRESS_H +./inet/networklayer/contract/ipv4/Ipv4Address.h:44:17: warning: invalid case style for method '_checkNetmaskLength' [readability-identifier-naming] + 44 | static void _checkNetmaskLength(int length); + | ^~~~~~~~~~~~~~~~~~~ + | checkNetmaskLength +./inet/networklayer/contract/ipv4/Ipv4Address.h:46:21: warning: invalid case style for method '_makeNetmask' [readability-identifier-naming] + 46 | static uint32_t _makeNetmask(int length) { return length >= 32 ? 0xffffffffu : ~(0xffffffffu >> length); } + | ^~~~~~~~~~~~ + | makeNetmask +./inet/networklayer/contract/ipv4/Ipv4Address.h:81:9: warning: invalid case style for enum constant 'IPv6_TO_IPv4_RELAY' [readability-identifier-naming] + 81 | IPv6_TO_IPv4_RELAY, // 192.88.99.0/24 + | ^~~~~~~~~~~~~~~~~~ + | I_PV6_TO_I_PV4_RELAY +./inet/networklayer/contract/ipv4/Ipv4Address.h:134:5: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 134 | ~Ipv4Address() {} + | ^ ~~ + | = default; +./inet/networklayer/contract/ipv4/Ipv4Address.h:158:18: warning: use '= default' to define a trivial copy-assignment operator [modernize-use-equals-default] + 158 | Ipv4Address& operator=(const Ipv4Address& obj) { addr = obj.addr; return *this; } + | ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | = default; +./inet/networklayer/contract/ipv4/Ipv4Address.h:165:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 165 | bool isUnspecified() const { return addr == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:170:5: warning: function 'equals' should be marked [[nodiscard]] [modernize-use-nodiscard] + 170 | bool equals(const Ipv4Address& toCmp) const { return addr == toCmp.addr; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:175:5: warning: function 'doAnd' should be marked [[nodiscard]] [modernize-use-nodiscard] + 175 | Ipv4Address doAnd(const Ipv4Address& ip) const { return Ipv4Address(addr & ip.addr); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:181:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 181 | std::string str(bool printUnspec = true) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:186:5: warning: function 'getInt' should be marked [[nodiscard]] [modernize-use-nodiscard] + 186 | uint32_t getInt() const { return addr; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:192:5: warning: function 'getDByte' should be marked [[nodiscard]] [modernize-use-nodiscard] + 192 | int getDByte(int i) const { return (addr >> (3 - i) * 8) & 0xFF; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:198:5: warning: function 'getIPClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 198 | char getIPClass() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:203:5: warning: function 'getAddressCategory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 203 | AddressCategory getAddressCategory() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:209:5: warning: function 'isLimitedBroadcastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 209 | bool isLimitedBroadcastAddress() const { return addr == 0xFFFFFFFF; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:215:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 215 | bool isMulticast() const { return (addr & 0xF0000000) == 0xE0000000; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:220:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 220 | bool isUnicast() const { return !isMulticast() && !isLimitedBroadcastAddress(); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:228:5: warning: function 'isLinkLocalMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 228 | bool isLinkLocalMulticast() const { return (addr & 0xFFFFFF00) == 0xE0000000; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:234:5: warning: function 'isSsm' should be marked [[nodiscard]] [modernize-use-nodiscard] + 234 | bool isSsm() const { return (addr & 0xFF000000) == 0xE8000000; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:241:5: warning: function 'getNetwork' should be marked [[nodiscard]] [modernize-use-nodiscard] + 241 | Ipv4Address getNetwork() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:247:5: warning: function 'getNetworkMask' should be marked [[nodiscard]] [modernize-use-nodiscard] + 247 | Ipv4Address getNetworkMask() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:252:5: warning: function 'isNetwork' should be marked [[nodiscard]] [modernize-use-nodiscard] + 252 | bool isNetwork(const Ipv4Address& toCmp) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:257:5: warning: function 'prefixMatches' should be marked [[nodiscard]] [modernize-use-nodiscard] + 257 | bool prefixMatches(const Ipv4Address& to_cmp, int numbits) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:257:43: warning: invalid case style for parameter 'to_cmp' [readability-identifier-naming] + 257 | bool prefixMatches(const Ipv4Address& to_cmp, int numbits) const; + | ^~~~~~ + | toCmp +./inet/networklayer/contract/ipv4/Ipv4Address.h:267:5: warning: function 'getNumMatchingPrefixBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 267 | int getNumMatchingPrefixBits(const Ipv4Address& to_cmp) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:267:53: warning: invalid case style for parameter 'to_cmp' [readability-identifier-naming] + 267 | int getNumMatchingPrefixBits(const Ipv4Address& to_cmp) const; + | ^~~~~~ + | toCmp +./inet/networklayer/contract/ipv4/Ipv4Address.h:272:5: warning: function 'getNetmaskLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 272 | int getNetmaskLength() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:277:5: warning: function 'getPrefix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 277 | Ipv4Address getPrefix(int prefixLength) const { return doAnd(makeNetmask(prefixLength)); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:283:5: warning: function 'isValidNetmask' should be marked [[nodiscard]] [modernize-use-nodiscard] + 283 | bool isValidNetmask() const { return addr == _makeNetmask(getNetmaskLength()); } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:296:5: warning: function 'makeBroadcastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 296 | Ipv4Address makeBroadcastAddress(Ipv4Address netmask) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv4/Ipv4Address.h:319:5: warning: function 'mapToMulticastMacAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 319 | MacAddress mapToMulticastMacAddress() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:9:9: warning: invalid case style for macro definition '__INET_IPV6ADDRESS_H' [readability-identifier-naming] + 9 | #define __INET_IPV6ADDRESS_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IP_V6_ADDRESS_H +./inet/networklayer/contract/ipv6/Ipv6Address.h:20:5: warning: invalid case style for enum constant 'IPv6_ADDRESS_SIZE' [readability-identifier-naming] + 20 | IPv6_ADDRESS_SIZE = 16 // bytes + | ^~~~~~~~~~~~~~~~~ + | I_PV6_ADDRESS_SIZE +./inet/networklayer/contract/ipv6/Ipv6Address.h:101:17: warning: 2 adjacent parameters of 'Ipv6Address' of similar type ('uint64_t') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 101 | Ipv6Address(uint64_t hi, uint64_t lo) + | ^~~~~~~~~~~~~~~~~~~~~~~~ +./inet/networklayer/contract/ipv6/Ipv6Address.h:101:26: note: the first parameter in the range is 'hi' + 101 | Ipv6Address(uint64_t hi, uint64_t lo) + | ^~ +./inet/networklayer/contract/ipv6/Ipv6Address.h:101:39: note: the last parameter in the range is 'lo' + 101 | Ipv6Address(uint64_t hi, uint64_t lo) + | ^~ +./inet/networklayer/contract/ipv6/Ipv6Address.h:141:5: warning: function 'compare' should be marked [[nodiscard]] [modernize-use-nodiscard] + 141 | int compare(const Ipv6Address& addr) const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:177:5: warning: function 'str' should be marked [[nodiscard]] [modernize-use-nodiscard] + 177 | std::string str() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:201:5: warning: function 'words' should be marked [[nodiscard]] [modernize-use-nodiscard] + 201 | const uint32_t *words() const { return d; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:206:5: warning: function 'getScope' should be marked [[nodiscard]] [modernize-use-nodiscard] + 206 | Scope getScope() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:224:5: warning: function 'getPrefix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 224 | Ipv6Address getPrefix(int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:230:5: warning: function 'getSuffix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 230 | Ipv6Address getSuffix(int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:250:5: warning: function 'formSolicitedNodeMulticastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 250 | Ipv6Address formSolicitedNodeMulticastAddress() const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:255:5: warning: function 'isSolicitedNodeMulticastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 255 | bool isSolicitedNodeMulticastAddress() const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:265:5: warning: function 'formSubnetRouterAnycastAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 265 | Ipv6Address formSubnetRouterAnycastAddress(int prefixLength) const + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:278:5: warning: function 'matches' should be marked [[nodiscard]] [modernize-use-nodiscard] + 278 | bool matches(const Ipv6Address& prefix, int prefixLength) const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:283:5: warning: function 'isUnspecified' should be marked [[nodiscard]] [modernize-use-nodiscard] + 283 | bool isUnspecified() const { return (d[0] | d[1] | d[2] | d[3]) == 0; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:286:5: warning: function 'isMulticast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 286 | bool isMulticast() const { return getScope() == MULTICAST; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:289:5: warning: function 'isUnicast' should be marked [[nodiscard]] [modernize-use-nodiscard] + 289 | bool isUnicast() const { return getScope() != MULTICAST && getScope() != UNSPECIFIED; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:292:5: warning: function 'isLoopback' should be marked [[nodiscard]] [modernize-use-nodiscard] + 292 | bool isLoopback() const { return getScope() == LOOPBACK; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:295:5: warning: function 'isLinkLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 295 | bool isLinkLocal() const { return getScope() == LINK; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:298:5: warning: function 'isSiteLocal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 298 | bool isSiteLocal() const { return getScope() == SITE; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:301:5: warning: function 'isGlobal' should be marked [[nodiscard]] [modernize-use-nodiscard] + 301 | bool isGlobal() const { return getScope() == GLOBAL; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:306:5: warning: function 'getMulticastScope' should be marked [[nodiscard]] [modernize-use-nodiscard] + 306 | int getMulticastScope() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:313:5: warning: function 'isSsm' should be marked [[nodiscard]] [modernize-use-nodiscard] + 313 | bool isSsm() const { return isMulticast() && ((d[0] >> 20) & 0x0F) == 0x03; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:321:5: warning: function 'isEmbeddedRp' should be marked [[nodiscard]] [modernize-use-nodiscard] + 321 | bool isEmbeddedRp() const { return isMulticast() && ((d[0] >> 20) & 0x0F) == 0x07; } + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:329:5: warning: function 'getEmbeddedRpAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 329 | Ipv6Address getEmbeddedRpAddress() const; + | ^ + | [[nodiscard]] +./inet/networklayer/contract/ipv6/Ipv6Address.h:331:5: warning: function 'mapToMulticastMacAddress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 331 | MacAddress mapToMulticastMacAddress() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:9:9: warning: invalid case style for macro definition '__INET_APSKMODULATIONBASE_H' [readability-identifier-naming] + 9 | #define __INET_APSKMODULATIONBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_APSKMODULATIONBASE_H +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:32:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:35:5: warning: function 'getConstellation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const std::vector *getConstellation() const { return constellation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:36:5: warning: function 'getConstellationSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual unsigned int getConstellationSize() const override { return constellationSize; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:36:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 36 | virtual unsigned int getConstellationSize() const override { return constellationSize; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:37:5: warning: function 'getCodeWordSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual unsigned int getCodeWordSize() const override { return codeWordSize; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:37:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual unsigned int getCodeWordSize() const override { return codeWordSize; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/ApskModulationBase.h:39:5: warning: function 'mapToConstellationDiagram' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual const ApskSymbol *mapToConstellationDiagram(const ShortBitVector& symbol) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/PhysicalLayerDefs.h:9:9: warning: invalid case style for macro definition '__INET_PHYSICALLAYERDEFS_H' [readability-identifier-naming] + 9 | #define __INET_PHYSICALLAYERDEFS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYERDEFS_H +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:9:9: warning: invalid case style for macro definition '__INET_TRANSMISSIONBASE_H' [readability-identifier-naming] + 9 | #define __INET_TRANSMISSIONBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_TRANSMISSIONBASE_H +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:50:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 50 | virtual ~TransmissionBase(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:52:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual int getId() const override { return id; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:52:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 52 | virtual int getId() const override { return id; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:54:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 54 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:56:5: warning: function 'getTransmitterRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual const IRadio *getTransmitterRadio() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:56:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 56 | virtual const IRadio *getTransmitterRadio() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:57:5: warning: function 'getTransmitterRadioId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual int getTransmitterRadioId() const override { return transmitterRadioId; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:57:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 57 | virtual int getTransmitterRadioId() const override { return transmitterRadioId; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:58:5: warning: function 'getTransmitterAntennaGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual const IAntennaGain *getTransmitterAntennaGain() const override { return transmitterGain.get(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:58:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 58 | virtual const IAntennaGain *getTransmitterAntennaGain() const override { return transmitterGain.get(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:59:5: warning: function 'getMedium' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual const IRadioMedium *getMedium() const override { return radioMedium; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:59:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 59 | virtual const IRadioMedium *getMedium() const override { return radioMedium; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:60:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual const Packet *getPacket() const override { return packetModel != nullptr ? packetModel->getPacket() : packet; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:60:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 60 | virtual const Packet *getPacket() const override { return packetModel != nullptr ? packetModel->getPacket() : packet; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:62:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual const simtime_t getStartTime() const override { return startTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:62:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual const simtime_t getStartTime() const override { return startTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:63:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual const simtime_t getEndTime() const override { return endTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:63:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual const simtime_t getEndTime() const override { return endTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:64:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:64:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:65:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:65:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:67:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 67 | virtual const simtime_t getPreambleStartTime() const override { return startTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:67:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 67 | virtual const simtime_t getPreambleStartTime() const override { return startTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:68:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 68 | virtual const simtime_t getPreambleEndTime() const override { return startTime + preambleDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:68:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 68 | virtual const simtime_t getPreambleEndTime() const override { return startTime + preambleDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:69:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual const simtime_t getHeaderStartTime() const override { return startTime + preambleDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:69:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 69 | virtual const simtime_t getHeaderStartTime() const override { return startTime + preambleDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:70:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | virtual const simtime_t getHeaderEndTime() const override { return endTime - dataDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:70:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual const simtime_t getHeaderEndTime() const override { return endTime - dataDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:71:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 71 | virtual const simtime_t getDataStartTime() const override { return endTime - dataDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:71:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 71 | virtual const simtime_t getDataStartTime() const override { return endTime - dataDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:72:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | virtual const simtime_t getDataEndTime() const override { return endTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:72:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual const simtime_t getDataEndTime() const override { return endTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:74:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual const simtime_t getDuration() const override { return endTime - startTime; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:74:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual const simtime_t getDuration() const override { return endTime - startTime; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:75:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:75:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:77:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | virtual const simtime_t getPreambleDuration() const override { return preambleDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:77:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual const simtime_t getPreambleDuration() const override { return preambleDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:78:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | virtual const simtime_t getHeaderDuration() const override { return headerDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:78:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual const simtime_t getHeaderDuration() const override { return headerDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:79:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | virtual const simtime_t getDataDuration() const override { return dataDuration; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:79:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual const simtime_t getDataDuration() const override { return dataDuration; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:81:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual const Coord& getStartPosition() const override { return startPosition; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:81:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual const Coord& getStartPosition() const override { return startPosition; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:82:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual const Coord& getEndPosition() const override { return endPosition; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:82:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 82 | virtual const Coord& getEndPosition() const override { return endPosition; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:84:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | virtual const Quaternion& getStartOrientation() const override { return startOrientation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:84:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 84 | virtual const Quaternion& getStartOrientation() const override { return startOrientation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:85:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const Quaternion& getEndOrientation() const override { return endOrientation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:85:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 85 | virtual const Quaternion& getEndOrientation() const override { return endOrientation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:87:5: warning: function 'getPacketModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 87 | virtual const ITransmissionPacketModel *getPacketModel() const override { return packetModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:87:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 87 | virtual const ITransmissionPacketModel *getPacketModel() const override { return packetModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:88:5: warning: function 'getBitModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | virtual const ITransmissionBitModel *getBitModel() const override { return bitModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:88:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual const ITransmissionBitModel *getBitModel() const override { return bitModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:89:5: warning: function 'getSymbolModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | virtual const ITransmissionSymbolModel *getSymbolModel() const override { return symbolModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:89:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual const ITransmissionSymbolModel *getSymbolModel() const override { return symbolModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:90:5: warning: function 'getSampleModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const ITransmissionSampleModel *getSampleModel() const override { return sampleModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:90:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual const ITransmissionSampleModel *getSampleModel() const override { return sampleModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:91:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const ITransmissionAnalogModel *getAnalogModel() const override { return analogModel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/base/packetlevel/TransmissionBase.h:91:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual const ITransmissionAnalogModel *getAnalogModel() const override { return analogModel; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/contract/bitlevel/ICode.h:9:9: warning: invalid case style for macro definition '__INET_ICODE_H' [readability-identifier-naming] + 9 | #define __INET_ICODE_H + | ^~~~~~~~~~~~~~ + | INET_ICODE_H +./inet/physicallayer/wireless/common/contract/bitlevel/ICode.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 15 | + 16 | class INET_API ICode : public IPrintableObject + 17 | { + 18 | }; + 19 | + 20 | } /* namespace physicallayer */ + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 21 | } /* namespace inet */ + | ~~~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:9:9: warning: invalid case style for macro definition '__INET_IFECCODER_H' [readability-identifier-naming] + 9 | #define __INET_IFECCODER_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IFECCODER_H +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:20:5: warning: function 'getCodeRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 20 | virtual double getCodeRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:21:5: warning: function 'getEncodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual int getEncodedLength(int decodedLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:22:5: warning: function 'getDecodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual int getDecodedLength(int encodedLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:23:5: warning: function 'computeNetBitErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual double computeNetBitErrorRate(double grossBitErrorRate) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:29:5: warning: function 'encode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual BitVector encode(const BitVector& informationBits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:30:5: warning: function 'decode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual std::pair decode(const BitVector& encodedBits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IFecCoder.h:31:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const IForwardErrorCorrection *getForwardErrorCorrection() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:9:9: warning: invalid case style for macro definition '__INET_IINTERLEAVER_H' [readability-identifier-naming] + 9 | #define __INET_IINTERLEAVER_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IINTERLEAVER_H +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 16 | + 17 | class INET_API IInterleaving : public IPrintableObject + 18 | { + 19 | }; + 20 | + 21 | class INET_API IInterleaver : public IPrintableObject + 22 | { + 23 | public: + 24 | virtual BitVector interleave(const BitVector& bits) const = 0; + 25 | virtual BitVector deinterleave(const BitVector& bits) const = 0; + 26 | virtual const IInterleaving *getInterleaving() const = 0; + 27 | }; + 28 | + 29 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:24:5: warning: function 'interleave' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual BitVector interleave(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:25:5: warning: function 'deinterleave' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual BitVector deinterleave(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IInterleaver.h:26:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const IInterleaving *getInterleaving() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:9:9: warning: invalid case style for macro definition '__INET_ISCRAMBLER_H' [readability-identifier-naming] + 9 | #define __INET_ISCRAMBLER_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ISCRAMBLER_H +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:21:5: warning: function 'getGeneratorPolynomial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | const ShortBitVector& getGeneratorPolynomial() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:22:5: warning: function 'getSeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | const ShortBitVector& getSeed() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:28:5: warning: function 'scramble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual BitVector scramble(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:29:5: warning: function 'descramble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual BitVector descramble(const BitVector& bits) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/IScrambler.h:30:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const IScrambling *getScrambling() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALANALOGMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALANALOGMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALANALOGMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:27:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual const simtime_t getPreambleDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:32:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getHeaderDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:37:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual const simtime_t getDataDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalAnalogModel.h:42:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALBITMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALBITMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALBITMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:29:5: warning: function 'getHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual b getHeaderLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:34:5: warning: function 'getDataLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual b getDataLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:39:5: warning: function 'getHeaderGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual bps getHeaderGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:44:5: warning: function 'getDataGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual bps getDataGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:49:5: warning: function 'getAllBits' should be marked [[nodiscard]] [modernize-use-nodiscard] + 49 | virtual const BitVector *getAllBits() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:55:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual const IForwardErrorCorrection *getForwardErrorCorrection() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:56:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual const IScrambling *getScrambling() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:57:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual const IInterleaving *getInterleaving() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalBitModel.h:63:5: warning: function 'getBitErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual double getBitErrorRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALPACKETMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALPACKETMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALPACKETMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | + 19 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:31:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const Packet *getPacket() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:36:5: warning: function 'getHeaderNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual bps getHeaderNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:41:5: warning: function 'getDataNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual bps getDataNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalPacketModel.h:51:5: warning: function 'getPacketErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual double getPacketErrorRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALSAMPLEMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALSAMPLEMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALSAMPLEMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:27:5: warning: function 'getHeaderSampleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual int getHeaderSampleLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:29:5: warning: function 'getHeaderSampleRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual double getHeaderSampleRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:31:5: warning: function 'getDataSampleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual int getDataSampleLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:33:5: warning: function 'getDataSampleRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual double getDataSampleRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSampleModel.h:35:5: warning: function 'getSamples' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const std::vector *getSamples() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:9:9: warning: invalid case style for macro definition '__INET_ISIGNALSYMBOLMODEL_H' [readability-identifier-naming] + 9 | #define __INET_ISIGNALSYMBOLMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISIGNALSYMBOLMODEL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:28:5: warning: function 'getHeaderSymbolLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual int getHeaderSymbolLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:33:5: warning: function 'getHeaderSymbolRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual double getHeaderSymbolRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:38:5: warning: function 'getDataSymbolLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getDataSymbolLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:43:5: warning: function 'getDataSymbolRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual double getDataSymbolRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:48:5: warning: function 'getAllSymbols' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual const std::vector *getAllSymbols() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:54:5: warning: function 'getHeaderModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 54 | virtual const IModulation *getHeaderModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:55:5: warning: function 'getDataModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual const IModulation *getDataModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISignalSymbolModel.h:61:5: warning: function 'getSymbolErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | virtual double getSymbolErrorRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/bitlevel/ISymbol.h:9:9: warning: invalid case style for macro definition '__INET_ISYMBOL_H' [readability-identifier-naming] + 9 | #define __INET_ISYMBOL_H + | ^~~~~~~~~~~~~~~~ + | INET_ISYMBOL_H +./inet/physicallayer/wireless/common/contract/bitlevel/ISymbol.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 16 | + 17 | class INET_API ISymbol + 18 | { + 19 | public: + 20 | virtual ~ISymbol() {} + 21 | }; + 22 | + 23 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 24 | + 25 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/bitlevel/ISymbol.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~ISymbol() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:9:9: warning: invalid case style for macro definition '__INET_IANTENNA_H' [readability-identifier-naming] + 9 | #define __INET_IANTENNA_H + | ^~~~~~~~~~~~~~~~~ + | INET_IANTENNA_H +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:29:5: warning: function 'getMobility' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual IMobility *getMobility() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:34:5: warning: function 'isDirectional' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual bool isDirectional() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:41:5: warning: function 'getGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual Ptr getGain() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntenna.h:46:5: warning: function 'getNumAntennas' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual int getNumAntennas() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IAntennaGain.h:8:9: warning: invalid case style for macro definition '__INET_IANTENNAGAIN_H' [readability-identifier-naming] + 8 | #define __INET_IANTENNAGAIN_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IANTENNAGAIN_H +./inet/physicallayer/wireless/common/contract/packetlevel/IAntennaGain.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:9:9: warning: invalid case style for macro definition '__INET_IAPSKMODULATION_H' [readability-identifier-naming] + 9 | #define __INET_IAPSKMODULATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IAPSKMODULATION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 16 | + 17 | /** + 18 | * This interface represents an amplitude phase shift keying method. + 19 | */ + 20 | class INET_API IApskModulation : public IModulation + 21 | { + 22 | public: + 23 | virtual unsigned int getCodeWordSize() const = 0; + 24 | virtual unsigned int getConstellationSize() const = 0; + 25 | }; + 26 | + 27 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:23:5: warning: function 'getCodeWordSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual unsigned int getCodeWordSize() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IApskModulation.h:24:5: warning: function 'getConstellationSize' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | virtual unsigned int getConstellationSize() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:9:9: warning: invalid case style for macro definition '__INET_IARRIVAL_H' [readability-identifier-naming] + 9 | #define __INET_IARRIVAL_H + | ^~~~~~~~~~~~~~~~~ + | INET_IARRIVAL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:29:5: warning: function 'getStartPropagationTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const simtime_t getStartPropagationTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:30:5: warning: function 'getEndPropagationTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual const simtime_t getEndPropagationTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:32:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:33:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:35:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:36:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:38:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual const simtime_t getPreambleStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:39:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual const simtime_t getPreambleEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:40:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual const simtime_t getHeaderStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:41:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual const simtime_t getHeaderEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:42:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual const simtime_t getDataStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:43:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual const simtime_t getDataEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:45:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:46:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:48:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual const Quaternion& getStartOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IArrival.h:49:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 49 | virtual const Quaternion& getEndOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IBackgroundNoise.h:9:9: warning: invalid case style for macro definition '__INET_IBACKGROUNDNOISE_H' [readability-identifier-naming] + 9 | #define __INET_IBACKGROUNDNOISE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IBACKGROUNDNOISE_H +./inet/physicallayer/wireless/common/contract/packetlevel/IBackgroundNoise.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 17 | + 18 | /** + 19 | * This interface models a source which provides background noise over space and time. + 20 | */ + 21 | class INET_API IBackgroundNoise : public virtual IPrintableObject + 22 | { + 23 | public: + 24 | virtual const INoise *computeNoise(const IListening *listening) const = 0; + 25 | }; + 26 | + 27 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 28 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:9:9: warning: invalid case style for macro definition '__INET_ICOMMUNICATIONCACHE_H' [readability-identifier-naming] + 9 | #define __INET_ICOMMUNICATIONCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ICOMMUNICATIONCACHE_H +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:20:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 20 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 21 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:31:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 31 | virtual ~ICommunicationCache() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:31:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 31 | virtual ~ICommunicationCache() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:37:5: warning: function 'getRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual const IRadio *getRadio(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:39:5: warning: function 'getNumRadios' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual int getNumRadios() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:46:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const ITransmission *getTransmission(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ICommunicationCache.h:48:5: warning: function 'getNumTransmissions' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual int getNumTransmissions() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:9:9: warning: invalid case style for macro definition '__INET_IINTERFERENCE_H' [readability-identifier-naming] + 9 | #define __INET_IINTERFERENCE_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IINTERFERENCE_H +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:26:5: warning: function 'getBackgroundNoise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const INoise *getBackgroundNoise() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IInterference.h:28:5: warning: function 'getInterferingReceptions' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual const std::vector *getInterferingReceptions() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:9:9: warning: invalid case style for macro definition '__INET_ILISTENING_H' [readability-identifier-naming] + 9 | #define __INET_ILISTENING_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_ILISTENING_H +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:26:5: warning: function 'getReceiverRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const IRadio *getReceiverRadio() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:28:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:29:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:31:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListening.h:32:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:9:9: warning: invalid case style for macro definition '__INET_ILISTENINGDECISION_H' [readability-identifier-naming] + 9 | #define __INET_ILISTENINGDECISION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ILISTENINGDECISION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:25:5: warning: function 'getListening' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual const IListening *getListening() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IListeningDecision.h:27:5: warning: function 'isListeningPossible' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual bool isListeningPossible() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumAnalogModel.h:9:9: warning: invalid case style for macro definition '__INET_IMEDIUMANALOGMODEL_H' [readability-identifier-naming] + 9 | #define __INET_IMEDIUMANALOGMODEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMEDIUMANALOGMODEL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumAnalogModel.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:9:9: warning: invalid case style for macro definition '__INET_IMEDIUMLIMITCACHE_H' [readability-identifier-naming] + 9 | #define __INET_IMEDIUMLIMITCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IMEDIUMLIMITCACHE_H +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:38:5: warning: function 'getMinConstraintArea' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual Coord getMinConstraintArea() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:44:5: warning: function 'getMaxConstraintArea' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual Coord getMaxConstraintArea() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:50:5: warning: function 'getMaxSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual mps getMaxSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:56:5: warning: function 'getMaxTransmissionPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual W getMaxTransmissionPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:62:5: warning: function 'getMinInterferencePower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual W getMinInterferencePower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:68:5: warning: function 'getMinReceptionPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 68 | virtual W getMinReceptionPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:74:5: warning: function 'getMaxAntennaGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual double getMaxAntennaGain() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:80:5: warning: function 'getMinInterferenceTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual const simtime_t& getMinInterferenceTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:86:5: warning: function 'getMaxTransmissionDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 86 | virtual const simtime_t& getMaxTransmissionDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:92:5: warning: function 'getMaxCommunicationRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | virtual m getMaxCommunicationRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IMediumLimitCache.h:98:5: warning: function 'getMaxInterferenceRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual m getMaxInterferenceRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:9:9: warning: invalid case style for macro definition '__INET_IMODULATION_H' [readability-identifier-naming] + 9 | #define __INET_IMODULATION_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_IMODULATION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:32:5: warning: function 'calculateBER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual double calculateBER(double snir, Hz bandwidth, bps bitrate) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation.h:38:5: warning: function 'calculateSER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual double calculateSER(double snir, Hz bandwidth, bps bitrate) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IMODULATION_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IMODULATION_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IMODULATION_M_H +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | + 35 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 36 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/packetlevel/IModulation_m.h:46:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 46 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 47 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 48 | + 49 | + 50 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 51 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/contract/packetlevel/INeighborCache.h:9:9: warning: invalid case style for macro definition '__INET_INEIGHBORCACHE_H' [readability-identifier-naming] + 9 | #define __INET_INEIGHBORCACHE_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_INEIGHBORCACHE_H +./inet/physicallayer/wireless/common/contract/packetlevel/INeighborCache.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:9:9: warning: invalid case style for macro definition '__INET_INOISE_H' [readability-identifier-naming] + 9 | #define __INET_INOISE_H + | ^~~~~~~~~~~~~~~ + | INET_INOISE_H +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:26:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:27:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:29:5: warning: function 'computeMinPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual W computeMinPower(simtime_t startTime, simtime_t endTime) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/INoise.h:30:5: warning: function 'computeMaxPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual W computeMaxPower(simtime_t startTime, simtime_t endTime) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IObstacleLoss.h:9:9: warning: invalid case style for macro definition '__INET_IOBSTACLELOSS_H' [readability-identifier-naming] + 9 | #define __INET_IOBSTACLELOSS_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IOBSTACLELOSS_H +./inet/physicallayer/wireless/common/contract/packetlevel/IObstacleLoss.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IObstacleLoss.h:31:5: warning: function 'computeObstacleLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual double computeObstacleLoss(Hz frequency, const Coord& transmissionPosition, const Coord& receptionPosition) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:9:9: warning: invalid case style for macro definition '__INET_IPATHLOSS_H' [readability-identifier-naming] + 9 | #define __INET_IPATHLOSS_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IPATHLOSS_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:47:5: warning: function 'computeDistancePathLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual double computeDistancePathLoss(mps propagationSpeed, Hz frequency, m distance) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IPathLoss.h:53:5: warning: function 'computeRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | virtual m computeRange(mps propagationSpeed, Hz frequency, double loss) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayer.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALLAYER_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALLAYER_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALLAYER_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayer.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IPhysicalLayer() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayerFrame.h:9:9: warning: invalid case style for macro definition '__INET_IPHYSICALLAYERFRAME_H' [readability-identifier-naming] + 9 | #define __INET_IPHYSICALLAYERFRAME_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPHYSICALLAYERFRAME_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPhysicalLayerFrame.h:21:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 21 | virtual ~IPhysicalLayerFrame() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/common/contract/packetlevel/IPropagation.h:9:9: warning: invalid case style for macro definition '__INET_IPROPAGATION_H' [readability-identifier-naming] + 9 | #define __INET_IPROPAGATION_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IPROPAGATION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IPropagation.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IPropagation.h:30:5: warning: function 'getPropagationSpeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual mps getPropagationSpeed() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:9:9: warning: invalid case style for macro definition '__INET_IRADIO_H' [readability-identifier-naming] + 9 | #define __INET_IRADIO_H + | ^~~~~~~~~~~~~~~ + | INET_IRADIO_H +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:196:5: warning: function 'getRadioGate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 196 | virtual const cGate *getRadioGate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:202:5: warning: function 'getRadioMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 202 | virtual RadioMode getRadioMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:214:5: warning: function 'getReceptionState' should be marked [[nodiscard]] [modernize-use-nodiscard] + 214 | virtual ReceptionState getReceptionState() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:220:5: warning: function 'getTransmissionState' should be marked [[nodiscard]] [modernize-use-nodiscard] + 220 | virtual TransmissionState getTransmissionState() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:226:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 226 | virtual int getId() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:232:5: warning: function 'getAntenna' should be marked [[nodiscard]] [modernize-use-nodiscard] + 232 | virtual const IAntenna *getAntenna() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:237:5: warning: function 'getTransmitter' should be marked [[nodiscard]] [modernize-use-nodiscard] + 237 | virtual const ITransmitter *getTransmitter() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:242:5: warning: function 'getReceiver' should be marked [[nodiscard]] [modernize-use-nodiscard] + 242 | virtual const IReceiver *getReceiver() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:248:5: warning: function 'getMedium' should be marked [[nodiscard]] [modernize-use-nodiscard] + 248 | virtual const IRadioMedium *getMedium() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:255:5: warning: function 'getTransmissionInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 255 | virtual const ITransmission *getTransmissionInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:261:5: warning: function 'getTransmissionsInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 261 | virtual std::vector getTransmissionsInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:268:5: warning: function 'getReceptionInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 268 | virtual const ITransmission *getReceptionInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:274:5: warning: function 'getReceptionsInProgress' should be marked [[nodiscard]] [modernize-use-nodiscard] + 274 | virtual std::vector getReceptionsInProgress() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:282:5: warning: function 'getTransmittedSignalPart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 282 | virtual IRadioSignal::SignalPart getTransmittedSignalPart() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadio.h:290:5: warning: function 'getReceivedSignalPart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 290 | virtual IRadioSignal::SignalPart getReceivedSignalPart() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:9:9: warning: invalid case style for macro definition '__INET_IRADIOMEDIUM_H' [readability-identifier-naming] + 9 | #define __INET_IRADIOMEDIUM_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IRADIOMEDIUM_H +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:32:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 32 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 33 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:97:5: warning: function 'getMaterial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual const physicalenvironment::IMaterial *getMaterial() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:103:5: warning: function 'getPropagation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | virtual const IPropagation *getPropagation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:109:5: warning: function 'getPathLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | virtual const IPathLoss *getPathLoss() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:115:5: warning: function 'getObstacleLoss' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | virtual const IObstacleLoss *getObstacleLoss() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:121:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 121 | virtual const IMediumAnalogModel *getAnalogModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:127:5: warning: function 'getBackgroundNoise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 127 | virtual const IBackgroundNoise *getBackgroundNoise() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:133:5: warning: function 'getPhysicalEnvironment' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual const physicalenvironment::IPhysicalEnvironment *getPhysicalEnvironment() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:135:5: warning: function 'getMediumLimitCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 135 | virtual const IMediumLimitCache *getMediumLimitCache() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:136:5: warning: function 'getNeighborCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 136 | virtual const INeighborCache *getNeighborCache() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:137:5: warning: function 'getCommunicationCache' should be marked [[nodiscard]] [modernize-use-nodiscard] + 137 | virtual const ICommunicationCache *getCommunicationCache() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:157:5: warning: function 'getRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 157 | virtual const IRadio *getRadio(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:175:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 175 | virtual const ITransmission *getTransmission(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:183:5: warning: function 'getTransmissionTimingSnapshot' should be marked [[nodiscard]] [modernize-use-nodiscard] + 183 | virtual TransmissionTimingSnapshot getTransmissionTimingSnapshot(int id) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioMedium.h:192:5: warning: function 'computePrecedingSignalGap' should be marked [[nodiscard]] [modernize-use-nodiscard] + 192 | virtual std::optional computePrecedingSignalGap(int currentTransmissionId, + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioSignal.h:9:9: warning: invalid case style for macro definition '__INET_IRADIOSIGNAL_H' [readability-identifier-naming] + 9 | #define __INET_IRADIOSIGNAL_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IRADIOSIGNAL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IRadioSignal.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:9:9: warning: invalid case style for macro definition '__INET_IRECEIVER_H' [readability-identifier-naming] + 9 | #define __INET_IRECEIVER_H + | ^~~~~~~~~~~~~~~~~~ + | INET_IRECEIVER_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:22:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 22 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 23 | + 24 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:50:5: warning: function 'getMinInterferencePower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual W getMinInterferencePower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceiver.h:57:5: warning: function 'getMinReceptionPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual W getMinReceptionPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTION_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTION_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:32:5: warning: function 'getReceiverRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const IRadio *getReceiverRadio() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:38:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual const ITransmission *getTransmission() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:44:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:50:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 50 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:52:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:53:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:55:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 55 | virtual const simtime_t getPreambleStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:56:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 56 | virtual const simtime_t getPreambleEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:57:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 57 | virtual const simtime_t getHeaderStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:58:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual const simtime_t getHeaderEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:59:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual const simtime_t getDataStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:60:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual const simtime_t getDataEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:65:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:70:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:75:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const simtime_t getPreambleDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:80:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual const simtime_t getHeaderDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:85:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const simtime_t getDataDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:91:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:97:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:103:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | virtual const Quaternion& getStartOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:109:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 109 | virtual const Quaternion& getEndOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReception.h:114:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | virtual const IReceptionAnalogModel *getAnalogModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTIONDECISION_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTIONDECISION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTIONDECISION_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:29:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:34:5: warning: function 'getSignalPart' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual IRadioSignal::SignalPart getSignalPart() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:40:5: warning: function 'isReceptionPossible' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual bool isReceptionPossible() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:46:5: warning: function 'isReceptionAttempted' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual bool isReceptionAttempted() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionDecision.h:51:5: warning: function 'isReceptionSuccessful' should be marked [[nodiscard]] [modernize-use-nodiscard] + 51 | virtual bool isReceptionSuccessful() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionPathLoss.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTIONPATHLOSS_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTIONPATHLOSS_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTIONPATHLOSS_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionPathLoss.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:9:9: warning: invalid case style for macro definition '__INET_IRECEPTIONRESULT_H' [readability-identifier-naming] + 9 | #define __INET_IRECEPTIONRESULT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IRECEPTIONRESULT_H +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:31:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:37:5: warning: function 'getDecisions' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual const std::vector *getDecisions() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IReceptionResult.h:43:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual const Packet *getPacket() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:9:9: warning: invalid case style for macro definition '__INET_ISNIR_H' [readability-identifier-naming] + 9 | #define __INET_ISNIR_H + | ^~~~~~~~~~~~~~ + | INET_ISNIR_H +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:21:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:23:5: warning: function 'getNoise' should be marked [[nodiscard]] [modernize-use-nodiscard] + 23 | virtual const INoise *getNoise() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:25:5: warning: function 'getMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual double getMin() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:26:5: warning: function 'getMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual double getMax() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ISnir.h:27:5: warning: function 'getMean' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual double getMean() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:9:9: warning: invalid case style for macro definition '__INET_ITRANSMISSION_H' [readability-identifier-naming] + 9 | #define __INET_ITRANSMISSION_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_ITRANSMISSION_H +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:24:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 24 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 25 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:47:5: warning: function 'getId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual int getId() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:53:5: warning: function 'getTransmitterRadio' should be marked [[nodiscard]] [modernize-use-nodiscard] + 53 | virtual const IRadio *getTransmitterRadio() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:59:5: warning: function 'getTransmitterRadioId' should be marked [[nodiscard]] [modernize-use-nodiscard] + 59 | virtual int getTransmitterRadioId() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:64:5: warning: function 'getTransmitterAntennaGain' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual const IAntennaGain *getTransmitterAntennaGain() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:70:5: warning: function 'getMedium' should be marked [[nodiscard]] [modernize-use-nodiscard] + 70 | virtual const IRadioMedium *getMedium() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:76:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | virtual const Packet *getPacket() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:82:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual const simtime_t getStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:88:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | virtual const simtime_t getEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:90:5: warning: function 'getStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const simtime_t getStartTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:91:5: warning: function 'getEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const simtime_t getEndTime(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:93:5: warning: function 'getPreambleStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 93 | virtual const simtime_t getPreambleStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:94:5: warning: function 'getPreambleEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 94 | virtual const simtime_t getPreambleEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:95:5: warning: function 'getHeaderStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 95 | virtual const simtime_t getHeaderStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:96:5: warning: function 'getHeaderEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | virtual const simtime_t getHeaderEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:97:5: warning: function 'getDataStartTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | virtual const simtime_t getDataStartTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:98:5: warning: function 'getDataEndTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual const simtime_t getDataEndTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:103:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 103 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:108:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | virtual const simtime_t getDuration(IRadioSignal::SignalPart part) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:113:5: warning: function 'getPreambleDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 113 | virtual const simtime_t getPreambleDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:118:5: warning: function 'getHeaderDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 118 | virtual const simtime_t getHeaderDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:123:5: warning: function 'getDataDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | virtual const simtime_t getDataDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:128:5: warning: function 'getStartPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 128 | virtual const Coord& getStartPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:133:5: warning: function 'getEndPosition' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | virtual const Coord& getEndPosition() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:138:5: warning: function 'getStartOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 138 | virtual const Quaternion& getStartOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:143:5: warning: function 'getEndOrientation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 143 | virtual const Quaternion& getEndOrientation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:145:5: warning: function 'getPacketModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 145 | virtual const ITransmissionPacketModel *getPacketModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:146:5: warning: function 'getBitModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 146 | virtual const ITransmissionBitModel *getBitModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:147:5: warning: function 'getSymbolModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 147 | virtual const ITransmissionSymbolModel *getSymbolModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:148:5: warning: function 'getSampleModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 148 | virtual const ITransmissionSampleModel *getSampleModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmission.h:153:5: warning: function 'getAnalogModel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 153 | virtual const ITransmissionAnalogModel *getAnalogModel() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:9:9: warning: invalid case style for macro definition '__INET_ITRANSMITTER_H' [readability-identifier-naming] + 9 | #define __INET_ITRANSMITTER_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_ITRANSMITTER_H +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:30:5: warning: function 'getMaxPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual W getMaxPower() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:36:5: warning: function 'getMaxCommunicationRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual m getMaxCommunicationRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/ITransmitter.h:42:5: warning: function 'getMaxInterferenceRange' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual m getMaxInterferenceRange() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:9:9: warning: invalid case style for macro definition '__INET_IWIRELESSSIGNAL_H' [readability-identifier-naming] + 9 | #define __INET_IWIRELESSSIGNAL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IWIRELESSSIGNAL_H +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | + 19 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:31:5: warning: function 'getTransmission' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const ITransmission *getTransmission() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:36:5: warning: function 'getArrival' should be marked [[nodiscard]] [modernize-use-nodiscard] + 36 | virtual const IArrival *getArrival() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:41:5: warning: function 'getListening' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual const IListening *getListening() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/contract/packetlevel/IWirelessSignal.h:46:5: warning: function 'getReception' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const IReception *getReception() const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_RADIOCONTROLINFO_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_RADIOCONTROLINFO_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_RADIOCONTROLINFO_M_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | class ConfigureRadioCommand; + 35 | + 36 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:46:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 46 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 47 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:99:10: warning: deleted member function should be public [modernize-use-equals-delete] + 99 | bool operator==(const ConfigureRadioCommand&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:104:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 104 | virtual ~ConfigureRadioCommand(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:106:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 106 | virtual ConfigureRadioCommand *dup() const override {return new ConfigureRadioCommand(*this);} + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:106:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual ConfigureRadioCommand *dup() const override {return new ConfigureRadioCommand(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:107:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:108:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:110:5: warning: function 'getRadioMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 110 | virtual int getRadioMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:113:5: warning: function 'getPower' should be marked [[nodiscard]] [modernize-use-nodiscard] + 113 | virtual ::inet::W getPower() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:116:5: warning: function 'getBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | virtual ::inet::bps getBitrate() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:119:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 119 | virtual const IModulation * getModulation() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:123:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | virtual ::inet::Hz getCenterFrequency() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/RadioControlInfo_m.h:126:5: warning: function 'getBandwidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 126 | virtual ::inet::Hz getBandwidth() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:6:9: warning: invalid case style for macro definition '__INET_SIGNALTAG_M_H' [readability-identifier-naming] + 6 | #define __INET_SIGNALTAG_M_H + | ^~~~~~~~~~~~~~~~~~~~ + | INET_SIGNALTAG_M_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:81:10: warning: deleted member function should be public [modernize-use-equals-delete] + 81 | bool operator==(const SignalTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:86:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 86 | virtual ~SignalTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:88:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 88 | virtual SignalTagBase *dup() const override {return new SignalTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:89:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:90:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 90 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:117:10: warning: deleted member function should be public [modernize-use-equals-delete] + 117 | bool operator==(const SignalPowerTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:122:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 122 | virtual ~SignalPowerTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:124:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 124 | virtual SignalPowerTagBase *dup() const override {return new SignalPowerTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:125:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 125 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:126:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 126 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:155:10: warning: deleted member function should be public [modernize-use-equals-delete] + 155 | bool operator==(const SignalPowerReq&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:160:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 160 | virtual ~SignalPowerReq(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:162:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 162 | virtual SignalPowerReq *dup() const override {return new SignalPowerReq(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:163:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 163 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:164:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 164 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:190:10: warning: deleted member function should be public [modernize-use-equals-delete] + 190 | bool operator==(const SignalPowerInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:195:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 195 | virtual ~SignalPowerInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:197:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 197 | virtual SignalPowerInd *dup() const override {return new SignalPowerInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:198:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 198 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:199:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 199 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:228:10: warning: deleted member function should be public [modernize-use-equals-delete] + 228 | bool operator==(const SignalBandTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:233:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 233 | virtual ~SignalBandTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:235:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 235 | virtual SignalBandTagBase *dup() const override {return new SignalBandTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:236:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 236 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:237:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 237 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:269:10: warning: deleted member function should be public [modernize-use-equals-delete] + 269 | bool operator==(const SignalBandReq&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:274:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 274 | virtual ~SignalBandReq(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:276:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 276 | virtual SignalBandReq *dup() const override {return new SignalBandReq(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:277:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 277 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 278 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:304:10: warning: deleted member function should be public [modernize-use-equals-delete] + 304 | bool operator==(const SignalBandInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:309:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 309 | virtual ~SignalBandInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:311:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 311 | virtual SignalBandInd *dup() const override {return new SignalBandInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:312:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 312 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:313:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 313 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:344:10: warning: deleted member function should be public [modernize-use-equals-delete] + 344 | bool operator==(const SignalBitrateTagBase&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:349:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 349 | virtual ~SignalBitrateTagBase(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:351:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 351 | virtual SignalBitrateTagBase *dup() const override {return new SignalBitrateTagBase(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:352:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 352 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:353:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 353 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:388:10: warning: deleted member function should be public [modernize-use-equals-delete] + 388 | bool operator==(const SignalBitrateReq&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:393:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 393 | virtual ~SignalBitrateReq(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:395:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 395 | virtual SignalBitrateReq *dup() const override {return new SignalBitrateReq(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:396:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 396 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:397:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 397 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:423:10: warning: deleted member function should be public [modernize-use-equals-delete] + 423 | bool operator==(const SignalBitrateInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:428:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 428 | virtual ~SignalBitrateInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:430:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 430 | virtual SignalBitrateInd *dup() const override {return new SignalBitrateInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:431:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 431 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:432:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 432 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:464:10: warning: deleted member function should be public [modernize-use-equals-delete] + 464 | bool operator==(const SnirInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:469:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 469 | virtual ~SnirInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:471:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 471 | virtual SnirInd *dup() const override {return new SnirInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:472:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 472 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:473:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 473 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:514:10: warning: deleted member function should be public [modernize-use-equals-delete] + 514 | bool operator==(const ErrorRateInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:519:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 519 | virtual ~ErrorRateInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:521:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 521 | virtual ErrorRateInd *dup() const override {return new ErrorRateInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:522:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 522 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:523:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 523 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:564:10: warning: deleted member function should be public [modernize-use-equals-delete] + 564 | bool operator==(const SignalTimeInd&) = delete; + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:569:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 569 | virtual ~SignalTimeInd(); + | ~~~~~~~ ^ + | override +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:571:28: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 571 | virtual SignalTimeInd *dup() const override {return new SignalTimeInd(*this);} + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:572:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 572 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/common/contract/packetlevel/SignalTag_m.h:573:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 573 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h:4:9: warning: invalid case style for macro definition '__INET_TRANSMISSIONTIMINGSNAPSHOT_H' [readability-identifier-naming] + 4 | #define __INET_TRANSMISSIONTIMINGSNAPSHOT_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_TRANSMISSIONTIMINGSNAPSHOT_H +./inet/physicallayer/wireless/common/contract/packetlevel/TransmissionTimingSnapshot.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/modulation/ApskSymbol.h:9:9: warning: invalid case style for macro definition '__INET_APSKSYMBOL_H' [readability-identifier-naming] + 9 | #define __INET_APSKSYMBOL_H + | ^~~~~~~~~~~~~~~~~~~ + | INET_APSKSYMBOL_H +./inet/physicallayer/wireless/common/modulation/ApskSymbol.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 19 | + 20 | class INET_API ApskSymbol : public std::complex, public ISymbol + 21 | { + 22 | public: + 23 | ApskSymbol() : std::complex() {} + 24 | ApskSymbol(const double& r) : std::complex(r) {} + 25 | ApskSymbol(const double& q, const double& i) : std::complex(q, i) {} + 26 | ApskSymbol(const std::complex& w) : std::complex(w) {} + 27 | }; + 28 | + 29 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 30 | + 31 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:9:9: warning: invalid case style for macro definition '__INET_ADDITIVESCRAMBLING_H' [readability-identifier-naming] + 9 | #define __INET_ADDITIVESCRAMBLING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ADDITIVESCRAMBLING_H +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:26:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:28:5: warning: function 'getGeneratorPolynomial' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const ShortBitVector& getGeneratorPolynomial() const { return generatorPolynomial; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/AdditiveScrambling.h:29:5: warning: function 'getSeed' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | const ShortBitVector& getSeed() const { return seed; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:9:9: warning: invalid case style for macro definition '__INET_CONVOLUTIONALCODE_H' [readability-identifier-naming] + 9 | #define __INET_CONVOLUTIONALCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_CONVOLUTIONALCODE_H +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:30:5: warning: function 'getCodeRatePuncturingK' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | int getCodeRatePuncturingK() const { return codeRatePuncturingK; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:31:5: warning: function 'getCodeRatePuncturingN' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | int getCodeRatePuncturingN() const { return codeRatePuncturingN; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:32:5: warning: function 'getConstraintLengthVector' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const char *getConstraintLengthVector() const { return constraintLengthVector; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:33:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | const char *getMode() const { return mode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:34:5: warning: function 'getPuncturingMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | const char *getPuncturingMatrix() const { return puncturingMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:35:5: warning: function 'getTransferFunctionMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 35 | const char *getTransferFunctionMatrix() const { return transferFunctionMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:37:5: warning: function 'getCodeRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual double getCodeRate() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:37:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 37 | virtual double getCodeRate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:38:5: warning: function 'getEncodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 38 | virtual int getEncodedLength(int decodedLength) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:38:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 38 | virtual int getEncodedLength(int decodedLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:39:5: warning: function 'getDecodedLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 39 | virtual int getDecodedLength(int encodedLength) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:39:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 39 | virtual int getDecodedLength(int encodedLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:40:5: warning: function 'computeNetBitErrorRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual double computeNetBitErrorRate(double grossBitErrorRate) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCode.h:40:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 40 | virtual double computeNetBitErrorRate(double grossBitErrorRate) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:9:9: warning: invalid case style for macro definition '__INET_CONVOLUTIONALCODER_H' [readability-identifier-naming] + 9 | #define __INET_CONVOLUTIONALCODER_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_CONVOLUTIONALCODER_H +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:19:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 19 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:40:5: warning: use 'using' instead of 'typedef' [modernize-use-using] + 40 | typedef std::vector> ShortBitVectorMatrix; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | using ShortBitVectorMatrix = std::vector> +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:26: warning: 6 adjacent parameters of 'TrellisGraphNode' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:30: note: the first parameter in the range is 'symbol' + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^~~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:118: note: the last parameter in the range is 'depth' + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^~~~~ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:51:105: note: 'int' and 'unsigned int' may be implicitly converted + 51 | TrellisGraphNode(int symbol, int state, int prevState, int hammingDistance, int numberOfErrors, unsigned int depth) : + | ^ +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:77:5: warning: function 'eXOR' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | inline bool eXOR(bool alpha, bool beta) const { return alpha != beta; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:79:5: warning: function 'inputSymbolToOutputSymbol' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | ShortBitVector inputSymbolToOutputSymbol(const ShortBitVector& state, const ShortBitVector& inputSymbol) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:80:5: warning: function 'modulo2Adder' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | bool modulo2Adder(const ShortBitVector& shiftRegisters, const ShortBitVector& generatorPolynomial) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:82:5: warning: function 'puncturing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | BitVector puncturing(const BitVector& informationBits) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:84:5: warning: function 'getPuncturedIndices' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | BitVector getPuncturedIndices(unsigned int length) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:85:5: warning: function 'computeHammingDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | inline unsigned int computeHammingDistance(const ShortBitVector& u, const ShortBitVector& excludedBits, const ShortBitVector& w) const + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:97:5: warning: function 'isCompletelyDecoded' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | bool isCompletelyDecoded(unsigned int encodedLength, unsigned int decodedLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:114:5: warning: function 'octalToBinary' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | ShortBitVector octalToBinary(int octalNum, int fixedSize) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:115:5: warning: function 'octalToDec' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | int octalToDec(int octalNum) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:120:5: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + 120 | ~ConvolutionalCoder(); + | ^ + | override +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:122:5: warning: function 'encode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | BitVector encode(const BitVector& informationBits) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:123:5: warning: function 'decode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | std::pair decode(const BitVector& encodedBits) const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:124:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | const ConvolutionalCode *getForwardErrorCorrection() const override { return convolutionalCode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:129:5: warning: function 'getMemorySizeSum' should be marked [[nodiscard]] [modernize-use-nodiscard] + 129 | unsigned int getMemorySizeSum() const { return memorySizeSum; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:130:5: warning: function 'getConstraintLengthVector' should be marked [[nodiscard]] [modernize-use-nodiscard] + 130 | const std::vector& getConstraintLengthVector() const { return constraintLengths; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:131:5: warning: function 'getTransferFunctionMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 131 | const ShortBitVectorMatrix& getTransferFunctionMatrix() const { return transferFunctionMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:132:5: warning: function 'getPuncturingMatrix' should be marked [[nodiscard]] [modernize-use-nodiscard] + 132 | const std::vector& getPuncturingMatrix() const { return puncturingMatrix; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:133:5: warning: function 'getNumberOfStates' should be marked [[nodiscard]] [modernize-use-nodiscard] + 133 | int getNumberOfStates() const { return numberOfStates; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:134:5: warning: function 'getNumberOfOutputSymbols' should be marked [[nodiscard]] [modernize-use-nodiscard] + 134 | int getNumberOfOutputSymbols() const { return numberOfOutputSymbols; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:135:5: warning: function 'getNumberOfInputSymbols' should be marked [[nodiscard]] [modernize-use-nodiscard] + 135 | int getNumberOfInputSymbols() const { return numberOfInputSymbols; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:140:5: warning: function 'getStateTransitionTable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 140 | const int **getStateTransitionTable() const { return (const int **)stateTransitions; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/common/radio/bitlevel/ConvolutionalCoder.h:141:5: warning: function 'getOutputTable' should be marked [[nodiscard]] [modernize-use-nodiscard] + 141 | const int **getOutputTable() const { return (const int **)inputSymbols; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211ConvolutionalCode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211CONVOLUTIONALCODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211CONVOLUTIONALCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_CONVOLUTIONALCODE_H +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211ConvolutionalCode.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211HTINTERLEAVING_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211HTINTERLEAVING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTINTERLEAVING_H +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:67: note: the first parameter in the range is 'level' + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ^~~~~ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211HtInterleaving.h:29:78: note: the last parameter in the range is 'evFlags' + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211HtInterleaving"; } + | ^~~~~~~ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMINTERLEAVING_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMINTERLEAVING_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMINTERLEAVING_H +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:26:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:28:5: warning: function 'getNumberOfCodedBitsPerSubcarrier' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | int getNumberOfCodedBitsPerSubcarrier() const { return numberOfCodedBitsPerSubcarrier; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211OfdmInterleaving.h:29:5: warning: function 'getNumberOfCodedBitsPerSymbol' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | int getNumberOfCodedBitsPerSymbol() const { return numberOfCodedBitsPerSymbol; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:9:9: warning: invalid case style for macro definition '__INET_IIEEE80211MODE_H' [readability-identifier-naming] + 9 | #define __INET_IIEEE80211MODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~ + | INET_IIEE_E80211_MODE_H +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:21:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 21 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:22:5: warning: function 'createPreamble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual Ptr createPreamble() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:28:5: warning: function 'getNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual bps getNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:29:5: warning: function 'getGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual bps getGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:30:5: warning: function 'getLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual b getLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:31:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual const simtime_t getDuration() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:32:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getSymbolInterval() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:33:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const IModulation *getModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:34:5: warning: function 'createHeader' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual Ptr createHeader() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:40:5: warning: function 'getBandwidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 40 | virtual Hz getBandwidth() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:41:5: warning: function 'getNetBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 41 | virtual bps getNetBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:42:5: warning: function 'getGrossBitrate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual bps getGrossBitrate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:43:5: warning: function 'getPaddingLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 43 | virtual b getPaddingLength(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:44:5: warning: function 'getCompleteLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual b getCompleteLength(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:45:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual const simtime_t getDuration(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:46:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual const simtime_t getSymbolInterval() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:47:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual const IModulation *getModulation() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:48:5: warning: function 'getNumberOfSpatialStreams' should be marked [[nodiscard]] [modernize-use-nodiscard] + 48 | virtual int getNumberOfSpatialStreams() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:58:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 58 | virtual ModulationClass getModulationClass() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:60:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 60 | virtual PreambleType getLegacyPreambleType() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:65:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual bps getNonHtReferenceRate() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:69:5: warning: function 'getHtMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 69 | virtual int getHtMcsIndex() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:72:5: warning: function 'isHtShortGuardInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | virtual bool isHtShortGuardInterval() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:73:5: warning: function 'getLegacyCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | virtual int getLegacyCwMin() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:74:5: warning: function 'getLegacyCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | virtual int getLegacyCwMax() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:75:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const char *getName() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:75:25: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 75 | virtual const char *getName() const = 0; + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:76:5: warning: function 'getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | virtual const IIeee80211PreambleMode *getPreambleMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:77:5: warning: function 'getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | virtual const IIeee80211HeaderMode *getHeaderMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:78:5: warning: function 'getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | virtual const IIeee80211DataMode *getDataMode() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:79:5: warning: function '_getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | IIeee80211PreambleMode *_getPreambleMode() const { return const_cast(getPreambleMode()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:79:29: warning: invalid case style for method '_getPreambleMode' [readability-identifier-naming] + 79 | IIeee80211PreambleMode *_getPreambleMode() const { return const_cast(getPreambleMode()); } + | ^~~~~~~~~~~~~~~~ + | getPreambleMode +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:80:5: warning: function '_getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | IIeee80211HeaderMode *_getHeaderMode() const { return const_cast(getHeaderMode()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:80:27: warning: invalid case style for method '_getHeaderMode' [readability-identifier-naming] + 80 | IIeee80211HeaderMode *_getHeaderMode() const { return const_cast(getHeaderMode()); } + | ^~~~~~~~~~~~~~ + | getHeaderMode +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:81:5: warning: function '_getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | IIeee80211DataMode *_getDataMode() const { return const_cast(getDataMode()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:81:25: warning: invalid case style for method '_getDataMode' [readability-identifier-naming] + 81 | IIeee80211DataMode *_getDataMode() const { return const_cast(getDataMode()); } + | ^~~~~~~~~~~~ + | getDataMode +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:82:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 82 | virtual const simtime_t getDuration(b dataLength) const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:83:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 83 | virtual const simtime_t getSlotTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:84:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 84 | virtual const simtime_t getSifsTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:85:5: warning: function 'getRifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | virtual const simtime_t getRifsTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:87:5: warning: function 'getSignalExtensionTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 87 | virtual const simtime_t getSignalExtensionTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:88:5: warning: function 'getCcaTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | virtual const simtime_t getCcaTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:89:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | virtual const simtime_t getPhyRxStartDelay() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:90:5: warning: function 'getRxTxTurnaroundTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | virtual const simtime_t getRxTxTurnaroundTime() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:91:5: warning: function 'getPreambleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual const simtime_t getPreambleLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:92:5: warning: function 'getPlcpHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 92 | virtual const simtime_t getPlcpHeaderLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode.h:93:5: warning: function 'getMpduMaxLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 93 | virtual int getMpduMaxLength() const = 0; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IIEEE80211MODE_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IIEEE80211MODE_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IIEE_E80211_MODE_M_H +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | + 35 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 36 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/mode/IIeee80211Mode_m.h:51:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 51 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 52 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 53 | + 54 | + 55 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 56 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211BAND_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211BAND_H + | ^~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_BAND_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:25:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override = 0; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:26:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual const char *getName() const override = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:26:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual const char *getName() const override = 0; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:27:5: warning: function 'getNumChannels' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual int getNumChannels() const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:28:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual Hz getCenterFrequency(int channelNumber) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:29:5: warning: function 'getSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual Hz getSpacing() const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:30:5: warning: function 'getStandardChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual int getStandardChannelNumber(int channelIndex) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:31:5: warning: function 'getChannelIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual int getChannelIndex(int standardChannelNumber) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:32:5: warning: function 'isHt40OperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const = 0; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:67: note: the first parameter in the range is 'level' + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ^~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:43:78: note: the last parameter in the range is 'evFlags' + 43 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211Band, name = " << getName(); } + | ^~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:44:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 44 | virtual const char *getName() const override { return name; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:44:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 44 | virtual const char *getName() const override { return name; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:45:5: warning: function 'getStandardChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 45 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:45:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 45 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:46:5: warning: function 'getChannelIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 46 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:46:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 46 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:47:5: warning: function 'isHt40OperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:47:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 47 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:61:5: warning: function 'getNumChannels' should be marked [[nodiscard]] [modernize-use-nodiscard] + 61 | virtual int getNumChannels() const override { return centers.size(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:61:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 61 | virtual int getNumChannels() const override { return centers.size(); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:62:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 62 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:62:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 62 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:63:5: warning: function 'getSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 63 | virtual Hz getSpacing() const override { return Hz(NaN); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:63:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 63 | virtual Hz getSpacing() const override { return Hz(NaN); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:64:5: warning: function 'getStandardChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 64 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:64:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 64 | virtual int getStandardChannelNumber(int channelIndex) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:65:5: warning: function 'getChannelIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 65 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:65:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 65 | virtual int getChannelIndex(int standardChannelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:66:5: warning: function 'isHt40OperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 66 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:66:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 66 | virtual bool isHt40OperationSupported(int primaryChannelIndex, int secondaryChannelOffset) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:79:5: warning: function 'getNumChannels' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | virtual int getNumChannels() const override { return numChannels; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:79:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 79 | virtual int getNumChannels() const override { return numChannels; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:80:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:80:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 80 | virtual Hz getCenterFrequency(int channelNumber) const override; + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:81:5: warning: function 'getSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | virtual Hz getSpacing() const override { return spacing; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:81:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 81 | virtual Hz getSpacing() const override { return spacing; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:87:54: warning: invalid case style for global constant 'bands' [readability-identifier-naming] + 87 | static const std::vector bands; + | ^~~~~ + | BANDS +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:90:42: warning: invalid case style for global constant 'band2_4GHz' [readability-identifier-naming] + 90 | static const Ieee80211EnumeratedBand band2_4GHz; + | ^~~~~~~~~~ + | BAND2_4_G_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:91:44: warning: invalid case style for global constant 'band5GHz' [readability-identifier-naming] + 91 | static const Ieee80211ArithmeticalBand band5GHz; + | ^~~~~~~~ + | BAND5_G_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:92:44: warning: invalid case style for global constant 'band5GHz20MHz' [readability-identifier-naming] + 92 | static const Ieee80211ArithmeticalBand band5GHz20MHz; + | ^~~~~~~~~~~~~ + | BAND5_G_HZ20_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:94:42: warning: invalid case style for global constant 'band5GHzMapped20MHz' [readability-identifier-naming] + 94 | static const Ieee80211EnumeratedBand band5GHzMapped20MHz; + | ^~~~~~~~~~~~~~~~~~~ + | BAND5_G_HZ_MAPPED20_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:95:44: warning: invalid case style for global constant 'band5GHz40MHz' [readability-identifier-naming] + 95 | static const Ieee80211ArithmeticalBand band5GHz40MHz; + | ^~~~~~~~~~~~~ + | BAND5_G_HZ40_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:96:44: warning: invalid case style for global constant 'band5GHz80MHz' [readability-identifier-naming] + 96 | static const Ieee80211ArithmeticalBand band5GHz80MHz; + | ^~~~~~~~~~~~~ + | BAND5_G_HZ80_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:97:44: warning: invalid case style for global constant 'band5GHz160MHz' [readability-identifier-naming] + 97 | static const Ieee80211ArithmeticalBand band5GHz160MHz; + | ^~~~~~~~~~~~~~ + | BAND5_G_HZ160_M_HZ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h:98:44: warning: invalid case style for global constant 'band5_9GHz' [readability-identifier-naming] + 98 | static const Ieee80211ArithmeticalBand band5_9GHz; + | ^~~~~~~~~~ + | BAND5_9_G_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211CHANNEL_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211CHANNEL_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_CHANNEL_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | + 15 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:26:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 26 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:28:5: warning: function 'getBand' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual const IIeee80211Band *getBand() const { return band; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:29:5: warning: function 'getChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual int getChannelNumber() const { return channelNumber; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h:30:5: warning: function 'getCenterFrequency' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual Hz getCenterFrequency() const { return band->getCenterFrequency(channelNumber); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211CHANNEL_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211CHANNEL_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_CHANNEL_M_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | + 35 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 36 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel_m.h:48:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 48 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 49 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 50 | + 51 | + 52 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 53 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211HTCODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211HTCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTCODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:30:5: warning: function 'getForwardErrorCorrection' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | const Ieee80211ConvolutionalCode *getForwardErrorCorrection() const { return forwardErrorCorrection; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:31:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | const AdditiveScrambling *getScrambling() const { return scrambling; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:32:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const Ieee80211HtInterleaving *getInterleaving() const { return interleaving; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:34:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 34 | virtual ~Ieee80211HtCode(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtCode.h:42:45: warning: invalid case style for global constant 'htConvolutionalCode5_6' [readability-identifier-naming] + 42 | static const Ieee80211ConvolutionalCode htConvolutionalCode5_6; + | ^~~~~~~~~~~~~~~~~~~~~~ + | HT_CONVOLUTIONAL_CODE5_6 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211HTMODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211HTMODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_HTMODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:24:5: warning: function 'getDFTPeriod' should be marked [[nodiscard]] [modernize-use-nodiscard] + 24 | const simtime_t getDFTPeriod() const { return 3.2E-6; } // DFT + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:25:5: warning: function 'getGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | const simtime_t getGIDuration() const { return getDFTPeriod() / 4; } // GI + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:26:5: warning: function 'getShortGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | const simtime_t getShortGIDuration() const { return getDFTPeriod() / 8; } // GIS + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:27:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | const simtime_t getSymbolInterval() const { return getDFTPeriod() + getGIDuration(); } // SYM + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:28:5: warning: function 'getShortGISymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const simtime_t getShortGISymbolInterval() const { return getDFTPeriod() + getShortGIDuration(); } // SYMS + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:73:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 73 | virtual bps computeGrossBitrate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:74:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bps computeNetBitrate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:79:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 79 | virtual ~Ieee80211HtSignalMode(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:104:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual const simtime_t getDuration() const override { return getHTSIGDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:105:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 105 | virtual b getLength() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:106:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual bps getNetBitrate() const override { return Ieee80211HtModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:107:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual bps getGrossBitrate() const override { return Ieee80211HtModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:108:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 108 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211HtTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:109:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:112:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 112 | virtual Ptr createHeader() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:134:5: warning: function 'computeNumberOfSpaceTimeStreams' should be marked [[nodiscard]] [modernize-use-nodiscard] + 134 | virtual unsigned int computeNumberOfSpaceTimeStreams(unsigned int numberOfSpatialStreams) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:135:5: warning: function 'computeNumberOfHTLongTrainings' should be marked [[nodiscard]] [modernize-use-nodiscard] + 135 | virtual unsigned int computeNumberOfHTLongTrainings(unsigned int numberOfSpaceTimeStreams) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:139:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 139 | virtual ~Ieee80211HtPreambleMode() { delete highThroughputSignalMode; } + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:141:5: warning: function 'getPreambleFormat' should be marked [[nodiscard]] [modernize-use-nodiscard] + 141 | HighTroughputPreambleFormat getPreambleFormat() const { return preambleFormat; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:142:5: warning: function 'getSignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 142 | virtual const Ieee80211HtSignalMode *getSignalMode() const { return highThroughputSignalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:143:5: warning: function 'getLegacySignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 143 | virtual const Ieee80211OfdmSignalMode *getLegacySignalMode() const { return legacySignalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:144:5: warning: function 'getHighThroughputSignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 144 | virtual const Ieee80211HtSignalMode *getHighThroughputSignalMode() const { return highThroughputSignalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:146:5: warning: function 'getDoubleGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 146 | virtual const simtime_t getDoubleGIDuration() const { return 2 * getGIDuration(); } // GI2 + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:147:5: warning: function 'getLSIGDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 147 | virtual const simtime_t getLSIGDuration() const { return getSymbolInterval(); } // L-SIG + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:148:5: warning: function 'getNonHTShortTrainingSequenceDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 148 | virtual const simtime_t getNonHTShortTrainingSequenceDuration() const { return 10 * getDFTPeriod() / 4; } // L-STF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:149:5: warning: function 'getHTGreenfieldShortTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 149 | virtual const simtime_t getHTGreenfieldShortTrainingFieldDuration() const { return 10 * getDFTPeriod() / 4; } // HT-GF-STF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:150:5: warning: function 'getNonHTLongTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 150 | virtual const simtime_t getNonHTLongTrainingFieldDuration() const { return 2 * getDFTPeriod() + getDoubleGIDuration(); } // L-LTF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:151:5: warning: function 'getHTShortTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 151 | virtual const simtime_t getHTShortTrainingFieldDuration() const { return 4E-6; } // HT-STF + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:152:5: warning: function 'getFirstHTLongTrainingFieldDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 152 | virtual const simtime_t getFirstHTLongTrainingFieldDuration() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:153:5: warning: function 'getSecondAndSubsequentHTLongTrainingFielDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 153 | virtual const simtime_t getSecondAndSubsequentHTLongTrainingFielDuration() const { return 4E-6; } // HT-LTFs, s = 2,3,..,n + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:154:5: warning: function 'getNumberOfHtLongTrainings' should be marked [[nodiscard]] [modernize-use-nodiscard] + 154 | virtual unsigned int getNumberOfHtLongTrainings() const { return numberOfHTLongTrainings; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:156:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 156 | virtual const simtime_t getDuration() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:156:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 156 | virtual const simtime_t getDuration() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:158:5: warning: function 'createPreamble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 158 | virtual Ptr createPreamble() const override { return makeShared(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:158:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 158 | virtual Ptr createPreamble() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:179:5: warning: function 'getCode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 179 | const Ieee80211HtCode *getCode() const { return code; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:180:5: warning: function 'getMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 180 | unsigned int getMcsIndex() const { return mcsIndex; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:181:5: warning: function 'getModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 181 | virtual const Ieee80211OfdmModulation *getModulation() const { return stream1Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:182:5: warning: function 'getStreamExtension1Modulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 182 | virtual const Ieee80211OfdmModulation *getStreamExtension1Modulation() const { return stream2Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:183:5: warning: function 'getStreamExtension2Modulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 183 | virtual const Ieee80211OfdmModulation *getStreamExtension2Modulation() const { return stream3Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:184:5: warning: function 'getStreamExtension3Modulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 184 | virtual const Ieee80211OfdmModulation *getStreamExtension3Modulation() const { return stream4Modulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:185:5: warning: function 'getBandwidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 185 | virtual Hz getBandwidth() const { return bandwidth; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:212:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 212 | virtual Hz getBandwidth() const override { return bandwidth; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:213:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 213 | virtual int getNumberOfSpatialStreams() const override { return Ieee80211HtModeBase::getNumberOfSpatialStreams(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:214:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 214 | virtual b getPaddingLength(b dataLength) const override { return b(0); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:215:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 215 | virtual b getCompleteLength(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:216:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 216 | virtual const simtime_t getDuration(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:217:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 217 | virtual bps getNetBitrate() const override { return Ieee80211HtModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:218:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 218 | virtual bps getGrossBitrate() const override { return Ieee80211HtModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:221:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 221 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211HtTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:222:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 222 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulationAndCodingScheme->getModulation(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:239:5: warning: function 'getLegacyCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 239 | virtual int getLegacyCwMin() const override { return 15; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:239:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 239 | virtual int getLegacyCwMin() const override { return 15; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:240:5: warning: function 'getLegacyCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 240 | virtual int getLegacyCwMax() const override { return 1023; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:240:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 240 | virtual int getLegacyCwMax() const override { return 1023; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:244:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 244 | virtual ~Ieee80211HtMode() { delete preambleMode; delete dataMode; } + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:246:5: warning: function 'getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 246 | virtual const Ieee80211HtDataMode *getDataMode() const override { return dataMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:246:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 246 | virtual const Ieee80211HtDataMode *getDataMode() const override { return dataMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:247:5: warning: function 'getHtMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 247 | virtual int getHtMcsIndex() const override { return dataMode->getMcsIndex(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:247:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 247 | virtual int getHtMcsIndex() const override { return dataMode->getMcsIndex(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:248:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 248 | virtual bps getNonHtReferenceRate() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:248:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 248 | virtual bps getNonHtReferenceRate() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:249:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 249 | virtual ModulationClass getModulationClass() const override { return ModulationClass::HT; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:249:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 249 | virtual ModulationClass getModulationClass() const override { return ModulationClass::HT; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:250:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 250 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:250:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 250 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:251:5: warning: function 'isHtShortGuardInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 251 | virtual bool isHtShortGuardInterval() const override { return dataMode->getGuardIntervalType() == Ieee80211HtModeBase::HT_GUARD_INTERVAL_SHORT; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:251:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 251 | virtual bool isHtShortGuardInterval() const override { return dataMode->getGuardIntervalType() == Ieee80211HtModeBase::HT_GUARD_INTERVAL_SHORT; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:252:5: warning: function 'getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 252 | virtual const Ieee80211HtPreambleMode *getPreambleMode() const override { return preambleMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:252:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 252 | virtual const Ieee80211HtPreambleMode *getPreambleMode() const override { return preambleMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:253:5: warning: function 'getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 253 | virtual const Ieee80211HtSignalMode *getHeaderMode() const override { return preambleMode->getSignalMode(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:253:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 253 | virtual const Ieee80211HtSignalMode *getHeaderMode() const override { return preambleMode->getSignalMode(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:254:5: warning: function 'getLegacySignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 254 | virtual const Ieee80211OfdmSignalMode *getLegacySignalMode() const { return preambleMode->getLegacySignalMode(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:257:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 257 | virtual const simtime_t getSlotTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:257:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 257 | virtual const simtime_t getSlotTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:258:5: warning: function 'getShortSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 258 | virtual const simtime_t getShortSlotTime() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:259:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 259 | virtual const simtime_t getSifsTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:259:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 259 | virtual const simtime_t getSifsTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:260:5: warning: function 'getRifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 260 | virtual const simtime_t getRifsTime() const override { return 2E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:260:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 260 | virtual const simtime_t getRifsTime() const override { return 2E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:262:5: warning: function 'getSignalExtensionTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 262 | virtual const simtime_t getSignalExtensionTime() const override { return centerFrequencyMode == BAND_2_4GHZ ? SimTime(6, SIMTIME_US) : SIMTIME_ZERO; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:262:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 262 | virtual const simtime_t getSignalExtensionTime() const override { return centerFrequencyMode == BAND_2_4GHZ ? SimTime(6, SIMTIME_US) : SIMTIME_ZERO; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:263:5: warning: function 'getCcaTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 263 | virtual const simtime_t getCcaTime() const override { return 4E-6; } // < 4 + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:263:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 263 | virtual const simtime_t getCcaTime() const override { return 4E-6; } // < 4 + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:264:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 264 | virtual const simtime_t getPhyRxStartDelay() const override { return 24E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:264:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 264 | virtual const simtime_t getPhyRxStartDelay() const override { return 24E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:265:5: warning: function 'getRxTxTurnaroundTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 265 | virtual const simtime_t getRxTxTurnaroundTime() const override { return 2E-6; } // < 2 + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:265:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 265 | virtual const simtime_t getRxTxTurnaroundTime() const override { return 2E-6; } // < 2 + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:266:5: warning: function 'getPreambleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 266 | virtual const simtime_t getPreambleLength() const override { return 16E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:266:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 266 | virtual const simtime_t getPreambleLength() const override { return 16E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:267:5: warning: function 'getPlcpHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 267 | virtual const simtime_t getPlcpHeaderLength() const override { return 4E-6; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:267:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 267 | virtual const simtime_t getPlcpHeaderLength() const override { return 4E-6; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:268:5: warning: function 'getMpduMaxLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 268 | virtual int getMpduMaxLength() const override { return 65535; } // in octets + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:268:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 268 | virtual int getMpduMaxLength() const override { return 65535; } // in octets + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:269:5: warning: function 'getCenterFrequencyMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 269 | virtual BandMode getCenterFrequencyMode() const { return centerFrequencyMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:272:5: warning: function 'getMinimumMpduStartDistance' should be marked [[nodiscard]] [modernize-use-nodiscard] + 272 | B getMinimumMpduStartDistance(int minimumMpduStartSpacing) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:274:5: warning: function 'getLSigLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 274 | int getLSigLength(b dataLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:276:5: warning: function 'isPpduDurationWithinLimit' should be marked [[nodiscard]] [modernize-use-nodiscard] + 276 | bool isPpduDurationWithinLimit(b dataLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:278:5: warning: function 'isPpduDurationValid' should be marked [[nodiscard]] [modernize-use-nodiscard] + 278 | bool isPpduDurationValid(b dataLength) const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:280:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 280 | virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + dataMode->getDuration(dataLength) + getSignalExtensionTime(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:280:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 280 | virtual const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + dataMode->getDuration(dataLength) + getSignalExtensionTime(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:291:37: warning: invalid case style for global constant 'htMcs0BW20MHz' [readability-identifier-naming] + 291 | static const DI htMcs0BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS0_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:292:37: warning: invalid case style for global constant 'htMcs1BW20MHz' [readability-identifier-naming] + 292 | static const DI htMcs1BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS1_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:293:37: warning: invalid case style for global constant 'htMcs2BW20MHz' [readability-identifier-naming] + 293 | static const DI htMcs2BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS2_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:294:37: warning: invalid case style for global constant 'htMcs3BW20MHz' [readability-identifier-naming] + 294 | static const DI htMcs3BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS3_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:295:37: warning: invalid case style for global constant 'htMcs4BW20MHz' [readability-identifier-naming] + 295 | static const DI htMcs4BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS4_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:296:37: warning: invalid case style for global constant 'htMcs5BW20MHz' [readability-identifier-naming] + 296 | static const DI htMcs5BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS5_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:297:37: warning: invalid case style for global constant 'htMcs6BW20MHz' [readability-identifier-naming] + 297 | static const DI htMcs6BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS6_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:298:37: warning: invalid case style for global constant 'htMcs7BW20MHz' [readability-identifier-naming] + 298 | static const DI htMcs7BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS7_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:301:37: warning: invalid case style for global constant 'htMcs8BW20MHz' [readability-identifier-naming] + 301 | static const DI htMcs8BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS8_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:302:37: warning: invalid case style for global constant 'htMcs9BW20MHz' [readability-identifier-naming] + 302 | static const DI htMcs9BW20MHz; + | ^~~~~~~~~~~~~ + | HT_MCS9_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:303:37: warning: invalid case style for global constant 'htMcs10BW20MHz' [readability-identifier-naming] + 303 | static const DI htMcs10BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS10_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:304:37: warning: invalid case style for global constant 'htMcs11BW20MHz' [readability-identifier-naming] + 304 | static const DI htMcs11BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS11_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:305:37: warning: invalid case style for global constant 'htMcs12BW20MHz' [readability-identifier-naming] + 305 | static const DI htMcs12BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS12_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:306:37: warning: invalid case style for global constant 'htMcs13BW20MHz' [readability-identifier-naming] + 306 | static const DI htMcs13BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS13_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:307:37: warning: invalid case style for global constant 'htMcs14BW20MHz' [readability-identifier-naming] + 307 | static const DI htMcs14BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS14_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:308:37: warning: invalid case style for global constant 'htMcs15BW20MHz' [readability-identifier-naming] + 308 | static const DI htMcs15BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS15_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:311:37: warning: invalid case style for global constant 'htMcs16BW20MHz' [readability-identifier-naming] + 311 | static const DI htMcs16BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS16_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:312:37: warning: invalid case style for global constant 'htMcs17BW20MHz' [readability-identifier-naming] + 312 | static const DI htMcs17BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS17_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:313:37: warning: invalid case style for global constant 'htMcs18BW20MHz' [readability-identifier-naming] + 313 | static const DI htMcs18BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS18_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:314:37: warning: invalid case style for global constant 'htMcs19BW20MHz' [readability-identifier-naming] + 314 | static const DI htMcs19BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS19_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:315:37: warning: invalid case style for global constant 'htMcs20BW20MHz' [readability-identifier-naming] + 315 | static const DI htMcs20BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS20_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:316:37: warning: invalid case style for global constant 'htMcs21BW20MHz' [readability-identifier-naming] + 316 | static const DI htMcs21BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS21_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:317:37: warning: invalid case style for global constant 'htMcs22BW20MHz' [readability-identifier-naming] + 317 | static const DI htMcs22BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS22_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:318:37: warning: invalid case style for global constant 'htMcs23BW20MHz' [readability-identifier-naming] + 318 | static const DI htMcs23BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS23_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:321:37: warning: invalid case style for global constant 'htMcs24BW20MHz' [readability-identifier-naming] + 321 | static const DI htMcs24BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS24_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:322:37: warning: invalid case style for global constant 'htMcs25BW20MHz' [readability-identifier-naming] + 322 | static const DI htMcs25BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS25_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:323:37: warning: invalid case style for global constant 'htMcs26BW20MHz' [readability-identifier-naming] + 323 | static const DI htMcs26BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS26_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:324:37: warning: invalid case style for global constant 'htMcs27BW20MHz' [readability-identifier-naming] + 324 | static const DI htMcs27BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS27_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:325:37: warning: invalid case style for global constant 'htMcs28BW20MHz' [readability-identifier-naming] + 325 | static const DI htMcs28BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS28_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:326:37: warning: invalid case style for global constant 'htMcs29BW20MHz' [readability-identifier-naming] + 326 | static const DI htMcs29BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS29_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:327:37: warning: invalid case style for global constant 'htMcs30BW20MHz' [readability-identifier-naming] + 327 | static const DI htMcs30BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS30_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:328:37: warning: invalid case style for global constant 'htMcs31BW20MHz' [readability-identifier-naming] + 328 | static const DI htMcs31BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS31_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:331:37: warning: invalid case style for global constant 'htMcs0BW40MHz' [readability-identifier-naming] + 331 | static const DI htMcs0BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS0_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:332:37: warning: invalid case style for global constant 'htMcs1BW40MHz' [readability-identifier-naming] + 332 | static const DI htMcs1BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS1_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:333:37: warning: invalid case style for global constant 'htMcs2BW40MHz' [readability-identifier-naming] + 333 | static const DI htMcs2BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS2_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:334:37: warning: invalid case style for global constant 'htMcs3BW40MHz' [readability-identifier-naming] + 334 | static const DI htMcs3BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS3_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:335:37: warning: invalid case style for global constant 'htMcs4BW40MHz' [readability-identifier-naming] + 335 | static const DI htMcs4BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS4_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:336:37: warning: invalid case style for global constant 'htMcs5BW40MHz' [readability-identifier-naming] + 336 | static const DI htMcs5BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS5_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:337:37: warning: invalid case style for global constant 'htMcs6BW40MHz' [readability-identifier-naming] + 337 | static const DI htMcs6BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS6_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:338:37: warning: invalid case style for global constant 'htMcs7BW40MHz' [readability-identifier-naming] + 338 | static const DI htMcs7BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS7_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:341:37: warning: invalid case style for global constant 'htMcs8BW40MHz' [readability-identifier-naming] + 341 | static const DI htMcs8BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS8_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:342:37: warning: invalid case style for global constant 'htMcs9BW40MHz' [readability-identifier-naming] + 342 | static const DI htMcs9BW40MHz; + | ^~~~~~~~~~~~~ + | HT_MCS9_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:343:37: warning: invalid case style for global constant 'htMcs10BW40MHz' [readability-identifier-naming] + 343 | static const DI htMcs10BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS10_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:344:37: warning: invalid case style for global constant 'htMcs11BW40MHz' [readability-identifier-naming] + 344 | static const DI htMcs11BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS11_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:345:37: warning: invalid case style for global constant 'htMcs12BW40MHz' [readability-identifier-naming] + 345 | static const DI htMcs12BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS12_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:346:37: warning: invalid case style for global constant 'htMcs13BW40MHz' [readability-identifier-naming] + 346 | static const DI htMcs13BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS13_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:347:37: warning: invalid case style for global constant 'htMcs14BW40MHz' [readability-identifier-naming] + 347 | static const DI htMcs14BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS14_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:348:37: warning: invalid case style for global constant 'htMcs15BW40MHz' [readability-identifier-naming] + 348 | static const DI htMcs15BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS15_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:351:37: warning: invalid case style for global constant 'htMcs16BW40MHz' [readability-identifier-naming] + 351 | static const DI htMcs16BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS16_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:352:37: warning: invalid case style for global constant 'htMcs17BW40MHz' [readability-identifier-naming] + 352 | static const DI htMcs17BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS17_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:353:37: warning: invalid case style for global constant 'htMcs18BW40MHz' [readability-identifier-naming] + 353 | static const DI htMcs18BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS18_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:354:37: warning: invalid case style for global constant 'htMcs19BW40MHz' [readability-identifier-naming] + 354 | static const DI htMcs19BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS19_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:355:37: warning: invalid case style for global constant 'htMcs20BW40MHz' [readability-identifier-naming] + 355 | static const DI htMcs20BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS20_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:356:37: warning: invalid case style for global constant 'htMcs21BW40MHz' [readability-identifier-naming] + 356 | static const DI htMcs21BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS21_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:357:37: warning: invalid case style for global constant 'htMcs22BW40MHz' [readability-identifier-naming] + 357 | static const DI htMcs22BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS22_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:358:37: warning: invalid case style for global constant 'htMcs23BW40MHz' [readability-identifier-naming] + 358 | static const DI htMcs23BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS23_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:361:37: warning: invalid case style for global constant 'htMcs24BW40MHz' [readability-identifier-naming] + 361 | static const DI htMcs24BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS24_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:362:37: warning: invalid case style for global constant 'htMcs25BW40MHz' [readability-identifier-naming] + 362 | static const DI htMcs25BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS25_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:363:37: warning: invalid case style for global constant 'htMcs26BW40MHz' [readability-identifier-naming] + 363 | static const DI htMcs26BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS26_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:364:37: warning: invalid case style for global constant 'htMcs27BW40MHz' [readability-identifier-naming] + 364 | static const DI htMcs27BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS27_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:365:37: warning: invalid case style for global constant 'htMcs28BW40MHz' [readability-identifier-naming] + 365 | static const DI htMcs28BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS28_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:366:37: warning: invalid case style for global constant 'htMcs29BW40MHz' [readability-identifier-naming] + 366 | static const DI htMcs29BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS29_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:367:37: warning: invalid case style for global constant 'htMcs30BW40MHz' [readability-identifier-naming] + 367 | static const DI htMcs30BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS30_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:368:37: warning: invalid case style for global constant 'htMcs31BW40MHz' [readability-identifier-naming] + 368 | static const DI htMcs31BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS31_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:371:37: warning: invalid case style for global constant 'htMcs32BW40MHz' [readability-identifier-naming] + 371 | static const DI htMcs32BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS32_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:374:37: warning: invalid case style for global constant 'htMcs33BW20MHz' [readability-identifier-naming] + 374 | static const DI htMcs33BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS33_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:375:37: warning: invalid case style for global constant 'htMcs34BW20MHz' [readability-identifier-naming] + 375 | static const DI htMcs34BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS34_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:376:37: warning: invalid case style for global constant 'htMcs35BW20MHz' [readability-identifier-naming] + 376 | static const DI htMcs35BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS35_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:377:37: warning: invalid case style for global constant 'htMcs36BW20MHz' [readability-identifier-naming] + 377 | static const DI htMcs36BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS36_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:378:37: warning: invalid case style for global constant 'htMcs37BW20MHz' [readability-identifier-naming] + 378 | static const DI htMcs37BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS37_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:379:37: warning: invalid case style for global constant 'htMcs38BW20MHz' [readability-identifier-naming] + 379 | static const DI htMcs38BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS38_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:382:37: warning: invalid case style for global constant 'htMcs39BW20MHz' [readability-identifier-naming] + 382 | static const DI htMcs39BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS39_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:383:37: warning: invalid case style for global constant 'htMcs40BW20MHz' [readability-identifier-naming] + 383 | static const DI htMcs40BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS40_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:384:37: warning: invalid case style for global constant 'htMcs41BW20MHz' [readability-identifier-naming] + 384 | static const DI htMcs41BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS41_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:385:37: warning: invalid case style for global constant 'htMcs42BW20MHz' [readability-identifier-naming] + 385 | static const DI htMcs42BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS42_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:386:37: warning: invalid case style for global constant 'htMcs43BW20MHz' [readability-identifier-naming] + 386 | static const DI htMcs43BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS43_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:387:37: warning: invalid case style for global constant 'htMcs44BW20MHz' [readability-identifier-naming] + 387 | static const DI htMcs44BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS44_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:388:37: warning: invalid case style for global constant 'htMcs45BW20MHz' [readability-identifier-naming] + 388 | static const DI htMcs45BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS45_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:389:37: warning: invalid case style for global constant 'htMcs46BW20MHz' [readability-identifier-naming] + 389 | static const DI htMcs46BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS46_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:390:37: warning: invalid case style for global constant 'htMcs47BW20MHz' [readability-identifier-naming] + 390 | static const DI htMcs47BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS47_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:391:37: warning: invalid case style for global constant 'htMcs48BW20MHz' [readability-identifier-naming] + 391 | static const DI htMcs48BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS48_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:392:37: warning: invalid case style for global constant 'htMcs49BW20MHz' [readability-identifier-naming] + 392 | static const DI htMcs49BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS49_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:393:37: warning: invalid case style for global constant 'htMcs50BW20MHz' [readability-identifier-naming] + 393 | static const DI htMcs50BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS50_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:394:37: warning: invalid case style for global constant 'htMcs51BW20MHz' [readability-identifier-naming] + 394 | static const DI htMcs51BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS51_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:395:37: warning: invalid case style for global constant 'htMcs52BW20MHz' [readability-identifier-naming] + 395 | static const DI htMcs52BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS52_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:398:37: warning: invalid case style for global constant 'htMcs53BW20MHz' [readability-identifier-naming] + 398 | static const DI htMcs53BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS53_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:399:37: warning: invalid case style for global constant 'htMcs54BW20MHz' [readability-identifier-naming] + 399 | static const DI htMcs54BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS54_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:400:37: warning: invalid case style for global constant 'htMcs55BW20MHz' [readability-identifier-naming] + 400 | static const DI htMcs55BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS55_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:401:37: warning: invalid case style for global constant 'htMcs56BW20MHz' [readability-identifier-naming] + 401 | static const DI htMcs56BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS56_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:402:37: warning: invalid case style for global constant 'htMcs57BW20MHz' [readability-identifier-naming] + 402 | static const DI htMcs57BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS57_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:403:37: warning: invalid case style for global constant 'htMcs58BW20MHz' [readability-identifier-naming] + 403 | static const DI htMcs58BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS58_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:404:37: warning: invalid case style for global constant 'htMcs59BW20MHz' [readability-identifier-naming] + 404 | static const DI htMcs59BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS59_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:405:37: warning: invalid case style for global constant 'htMcs60BW20MHz' [readability-identifier-naming] + 405 | static const DI htMcs60BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS60_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:406:37: warning: invalid case style for global constant 'htMcs61BW20MHz' [readability-identifier-naming] + 406 | static const DI htMcs61BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS61_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:407:37: warning: invalid case style for global constant 'htMcs62BW20MHz' [readability-identifier-naming] + 407 | static const DI htMcs62BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS62_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:408:37: warning: invalid case style for global constant 'htMcs63BW20MHz' [readability-identifier-naming] + 408 | static const DI htMcs63BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS63_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:409:37: warning: invalid case style for global constant 'htMcs64BW20MHz' [readability-identifier-naming] + 409 | static const DI htMcs64BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS64_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:410:37: warning: invalid case style for global constant 'htMcs65BW20MHz' [readability-identifier-naming] + 410 | static const DI htMcs65BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS65_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:411:37: warning: invalid case style for global constant 'htMcs66BW20MHz' [readability-identifier-naming] + 411 | static const DI htMcs66BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS66_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:412:37: warning: invalid case style for global constant 'htMcs67BW20MHz' [readability-identifier-naming] + 412 | static const DI htMcs67BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS67_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:413:37: warning: invalid case style for global constant 'htMcs68BW20MHz' [readability-identifier-naming] + 413 | static const DI htMcs68BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS68_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:414:37: warning: invalid case style for global constant 'htMcs69BW20MHz' [readability-identifier-naming] + 414 | static const DI htMcs69BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS69_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:415:37: warning: invalid case style for global constant 'htMcs70BW20MHz' [readability-identifier-naming] + 415 | static const DI htMcs70BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS70_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:416:37: warning: invalid case style for global constant 'htMcs71BW20MHz' [readability-identifier-naming] + 416 | static const DI htMcs71BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS71_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:417:37: warning: invalid case style for global constant 'htMcs72BW20MHz' [readability-identifier-naming] + 417 | static const DI htMcs72BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS72_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:418:37: warning: invalid case style for global constant 'htMcs73BW20MHz' [readability-identifier-naming] + 418 | static const DI htMcs73BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS73_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:419:37: warning: invalid case style for global constant 'htMcs74BW20MHz' [readability-identifier-naming] + 419 | static const DI htMcs74BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS74_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:420:37: warning: invalid case style for global constant 'htMcs75BW20MHz' [readability-identifier-naming] + 420 | static const DI htMcs75BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS75_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:421:37: warning: invalid case style for global constant 'htMcs76BW20MHz' [readability-identifier-naming] + 421 | static const DI htMcs76BW20MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS76_B_W20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:424:37: warning: invalid case style for global constant 'htMcs33BW40MHz' [readability-identifier-naming] + 424 | static const DI htMcs33BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS33_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:425:37: warning: invalid case style for global constant 'htMcs34BW40MHz' [readability-identifier-naming] + 425 | static const DI htMcs34BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS34_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:426:37: warning: invalid case style for global constant 'htMcs35BW40MHz' [readability-identifier-naming] + 426 | static const DI htMcs35BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS35_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:427:37: warning: invalid case style for global constant 'htMcs36BW40MHz' [readability-identifier-naming] + 427 | static const DI htMcs36BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS36_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:428:37: warning: invalid case style for global constant 'htMcs37BW40MHz' [readability-identifier-naming] + 428 | static const DI htMcs37BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS37_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:429:37: warning: invalid case style for global constant 'htMcs38BW40MHz' [readability-identifier-naming] + 429 | static const DI htMcs38BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS38_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:432:37: warning: invalid case style for global constant 'htMcs39BW40MHz' [readability-identifier-naming] + 432 | static const DI htMcs39BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS39_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:433:37: warning: invalid case style for global constant 'htMcs40BW40MHz' [readability-identifier-naming] + 433 | static const DI htMcs40BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS40_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:434:37: warning: invalid case style for global constant 'htMcs41BW40MHz' [readability-identifier-naming] + 434 | static const DI htMcs41BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS41_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:435:37: warning: invalid case style for global constant 'htMcs42BW40MHz' [readability-identifier-naming] + 435 | static const DI htMcs42BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS42_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:436:37: warning: invalid case style for global constant 'htMcs43BW40MHz' [readability-identifier-naming] + 436 | static const DI htMcs43BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS43_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:437:37: warning: invalid case style for global constant 'htMcs44BW40MHz' [readability-identifier-naming] + 437 | static const DI htMcs44BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS44_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:438:37: warning: invalid case style for global constant 'htMcs45BW40MHz' [readability-identifier-naming] + 438 | static const DI htMcs45BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS45_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:439:37: warning: invalid case style for global constant 'htMcs46BW40MHz' [readability-identifier-naming] + 439 | static const DI htMcs46BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS46_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:440:37: warning: invalid case style for global constant 'htMcs47BW40MHz' [readability-identifier-naming] + 440 | static const DI htMcs47BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS47_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:441:37: warning: invalid case style for global constant 'htMcs48BW40MHz' [readability-identifier-naming] + 441 | static const DI htMcs48BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS48_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:442:37: warning: invalid case style for global constant 'htMcs49BW40MHz' [readability-identifier-naming] + 442 | static const DI htMcs49BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS49_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:443:37: warning: invalid case style for global constant 'htMcs50BW40MHz' [readability-identifier-naming] + 443 | static const DI htMcs50BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS50_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:444:37: warning: invalid case style for global constant 'htMcs51BW40MHz' [readability-identifier-naming] + 444 | static const DI htMcs51BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS51_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:445:37: warning: invalid case style for global constant 'htMcs52BW40MHz' [readability-identifier-naming] + 445 | static const DI htMcs52BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS52_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:448:37: warning: invalid case style for global constant 'htMcs53BW40MHz' [readability-identifier-naming] + 448 | static const DI htMcs53BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS53_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:449:37: warning: invalid case style for global constant 'htMcs54BW40MHz' [readability-identifier-naming] + 449 | static const DI htMcs54BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS54_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:450:37: warning: invalid case style for global constant 'htMcs55BW40MHz' [readability-identifier-naming] + 450 | static const DI htMcs55BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS55_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:451:37: warning: invalid case style for global constant 'htMcs56BW40MHz' [readability-identifier-naming] + 451 | static const DI htMcs56BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS56_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:452:37: warning: invalid case style for global constant 'htMcs57BW40MHz' [readability-identifier-naming] + 452 | static const DI htMcs57BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS57_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:453:37: warning: invalid case style for global constant 'htMcs58BW40MHz' [readability-identifier-naming] + 453 | static const DI htMcs58BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS58_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:454:37: warning: invalid case style for global constant 'htMcs59BW40MHz' [readability-identifier-naming] + 454 | static const DI htMcs59BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS59_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:455:37: warning: invalid case style for global constant 'htMcs60BW40MHz' [readability-identifier-naming] + 455 | static const DI htMcs60BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS60_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:456:37: warning: invalid case style for global constant 'htMcs61BW40MHz' [readability-identifier-naming] + 456 | static const DI htMcs61BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS61_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:457:37: warning: invalid case style for global constant 'htMcs62BW40MHz' [readability-identifier-naming] + 457 | static const DI htMcs62BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS62_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:458:37: warning: invalid case style for global constant 'htMcs63BW40MHz' [readability-identifier-naming] + 458 | static const DI htMcs63BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS63_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:459:37: warning: invalid case style for global constant 'htMcs64BW40MHz' [readability-identifier-naming] + 459 | static const DI htMcs64BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS64_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:460:37: warning: invalid case style for global constant 'htMcs65BW40MHz' [readability-identifier-naming] + 460 | static const DI htMcs65BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS65_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:461:37: warning: invalid case style for global constant 'htMcs66BW40MHz' [readability-identifier-naming] + 461 | static const DI htMcs66BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS66_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:462:37: warning: invalid case style for global constant 'htMcs67BW40MHz' [readability-identifier-naming] + 462 | static const DI htMcs67BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS67_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:463:37: warning: invalid case style for global constant 'htMcs68BW40MHz' [readability-identifier-naming] + 463 | static const DI htMcs68BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS68_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:464:37: warning: invalid case style for global constant 'htMcs69BW40MHz' [readability-identifier-naming] + 464 | static const DI htMcs69BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS69_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:465:37: warning: invalid case style for global constant 'htMcs70BW40MHz' [readability-identifier-naming] + 465 | static const DI htMcs70BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS70_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:466:37: warning: invalid case style for global constant 'htMcs71BW40MHz' [readability-identifier-naming] + 466 | static const DI htMcs71BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS71_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:467:37: warning: invalid case style for global constant 'htMcs72BW40MHz' [readability-identifier-naming] + 467 | static const DI htMcs72BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS72_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:468:37: warning: invalid case style for global constant 'htMcs73BW40MHz' [readability-identifier-naming] + 468 | static const DI htMcs73BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS73_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:469:37: warning: invalid case style for global constant 'htMcs74BW40MHz' [readability-identifier-naming] + 469 | static const DI htMcs74BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS74_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:470:37: warning: invalid case style for global constant 'htMcs75BW40MHz' [readability-identifier-naming] + 470 | static const DI htMcs75BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS75_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:471:37: warning: invalid case style for global constant 'htMcs76BW40MHz' [readability-identifier-naming] + 471 | static const DI htMcs76BW40MHz; + | ^~~~~~~~~~~~~~ + | HT_MCS76_B_W40_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211HtMode.h:477:61: warning: invalid case style for global constant 'singleton' [readability-identifier-naming] + 477 | static OPP_THREAD_LOCAL const Ieee80211HtCompliantModes singleton; + | ^~~~~~~~~ + | SINGLETON +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MODEBASE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MODEBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MODEBASE_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:27:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual bps getNonHtReferenceRate() const override { return bps(NaN); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:27:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 27 | virtual bps getNonHtReferenceRate() const override { return bps(NaN); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:28:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | virtual ModulationClass getModulationClass() const override { return ModulationClass::UNKNOWN; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:28:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 28 | virtual ModulationClass getModulationClass() const override { return ModulationClass::UNKNOWN; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:29:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::UNKNOWN; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:29:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::UNKNOWN; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:30:5: warning: function 'getHtMcsIndex' should be marked [[nodiscard]] [modernize-use-nodiscard] + 30 | virtual int getHtMcsIndex() const override { return -1; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:30:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 30 | virtual int getHtMcsIndex() const override { return -1; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:31:5: warning: function 'isHtShortGuardInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual bool isHtShortGuardInterval() const override { return false; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:31:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual bool isHtShortGuardInterval() const override { return false; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:32:5: warning: function 'getSignalExtensionTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual const simtime_t getSignalExtensionTime() const override { return SIMTIME_ZERO; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:32:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual const simtime_t getSignalExtensionTime() const override { return SIMTIME_ZERO; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:33:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const char *getName() const override { return name.c_str(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeBase.h:33:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual const char *getName() const override { return name.c_str(); } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211MODESET_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211MODESET_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_MODESET_H +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:62:68: warning: invalid case style for global constant 'modeSets' [readability-identifier-naming] + 62 | static const DelayedInitializer> modeSets; + | ^~~~~~~~ + | MODE_SETS +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ~~~~~~~ ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:63: warning: 2 adjacent parameters of 'printToStream' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:67: note: the first parameter in the range is 'level' + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ^~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:72:78: note: the last parameter in the range is 'evFlags' + 72 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override { return stream << "Ieee80211ModeSet, name = " << name; } + | ^~~~~~~ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:74:5: warning: function 'getName' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | const char *getName() const override { return name.c_str(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:76:5: warning: function 'getNumModes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 76 | int getNumModes() const { return entries.size(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:77:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | const IIeee80211Mode *getMode(int index) const { return entries[index].mode; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:78:5: warning: function 'isMandatory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 78 | bool isMandatory(int index) const { return entries[index].isMandatory; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:79:5: warning: function 'isHtOperationSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 79 | bool isHtOperationSupported() const { return htOperationSupported; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:80:5: warning: function 'getMaximumChannelWidth' should be marked [[nodiscard]] [modernize-use-nodiscard] + 80 | Hz getMaximumChannelWidth() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:81:5: warning: function 'getMaximumNumberOfSpatialStreams' should be marked [[nodiscard]] [modernize-use-nodiscard] + 81 | int getMaximumNumberOfSpatialStreams() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:85:5: warning: function 'getLegacyOperationalModes' should be marked [[nodiscard]] [modernize-use-nodiscard] + 85 | const std::vector& getLegacyOperationalModes() const { return legacyOperationalModes; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:86:5: warning: function 'getFastestLegacyOperationalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 86 | const IIeee80211Mode *getFastestLegacyOperationalMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:87:5: warning: function 'getHtMcsSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 87 | const std::array& getHtMcsSupported() const { return htMcsSupported; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:88:5: warning: function 'getHtMcsMandatory' should be marked [[nodiscard]] [modernize-use-nodiscard] + 88 | const std::array& getHtMcsMandatory() const { return htMcsMandatory; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:89:5: warning: function 'getHtSupportedChannelWidths' should be marked [[nodiscard]] [modernize-use-nodiscard] + 89 | const std::set& getHtSupportedChannelWidths() const { return htSupportedChannelWidths; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:90:5: warning: function 'getHtShortGuardIntervalChannelWidths' should be marked [[nodiscard]] [modernize-use-nodiscard] + 90 | const std::set& getHtShortGuardIntervalChannelWidths() const { return htShortGuardIntervalChannelWidths; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:91:5: warning: function 'isHtShortGuardIntervalSupported' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | bool isHtShortGuardIntervalSupported(Hz bandwidth) const { return htShortGuardIntervalChannelWidths.count(bandwidth) != 0; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:96:5: warning: function 'findMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 96 | const IIeee80211Mode *findMode(bps bitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:97:5: warning: function 'findMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 97 | const IIeee80211Mode *findMode(bps minBitrate, bps maxBitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:98:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | const IIeee80211Mode *getMode(bps bitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:99:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 99 | const IIeee80211Mode *getMode(bps minBitrate, bps maxBitrate, Hz bandwidth = Hz(NaN), int numSpatialStreams = -1) const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:100:5: warning: function 'getSlowestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 100 | const IIeee80211Mode *getSlowestMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:101:5: warning: function 'getFastestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | const IIeee80211Mode *getFastestMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:104:5: warning: function 'getSlowestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 104 | const IIeee80211Mode *getSlowestMandatoryMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:105:5: warning: function 'getFastestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 105 | const IIeee80211Mode *getFastestMandatoryMode() const; + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:114:5: warning: function 'getPhyType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 114 | PhyType getPhyType() const { return phyType; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:115:5: warning: function 'getReferenceMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 115 | const IIeee80211Mode *getReferenceMode() const { return referenceMode; } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:116:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 116 | simtime_t getSifsTime() const { return referenceMode->getSifsTime(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:117:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 117 | simtime_t getSlotTime() const { return referenceMode->getSlotTime(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:118:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 118 | simtime_t getPhyRxStartDelay() const { return referenceMode->getPhyRxStartDelay(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:119:5: warning: function 'getCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 119 | int getCwMin() const { return referenceMode->getLegacyCwMin(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:120:5: warning: function 'getCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 120 | int getCwMax() const { return referenceMode->getLegacyCwMax(); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:122:5: warning: function '_getSlowestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 122 | IIeee80211Mode *_getSlowestMode() const { return const_cast(getSlowestMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:122:21: warning: invalid case style for method '_getSlowestMode' [readability-identifier-naming] + 122 | IIeee80211Mode *_getSlowestMode() const { return const_cast(getSlowestMode()); } + | ^~~~~~~~~~~~~~~ + | getSlowestMode +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:123:5: warning: function '_getFastestMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 123 | IIeee80211Mode *_getFastestMode() const { return const_cast(getFastestMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:123:21: warning: invalid case style for method '_getFastestMode' [readability-identifier-naming] + 123 | IIeee80211Mode *_getFastestMode() const { return const_cast(getFastestMode()); } + | ^~~~~~~~~~~~~~~ + | getFastestMode +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:124:5: warning: function '_getSlowestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 124 | IIeee80211Mode *_getSlowestMandatoryMode() const { return const_cast(getSlowestMandatoryMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:124:21: warning: invalid case style for method '_getSlowestMandatoryMode' [readability-identifier-naming] + 124 | IIeee80211Mode *_getSlowestMandatoryMode() const { return const_cast(getSlowestMandatoryMode()); } + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | getSlowestMandatoryMode +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:125:5: warning: function '_getFastestMandatoryMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 125 | IIeee80211Mode *_getFastestMandatoryMode() const { return const_cast(getFastestMandatoryMode()); } + | ^ + | [[nodiscard]] +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/./inet/physicallayer/wireless/ieee80211/mode/Ieee80211ModeSet.h:125:21: warning: invalid case style for method '_getFastestMandatoryMode' [readability-identifier-naming] + 125 | IIeee80211Mode *_getFastestMandatoryMode() const { return const_cast(getFastestMandatoryMode()); } + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | getFastestMandatoryMode +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMCODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMCODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMCODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:16:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 16 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 17 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:29:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 29 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:31:5: warning: function 'getConvolutionalCode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | const ConvolutionalCode *getConvolutionalCode() const { return convolutionalCode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:32:5: warning: function 'getInterleaving' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | const Ieee80211OfdmInterleaving *getInterleaving() const { return interleaving; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:33:5: warning: function 'getScrambling' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | const AdditiveScrambling *getScrambling() const { return scrambling; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:40:45: warning: invalid case style for global constant 'ofdmConvolutionalCode1_2' [readability-identifier-naming] + 40 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode1_2; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE1_2 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:41:45: warning: invalid case style for global constant 'ofdmConvolutionalCode2_3' [readability-identifier-naming] + 41 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode2_3; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE2_3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:42:45: warning: invalid case style for global constant 'ofdmConvolutionalCode3_4' [readability-identifier-naming] + 42 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode3_4; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE3_4 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:43:45: warning: invalid case style for global constant 'ofdmConvolutionalCode5_6' [readability-identifier-naming] + 43 | static const Ieee80211ConvolutionalCode ofdmConvolutionalCode5_6; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_CONVOLUTIONAL_CODE5_6 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:46:44: warning: invalid case style for global constant 'ofdmBPSKInterleaving' [readability-identifier-naming] + 46 | static const Ieee80211OfdmInterleaving ofdmBPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_BPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:47:44: warning: invalid case style for global constant 'ofdmQPSKInterleaving' [readability-identifier-naming] + 47 | static const Ieee80211OfdmInterleaving ofdmQPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_QPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:48:44: warning: invalid case style for global constant 'ofdmQAM16Interleaving' [readability-identifier-naming] + 48 | static const Ieee80211OfdmInterleaving ofdmQAM16Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M16_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:49:44: warning: invalid case style for global constant 'ofdmQAM64Interleaving' [readability-identifier-naming] + 49 | static const Ieee80211OfdmInterleaving ofdmQAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:50:44: warning: invalid case style for global constant 'ofdmQAM256Interleaving' [readability-identifier-naming] + 50 | static const Ieee80211OfdmInterleaving ofdmQAM256Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M256_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:51:44: warning: invalid case style for global constant 'ofdmQAM1024Interleaving' [readability-identifier-naming] + 51 | static const Ieee80211OfdmInterleaving ofdmQAM1024Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_QA_M1024_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:54:37: warning: invalid case style for global constant 'ofdmScrambling' [readability-identifier-naming] + 54 | static const AdditiveScrambling ofdmScrambling; + | ^~~~~~~~~~~~~~ + | OFDM_SCRAMBLING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:57:36: warning: invalid case style for global constant 'ofdmCC1_2BPSKInterleaving' [readability-identifier-naming] + 57 | static const Ieee80211OfdmCode ofdmCC1_2BPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_BPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:58:36: warning: invalid case style for global constant 'ofdmCC1_2BPSKInterleavingWithoutScrambling' [readability-identifier-naming] + 58 | static const Ieee80211OfdmCode ofdmCC1_2BPSKInterleavingWithoutScrambling; // For the SIGNAL field + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_BPSK_INTERLEAVING_WITHOUT_SCRAMBLING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:59:36: warning: invalid case style for global constant 'ofdmCC3_4BPSKInterleaving' [readability-identifier-naming] + 59 | static const Ieee80211OfdmCode ofdmCC3_4BPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_BPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:60:36: warning: invalid case style for global constant 'ofdmCC1_2QPSKInterleaving' [readability-identifier-naming] + 60 | static const Ieee80211OfdmCode ofdmCC1_2QPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_QPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:61:36: warning: invalid case style for global constant 'ofdmCC3_4QPSKInterleaving' [readability-identifier-naming] + 61 | static const Ieee80211OfdmCode ofdmCC3_4QPSKInterleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QPSK_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:62:36: warning: invalid case style for global constant 'ofdmCC1_2QAM16Interleaving' [readability-identifier-naming] + 62 | static const Ieee80211OfdmCode ofdmCC1_2QAM16Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C1_2_QA_M16_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:63:36: warning: invalid case style for global constant 'ofdmCC3_4QAM16Interleaving' [readability-identifier-naming] + 63 | static const Ieee80211OfdmCode ofdmCC3_4QAM16Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M16_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:64:36: warning: invalid case style for global constant 'ofdmCC2_3QAM64Interleaving' [readability-identifier-naming] + 64 | static const Ieee80211OfdmCode ofdmCC2_3QAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C2_3_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:65:36: warning: invalid case style for global constant 'ofdmCC3_4QAM64Interleaving' [readability-identifier-naming] + 65 | static const Ieee80211OfdmCode ofdmCC3_4QAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:66:36: warning: invalid case style for global constant 'ofdmCC5_6QAM64Interleaving' [readability-identifier-naming] + 66 | static const Ieee80211OfdmCode ofdmCC5_6QAM64Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C5_6_QA_M64_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:67:36: warning: invalid case style for global constant 'ofdmCC3_4QAM256Interleaving' [readability-identifier-naming] + 67 | static const Ieee80211OfdmCode ofdmCC3_4QAM256Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M256_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:68:36: warning: invalid case style for global constant 'ofdmCC5_6QAM256Interleaving' [readability-identifier-naming] + 68 | static const Ieee80211OfdmCode ofdmCC5_6QAM256Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C5_6_QA_M256_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:69:36: warning: invalid case style for global constant 'ofdmCC3_4QAM1024Interleaving' [readability-identifier-naming] + 69 | static const Ieee80211OfdmCode ofdmCC3_4QAM1024Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C3_4_QA_M1024_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmCode.h:70:36: warning: invalid case style for global constant 'ofdmCC5_6QAM1024Interleaving' [readability-identifier-naming] + 70 | static const Ieee80211OfdmCode ofdmCC5_6QAM1024Interleaving; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_C_C5_6_QA_M1024_INTERLEAVING +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMMODE_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMMODE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMMODE_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:26:5: warning: function 'getSubcarrierFrequencySpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | Hz getSubcarrierFrequencySpacing() const { return channelSpacing / 64; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:27:5: warning: function 'getFFTTransformPeriod' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | const simtime_t getFFTTransformPeriod() const { return simtime_t(1 / getSubcarrierFrequencySpacing().get()); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:28:5: warning: function 'getGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const simtime_t getGIDuration() const { return getFFTTransformPeriod() / 4; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:29:5: warning: function 'getSymbolInterval' should be marked [[nodiscard]] [modernize-use-nodiscard] + 29 | const simtime_t getSymbolInterval() const { return getGIDuration() + getFFTTransformPeriod(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:31:5: warning: function 'getChannelSpacing' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | const Hz getChannelSpacing() const { return channelSpacing; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:49:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 49 | virtual ~Ieee80211OfdmModeBase() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:68:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 68 | virtual ~Ieee80211OfdmPreambleMode() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:68:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 68 | virtual ~Ieee80211OfdmPreambleMode() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:70:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 70 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:72:5: warning: function 'getTrainingSymbolGIDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 72 | const simtime_t getTrainingSymbolGIDuration() const { return getFFTTransformPeriod() / 2; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:73:5: warning: function 'getShortTrainingSequenceDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 73 | const simtime_t getShortTrainingSequenceDuration() const { return 10 * getFFTTransformPeriod() / 4; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:74:5: warning: function 'getLongTrainingSequenceDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 74 | const simtime_t getLongTrainingSequenceDuration() const { return getTrainingSymbolGIDuration() + 2 * getFFTTransformPeriod(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:75:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 75 | virtual const simtime_t getDuration() const override { return getShortTrainingSequenceDuration() + getLongTrainingSequenceDuration(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:75:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual const simtime_t getDuration() const override { return getShortTrainingSequenceDuration() + getLongTrainingSequenceDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:77:5: warning: function 'createPreamble' should be marked [[nodiscard]] [modernize-use-nodiscard] + 77 | virtual Ptr createPreamble() const override { return makeShared(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:77:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 77 | virtual Ptr createPreamble() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:87:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 87 | virtual ~Ieee80211OfdmSignalMode() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:87:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 87 | virtual ~Ieee80211OfdmSignalMode() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:89:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 89 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:99:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 99 | virtual b getLength() const override { return getRateFieldLength() + getReservedFieldLength() + getLengthFieldLength() + getParityFieldLength() + getTailFieldLength() + getServiceFieldLength(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:100:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 100 | virtual const simtime_t getDuration() const override { return getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:103:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 103 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211OfdmTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:104:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 104 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:106:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 106 | virtual bps getGrossBitrate() const override { return Ieee80211OfdmModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:107:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 107 | virtual bps getNetBitrate() const override { return Ieee80211OfdmModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:109:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 109 | virtual Ptr createHeader() const override { return makeShared(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:116:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 116 | virtual ~Ieee80211OfdmDataMode() {} + | ^ ~~ + | = default; +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:116:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 116 | virtual ~Ieee80211OfdmDataMode() {} + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:118:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 118 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:123:16: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 123 | virtual Hz getBandwidth() const override { return bandwidth; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:124:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 124 | virtual b getPaddingLength(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:125:15: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 125 | virtual b getCompleteLength(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:126:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 126 | virtual const simtime_t getDuration(b dataLength) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:129:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 129 | virtual const simtime_t getSymbolInterval() const override { return Ieee80211OfdmTimingRelatedParametersBase::getSymbolInterval(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:130:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 130 | virtual const Ieee80211OfdmModulation *getModulation() const override { return modulation; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:131:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 131 | virtual bps getGrossBitrate() const override { return Ieee80211OfdmModeBase::getGrossBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:132:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 132 | virtual bps getNetBitrate() const override { return Ieee80211OfdmModeBase::getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:133:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 133 | virtual int getNumberOfSpatialStreams() const override { return 1; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:144:5: warning: function 'getLegacyCwMin' should be marked [[nodiscard]] [modernize-use-nodiscard] + 144 | virtual int getLegacyCwMin() const override { return 15; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:144:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 144 | virtual int getLegacyCwMin() const override { return 15; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:145:5: warning: function 'getLegacyCwMax' should be marked [[nodiscard]] [modernize-use-nodiscard] + 145 | virtual int getLegacyCwMax() const override { return 1023; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:145:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 145 | virtual int getLegacyCwMax() const override { return 1023; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:150:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 150 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:152:5: warning: function 'getPreambleMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 152 | virtual const Ieee80211OfdmPreambleMode *getPreambleMode() const override { return preambleMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:152:46: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 152 | virtual const Ieee80211OfdmPreambleMode *getPreambleMode() const override { return preambleMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:153:5: warning: function 'getHeaderMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 153 | virtual const Ieee80211OfdmSignalMode *getHeaderMode() const override { return signalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:153:44: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 153 | virtual const Ieee80211OfdmSignalMode *getHeaderMode() const override { return signalMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:154:5: warning: function 'getDataMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 154 | virtual const Ieee80211OfdmDataMode *getDataMode() const override { return dataMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:154:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 154 | virtual const Ieee80211OfdmDataMode *getDataMode() const override { return dataMode; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:155:5: warning: function 'getNonHtReferenceRate' should be marked [[nodiscard]] [modernize-use-nodiscard] + 155 | virtual bps getNonHtReferenceRate() const override { return dataMode->getNetBitrate(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:155:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 155 | virtual bps getNonHtReferenceRate() const override { return dataMode->getNetBitrate(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:156:5: warning: function 'getModulationClass' should be marked [[nodiscard]] [modernize-use-nodiscard] + 156 | virtual ModulationClass getModulationClass() const override { return ModulationClass::OFDM; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:156:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 156 | virtual ModulationClass getModulationClass() const override { return ModulationClass::OFDM; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:157:5: warning: function 'getLegacyPreambleType' should be marked [[nodiscard]] [modernize-use-nodiscard] + 157 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:157:26: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 157 | virtual PreambleType getLegacyPreambleType() const override { return PreambleType::NOT_APPLICABLE; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:158:5: warning: function 'getSignalMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 158 | virtual const Ieee80211OfdmSignalMode *getSignalMode() const { return signalMode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:160:5: warning: function 'getDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 160 | virtual inline const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + signalMode->getDuration() + dataMode->getDuration(dataLength); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:160:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 160 | virtual inline const simtime_t getDuration(b dataLength) const override { return preambleMode->getDuration() + signalMode->getDuration() + dataMode->getDuration(dataLength); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:163:5: warning: function 'getSlotTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 163 | virtual const simtime_t getSlotTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:163:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 163 | virtual const simtime_t getSlotTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:164:5: warning: function 'getSifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 164 | virtual const simtime_t getSifsTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:164:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 164 | virtual const simtime_t getSifsTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:165:5: warning: function 'getRifsTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 165 | virtual const simtime_t getRifsTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:165:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 165 | virtual const simtime_t getRifsTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:166:5: warning: function 'getCcaTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 166 | virtual const simtime_t getCcaTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:166:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 166 | virtual const simtime_t getCcaTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:167:5: warning: function 'getPhyRxStartDelay' should be marked [[nodiscard]] [modernize-use-nodiscard] + 167 | virtual const simtime_t getPhyRxStartDelay() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:167:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 167 | virtual const simtime_t getPhyRxStartDelay() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:168:5: warning: function 'getRxTxTurnaroundTime' should be marked [[nodiscard]] [modernize-use-nodiscard] + 168 | virtual const simtime_t getRxTxTurnaroundTime() const override; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:168:29: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 168 | virtual const simtime_t getRxTxTurnaroundTime() const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:169:5: warning: function 'getPreambleLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 169 | virtual inline const simtime_t getPreambleLength() const override { return preambleMode->getDuration(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:169:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual inline const simtime_t getPreambleLength() const override { return preambleMode->getDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:170:5: warning: function 'getPlcpHeaderLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 170 | virtual inline const simtime_t getPlcpHeaderLength() const override { return signalMode->getDuration(); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:170:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual inline const simtime_t getPlcpHeaderLength() const override { return signalMode->getDuration(); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:171:5: warning: function 'getMpduMaxLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 171 | virtual inline int getMpduMaxLength() const override { return 4095; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:171:24: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 171 | virtual inline int getMpduMaxLength() const override { return 4095; } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:178:44: warning: invalid case style for global constant 'ofdmPreambleModeCS5MHz' [readability-identifier-naming] + 178 | static const Ieee80211OfdmPreambleMode ofdmPreambleModeCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~ + | OFDM_PREAMBLE_MODE_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:179:44: warning: invalid case style for global constant 'ofdmPreambleModeCS10MHz' [readability-identifier-naming] + 179 | static const Ieee80211OfdmPreambleMode ofdmPreambleModeCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_PREAMBLE_MODE_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:180:44: warning: invalid case style for global constant 'ofdmPreambleModeCS20MHz' [readability-identifier-naming] + 180 | static const Ieee80211OfdmPreambleMode ofdmPreambleModeCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_PREAMBLE_MODE_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:183:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate13' [readability-identifier-naming] + 183 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate13; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE13 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:184:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate15' [readability-identifier-naming] + 184 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate15; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE15 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:185:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate5' [readability-identifier-naming] + 185 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate5; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE5 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:186:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate7' [readability-identifier-naming] + 186 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate7; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE7 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:187:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate9' [readability-identifier-naming] + 187 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate9; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE9 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:188:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate11' [readability-identifier-naming] + 188 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate11; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE11 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:189:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate1' [readability-identifier-naming] + 189 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate1; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE1 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:190:42: warning: invalid case style for global constant 'ofdmHeaderMode6MbpsRate3' [readability-identifier-naming] + 190 | static const Ieee80211OfdmSignalMode ofdmHeaderMode6MbpsRate3; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE6_MBPS_RATE3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:192:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate13' [readability-identifier-naming] + 192 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate13; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE13 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:193:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate15' [readability-identifier-naming] + 193 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate15; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE15 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:194:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate5' [readability-identifier-naming] + 194 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate5; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE5 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:195:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate7' [readability-identifier-naming] + 195 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate7; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE7 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:196:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate9' [readability-identifier-naming] + 196 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate9; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE9 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:197:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate11' [readability-identifier-naming] + 197 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate11; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE11 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:198:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate1' [readability-identifier-naming] + 198 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate1; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE1 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:199:42: warning: invalid case style for global constant 'ofdmHeaderMode3MbpsRate3' [readability-identifier-naming] + 199 | static const Ieee80211OfdmSignalMode ofdmHeaderMode3MbpsRate3; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE3_MBPS_RATE3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:201:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate13' [readability-identifier-naming] + 201 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate13; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE13 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:202:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate15' [readability-identifier-naming] + 202 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate15; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE15 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:203:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate5' [readability-identifier-naming] + 203 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate5; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE5 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:204:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate7' [readability-identifier-naming] + 204 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate7; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE7 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:205:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate9' [readability-identifier-naming] + 205 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate9; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE9 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:206:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate11' [readability-identifier-naming] + 206 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate11; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE11 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:207:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate1' [readability-identifier-naming] + 207 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate1; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE1 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:208:42: warning: invalid case style for global constant 'ofdmHeaderMode1_5MbpsRate3' [readability-identifier-naming] + 208 | static const Ieee80211OfdmSignalMode ofdmHeaderMode1_5MbpsRate3; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_HEADER_MODE1_5_MBPS_RATE3 +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:211:40: warning: invalid case style for global constant 'ofdmDataMode1_5Mbps' [readability-identifier-naming] + 211 | static const Ieee80211OfdmDataMode ofdmDataMode1_5Mbps; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE1_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:212:40: warning: invalid case style for global constant 'ofdmDataMode2_25Mbps' [readability-identifier-naming] + 212 | static const Ieee80211OfdmDataMode ofdmDataMode2_25Mbps; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE2_25_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:213:40: warning: invalid case style for global constant 'ofdmDataMode3MbpsCS5MHz' [readability-identifier-naming] + 213 | static const Ieee80211OfdmDataMode ofdmDataMode3MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE3_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:214:40: warning: invalid case style for global constant 'ofdmDataMode3MbpsCS10MHz' [readability-identifier-naming] + 214 | static const Ieee80211OfdmDataMode ofdmDataMode3MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE3_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:215:40: warning: invalid case style for global constant 'ofdmDataMode4_5MbpsCS5MHz' [readability-identifier-naming] + 215 | static const Ieee80211OfdmDataMode ofdmDataMode4_5MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE4_5_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:216:40: warning: invalid case style for global constant 'ofdmDataMode4_5MbpsCS10MHz' [readability-identifier-naming] + 216 | static const Ieee80211OfdmDataMode ofdmDataMode4_5MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE4_5_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:217:40: warning: invalid case style for global constant 'ofdmDataMode6MbpsCS5MHz' [readability-identifier-naming] + 217 | static const Ieee80211OfdmDataMode ofdmDataMode6MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE6_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:218:40: warning: invalid case style for global constant 'ofdmDataMode6MbpsCS10MHz' [readability-identifier-naming] + 218 | static const Ieee80211OfdmDataMode ofdmDataMode6MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE6_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:219:40: warning: invalid case style for global constant 'ofdmDataMode6MbpsCS20MHz' [readability-identifier-naming] + 219 | static const Ieee80211OfdmDataMode ofdmDataMode6MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE6_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:220:40: warning: invalid case style for global constant 'ofdmDataMode9MbpsCS5MHz' [readability-identifier-naming] + 220 | static const Ieee80211OfdmDataMode ofdmDataMode9MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE9_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:221:40: warning: invalid case style for global constant 'ofdmDataMode9MbpsCS10MHz' [readability-identifier-naming] + 221 | static const Ieee80211OfdmDataMode ofdmDataMode9MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE9_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:222:40: warning: invalid case style for global constant 'ofdmDataMode9MbpsCS20MHz' [readability-identifier-naming] + 222 | static const Ieee80211OfdmDataMode ofdmDataMode9MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE9_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:223:40: warning: invalid case style for global constant 'ofdmDataMode12MbpsCS5MHz' [readability-identifier-naming] + 223 | static const Ieee80211OfdmDataMode ofdmDataMode12MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE12_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:224:40: warning: invalid case style for global constant 'ofdmDataMode12MbpsCS10MHz' [readability-identifier-naming] + 224 | static const Ieee80211OfdmDataMode ofdmDataMode12MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE12_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:225:40: warning: invalid case style for global constant 'ofdmDataMode12MbpsCS20MHz' [readability-identifier-naming] + 225 | static const Ieee80211OfdmDataMode ofdmDataMode12MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE12_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:226:40: warning: invalid case style for global constant 'ofdmDataMode13_5Mbps' [readability-identifier-naming] + 226 | static const Ieee80211OfdmDataMode ofdmDataMode13_5Mbps; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE13_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:227:40: warning: invalid case style for global constant 'ofdmDataMode18MbpsCS10MHz' [readability-identifier-naming] + 227 | static const Ieee80211OfdmDataMode ofdmDataMode18MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE18_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:228:40: warning: invalid case style for global constant 'ofdmDataMode18MbpsCS20MHz' [readability-identifier-naming] + 228 | static const Ieee80211OfdmDataMode ofdmDataMode18MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE18_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:229:40: warning: invalid case style for global constant 'ofdmDataMode24MbpsCS10MHz' [readability-identifier-naming] + 229 | static const Ieee80211OfdmDataMode ofdmDataMode24MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE24_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:230:40: warning: invalid case style for global constant 'ofdmDataMode24MbpsCS20MHz' [readability-identifier-naming] + 230 | static const Ieee80211OfdmDataMode ofdmDataMode24MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE24_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:231:40: warning: invalid case style for global constant 'ofdmDataMode27Mbps' [readability-identifier-naming] + 231 | static const Ieee80211OfdmDataMode ofdmDataMode27Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE27_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:232:40: warning: invalid case style for global constant 'ofdmDataMode36Mbps' [readability-identifier-naming] + 232 | static const Ieee80211OfdmDataMode ofdmDataMode36Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE36_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:233:40: warning: invalid case style for global constant 'ofdmDataMode48Mbps' [readability-identifier-naming] + 233 | static const Ieee80211OfdmDataMode ofdmDataMode48Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE48_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:234:40: warning: invalid case style for global constant 'ofdmDataMode54Mbps' [readability-identifier-naming] + 234 | static const Ieee80211OfdmDataMode ofdmDataMode54Mbps; + | ^~~~~~~~~~~~~~~~~~ + | OFDM_DATA_MODE54_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:237:36: warning: invalid case style for global constant 'ofdmMode1_5Mbps' [readability-identifier-naming] + 237 | static const Ieee80211OfdmMode ofdmMode1_5Mbps; + | ^~~~~~~~~~~~~~~ + | OFDM_MODE1_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:238:36: warning: invalid case style for global constant 'ofdmMode2_25Mbps' [readability-identifier-naming] + 238 | static const Ieee80211OfdmMode ofdmMode2_25Mbps; + | ^~~~~~~~~~~~~~~~ + | OFDM_MODE2_25_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:239:36: warning: invalid case style for global constant 'ofdmMode3MbpsCS5MHz' [readability-identifier-naming] + 239 | static const Ieee80211OfdmMode ofdmMode3MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_MODE3_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:240:36: warning: invalid case style for global constant 'ofdmMode3MbpsCS10MHz' [readability-identifier-naming] + 240 | static const Ieee80211OfdmMode ofdmMode3MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE3_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:241:36: warning: invalid case style for global constant 'ofdmMode4_5MbpsCS5MHz' [readability-identifier-naming] + 241 | static const Ieee80211OfdmMode ofdmMode4_5MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE4_5_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:242:36: warning: invalid case style for global constant 'ofdmMode4_5MbpsCS10MHz' [readability-identifier-naming] + 242 | static const Ieee80211OfdmMode ofdmMode4_5MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE4_5_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:243:36: warning: invalid case style for global constant 'ofdmMode6MbpsCS5MHz' [readability-identifier-naming] + 243 | static const Ieee80211OfdmMode ofdmMode6MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_MODE6_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:244:36: warning: invalid case style for global constant 'ofdmMode6MbpsCS10MHz' [readability-identifier-naming] + 244 | static const Ieee80211OfdmMode ofdmMode6MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE6_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:245:36: warning: invalid case style for global constant 'ofdmMode6MbpsCS20MHz' [readability-identifier-naming] + 245 | static const Ieee80211OfdmMode ofdmMode6MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE6_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:246:36: warning: invalid case style for global constant 'ofdmMode9MbpsCS5MHz' [readability-identifier-naming] + 246 | static const Ieee80211OfdmMode ofdmMode9MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~ + | OFDM_MODE9_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:247:36: warning: invalid case style for global constant 'ofdmMode9MbpsCS10MHz' [readability-identifier-naming] + 247 | static const Ieee80211OfdmMode ofdmMode9MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE9_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:248:36: warning: invalid case style for global constant 'ofdmMode9MbpsCS20MHz' [readability-identifier-naming] + 248 | static const Ieee80211OfdmMode ofdmMode9MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE9_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:249:36: warning: invalid case style for global constant 'ofdmMode12MbpsCS5MHz' [readability-identifier-naming] + 249 | static const Ieee80211OfdmMode ofdmMode12MbpsCS5MHz; + | ^~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE12_MBPS_C_S5_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:250:36: warning: invalid case style for global constant 'ofdmMode12MbpsCS10MHz' [readability-identifier-naming] + 250 | static const Ieee80211OfdmMode ofdmMode12MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE12_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:251:36: warning: invalid case style for global constant 'ofdmMode12MbpsCS20MHz' [readability-identifier-naming] + 251 | static const Ieee80211OfdmMode ofdmMode12MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE12_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:252:36: warning: invalid case style for global constant 'ofdmMode13_5Mbps' [readability-identifier-naming] + 252 | static const Ieee80211OfdmMode ofdmMode13_5Mbps; + | ^~~~~~~~~~~~~~~~ + | OFDM_MODE13_5_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:253:36: warning: invalid case style for global constant 'ofdmMode18MbpsCS10MHz' [readability-identifier-naming] + 253 | static const Ieee80211OfdmMode ofdmMode18MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE18_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:254:36: warning: invalid case style for global constant 'ofdmMode18MbpsCS20MHz' [readability-identifier-naming] + 254 | static const Ieee80211OfdmMode ofdmMode18MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE18_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:255:36: warning: invalid case style for global constant 'ofdmMode24MbpsCS10MHz' [readability-identifier-naming] + 255 | static const Ieee80211OfdmMode ofdmMode24MbpsCS10MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE24_MBPS_C_S10_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:256:36: warning: invalid case style for global constant 'ofdmMode24MbpsCS20MHz' [readability-identifier-naming] + 256 | static const Ieee80211OfdmMode ofdmMode24MbpsCS20MHz; + | ^~~~~~~~~~~~~~~~~~~~~ + | OFDM_MODE24_MBPS_C_S20_M_HZ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:257:36: warning: invalid case style for global constant 'ofdmMode27Mbps' [readability-identifier-naming] + 257 | static const Ieee80211OfdmMode ofdmMode27Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE27_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:258:36: warning: invalid case style for global constant 'ofdmMode36Mbps' [readability-identifier-naming] + 258 | static const Ieee80211OfdmMode ofdmMode36Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE36_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:259:36: warning: invalid case style for global constant 'ofdmMode48Mbps' [readability-identifier-naming] + 259 | static const Ieee80211OfdmMode ofdmMode48Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE48_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmMode.h:260:36: warning: invalid case style for global constant 'ofdmMode54Mbps' [readability-identifier-naming] + 260 | static const Ieee80211OfdmMode ofdmMode54Mbps; + | ^~~~~~~~~~~~~~ + | OFDM_MODE54_MBPS +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211OFDMMODULATION_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211OFDMMODULATION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_OFDMMODULATION_H +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:25:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 25 | virtual cObject *dup() const override { return new Ieee80211OfdmModulation(numSubcarriers, subcarrierModulation); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:25:22: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 25 | virtual cObject *dup() const override { return new Ieee80211OfdmModulation(numSubcarriers, subcarrierModulation); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:27:5: warning: function 'getNumSubcarriers' should be marked [[nodiscard]] [modernize-use-nodiscard] + 27 | virtual int getNumSubcarriers() const { return numSubcarriers; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:28:5: warning: function 'getSubcarrierModulation' should be marked [[nodiscard]] [modernize-use-nodiscard] + 28 | const ApskModulationBase *getSubcarrierModulation() const { return subcarrierModulation; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:31:5: warning: function 'calculateBER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual double calculateBER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateBER(snir, bandwidth, bitrate); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:31:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual double calculateBER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateBER(snir, bandwidth, bitrate); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:32:5: warning: function 'calculateSER' should be marked [[nodiscard]] [modernize-use-nodiscard] + 32 | virtual double calculateSER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateSER(snir, bandwidth, bitrate); } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:32:20: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual double calculateSER(double snir, Hz bandwidth, bps bitrate) const override { return subcarrierModulation->calculateSER(snir, bandwidth, bitrate); } + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:34:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 34 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:42:42: warning: invalid case style for global constant 'subcarriers52QbpskModulation' [readability-identifier-naming] + 42 | static const Ieee80211OfdmModulation subcarriers52QbpskModulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QBPSK_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:43:42: warning: invalid case style for global constant 'subcarriers52BpskModulation' [readability-identifier-naming] + 43 | static const Ieee80211OfdmModulation subcarriers52BpskModulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_BPSK_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:44:42: warning: invalid case style for global constant 'subcarriers52QpskModulation' [readability-identifier-naming] + 44 | static const Ieee80211OfdmModulation subcarriers52QpskModulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QPSK_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:45:42: warning: invalid case style for global constant 'subcarriers52Qam16Modulation' [readability-identifier-naming] + 45 | static const Ieee80211OfdmModulation subcarriers52Qam16Modulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QAM16_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:46:42: warning: invalid case style for global constant 'subcarriers52Qam64Modulation' [readability-identifier-naming] + 46 | static const Ieee80211OfdmModulation subcarriers52Qam64Modulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QAM64_MODULATION +./inet/physicallayer/wireless/ieee80211/mode/Ieee80211OfdmModulation.h:47:42: warning: invalid case style for global constant 'subcarriers52Qam256Modulation' [readability-identifier-naming] + 47 | static const Ieee80211OfdmModulation subcarriers52Qam256Modulation; + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | SUBCARRIERS52_QAM256_MODULATION +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211CONTROLINFO_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211CONTROLINFO_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_CONTROLINFO_M_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | class Ieee80211ConfigureRadioCommand; + 35 | + 36 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 37 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:50:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 50 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 51 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:84:10: warning: deleted member function should be public [modernize-use-equals-delete] + 84 | bool operator==(const Ieee80211ConfigureRadioCommand&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:89:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 89 | virtual ~Ieee80211ConfigureRadioCommand(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:91:5: warning: function 'dup' should be marked [[nodiscard]] [modernize-use-nodiscard] + 91 | virtual Ieee80211ConfigureRadioCommand *dup() const override {return new Ieee80211ConfigureRadioCommand(*this);} + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:91:45: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual Ieee80211ConfigureRadioCommand *dup() const override {return new Ieee80211ConfigureRadioCommand(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:95:5: warning: function 'getOpMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 95 | virtual const char * getOpMode() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:98:5: warning: function 'getModeSet' should be marked [[nodiscard]] [modernize-use-nodiscard] + 98 | virtual const Ieee80211ModeSet * getModeSet() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:101:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 101 | virtual const IIeee80211Mode * getMode() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:104:5: warning: function 'getBand' should be marked [[nodiscard]] [modernize-use-nodiscard] + 104 | virtual const IIeee80211Band * getBand() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:108:5: warning: function 'getChannel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 108 | virtual const Ieee80211Channel * getChannel() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211ControlInfo_m.h:112:5: warning: function 'getChannelNumber' should be marked [[nodiscard]] [modernize-use-nodiscard] + 112 | virtual int getChannelNumber() const; + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211PHYHEADER_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211PHYHEADER_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_PHYHEADER_M_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:65:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 65 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 66 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:84:10: warning: deleted member function should be public [modernize-use-equals-delete] + 84 | bool operator==(const Ieee80211PhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:89:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 89 | virtual ~Ieee80211PhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:91:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 91 | virtual Ieee80211PhyPreamble *dup() const override {return new Ieee80211PhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:92:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 92 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:93:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 93 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:118:10: warning: deleted member function should be public [modernize-use-equals-delete] + 118 | bool operator==(const Ieee80211PhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:123:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 123 | virtual ~Ieee80211PhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:125:33: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 125 | virtual Ieee80211PhyHeader *dup() const override {return new Ieee80211PhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:126:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 126 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:127:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 127 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:156:10: warning: deleted member function should be public [modernize-use-equals-delete] + 156 | bool operator==(const Ieee80211FhssPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:161:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 161 | virtual ~Ieee80211FhssPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:163:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 163 | virtual Ieee80211FhssPhyPreamble *dup() const override {return new Ieee80211FhssPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:164:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 164 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:165:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 165 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:196:10: warning: deleted member function should be public [modernize-use-equals-delete] + 196 | bool operator==(const Ieee80211FhssPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:201:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 201 | virtual ~Ieee80211FhssPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:203:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 203 | virtual Ieee80211FhssPhyHeader *dup() const override {return new Ieee80211FhssPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:204:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 204 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:205:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 205 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:242:10: warning: deleted member function should be public [modernize-use-equals-delete] + 242 | bool operator==(const Ieee80211IrPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:247:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 247 | virtual ~Ieee80211IrPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:249:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 249 | virtual Ieee80211IrPhyPreamble *dup() const override {return new Ieee80211IrPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:250:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 250 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:251:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 251 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:279:10: warning: deleted member function should be public [modernize-use-equals-delete] + 279 | bool operator==(const Ieee80211IrPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:284:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 284 | virtual ~Ieee80211IrPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:286:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 286 | virtual Ieee80211IrPhyHeader *dup() const override {return new Ieee80211IrPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:287:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 287 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:288:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 288 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:320:10: warning: deleted member function should be public [modernize-use-equals-delete] + 320 | bool operator==(const Ieee80211DsssPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:325:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 325 | virtual ~Ieee80211DsssPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:327:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 327 | virtual Ieee80211DsssPhyPreamble *dup() const override {return new Ieee80211DsssPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:328:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 328 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:329:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 329 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:361:10: warning: deleted member function should be public [modernize-use-equals-delete] + 361 | bool operator==(const Ieee80211DsssPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:366:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 366 | virtual ~Ieee80211DsssPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:368:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 368 | virtual Ieee80211DsssPhyHeader *dup() const override {return new Ieee80211DsssPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:369:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 369 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:370:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 370 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:407:10: warning: deleted member function should be public [modernize-use-equals-delete] + 407 | bool operator==(const Ieee80211HrDsssPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:412:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 412 | virtual ~Ieee80211HrDsssPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:414:41: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 414 | virtual Ieee80211HrDsssPhyPreamble *dup() const override {return new Ieee80211HrDsssPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:415:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 415 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:416:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 416 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:438:10: warning: deleted member function should be public [modernize-use-equals-delete] + 438 | bool operator==(const Ieee80211HrDsssPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:443:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 443 | virtual ~Ieee80211HrDsssPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:445:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 445 | virtual Ieee80211HrDsssPhyHeader *dup() const override {return new Ieee80211HrDsssPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:446:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 446 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:447:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 447 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:472:10: warning: deleted member function should be public [modernize-use-equals-delete] + 472 | bool operator==(const Ieee80211OfdmPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:477:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 477 | virtual ~Ieee80211OfdmPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:479:39: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 479 | virtual Ieee80211OfdmPhyPreamble *dup() const override {return new Ieee80211OfdmPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:480:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 480 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:481:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 481 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:533:10: warning: deleted member function should be public [modernize-use-equals-delete] + 533 | bool operator==(const Ieee80211OfdmPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:538:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 538 | virtual ~Ieee80211OfdmPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:540:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 540 | virtual Ieee80211OfdmPhyHeader *dup() const override {return new Ieee80211OfdmPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:541:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 541 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:542:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 542 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:582:10: warning: deleted member function should be public [modernize-use-equals-delete] + 582 | bool operator==(const Ieee80211ErpOfdmPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:587:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 587 | virtual ~Ieee80211ErpOfdmPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:589:42: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 589 | virtual Ieee80211ErpOfdmPhyPreamble *dup() const override {return new Ieee80211ErpOfdmPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:590:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 590 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:591:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 591 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:613:10: warning: deleted member function should be public [modernize-use-equals-delete] + 613 | bool operator==(const Ieee80211ErpOfdmPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:618:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 618 | virtual ~Ieee80211ErpOfdmPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:620:40: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 620 | virtual Ieee80211ErpOfdmPhyHeader *dup() const override {return new Ieee80211ErpOfdmPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:621:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 621 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:622:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 622 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:647:10: warning: deleted member function should be public [modernize-use-equals-delete] + 647 | bool operator==(const Ieee80211HtPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:652:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 652 | virtual ~Ieee80211HtPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:654:37: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 654 | virtual Ieee80211HtPhyPreamble *dup() const override {return new Ieee80211HtPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:655:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 655 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:656:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 656 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:704:10: warning: deleted member function should be public [modernize-use-equals-delete] + 704 | bool operator==(const Ieee80211HtPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:709:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 709 | virtual ~Ieee80211HtPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:711:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 711 | virtual Ieee80211HtPhyHeader *dup() const override {return new Ieee80211HtPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:712:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 712 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:713:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 713 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:773:10: warning: deleted member function should be public [modernize-use-equals-delete] + 773 | bool operator==(const Ieee80211VhtPhyPreamble&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:778:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 778 | virtual ~Ieee80211VhtPhyPreamble(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:780:38: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 780 | virtual Ieee80211VhtPhyPreamble *dup() const override {return new Ieee80211VhtPhyPreamble(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:781:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 781 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:782:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 782 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:804:10: warning: deleted member function should be public [modernize-use-equals-delete] + 804 | bool operator==(const Ieee80211VhtPhyHeader&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:809:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 809 | virtual ~Ieee80211VhtPhyHeader(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:811:36: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 811 | virtual Ieee80211VhtPhyHeader *dup() const override {return new Ieee80211VhtPhyHeader(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:812:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 812 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211PhyHeader_m.h:813:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 813 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:6:9: warning: invalid case style for macro definition '__INET__PHYSICALLAYER_IEEE80211TAG_M_H' [readability-identifier-naming] + 6 | #define __INET__PHYSICALLAYER_IEEE80211TAG_M_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PHYSICALLAYER_IEE_E80211_TAG_M_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:31:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 31 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 32 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer + 33 | + 34 | struct Ieee80211AmpduRange; + 35 | class Ieee80211AmpduInd; + 36 | class Ieee80211ModeTagBase; + 37 | class Ieee80211ModeReq; + 38 | class Ieee80211ModeInd; + 39 | class Ieee80211ChannelTagBase; + 40 | class Ieee80211ChannelReq; + 41 | class Ieee80211ChannelInd; + 42 | + 43 | } // namespace physicallayer + | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | } // namespace inet::physicallayer + 44 | } // namespace inet + | ~~~~~~~~~~~~~~~~~~~~ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:57:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 57 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 58 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:74:15: warning: invalid case style for function '__doPacking' [readability-identifier-naming] + 74 | void INET_API __doPacking(omnetpp::cCommBuffer *b, const Ieee80211AmpduRange& a); + | ^~~~~~~~~~~ + | doPacking + 75 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211AmpduRange& a); + 76 | + 77 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211AmpduRange& obj) { __doPacking(b, obj); } + | ~~~~~~~~~~~ + | doPacking +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:75:15: warning: invalid case style for function '__doUnpacking' [readability-identifier-naming] + 75 | void INET_API __doUnpacking(omnetpp::cCommBuffer *b, Ieee80211AmpduRange& a); + | ^~~~~~~~~~~~~ + | doUnpacking + 76 | + 77 | inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ieee80211AmpduRange& obj) { __doPacking(b, obj); } + 78 | inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ieee80211AmpduRange& obj) { __doUnpacking(b, obj); } + | ~~~~~~~~~~~~~ + | doUnpacking +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:100:12: warning: invalid case style for protected member 'ranges_arraysize' [readability-identifier-naming] + 100 | size_t ranges_arraysize = 0; + | ^~~~~~~~~~~~~~~~ + | rangesArraysize +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:106:10: warning: deleted member function should be public [modernize-use-equals-delete] + 106 | bool operator==(const Ieee80211AmpduInd&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:111:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 111 | virtual ~Ieee80211AmpduInd(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:113:32: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 113 | virtual Ieee80211AmpduInd *dup() const override {return new Ieee80211AmpduInd(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:114:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 114 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:115:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 115 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:161:10: warning: deleted member function should be public [modernize-use-equals-delete] + 161 | bool operator==(const Ieee80211ModeTagBase&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:166:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 166 | virtual ~Ieee80211ModeTagBase(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:168:35: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 168 | virtual Ieee80211ModeTagBase *dup() const override {return new Ieee80211ModeTagBase(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:169:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 169 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:170:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 170 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:199:10: warning: deleted member function should be public [modernize-use-equals-delete] + 199 | bool operator==(const Ieee80211ModeReq&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:204:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 204 | virtual ~Ieee80211ModeReq(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:206:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 206 | virtual Ieee80211ModeReq *dup() const override {return new Ieee80211ModeReq(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:207:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 207 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:208:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 208 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:234:10: warning: deleted member function should be public [modernize-use-equals-delete] + 234 | bool operator==(const Ieee80211ModeInd&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:239:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 239 | virtual ~Ieee80211ModeInd(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:241:31: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 241 | virtual Ieee80211ModeInd *dup() const override {return new Ieee80211ModeInd(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:242:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 242 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:243:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 243 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:270:10: warning: deleted member function should be public [modernize-use-equals-delete] + 270 | bool operator==(const Ieee80211ChannelTagBase&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:275:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 275 | virtual ~Ieee80211ChannelTagBase(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:277:38: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 277 | virtual Ieee80211ChannelTagBase *dup() const override {return new Ieee80211ChannelTagBase(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:278:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 278 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:279:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 279 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:308:10: warning: deleted member function should be public [modernize-use-equals-delete] + 308 | bool operator==(const Ieee80211ChannelReq&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:313:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 313 | virtual ~Ieee80211ChannelReq(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:315:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 315 | virtual Ieee80211ChannelReq *dup() const override {return new Ieee80211ChannelReq(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:316:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 316 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:317:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 317 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:343:10: warning: deleted member function should be public [modernize-use-equals-delete] + 343 | bool operator==(const Ieee80211ChannelInd&) = delete; + | ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:348:13: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + 348 | virtual ~Ieee80211ChannelInd(); + | ~~~~~~~ ^ + | override +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:350:34: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 350 | virtual Ieee80211ChannelInd *dup() const override {return new Ieee80211ChannelInd(*this);} + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:351:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 351 | virtual void parsimPack(omnetpp::cCommBuffer *b) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Tag_m.h:352:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 352 | virtual void parsimUnpack(omnetpp::cCommBuffer *b) override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:9:9: warning: invalid case style for macro definition '__INET_IEEE80211TRANSMISSION_H' [readability-identifier-naming] + 9 | #define __INET_IEEE80211TRANSMISSION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IEE_E80211_TRANSMISSION_H +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:18:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 18 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 19 | + 20 | namespace physicallayer { + | ~~~~~~~~~~~~~~~~~~~~~~~ + | namespace inet::physicallayer +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:31:27: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 31 | virtual std::ostream& printToStream(std::ostream& stream, int level, int evFlags = 0) const override; + | ~~~~~~~ ^ +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:33:5: warning: function 'getMode' should be marked [[nodiscard]] [modernize-use-nodiscard] + 33 | virtual const IIeee80211Mode *getMode() const { return mode; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:34:5: warning: function 'getChannel' should be marked [[nodiscard]] [modernize-use-nodiscard] + 34 | virtual const Ieee80211Channel *getChannel() const { return channel; } + | ^ + | [[nodiscard]] +./inet/physicallayer/wireless/ieee80211/packetlevel/Ieee80211Transmission.h:37:5: warning: function 'getSignalExtensionDuration' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | std::optional getSignalExtensionDuration() const; + | ^ + | [[nodiscard]] +./inet/queueing/base/PacketProcessorBase.h:9:9: warning: invalid case style for macro definition '__INET_PACKETPROCESSORBASE_H' [readability-identifier-naming] + 9 | #define __INET_PACKETPROCESSORBASE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PACKETPROCESSORBASE_H +./inet/queueing/base/PacketProcessorBase.h:17:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 17 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 18 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/base/PacketProcessorBase.h:32:17: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 32 | virtual int numInitStages() const override { return NUM_INIT_STAGES; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:33:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 33 | virtual void initialize(int stage) override; + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:74:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 74 | virtual bool supportsPacketSending(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:75:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 75 | virtual bool supportsPacketPassing(const cGate *gate) const override { return true; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:76:18: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 76 | virtual bool supportsPacketStreaming(const cGate *gate) const override { return false; } + | ~~~~~~~ ^ +./inet/queueing/base/PacketProcessorBase.h:78:25: warning: 'virtual' is redundant since the function is already declared 'override' [modernize-use-override] + 78 | virtual std::string resolveDirective(char directive) const override; + | ~~~~~~~ ^ +./inet/queueing/common/PassivePacketSinkRef.h:9:9: warning: invalid case style for macro definition '__INET_PASSIVEPACKETSINKREF_H' [readability-identifier-naming] + 9 | #define __INET_PASSIVEPACKETSINKREF_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_PASSIVEPACKETSINKREF_H +./inet/queueing/common/PassivePacketSinkRef.h:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/common/PassivePacketSinkRef.h:20:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 20 | virtual ~PassivePacketSinkRef() {} + | ^ ~~ + | = default; +./inet/queueing/common/PassivePacketSinkRef.h:22:5: warning: function 'canPushSomePacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 22 | virtual bool canPushSomePacket() const { + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:9:9: warning: invalid case style for macro definition '__INET_IPACKETCOLLECTION_H' [readability-identifier-naming] + 9 | #define __INET_IPACKETCOLLECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPACKETCOLLECTION_H +./inet/queueing/contract/IPacketCollection.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPacketCollection.h:26:5: warning: function 'getMaxNumPackets' should be marked [[nodiscard]] [modernize-use-nodiscard] + 26 | virtual int getMaxNumPackets() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:31:5: warning: function 'getNumPackets' should be marked [[nodiscard]] [modernize-use-nodiscard] + 31 | virtual int getNumPackets() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:37:5: warning: function 'getMaxTotalLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 37 | virtual b getMaxTotalLength() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:42:5: warning: function 'getTotalLength' should be marked [[nodiscard]] [modernize-use-nodiscard] + 42 | virtual b getTotalLength() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:47:5: warning: function 'getPacket' should be marked [[nodiscard]] [modernize-use-nodiscard] + 47 | virtual Packet *getPacket(int index) const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketCollection.h:52:5: warning: function 'isEmpty' should be marked [[nodiscard]] [modernize-use-nodiscard] + 52 | virtual bool isEmpty() const = 0; + | ^ + | [[nodiscard]] +./inet/queueing/contract/IPacketProcessor.h:9:9: warning: invalid case style for macro definition '__INET_IPACKETPROCESSOR_H' [readability-identifier-naming] + 9 | #define __INET_IPACKETPROCESSOR_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPACKETPROCESSOR_H +./inet/queueing/contract/IPacketProcessor.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPacketProcessor.h:22:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 22 | virtual ~IPacketProcessor() {} + | ^ ~~ + | = default; +./inet/queueing/contract/IPacketQueue.h:9:9: warning: invalid case style for macro definition '__INET_IPACKETQUEUE_H' [readability-identifier-naming] + 9 | #define __INET_IPACKETQUEUE_H + | ^~~~~~~~~~~~~~~~~~~~~ + | INET_IPACKETQUEUE_H +./inet/queueing/contract/IPacketQueue.h:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPassivePacketSink.h:9:9: warning: invalid case style for macro definition '__INET_IPASSIVEPACKETSINK_H' [readability-identifier-naming] + 9 | #define __INET_IPASSIVEPACKETSINK_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPASSIVEPACKETSINK_H +./inet/queueing/contract/IPassivePacketSink.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPassivePacketSink.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IPassivePacketSink() {} + | ^ ~~ + | = default; +./inet/queueing/contract/IPassivePacketSource.h:9:9: warning: invalid case style for macro definition '__INET_IPASSIVEPACKETSOURCE_H' [readability-identifier-naming] + 9 | #define __INET_IPASSIVEPACKETSOURCE_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_IPASSIVEPACKETSOURCE_H +./inet/queueing/contract/IPassivePacketSource.h:13:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 13 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 14 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/IPassivePacketSource.h:23:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 23 | virtual ~IPassivePacketSource() {} + | ^ ~~ + | = default; +./inet/queueing/contract/ISelectivePacketCollection.h:4:9: warning: invalid case style for macro definition '__INET_ISELECTIVEPACKETCOLLECTION_H' [readability-identifier-naming] + 4 | #define __INET_ISELECTIVEPACKETCOLLECTION_H + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | INET_ISELECTIVEPACKETCOLLECTION_H +./inet/queueing/contract/ISelectivePacketCollection.h:10:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 10 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 11 | namespace queueing { + | ~~~~~~~~~~~~~~~~~~ + | namespace inet::queueing +./inet/queueing/contract/ISelectivePacketCollection.h:24:13: warning: use '= default' to define a trivial destructor [modernize-use-equals-default] + 24 | virtual ~ISelectivePacketCollection() {} + | ^ ~~ + | = default; +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:36:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 36 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 37 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:57:33: warning: escaped string literal can be written as a raw string literal [modernize-raw-string-literal] + 57 | throw cRuntimeError("Unknown blockAckVariant \"%s\": expected \"basic\" or \"compressed\"", configuredVariant); + | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + | R"(Unknown blockAckVariant "%s": expected "basic" or "compressed")" +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:584:31: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 584 | if (originator && request->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:588:32: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 588 | if (!originator && response->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:592:56: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 592 | if (delba->getInitiator() == originator && delba->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:632:101: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 632 | return data && data->getType() == ST_DATA_WITH_QOS && data->getReceiverAddress() == peer && data->getTid() == tid && + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:646:13: warning: empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether [bugprone-empty-catch] + 646 | catch (const queueing::UnsupportedPacketSelection&) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:664:63: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 664 | if (data && data->getReceiverAddress() == peer && data->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:743:72: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 743 | data->getReceiverAddress() == entry.first.first && data->getTid() == entry.first.second) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:775:57: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 775 | if (header->getReceiverAddress() == peer && header->getTid() == tid) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:799:63: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 799 | if (data && data->getReceiverAddress() == peer && data->getTid() == tid && + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:827:67: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 827 | if (data && data->getReceiverAddress() == peer && data->getTid() == tid) + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:1996:9: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 1996 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:1996:10: note: end of the original + 1996 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2010:9: note: clone 1 starts here + 2010 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2012:9: note: clone 2 starts here + 2012 | ; // void + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2064:12: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 2064 | return SimTime(microseconds, SIMTIME_US); + | ^~~~~~~~ ~ + | { } +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:2611:70: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 2611 | if (data && data->getReceiverAddress() == limits.receiver && data->getTid() == limits.tid && + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3014:99: warning: repeated branch body in conditional chain [bugprone-branch-clone] + 3014 | if (dynamicPtrCast(header) && txop->getLimit() == 0) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3017:14: note: end of the original + 3017 | } + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3018:107: note: clone 1 starts here + 3018 | else if (pendingPacket && !channelOwner->getInProgressFrames()->containsFrame(pendingPacket)) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3193:6: warning: an exception may be thrown in function '~Hcf' which should not throw exceptions [bugprone-exception-escape] + 3193 | Hcf::~Hcf() + | ^ +/home/user/omnetpp-6.4.0aipre2/include/omnetpp/checkandcast.h:64:9: note: frame #0: unhandled exception of type 'omnetpp::cRuntimeError' may be thrown in function 'check_and_cast' here + 64 | throw cRuntimeError("check_and_cast(): Cannot cast nullptr to type '%s'", opp_typename(typeid(P))); + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/coordinationfunction/Hcf.cc:3198:28: note: frame #1: function '~Hcf' calls function 'check_and_cast' here + 3198 | auto radioModule = check_and_cast(interframeRadio.get()); + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/fragmentation/BasicFragmentationPolicy.cc:85:12: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 85 | return std::vector(); + | ^~~~~~~~~~~~~~~~~~ + | {} +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/framesequence/HcfFs.cc:12:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 12 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 13 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/framesequence/TxOpFs.cc:11:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 11 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 12 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc:21:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 21 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 22 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc:359:17: warning: comparison between 'signed char' and 'unsigned char' [bugprone-signed-char-misuse] + 359 | header->getTid() != limits.tid || + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/originator/OriginatorQosMacDataService.cc:573:9: warning: empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether [bugprone-empty-catch] + 573 | catch (const queueing::UnsupportedPacketSelection&) { + | ^ +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc:14:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 14 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 15 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/originator/QosRecoveryProcedure.cc:104:110: warning: 'signed char' passed to 'operator<<' outputs as character instead of integer. cast to 'unsigned int' to print numeric value or cast to 'char' to print as character [bugprone-unintended-char-ostream-output] + 104 | inline std::ostream& operator<<(std::ostream& os, const std::pair& p) { return os << p.first << "#" << p.second; } + | ^ ~~~~~~~ + | static_cast(p.first) +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc:15:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces] + 15 | namespace inet { + | ^~~~~~~~~~~~~~~~ + 16 | namespace ieee80211 { + | ~~~~~~~~~~~~~~~~~~~ + | namespace inet::ieee80211 +/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src/inet/linklayer/ieee80211/mac/queue/InProgressFrames.cc:39:16: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list] + 39 | return std::string("empty"); + | ^ +Suppressed 70261 warnings (70261 in non-user code). +Use -header-filter=.* to display errors from all non-system headers. Use -system-headers to display errors from system headers as well. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-unit.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-unit.txt new file mode 100644 index 00000000000..f2c27f509ef --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/c5-unit.txt @@ -0,0 +1,10 @@ +/home/user/.config/matplotlib is not a writable directory +Matplotlib created a temporary cache directory at /tmp/matplotlib-1p419sm2 because there was an issue with the default path ({configdir}); it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing. +No module named 'py4j': optional inet.common.ide package will not work +[0/5] ▶ 4 inet-ieee80211-txop-admission-remaining unit tests (concurrently) +[1/5]   ⏺ Ieee80211MultipleProtection_1.test PASS in 1.225 +[2/5]   ⏺ Ieee80211SingleProtection_1.test PASS in 1.422 +[3/5]   ⏺ Ieee80211TxopProcedure_1.test PASS in 1.422 +[4/5]   ⏺ Ieee80211BoundedFragmentation_1.test PASS in 1.432 +[5/5] ◉ 4 inet-ieee80211-txop-admission-remaining unit tests (concurrently) Multiple unit tests: 4 PASS in 1.509 +Multiple unit test results: PASS, summary: 4 PASS in 1.509 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/fingerprints.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/fingerprints.txt new file mode 100644 index 00000000000..6f2ace738dc --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/fingerprints.txt @@ -0,0 +1,17 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf' + +Failures: + /showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf') +---------------------------------------------------------------------- +Ran 3 tests in 13.703s + +FAILED (failures=2) + +Check showcases.csv.UPDATED for updated fingerprints +Check showcases.csv.FAILED for failed fingerprints +Log has been saved to fingerprinttest.out +Test results differ from expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/manifest.json b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/manifest.json new file mode 100644 index 00000000000..48acdbb1780 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/manifest.json @@ -0,0 +1,50 @@ +{ + "head": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "library_sha256": "36bab27ac268afe81ca4913bf29953ca12e2c10ff9e6c8f47b5ee2209e20c90a", + "production_diff_sha256": "5ff7a92152dee57747baf23608c0f0ce9f7c1bcc23e6a6eb0ea771913044477b", + "basic_runs": [ + { + "run": 0, + "name": "basic-6-single", + "invalid_boundaries": 10, + "invalid_continuations": 0 + }, + { + "run": 1, + "name": "basic-6-multiple", + "invalid_boundaries": 10, + "invalid_continuations": 0 + }, + { + "run": 2, + "name": "basic-24-single", + "invalid_boundaries": 0, + "invalid_continuations": 0 + }, + { + "run": 3, + "name": "basic-24-multiple", + "invalid_boundaries": 18, + "invalid_continuations": 18 + } + ], + "raw_artifacts": { + "aarf.txt": "556ecedbf3bfdcf94bacb69ccf2343eeb2fbc2816a0492edca4b3f38b7793845", + "admission.txt": "ebcb704e542a1062d20b75711a9cccf8331144fc57ec6813c972a2b66cb77de8", + "architecture.txt": "a13a5db7d35fdb39758c6d472c6798b09115edae4a47aa7541cd67aaec3b56a4", + "basic-24-multiple.txt": "5da60e08b0b0ba79fa8d5bc29a193d685c8c304432cec4e86005568ebf5a8585", + "basic-24-single.txt": "9e17f597420ad0d435e1a5f60800b374f90e2dcd3b94bbdb2343b21a57298477", + "basic-6-multiple.txt": "bae64ecc523008c56e2cc23ff886c58bcab03faa5401c5f83be9ac901d9dd7ce", + "basic-6-single.txt": "70fc7303939ff2e1266148080eb79519fcc7c68f10f5d7ab3a9ac48c73577039", + "build.txt": "877403940c9f5c331b229de107825d9028fee55d75b95ffc7ed8513e00197716", + "fingerprints.txt": "6c0aabbf8c5c0a416e2f124ff8f5617096feef131fa86a510a3d673dc6ebfa96", + "module.txt": "14a487b9829f3bb2f89dfc5d5c32ade7187b85a3d14451af29cb6900aaa947ca", + "normal-ack-2.txt": "1977241414a3ac3764d33b8984935a2bee225389b359ac23a54b4b6a9cab30cd", + "normal-ack-3.txt": "156708812c4f9201effe04d247a213109a618bc7abe513816b38d81c1dee6d1b", + "normal-ack-6.txt": "4e386b2a12385a99b21137e85d1a88e0cc78c65500bc8fa7124ff20dd3ac8e4b", + "normal-ack-7.txt": "4c239adfae357365eb9f1945860f395581747472e7c324673bf46de5554c01e1", + "onoe.txt": "11f4d405fa35e6b8908369eccfd6afb1f9ca097e8560e0846dd608e90d6fe2ae", + "protocol.txt": "e378df9fe86d120bb950fef6308df6b20714e41a9955621b6a82bcf79d77343f", + "unit.txt": "9e5bd762204ed4a47ecd5b0d4d4279568c6dad6ee6ec54557c3224c2ebd6825f" + } +} diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/module.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/module.txt new file mode 100644 index 00000000000..0a8e7e2c6db --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/module.txt @@ -0,0 +1,34 @@ +No module named 'py4j': optional inet.common.ide package will not work +[00/31] ▶ 30 inet-ieee80211-txop-admission-remaining module tests (concurrently) +[01/31]   ⏺ Ieee80211QosRecoveryPeerIdentity_1.test PASS in 0.912 +[02/31]   ⏺ Ieee80211EdcaDataLifetimeInvalid_3.test PASS in 1.003 +[03/31]   ⏺ Ieee80211BasicCompatibility_1.test PASS in 1.118 +[04/31]   ⏺ Ieee80211EdcaDataLifetimeInvalid_4.test PASS in 1.135 +[05/31]   ⏺ Ieee80211EdcaDataLifetimeInvalid_2.test PASS in 1.348 +[06/31]   ⏺ Ieee80211SingleProtectionGroup_1.test PASS in 1.342 +[07/31]   ⏺ Ieee80211CompressedBlockAckAdmission_1.test PASS in 2.601 +[08/31]   ⏺ Ieee80211AmpduPreparation_1.test PASS in 2.966 +[09/31]   ⏺ Ieee80211HcfManagementRecovery_1.test PASS in 2.992 +[10/31]   ⏺ Ieee80211EdcaDataLifetimeCongestion_1.test PASS in 1.695 +[11/31]   ⏺ Ieee80211EdcaDataLifetime_1.test PASS in 3.256 +[12/31]   ⏺ Ieee80211HcfSingleProtection_1.test PASS in 3.398 +[13/31]   ⏺ Ieee80211TxopMsduRecovery_1.test PASS in 1.135 +[14/31]   ⏺ Ieee80211EdcaDataLifetimeInvalid_1.test PASS in 1.025 +[15/31]   ⏺ Ieee80211EdcaDataLifetimeAggregation_1.test PASS in 1.585 +[16/31]   ⏺ Ieee80211PreparedQosFragments_1.test PASS in 1.147 +[17/31]   ⏺ Ieee80211HcfInternalCollision_1.test PASS in 1.251 +[18/31]   ⏺ Ieee80211HcfMultipleProtection_1.test PASS in 3.47 +[19/31]   ⏺ Ieee80211PreparedCancellation_1.test PASS in 1.148 +[20/31]   ⏺ Ieee80211EdcaDataLifetimeDefaults_1.test PASS in 1.183 +[21/31]   ⏺ Ieee80211EdcaDataLifetimeArbitration_1.test PASS in 1.52 +[22/31]   ⏺ Ieee80211PreparedQosData_1.test PASS in 1.312 +[23/31]   ⏺ Ieee80211BlockAckFragmentRetirement_1.test PASS in 4.505 +[24/31]   ⏺ Ieee80211HcfMultipleProtection_2.test PASS in 2.341 +[25/31]   ⏺ Ieee80211CompressedBlockAckExchange_1.test PASS in 8.227 +[26/31]   ⏺ Ieee80211AmpduExchange_1.test PASS in 9.128 +[27/31]   ⏺ Ieee80211AmpduRecovery_1.test PASS in 12.773 +[28/31]   ⏺ Ieee80211AmpduAdmission_1.test PASS in 11.561 +[29/31]   ⏺ Ieee80211BlockAckVariant_1.test PASS in 11.425 +[30/31]   ⏺ Ieee80211TxopAdmission_1.test PASS in 24.253 +[31/31] ◉ 30 inet-ieee80211-txop-admission-remaining module tests (concurrently) Multiple module tests: 30 PASS in 28.693 +Multiple module test results: PASS, summary: 30 PASS in 28.693 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-2.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-2.txt new file mode 100644 index 00000000000..520e5d585b7 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-2.txt @@ -0,0 +1,153 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #2... +Scenario: $rate=6, $profile="disabled", $protection="single", $repetition=0 +Assigned runID=General-2-20261019-02:43:17-16 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.6e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.734MiB +DATA node=sta1 decision=1.000102 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1 bound=1.001 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.001108 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.001108 bound=1.002108 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.001868 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.001766 bound=1.002766 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.002956 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.002854 bound=1.003854 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.003942 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.003942 bound=1.004942 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.00439 ifs=0 allocation=1 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.00439 bound=1.00539 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.00517 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.005068 bound=1.006068 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.006236 ifs=0 allocation=1 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.006236 bound=1.007236 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.007006 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.006904 bound=1.007904 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.008092 ifs=0 allocation=2 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.008092 bound=1.009092 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.008702 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.0086 bound=1.0096 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.009688 ifs=0 allocation=3 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.009688 bound=1.010688 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.010278 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.010176 bound=1.011176 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.011324 ifs=0 allocation=2 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.011324 bound=1.012324 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.012014 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.011912 bound=1.012912 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.013102 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.013 bound=1.014 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.014248 ifs=0 allocation=4 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.014248 bound=1.015248 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.014696 ifs=0 allocation=3 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.014696 bound=1.015696 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.015386 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.015284 bound=1.016284 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.016372 ifs=0 allocation=4 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.016372 bound=1.017372 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.017002 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.0169 bound=1.0179 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.017988 ifs=0 allocation=5 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.017988 bound=1.018988 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.018658 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.018556 bound=1.019556 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.019766 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.019664 bound=1.020664 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.020792 ifs=0 allocation=6 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.020792 bound=1.021792 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.0213 ifs=0 allocation=5 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.0213 bound=1.0223 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.02187 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.021768 bound=1.022768 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.023038 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.022936 bound=1.023936 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.024124 ifs=0 allocation=7 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.024124 bound=1.025124 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.024694 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.024592 bound=1.025592 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.02578 ifs=0 allocation=6 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.02578 bound=1.02678 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.02631 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.026208 bound=1.027208 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.027376 ifs=0 allocation=8 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.027376 bound=1.028376 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.027966 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.027864 bound=1.028864 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.029032 ifs=0 allocation=9 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.029032 bound=1.030032 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.02948 ifs=0 allocation=7 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.02948 bound=1.03048 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.03019 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.030088 bound=1.031088 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.031298 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.031196 bound=1.032196 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.032344 ifs=0 allocation=10 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.032344 bound=1.033344 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.032852 ifs=0 allocation=8 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.032852 bound=1.033852 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.033462 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.03336 bound=1.03436 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.03459 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.034488 bound=1.035488 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.035616 ifs=0 allocation=9 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.035616 bound=1.036616 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.036064 ifs=0 allocation=11 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.036064 bound=1.037064 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.036874 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.036772 bound=1.037772 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.037962 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.03786 bound=1.03886 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.038988 ifs=0 allocation=10 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.038988 bound=1.039988 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.038988 ifs=0 allocation=12 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.038988 bound=1.039988 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.039598 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.039496 bound=1.040496 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.040724 ifs=0 allocation=11 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.040724 bound=1.041724 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.041312 ifs=0 allocation=12 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.041312 bound=1.042312 count=1 agreement=0 aggregate=0 retry=1 exception=1 +DATA node=ap decision=1.042122 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.04202 bound=1.04302 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.04321 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.043108 bound=1.044108 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.044236 ifs=0 allocation=12 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.044236 bound=1.045236 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.044236 ifs=0 allocation=13 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.044236 bound=1.045236 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.045124 ifs=0 allocation=13 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.045124 bound=1.046124 count=1 agreement=0 aggregate=0 retry=1 exception=1 +DATA node=sta1 decision=1.045914 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.045812 bound=1.046812 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.047022 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.04692 bound=1.04792 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.048048 ifs=0 allocation=14 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.048048 bound=1.049048 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.048578 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.048476 bound=1.049476 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.049564 ifs=0 allocation=15 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.049564 bound=1.050564 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.050012 ifs=0 allocation=13 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.050012 bound=1.051012 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.050622 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.05052 bound=1.05152 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.051648 ifs=0 allocation=16 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.051648 bound=1.052648 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.052178 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.052076 bound=1.053076 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.053286 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.053184 bound=1.054184 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.054352 ifs=0 allocation=14 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.054352 bound=1.055352 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.05494 ifs=0 allocation=17 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.05494 bound=1.05594 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.05547 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.055368 bound=1.056368 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.056456 ifs=0 allocation=18 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.056456 bound=1.057456 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.057026 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.056924 bound=1.057924 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.058154 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.058052 bound=1.059052 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.05914 ifs=0 allocation=19 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.05914 bound=1.06014 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.05967 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.059568 bound=1.060568 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.060656 ifs=0 allocation=15 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.060656 bound=1.061656 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.061246 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.061144 bound=1.062144 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.062252 ifs=0 allocation=16 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.062252 bound=1.063252 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.06282 ifs=0 allocation=20 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.06282 bound=1.06382 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.06341 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.063308 bound=1.064308 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.064376 ifs=0 allocation=17 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.064376 bound=1.065376 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.065134 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.065032 bound=1.066032 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.066302 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.0662 bound=1.0672 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.067348 ifs=0 allocation=18 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.067348 bound=1.068348 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.067878 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.067776 bound=1.068776 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.069044 ifs=0 allocation=19 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.069044 bound=1.070044 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.069492 ifs=0 allocation=21 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.069492 bound=1.070492 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.070042 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.06994 bound=1.07094 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.071208 ifs=0 allocation=20 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.071208 bound=1.072208 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.072091 ifs=0 allocation=20 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.072091 bound=1.073091 count=1 agreement=0 aggregate=0 retry=1 exception=1 +DATA node=sta1 decision=1.072741 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.072639 bound=1.073639 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.073747 ifs=0 allocation=22 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.073747 bound=1.074747 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.074337 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.074235 bound=1.075235 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.075343 ifs=0 allocation=21 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.075343 bound=1.076343 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.075953 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.075851 bound=1.076851 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.076979 ifs=0 allocation=23 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.076979 bound=1.077979 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.077649 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.077547 bound=1.078547 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.078857 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.078755 bound=1.079755 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.079883 ifs=0 allocation=24 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.079883 bound=1.080883 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.080331 ifs=0 allocation=22 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.080331 bound=1.081331 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.080881 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.080779 bound=1.081779 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.081907 ifs=0 allocation=25 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.081907 bound=1.082907 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.082517 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.082415 bound=1.083415 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.083503 ifs=0 allocation=26 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.083503 bound=1.084503 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.084073 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.083971 bound=1.084971 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.085201 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.085099 bound=1.086099 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.086327 ifs=0 allocation=27 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.086327 bound=1.087327 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.086875 ifs=0 allocation=23 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.086875 bound=1.087875 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.087465 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.087363 bound=1.088363 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.088451 ifs=0 allocation=28 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.088451 bound=1.089451 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.089061 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.088959 bound=1.089959 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.090169 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.090067 bound=1.091067 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.091255 ifs=0 allocation=24 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.091255 bound=1.092255 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.091723 ifs=0 allocation=29 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.091723 bound=1.092723 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.092433 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.092331 bound=1.093331 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.093559 ifs=0 allocation=25 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.093559 bound=1.094559 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.094309 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.094207 bound=1.095207 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.095315 ifs=0 allocation=26 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.095315 bound=1.096315 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.095905 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.095803 bound=1.096803 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.096871 ifs=0 allocation=27 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.096871 bound=1.097871 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.097401 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.097299 bound=1.098299 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.098487 ifs=0 allocation=28 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.098487 bound=1.099487 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.099017 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.098915 bound=1.099915 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.100103 ifs=0 allocation=29 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.100103 bound=1.101103 count=1 agreement=0 aggregate=0 retry=0 exception=0 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=62 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=61 aggregates=0 delivered=30 +** Event #5860 t=1.2 Elapsed: 0.222999s (0m 00s) 92% completed (92% total) + Speed: ev/sec=26280.3 simsec/sec=5.2637 ev/simsec=4992.74 + Messages: created: 10096 present: 120 in FES: 4 Memory (RSS): 199.137MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #5860 + +Calling finish() at end of Run #2... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-3.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-3.txt new file mode 100644 index 00000000000..597e360550b --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-3.txt @@ -0,0 +1,150 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #3... +Scenario: $rate=6, $profile="disabled", $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-02:43:18-17 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.2e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 196.898MiB +DATA node=sta1 decision=1.000102 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1 bound=1.001 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.00111 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.00111 bound=1.00211 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.003 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.002898 bound=1.003898 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.004248 ifs=0.00001 allocation=0 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.004146 bound=1.005146 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.005256 ifs=0 allocation=0 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.005256 bound=1.006256 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.006366 ifs=0 allocation=1 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.006366 bound=1.007366 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.008216 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.008114 bound=1.009114 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.009284 ifs=0 allocation=2 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.009284 bound=1.010284 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.011064 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.010962 bound=1.011962 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.012112 ifs=0 allocation=3 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.012112 bound=1.013112 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.013304 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.013202 bound=1.014202 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.014572 ifs=0 allocation=4 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.014572 bound=1.015572 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.016272 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.01617 bound=1.01717 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.01744 ifs=0 allocation=5 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.01744 bound=1.01844 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.018812 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.01871 bound=1.01971 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.01996 ifs=0.00001 allocation=1 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.019858 bound=1.020858 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.021088 ifs=0 allocation=1 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.021088 bound=1.022088 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.02228 ifs=0.00001 allocation=2 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.022178 bound=1.023178 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.023268 ifs=0 allocation=2 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.023268 bound=1.024268 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.024378 ifs=0 allocation=6 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.024378 bound=1.025378 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.025678 ifs=0.00001 allocation=3 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.025576 bound=1.026576 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.026706 ifs=0 allocation=3 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.026706 bound=1.027706 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.028388 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.028286 bound=1.029286 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.029696 ifs=0.00001 allocation=4 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.029594 bound=1.030594 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.030704 ifs=0 allocation=4 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.030704 bound=1.031704 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.031794 ifs=0 allocation=7 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.031794 bound=1.032794 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.032974 ifs=0.00001 allocation=5 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.032872 bound=1.033872 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.034044 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.033942 bound=1.034942 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.03507 ifs=0 allocation=5 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.03507 bound=1.03607 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.0362 ifs=0 allocation=8 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.0362 bound=1.0372 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.03728 ifs=0.00001 allocation=6 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.037178 bound=1.038178 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.038328 ifs=0 allocation=6 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.038328 bound=1.039328 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.0396 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.039498 bound=1.040498 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.040648 ifs=0 allocation=9 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.040648 bound=1.041648 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.042578 ifs=0.00001 allocation=7 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.042476 bound=1.043476 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.043728 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.043626 bound=1.044626 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.044776 ifs=0 allocation=10 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.044776 bound=1.045776 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.045344 ifs=0 allocation=7 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.045344 bound=1.046344 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.046576 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.046474 bound=1.047474 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.047624 ifs=0 allocation=11 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.047624 bound=1.048624 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.049034 ifs=0.00001 allocation=8 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.048932 bound=1.049932 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.050184 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.050082 bound=1.051082 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.051232 ifs=0 allocation=12 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.051232 bound=1.052232 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.0518 ifs=0 allocation=8 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.0518 bound=1.0528 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.053032 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.05293 bound=1.05393 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.05424 ifs=0.00001 allocation=9 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.054138 bound=1.055138 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.055228 ifs=0 allocation=13 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.055228 bound=1.056228 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.055936 ifs=0 allocation=9 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.055936 bound=1.056936 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.057208 ifs=0.00001 allocation=10 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.057106 bound=1.058106 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.058276 ifs=0 allocation=10 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.058276 bound=1.059276 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.059448 ifs=0.00001 allocation=11 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.059346 bound=1.060346 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.060436 ifs=0 allocation=11 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.060436 bound=1.061436 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.061648 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.061546 bound=1.062546 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.062776 ifs=0.00001 allocation=12 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.062674 bound=1.063674 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.063804 ifs=0 allocation=12 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.063804 bound=1.064804 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.064976 ifs=0.00001 allocation=13 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.064874 bound=1.065874 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.067094 ifs=0 allocation=14 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.067094 bound=1.068094 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.067542 ifs=0 allocation=13 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.067542 bound=1.068542 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.068714 ifs=0.00001 allocation=14 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.068612 bound=1.069612 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.069702 ifs=0 allocation=14 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.069702 bound=1.070702 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.071134 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.071032 bound=1.072032 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.072142 ifs=0 allocation=15 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.072142 bound=1.073142 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.073242 ifs=0.00001 allocation=15 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.07314 bound=1.07414 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.074352 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.07425 bound=1.07525 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.07538 ifs=0 allocation=16 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.07538 bound=1.07638 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.075968 ifs=0 allocation=15 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.075968 bound=1.076968 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.07718 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.077078 bound=1.078078 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.078408 ifs=0.00001 allocation=16 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.078306 bound=1.079306 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.079376 ifs=0 allocation=16 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.079376 bound=1.080376 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.080566 ifs=0 allocation=17 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.080566 bound=1.081566 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.082756 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.082654 bound=1.083654 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.083724 ifs=0 allocation=18 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.083724 bound=1.084724 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.085784 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.085682 bound=1.086682 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.086972 ifs=0 allocation=19 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.086972 bound=1.087972 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.088344 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.088242 bound=1.089242 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.089532 ifs=0.00001 allocation=17 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.08943 bound=1.09043 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.09064 ifs=0 allocation=17 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.09064 bound=1.09164 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.09177 ifs=0 allocation=20 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.09177 bound=1.09277 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.09313 ifs=0.00001 allocation=18 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.093028 bound=1.094028 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.094138 ifs=0 allocation=18 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.094138 bound=1.095138 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.09559 ifs=0.00001 allocation=19 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.095488 bound=1.096488 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.096778 ifs=0 allocation=19 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.096778 bound=1.097778 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.09801 ifs=0.00001 allocation=20 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.097908 bound=1.098908 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.099018 ifs=0 allocation=20 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.099018 bound=1.100018 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.10111 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.101008 bound=1.102008 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.102158 ifs=0 allocation=21 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.102158 bound=1.103158 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.103418 ifs=0.00001 allocation=21 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.103316 bound=1.104316 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.104528 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.104426 bound=1.105426 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.105676 ifs=0 allocation=22 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.105676 bound=1.106676 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.106164 ifs=0 allocation=21 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.106164 bound=1.107164 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.107356 ifs=0.00001 allocation=22 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.107254 bound=1.108254 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.108404 ifs=0 allocation=22 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.108404 bound=1.109404 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.109676 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.109574 bound=1.110574 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.110844 ifs=0 allocation=23 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.110844 bound=1.111844 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.112214 ifs=0.00001 allocation=23 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.112112 bound=1.113112 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.113222 ifs=0 allocation=23 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.113222 bound=1.114222 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.114574 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.114472 bound=1.115472 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.115602 ifs=0 allocation=24 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.115602 bound=1.116602 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.116742 ifs=0.00001 allocation=24 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.11664 bound=1.11764 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.11771 ifs=0 allocation=24 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.11771 bound=1.11871 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.119002 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.1189 bound=1.1199 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.12025 ifs=0 allocation=25 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.12025 bound=1.12125 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.12163 ifs=0.00001 allocation=25 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.121528 bound=1.122528 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.12276 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.122658 bound=1.123658 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.123888 ifs=0 allocation=26 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.123888 bound=1.124888 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.124336 ifs=0 allocation=25 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.124336 bound=1.125336 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.125768 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.125666 bound=1.126666 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.126856 ifs=0.00001 allocation=26 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.126754 bound=1.127754 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.127984 ifs=0 allocation=27 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.127984 bound=1.128984 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.128512 ifs=0 allocation=26 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.128512 bound=1.129512 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.129724 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.129622 bound=1.130622 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.130812 ifs=0.00001 allocation=27 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.13071 bound=1.13171 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.13182 ifs=0 allocation=27 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.13182 bound=1.13282 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.13313 ifs=0 allocation=28 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.13313 bound=1.13413 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.13437 ifs=0.00001 allocation=28 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.134268 bound=1.135268 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.135498 ifs=0 allocation=28 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.135498 bound=1.136498 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.13677 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.136668 bound=1.137668 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.137898 ifs=0 allocation=29 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.137898 bound=1.138898 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.139278 ifs=0.00001 allocation=29 bitrate=6 Mbps airtime=0.000826 bytes=596 txopStart=1.139176 bound=1.140176 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.140406 ifs=0 allocation=29 bitrate=6 Mbps airtime=0.000298 bytes=200 txopStart=1.140406 bound=1.141406 count=1 agreement=0 aggregate=0 retry=0 exception=0 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=60 aggregates=0 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=60 aggregates=0 delivered=30 +** Event #6286 t=1.2 Elapsed: 0.223826s (0m 00s) 92% completed (92% total) + Speed: ev/sec=28086.6 simsec/sec=5.24425 ev/simsec=5355.69 + Messages: created: 10346 present: 120 in FES: 4 Memory (RSS): 198.344MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #6286 + +Calling finish() at end of Run #3... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-6.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-6.txt new file mode 100644 index 00000000000..b749cabf309 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-6.txt @@ -0,0 +1,62 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #6... +Scenario: $rate=24, $profile="disabled", $protection="single", $repetition=0 +Assigned runID=General-6-20261019-02:43:18-18 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.5e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.758MiB +DATA node=sta1 decision=1.000102 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1 bound=1.001 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.000674 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.000572 bound=1.001572 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.001466 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.001364 bound=1.002364 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.00241 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.002308 bound=1.003308 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.003294 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.003192 bound=1.004192 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.004198 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.004096 bound=1.005096 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.005062 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.00496 bound=1.00596 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.005826 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.005724 bound=1.006724 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.00659 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.006488 bound=1.007488 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.007394 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.007292 bound=1.008292 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.008198 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.008096 bound=1.009096 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.009022 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.00892 bound=1.00992 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.009826 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.009724 bound=1.010724 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.01067 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.010568 bound=1.011568 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.011984 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.011882 bound=1.012882 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.012788 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.012686 bound=1.013686 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.013592 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.01349 bound=1.01449 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.014496 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.014394 bound=1.015394 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.01532 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.015218 bound=1.016218 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.016224 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.016122 bound=1.017122 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.018288 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.018186 bound=1.019186 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.019092 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.01899 bound=1.01999 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.019916 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.019814 bound=1.020814 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.02076 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.020658 bound=1.021658 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.021564 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.021462 bound=1.022462 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.022428 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.022326 bound=1.023326 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.023312 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.02321 bound=1.02421 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.024116 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.024014 bound=1.025014 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.024748 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.024646 bound=1.025646 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.025732 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.02563 bound=1.02663 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.026496 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.026394 bound=1.027394 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.02754 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1.027438 bound=1.028438 count=1 agreement=0 aggregate=0 retry=0 exception=0 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=16 aggregates=14 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=16 aggregates=14 delivered=30 +** Event #2706 t=1.2 Elapsed: 0.098079s (0m 00s) 92% completed (92% total) + Speed: ev/sec=27595.9 simsec/sec=11.9695 ev/simsec=2305.52 + Messages: created: 4024 present: 120 in FES: 4 Memory (RSS): 199.211MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #2706 + +Calling finish() at end of Run #6... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-7.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-7.txt new file mode 100644 index 00000000000..f4f4b1aadde --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/normal-ack-7.txt @@ -0,0 +1,61 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from .: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 + +Preparing for running configuration General, run #7... +Scenario: $rate=24, $profile="disabled", $protection="multiple", $repetition=0 +Assigned runID=General-7-20261019-02:43:19-19 +Setting up network "ProbeNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.4e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 197.879MiB +DATA node=sta1 decision=1.000102 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1 bound=1.001 count=1 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=sta1 decision=1.000554 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000286 bytes=766 txopStart=1 bound=1.001 count=2 agreement=0 aggregate=0 retry=0 exception=0 +DATA node=ap decision=1.001126 ifs=0.00001 allocation=0 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.001024 bound=1.002024 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.002236 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.002134 bound=1.003134 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.00369 ifs=0.00001 allocation=1 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.003588 bound=1.004588 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.00498 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.004878 bound=1.005878 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.005984 ifs=0.00001 allocation=2 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.005882 bound=1.006882 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.007094 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.006992 bound=1.007992 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.008108 ifs=0.00001 allocation=3 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.008006 bound=1.009006 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.009178 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.009076 bound=1.010076 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.010332 ifs=0.00001 allocation=4 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.01023 bound=1.01123 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.011502 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.0114 bound=1.0124 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.012936 ifs=0.00001 allocation=5 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.012834 bound=1.013834 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.014086 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.013984 bound=1.014984 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.01515 ifs=0.00001 allocation=6 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.015048 bound=1.016048 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.0163 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.016198 bound=1.017198 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.017934 ifs=0.00001 allocation=7 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.017832 bound=1.018832 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.019204 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.019102 bound=1.020102 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.020268 ifs=0.00001 allocation=8 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.020166 bound=1.021166 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.021498 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.021396 bound=1.022396 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.022592 ifs=0.00001 allocation=9 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.02249 bound=1.02349 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.023682 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.02358 bound=1.02458 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.024856 ifs=0.00001 allocation=10 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.024754 bound=1.025754 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.026106 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.026004 bound=1.027004 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.02738 ifs=0.00001 allocation=11 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.027278 bound=1.028278 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.02859 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.028488 bound=1.029488 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.029634 ifs=0.00001 allocation=12 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.029532 bound=1.030532 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.030744 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.030642 bound=1.031642 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.031728 ifs=0.00001 allocation=13 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.031626 bound=1.032626 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=sta1 decision=1.032798 ifs=0.00001 allocation=15 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.032696 bound=1.033696 count=1 agreement=0 aggregate=1 retry=0 exception=0 +DATA node=ap decision=1.033842 ifs=0.00001 allocation=14 bitrate=24 Mbps airtime=0.000538 bytes=1532 txopStart=1.03374 bound=1.03474 count=1 agreement=0 aggregate=1 retry=0 exception=0 +SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=16 aggregates=14 delivered=30 +SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=15 aggregates=15 delivered=30 +** Event #2736 t=1.2 Elapsed: 0.095134s (0m 00s) 92% completed (92% total) + Speed: ev/sec=28764.6 simsec/sec=12.3396 ev/simsec=2331.08 + Messages: created: 3610 present: 120 in FES: 4 Memory (RSS): 199.281MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::ProbeTest) ProbeNetwork.test (id=7), at t=1.2s, event #2736 + +Calling finish() at end of Run #7... + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/onoe.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/onoe.txt new file mode 100644 index 00000000000..3102fe19c24 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/onoe.txt @@ -0,0 +1,333 @@ +OMNeT++ Discrete Event Simulation (C) 1992-2025 Andras Varga, OpenSim Ltd. +Version: 6.4.0aipre2, build: 260526-7b9114f72c, edition: Academic Public License -- NOT FOR COMMERCIAL USE +See the license for distribution terms and warranty disclaimer + +Setting up Cmdenv... + +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/work/Ieee80211TxopAdmission_1: 2 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src: 1287 +Loading NED files from /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/module/lib: 33 + +Preparing for running configuration General, run #0... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-0-20261019-02:43:21-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 2.9e-05s (0m 00s) 0% completed (0% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 194.066MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #7806 t=1.35 Elapsed: 0.297088s (0m 00s) 96% completed (6% total) + Speed: ev/sec=26276.9 simsec/sec=4.28534 ev/simsec=6131.82 + Messages: created: 12825 present: 120 in FES: 4 Memory (RSS): 195.719MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #7806 + +Calling finish() at end of Run #0... + +Preparing for running configuration General, run #1... +Scenario: $zero=false, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-1-20261019-02:43:21-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 6e-06s (0m 00s) 0% completed (6% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #8126 t=1.35 Elapsed: 0.285557s (0m 00s) 96% completed (12% total) + Speed: ev/sec=28457.4 simsec/sec=4.45818 ev/simsec=6383.18 + Messages: created: 13234 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #8126 + +Calling finish() at end of Run #1... + +Preparing for running configuration General, run #2... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-2-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (12% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4354 t=1.35 Elapsed: 0.173006s (0m 00s) 96% completed (18% total) + Speed: ev/sec=25167.9 simsec/sec=7.35865 ev/simsec=3420.18 + Messages: created: 6826 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4354 + +Calling finish() at end of Run #2... + +Preparing for running configuration General, run #3... +Scenario: $zero=false, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-3-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (18% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4479 t=1.35 Elapsed: 0.164656s (0m 00s) 96% completed (24% total) + Speed: ev/sec=27203.5 simsec/sec=7.73184 ev/simsec=3518.37 + Messages: created: 6386 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4479 + +Calling finish() at end of Run #3... + +Preparing for running configuration General, run #4... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-4-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (25% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #7806 t=1.35 Elapsed: 0.272887s (0m 00s) 96% completed (31% total) + Speed: ev/sec=28605.9 simsec/sec=4.66516 ev/simsec=6131.82 + Messages: created: 12825 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #7806 + +Calling finish() at end of Run #4... + +Preparing for running configuration General, run #5... +Scenario: $zero=false, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-5-20261019-02:43:22-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 7e-06s (0m 00s) 0% completed (31% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #8126 t=1.35 Elapsed: 0.28643s (0m 00s) 96% completed (37% total) + Speed: ev/sec=28370.5 simsec/sec=4.44457 ev/simsec=6383.18 + Messages: created: 13234 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #8126 + +Calling finish() at end of Run #5... + +Preparing for running configuration General, run #6... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-6-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (37% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4354 t=1.35 Elapsed: 0.180669s (0m 00s) 96% completed (43% total) + Speed: ev/sec=24100.3 simsec/sec=7.04649 ev/simsec=3420.18 + Messages: created: 6826 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4354 + +Calling finish() at end of Run #6... + +Preparing for running configuration General, run #7... +Scenario: $zero=false, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-7-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (43% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=30 expected=30 +Normal Ack TXOP admission assertions passed. +** Event #4479 t=1.35 Elapsed: 0.174211s (0m 00s) 96% completed (49% total) + Speed: ev/sec=25711.4 simsec/sec=7.30775 ev/simsec=3518.37 + Messages: created: 6386 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #4479 + +Calling finish() at end of Run #7... + +Preparing for running configuration General, run #48... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-48-20261019-02:43:23-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (50% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.048992s (0m 00s) 96% completed (56% total) + Speed: ev/sec=30417.5 simsec/sec=25.9882 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #48... + +Preparing for running configuration General, run #49... +Scenario: $zero=true, $loss=0, $rate=6, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-49-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (56% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.047724s (0m 00s) 96% completed (62% total) + Speed: ev/sec=31225.1 simsec/sec=26.6782 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #49... + +Preparing for running configuration General, run #50... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-50-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1.1e-05s (0m 00s) 0% completed (62% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.03545s (0m 00s) 96% completed (68% total) + Speed: ev/sec=29232.5 simsec/sec=35.9208 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #50... + +Preparing for running configuration General, run #51... +Scenario: $zero=true, $loss=0, $rate=6, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-51-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 9e-06s (0m 00s) 0% completed (68% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.036494s (0m 00s) 96% completed (74% total) + Speed: ev/sec=28393.7 simsec/sec=34.89 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #51... + +Preparing for running configuration General, run #52... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="single", $repetition=0 +Assigned runID=General-52-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 1e-05s (0m 00s) 0% completed (75% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.047603s (0m 00s) 96% completed (81% total) + Speed: ev/sec=31305.8 simsec/sec=26.7472 ev/simsec=1170.43 + Messages: created: 1881 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #52... + +Preparing for running configuration General, run #53... +Scenario: $zero=true, $loss=0, $rate=24, $rts=0, $protection="multiple", $repetition=0 +Assigned runID=General-53-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 7e-06s (0m 00s) 0% completed (81% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1490 t=1.35 Elapsed: 0.04292s (0m 00s) 96% completed (87% total) + Speed: ev/sec=34720.6 simsec/sec=29.6647 ev/simsec=1170.43 + Messages: created: 1895 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1490 + +Calling finish() at end of Run #53... + +Preparing for running configuration General, run #54... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="single", $repetition=0 +Assigned runID=General-54-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 8e-06s (0m 00s) 0% completed (87% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.032508s (0m 00s) 96% completed (93% total) + Speed: ev/sec=31875 simsec/sec=39.1678 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #54... + +Preparing for running configuration General, run #55... +Scenario: $zero=true, $loss=0, $rate=24, $rts=5000, $protection="multiple", $repetition=0 +Assigned runID=General-55-20261019-02:43:24-12 +Setting up network "TxopAdmissionNetwork"... +Initializing... + +Running simulation... +** Event #0 t=0 Elapsed: 7e-06s (0m 00s) 0% completed (93% total) + Speed: ev/sec=0 simsec/sec=0 ev/simsec=0 + Messages: created: 121 present: 121 in FES: 7 Memory (RSS): 195.855MiB +TXOP delivered=2 expected=2 +Normal Ack TXOP admission assertions passed. +** Event #1036 t=1.35 Elapsed: 0.033355s (0m 00s) 96% completed (99% total) + Speed: ev/sec=31065.4 simsec/sec=38.173 ev/simsec=813.805 + Messages: created: 1293 present: 120 in FES: 4 Memory (RSS): 195.855MiB + + Simulation stopped with endSimulation() -- in module (inet::ieee80211::TxopAdmissionTest) TxopAdmissionNetwork.test (id=7), at t=1.35s, event #1036 + +Calling finish() at end of Run #55... + +Run statistics: total 16, successful 16 + +End. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/protocol.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/protocol.txt new file mode 100644 index 00000000000..194a17d0e2c --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/protocol.txt @@ -0,0 +1,7 @@ +No module named 'py4j': optional inet.common.ide package will not work +[0/3] ▶ 1 protocol tests (sequentially) +[0/3]   ▶ 1 inet-ieee80211-txop-admission-remaining protocol wifi tests (concurrently) +[0/3]   ⏺ legacy/Legacy_Fragmentation.test PASS in 0.959 +[2/3]   ◉ 1 inet-ieee80211-txop-admission-remaining protocol wifi tests (concurrently) Multiple protocol wifi tests: PASS in 0.959 +[3/3] ◉ 1 protocol tests (sequentially) Multiple protocol tests: Multiple protocol wifi tests: PASS in 0.959 +Single protocol test result: Single protocol wifi test result: Result: PASS in 0.959 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/unit.txt b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/unit.txt new file mode 100644 index 00000000000..cfa01b76ac4 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/execution-20261019/unit.txt @@ -0,0 +1,8 @@ +No module named 'py4j': optional inet.common.ide package will not work +[0/5] ▶ 4 inet-ieee80211-txop-admission-remaining unit tests (concurrently) +[1/5]   ⏺ Ieee80211BoundedFragmentation_1.test PASS in 0.613 +[2/5]   ⏺ Ieee80211SingleProtection_1.test PASS in 0.613 +[3/5]   ⏺ Ieee80211MultipleProtection_1.test PASS in 0.615 +[4/5]   ⏺ Ieee80211TxopProcedure_1.test PASS in 0.657 +[5/5] ◉ 4 inet-ieee80211-txop-admission-remaining unit tests (concurrently) Multiple unit tests: 4 PASS in 0.699 +Multiple unit test results: PASS, summary: 4 PASS in 0.699 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/README.md b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/README.md new file mode 100644 index 00000000000..3b99e1f881c --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/README.md @@ -0,0 +1,79 @@ +# Approved TXOP admission fingerprints + +Twenty-one CSV rows change. Ten source changes belong to C4, and five belong to C5. Twenty rows also need inherited graphical updates. The first commit owns those graphical updates. C4 and C5 contain their additional changes. + +The user authorized fingerprint updates on 2026-10-19. The source and test definitions remain identical to the original published series. This task changes expectations and evidence only. + +## Cause and commit owner + +The unchanged dependency is `d841dc77db7d0b141bf31e5e215a0de9bb281957`. C3 is `d98c98fcfb`, C4 is `c419a07251`, and the original final source is `67bacef61c`. These identifiers name the source revisions used for the comparisons. The baseline amendments preserve those source trees. + +The dependency and C3 produce identical values in all twenty-five selected rows. Their event, communication, and packet-data expectations pass. Twenty graphical expectations differ from the stored values. The earlier cause of that graphical drift is unknown. The separate first commit records those measured dependency values. + +C4 changes ten rows from C3. C5 changes five rows from C4. The table names every final CSV update. An inherited entry means that the first commit changes only `tyf`. A later source commit can change that same row again. + +| Directory | Configuration | Commit owners | Reason | +| --- | --- | --- | --- | +| `showcases/wireless/aggregation/` | `NoAggregation; run 0` | inherited | Only inherited graphical drift changes. | +| `showcases/wireless/aggregation/` | `Aggregation; run 0` | inherited, C4 | C4 excludes A-MSDUs without HT capabilities. | +| `showcases/wireless/aggregation/` | `VoicePriorityAggregation; run 0` | inherited, C4 | C4 excludes A-MSDUs without HT capabilities. | +| `showcases/wireless/blockack/` | `Fragmentation; run 0` | C5 | C5 retains the Basic fragment group within a zero-limit TXOP. | +| `showcases/wireless/fragmentation/` | `DCFfrag; run 0` | inherited | Only inherited graphical drift changes. | +| `showcases/wireless/fragmentation/` | `HCFfrag; run 0` | inherited, C4 | C4 defers the next MSDU when its exchange cannot fit. | +| `showcases/wireless/fragmentation/` | `HCFfragblockack; run 0` | inherited, C5 | C5 applies prepared Basic admission and correct fragment reservations before BAR access. | +| `showcases/wireless/qos/` | `NonQos; run 0` | inherited | Only inherited graphical drift changes. | +| `showcases/wireless/qos/` | `Qos; run 0` | inherited, C4 | C4 excludes A-MSDUs without HT capabilities. | +| `showcases/wireless/txop/` | `General; run 0` | inherited, C5 | C5 applies prepared Basic admission and excludes non-HT A-MSDUs. | +| `examples/adhoc/qos/` | `MacQos; run 0` | inherited, C4 | C4 applies prepared admission and excludes non-HT A-MSDUs. | +| `examples/adhoc/qos/` | `MacQos; run 1` | inherited, C5 | C5 applies prepared Basic admission, legal frame forms, and the 2016 recovery contract. | +| `examples/adhoc/qos/` | `Fragmentation` | inherited | Only inherited graphical drift changes. | +| `examples/adhoc/qos/` | `MsduAggregation` | inherited, C4 | C4 excludes A-MSDUs without HT capabilities. | +| `examples/wireless/mactest/` | `MacEdca; run 0` | inherited, C4 | C4 sends the next fragment after SIFS within a zero-limit TXOP. | +| `examples/wireless/mactest/` | `MacDcf; run 0` | inherited | Only inherited graphical drift changes. | +| `examples/wireless/qos/` | `MacNonQos; run 0` | inherited | Only inherited graphical drift changes. | +| `examples/wireless/qos/` | `MacQos; run 0` | inherited, C4 | C4 applies prepared admission and excludes non-HT A-MSDUs. | +| `examples/wireless/qos/` | `MacQosWithoutAggregation; run 0` | inherited, C4 | C4 derives Retry from local ACK state. | +| `examples/wireless/qos/` | `MacQosWithRtsCts; run 0` | inherited, C4 | C4 excludes non-HT A-MSDUs before the protected exchange. | +| `examples/wireless/qos/` | `MacQosWithBlockAck; run 0` | inherited, C5 | C5 applies prepared Basic admission and excludes non-HT A-MSDUs. | + +The [value ledger](values.json) preserves every original, dependency, C3, C4, and final value. Thus, it also identifies graphical values that change twice. C4 never receives a C5 value. + +## Concrete evidence + +The aggregation traces show the first changed frame form. VoicePriorityAggregation first replaces a 516-byte A-MSDU with one 192-byte MPDU. The QoS examples show the same change without HT capabilities. The existing [three-case report](../execution-20261019/c5-fingerprint-causality.md) contains the original Aggregation trace. + +In HCFfrag, the next MSDU starts at 0.00345597088 seconds before C4. It starts at 0.00379597088 seconds after C4. Complete admission defers that MSDU after the current fragment group. + +In MacEdca, FTP-7-frag1 starts at 2.335881047819 seconds on the dependency. It starts at 2.335461047819 seconds after C4. The zero-limit sequence sends the next fragment after SIFS instead of new contention. + +MacQosWithoutAggregation exposes a distinct packet-data change. Video-16 reaches the AP after an uplink retry. Before C4, the AP retains that Retry bit for its first downlink transmission. C4 derives Retry from this hop's ACK state and clears it. The paired captures first differ at capture timestamp 1.019021 seconds, sequence 16, TID 5. Their event and communication fingerprints remain unchanged. + +The Basic traces separate C5 from C4. HCFfragblockack first moves its BAR from 0.004589367968 to 0.004773367968 seconds. Prepared Basic admission and fragment reservations change that access. The original Basic Fragmentation trace shows the next fragment after SIFS within a zero-limit TXOP. General and MacQosWithBlockAck replace non-HT A-MSDUs with ordinary MPDUs. + +The [trace excerpts](trace-excerpts.json) retain the first changed transmissions. The [trace commands](trace-commands.json) record the configuration, run, time limit, and status. The capture commands explicitly compute FCS and checksums. + +## Commands and results + +All fingerprint comparisons use debug libraries with OMNeT++ 6.4.0aipre2. The canonical command runs from `tests/fingerprint`: + +```sh +./fingerprinttest -d -t 8 -m '((showcases/wireless/(aggregation|blockack|fragmentation|qos|txop)|examples/(adhoc/qos|wireless/(qos|mactest)))/)' +``` + +The selector executes twenty-five rows. The CSV defines each simulation limit and run. MacQos in the ad hoc example includes runs zero and one. Configurations without an explicit run select run zero. + +The corrected dependency command selects an explicit launcher for the dependency library. The first launcher attempt resolved the current library through `PATH`; this record excludes that attempt. C3 and C4 each receive a debug build before their comparisons. The final source receives a debug rebuild after those comparisons. The [command record](commands.json) includes library hashes and exit statuses. + +| Check | Result | +| --- | --- | +| Dependency versus original expectations | Twenty graphical differences; all other selected ingredients pass. | +| Dependency versus approved graphical expectations | All twenty-five rows pass; status zero. | +| C3 versus dependency | All twenty-five rows match. | +| C4 versus C3 | Ten rows change. | +| Final source versus C4 | Five rows change. | +| C4 versus its approved expectations | All ten rows pass; status zero. | +| Final source versus approved CSV files | All twenty-five rows pass; status zero. | + +The [dependency output](base.txt), [C3 output](c3.txt), [C4 output](c4.txt), and [original final output](head-before-update.txt) preserve the comparisons before updates. These comparison runs return status one because they deliberately use earlier expectations. The [dependency check](base-approved.txt), [C4 check](c4-approved.txt), and [final check](final.txt) pass against their approved expectations. + +The fifteen changed non-graphical rows match the release CI failures on the original PR head. Graphical results describe this pinned local environment. They do not establish graphical stability across toolchains. The [publication record](../../../pending/ieee80211-txop-admission-publication.md) retains the broader source tests and global gate limits. diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base-approved.txt b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base-approved.txt new file mode 100644 index 00000000000..94ad7bfe93d --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base-approved.txt @@ -0,0 +1,34 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless ... : PASS +/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c NoFragmentation -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless adhoc Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFnofrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c MixedTraffic -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 ... : PASS +/showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 ... : PASS + +---------------------------------------------------------------------- +Ran 25 tests in 223.568s + +OK + +Log has been saved to fingerprinttest.out +Test results equals to expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base.txt b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base.txt new file mode 100644 index 00000000000..e2cffbe92ac --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/base.txt @@ -0,0 +1,59 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFnofrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c NoFragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf' +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'e394-4985/tyf', expected: '335d-6687/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c MixedTraffic -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '77f4-58c1/tyf', expected: '6f6e-b101/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '6cdd-e65e/tyf', expected: '95cc-1859/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'c99f-3188/tyf', expected: 'bd88-5ba6/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual '24e0-2e48/tyf', expected: 'dfcf-4644/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf' +/showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '6175-eb06/tyf', expected: 'c87d-3f3a/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '64d2-47e3/tyf', expected: 'bda9-15d1/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless adhoc Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '734c-15d1/tyf', expected: 'df04-18f7/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b06a-f098/tyf', expected: '9f3c-4512/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'f74f-a0c0/tyf', expected: '2c1e-66e5/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '57c2-84bd/tyf', expected: 'a587-3a4d/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '57cd-2e76/tyf', expected: 'a4c3-19bf/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '8cb9-109e/tyf', expected: 'b2d6-1329/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '0db4-29ea/tyf', expected: '08b5-d005/tyf' + +Failures: + /showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'e394-4985/tyf', expected: '335d-6687/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 (some fingerprint mismatch: actual '77f4-58c1/tyf', expected: '6f6e-b101/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '6cdd-e65e/tyf', expected: '95cc-1859/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 (some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'c99f-3188/tyf', expected: 'bd88-5ba6/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless (some fingerprint mismatch: actual '24e0-2e48/tyf', expected: 'dfcf-4644/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless (some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf') + /showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 (some fingerprint mismatch: actual '6175-eb06/tyf', expected: 'c87d-3f3a/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '64d2-47e3/tyf', expected: 'bda9-15d1/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 (some fingerprint mismatch: actual '734c-15d1/tyf', expected: 'df04-18f7/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b06a-f098/tyf', expected: '9f3c-4512/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 (some fingerprint mismatch: actual 'f74f-a0c0/tyf', expected: '2c1e-66e5/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 (some fingerprint mismatch: actual '57c2-84bd/tyf', expected: 'a587-3a4d/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '57cd-2e76/tyf', expected: 'a4c3-19bf/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 (some fingerprint mismatch: actual '8cb9-109e/tyf', expected: 'b2d6-1329/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 (some fingerprint mismatch: actual '0db4-29ea/tyf', expected: '08b5-d005/tyf') +---------------------------------------------------------------------- +Ran 25 tests in 373.594s + +FAILED (failures=20) + +Check showcases.csv.UPDATED for updated fingerprints +Check examples.csv.UPDATED for updated fingerprints +Check showcases.csv.FAILED for failed fingerprints +Check examples.csv.FAILED for failed fingerprints +Log has been saved to /tmp/inet-txop-fingerprint-update/base-runner.log +Test results differ from expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c3.txt b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c3.txt new file mode 100644 index 00000000000..b0bd62287f9 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c3.txt @@ -0,0 +1,59 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFnofrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c NoFragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'e394-4985/tyf', expected: '335d-6687/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c MixedTraffic -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '77f4-58c1/tyf', expected: '6f6e-b101/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '6cdd-e65e/tyf', expected: '95cc-1859/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'c99f-3188/tyf', expected: 'bd88-5ba6/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual '24e0-2e48/tyf', expected: 'dfcf-4644/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf' +/showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '6175-eb06/tyf', expected: 'c87d-3f3a/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '64d2-47e3/tyf', expected: 'bda9-15d1/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '734c-15d1/tyf', expected: 'df04-18f7/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless adhoc Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'f74f-a0c0/tyf', expected: '2c1e-66e5/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b06a-f098/tyf', expected: '9f3c-4512/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '57cd-2e76/tyf', expected: 'a4c3-19bf/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '57c2-84bd/tyf', expected: 'a587-3a4d/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '8cb9-109e/tyf', expected: 'b2d6-1329/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '0db4-29ea/tyf', expected: '08b5-d005/tyf' + +Failures: + /showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'e394-4985/tyf', expected: '335d-6687/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 (some fingerprint mismatch: actual '77f4-58c1/tyf', expected: '6f6e-b101/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '6cdd-e65e/tyf', expected: '95cc-1859/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 (some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'c99f-3188/tyf', expected: 'bd88-5ba6/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless (some fingerprint mismatch: actual '24e0-2e48/tyf', expected: 'dfcf-4644/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless (some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf') + /showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 (some fingerprint mismatch: actual '6175-eb06/tyf', expected: 'c87d-3f3a/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '64d2-47e3/tyf', expected: 'bda9-15d1/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 (some fingerprint mismatch: actual '734c-15d1/tyf', expected: 'df04-18f7/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 (some fingerprint mismatch: actual 'f74f-a0c0/tyf', expected: '2c1e-66e5/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b06a-f098/tyf', expected: '9f3c-4512/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '57cd-2e76/tyf', expected: 'a4c3-19bf/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 (some fingerprint mismatch: actual '57c2-84bd/tyf', expected: 'a587-3a4d/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 (some fingerprint mismatch: actual '8cb9-109e/tyf', expected: 'b2d6-1329/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 (some fingerprint mismatch: actual '0db4-29ea/tyf', expected: '08b5-d005/tyf') +---------------------------------------------------------------------- +Ran 25 tests in 333.483s + +FAILED (failures=20) + +Check showcases.csv.UPDATED for updated fingerprints +Check examples.csv.UPDATED for updated fingerprints +Check showcases.csv.FAILED for failed fingerprints +Check examples.csv.FAILED for failed fingerprints +Log has been saved to fingerprinttest.out +Test results differ from expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4-approved.txt b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4-approved.txt new file mode 100644 index 00000000000..59bede3de01 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4-approved.txt @@ -0,0 +1,19 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 ... : PASS + +---------------------------------------------------------------------- +Ran 10 tests in 175.212s + +OK + +Log has been saved to fingerprinttest.out +Test results equals to expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4.txt b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4.txt new file mode 100644 index 00000000000..f63878e2096 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/c4.txt @@ -0,0 +1,203 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf' +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFnofrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c MixedTraffic -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c NoFragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'd7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf', expected: 'c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;335d-6687/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf' +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '77f4-58c1/tyf', expected: '6f6e-b101/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf', expected: '1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;bd88-5ba6/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual 'c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf', expected: '5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;dfcf-4644/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf' +/showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '6175-eb06/tyf', expected: 'c87d-3f3a/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf', expected: '2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;bda9-15d1/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf', expected: '2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;df04-18f7/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf', expected: 'd929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;9f3c-4512/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf', expected: 'dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;2c1e-66e5/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '1906-1f5f/~tND;761d-e145/tyf', expected: '317d-aa4f/~tND;a4c3-19bf/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless adhoc Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '57c2-84bd/tyf', expected: 'a587-3a4d/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf', expected: 'e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;b2d6-1329/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '0db4-29ea/tyf', expected: '08b5-d005/tyf' + +Failures: + /showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'd7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf', expected: 'c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;335d-6687/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 (some fingerprint mismatch: actual '77f4-58c1/tyf', expected: '6f6e-b101/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 (some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf', expected: '1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;bd88-5ba6/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless (some fingerprint mismatch: actual 'c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf', expected: '5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;dfcf-4644/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless (some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf') + /showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 (some fingerprint mismatch: actual '6175-eb06/tyf', expected: 'c87d-3f3a/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf', expected: '2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;bda9-15d1/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 (some fingerprint mismatch: actual 'e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf', expected: '2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;df04-18f7/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf', expected: 'd929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;9f3c-4512/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 (some fingerprint mismatch: actual 'a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf', expected: 'dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;2c1e-66e5/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '1906-1f5f/~tND;761d-e145/tyf', expected: '317d-aa4f/~tND;a4c3-19bf/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 (some fingerprint mismatch: actual '57c2-84bd/tyf', expected: 'a587-3a4d/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 (some fingerprint mismatch: actual '5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf', expected: 'e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;b2d6-1329/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 (some fingerprint mismatch: actual '0db4-29ea/tyf', expected: '08b5-d005/tyf') +---------------------------------------------------------------------- +Ran 25 tests in 323.237s + +FAILED (failures=20) + +ERROR: Cannot replace fingerprint '27f2-4a52/tyf' to 'cb71-81f8/tyf' at 'showcases.csv' line 194 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c NoAggregation -r 0, 1s, 21a4-c882/tplx;ecf2-6e33/~tNl;5d9e-8fdf/~tND;cb71-81f8/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '0e94-675b/tplx' to 'b7d0-1c67/tplx' at 'showcases.csv' line 195 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '4545-c0de/~tNl' to 'd8f8-2120/~tNl' at 'showcases.csv' line 195 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'a778-2f83/~tND' to 'b2ba-0919/~tND' at 'showcases.csv' line 195 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '95cc-1859/tyf' to '7c83-f2e4/tyf' at 'showcases.csv' line 195 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '1ad6-ebce/tplx' to '455e-1981/tplx' at 'showcases.csv' line 196 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'cc40-e9c2/~tNl' to 'c6ed-de44/~tNl' at 'showcases.csv' line 196 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '5421-bc6d/~tND' to '6c9a-8f21/~tND' at 'showcases.csv' line 196 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'bd88-5ba6/tyf' to '2267-c230/tyf' at 'showcases.csv' line 196 (cnt: 0): + /showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'f985-34fb/tyf' to '74c3-9ba0/tyf' at 'showcases.csv' line 268 (cnt: 0): + /showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;74c3-9ba0/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'c99f-354d/tplx' to 'd7c1-fb92/tplx' at 'showcases.csv' line 269 (cnt: 0): + /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, d7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '8e10-a3f0/~tNl' to 'b7b8-b4e1/~tNl' at 'showcases.csv' line 269 (cnt: 0): + /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, d7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'ac4b-3ba1/~tND' to '7035-d6cb/~tND' at 'showcases.csv' line 269 (cnt: 0): + /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, d7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '335d-6687/tyf' to 'e791-f124/tyf' at 'showcases.csv' line 269 (cnt: 0): + /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, d7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '6f6e-b101/tyf' to '77f4-58c1/tyf' at 'showcases.csv' line 270 (cnt: 0): + /showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 99bc-a74d/tplx;fffd-4625/~tNl;5543-fbef/~tND;821e-8bed/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '093e-1ca4/tyf' to '34ac-bc95/tyf' at 'showcases.csv' line 316 (cnt: 0): + /showcases/wireless/qos/, -f omnetpp.ini -c NonQos -r 0, 10s, 5734-43a3/tplx;9c39-00a3/~tNl;03a9-2f02/~tND;34ac-bc95/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '2f30-f17c/tplx' to 'c105-8907/tplx' at 'showcases.csv' line 317 (cnt: 0): + /showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '0683-d978/~tNl' to 'f17b-f24c/~tNl' at 'showcases.csv' line 317 (cnt: 0): + /showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'a879-de03/~tND' to 'c055-873b/~tND' at 'showcases.csv' line 317 (cnt: 0): + /showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'bda9-15d1/tyf' to '1c08-f8f1/tyf' at 'showcases.csv' line 317 (cnt: 0): + /showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'c87d-3f3a/tyf' to '6175-eb06/tyf' at 'showcases.csv' line 344 (cnt: 0): + /showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, 92af-e665/tplx;7960-ff7c/~tNl;0ec4-ff6b/tyf, PASS, wireless Ipv4 + +Check showcases.csv.UPDATED for updated fingerprints +ERROR: Cannot replace fingerprint 'dd36-1076/tplx' to 'a78c-7701/tplx' at 'examples.csv' line 9 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint 'b703-3ef2/~tNl' to 'cedf-054d/~tNl' at 'examples.csv' line 9 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint 'e07d-2980/~tND' to '91a9-683f/~tND' at 'examples.csv' line 9 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint '2c1e-66e5/tyf' to 'f841-fef5/tyf' at 'examples.csv' line 9 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint 'a587-3a4d/tyf' to '57c2-84bd/tyf' at 'examples.csv' line 10 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 33e1-5ba7/tplx;f321-055c/~tNl;b439-5b70/~tND;5cb1-cbfe/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint '33b7-00f9/tyf' to '97f7-655d/tyf' at 'examples.csv' line 11 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;97f7-655d/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint '2c80-6844/tplx' to 'e24a-3845/tplx' at 'examples.csv' line 12 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint '4e9e-cf86/~tNl' to '5509-e838/~tNl' at 'examples.csv' line 12 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint 'ea3d-e802/~tND' to '636c-9cea/~tND' at 'examples.csv' line 12 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint 'df04-18f7/tyf' to 'cc7a-9b26/tyf' at 'examples.csv' line 12 (cnt: 0): + /examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf, PASS, wireless adhoc Ipv4 + +ERROR: Cannot replace fingerprint '5635-3aae/tplx' to 'c4a0-ea53/tplx' at 'examples.csv' line 608 (cnt: 0): + /examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf, PASS, wireless + +ERROR: Cannot replace fingerprint 'c574-69b7/~tNl' to '9c3d-fe57/~tNl' at 'examples.csv' line 608 (cnt: 0): + /examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf, PASS, wireless + +ERROR: Cannot replace fingerprint 'bb83-14c4/~tND' to 'ec7b-7e1e/~tND' at 'examples.csv' line 608 (cnt: 0): + /examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf, PASS, wireless + +ERROR: Cannot replace fingerprint 'dfcf-4644/tyf' to 'b459-aecf/tyf' at 'examples.csv' line 608 (cnt: 0): + /examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf, PASS, wireless + +ERROR: Cannot replace fingerprint 'f37f-cd48/tyf' to '3edc-eb8d/tyf' at 'examples.csv' line 609 (cnt: 0): + /examples/wireless/mactest/, -f omnetpp.ini -c MacDcf -r 0, 100s, 031d-548a/tplx;4db6-9460/~tNl;4c1d-35a0/~tND;3edc-eb8d/tyf, PASS, wireless + +ERROR: Cannot replace fingerprint '6097-a429/tyf' to 'b802-9992/tyf' at 'examples.csv' line 657 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 0be7-a22e/tplx;5eb9-6cea/~tNl;87a5-11a1/~tND;b802-9992/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'd929-5913/tplx' to '0473-f9d2/tplx' at 'examples.csv' line 658 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'f602-4424/~tNl' to 'e92c-7352/~tNl' at 'examples.csv' line 658 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'f2fb-4d98/~tND' to '1906-1f5f/~tND' at 'examples.csv' line 658 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '9f3c-4512/tyf' to '4196-a696/tyf' at 'examples.csv' line 658 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '317d-aa4f/~tND' to '1906-1f5f/~tND' at 'examples.csv' line 659 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;761d-e145/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'a4c3-19bf/tyf' to '761d-e145/tyf' at 'examples.csv' line 659 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;761d-e145/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'e07a-4c5f/tplx' to '5269-1e09/tplx' at 'examples.csv' line 660 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, 5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '9f6c-7889/~tNl' to 'b291-6797/~tNl' at 'examples.csv' line 660 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, 5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '29ea-169c/~tND' to '0378-ab11/~tND' at 'examples.csv' line 660 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, 5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint 'b2d6-1329/tyf' to '9b3b-150c/tyf' at 'examples.csv' line 660 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, 5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf, PASS, wireless Ipv4 + +ERROR: Cannot replace fingerprint '08b5-d005/tyf' to '0db4-29ea/tyf' at 'examples.csv' line 661 (cnt: 0): + /examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 7866-b50d/tplx;cf3d-0664/~tNl;5912-f4f1/~tND;7ed5-dd85/tyf, PASS, wireless Ipv4 + +Check examples.csv.UPDATED for updated fingerprints +Check showcases.csv.FAILED for failed fingerprints +Check examples.csv.FAILED for failed fingerprints +Log has been saved to fingerprinttest.out +Test results differ from expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/commands.json b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/commands.json new file mode 100644 index 00000000000..79cf4b9485c --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/commands.json @@ -0,0 +1,215 @@ +{ + "approval": "User request on 2026-10-19: Update fingerprints, justifiying each update in the corresponding commit. Then push and update PR", + "original_head": "67bacef61cd4031598c0aec6c1d3b7d6958f0b0f", + "base": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "mode": "debug", + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/fingerprint", + "selector": "((showcases/wireless/(aggregation|blockack|fragmentation|qos|txop)|examples/(adhoc/qos|wireless/(qos|mactest)))/)", + "base_command": [ + "./fingerprinttest", + "-d", + "-t", + "8", + "-e", + "/tmp/inet-txop-fingerprint-update/base", + "-m", + "((showcases/wireless/(aggregation|blockack|fragmentation|qos|txop)|examples/(adhoc/qos|wireless/(qos|mactest)))/)", + "-l", + "/tmp/inet-txop-fingerprint-update/base-runner.log" + ], + "base_launcher": "#!/bin/sh\nexec /home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet --debug \"$@\"\n", + "base_status": 1, + "base_library_sha256": "bc3595467d81df205051bc14f684b4e7ccae7c367c0efea7358fed1599efcaf7", + "prefixes": [ + { + "label": "c3-build", + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining", + "exit_status": 0, + "log": "/tmp/inet-txop-fingerprint-update/c3-build.log" + }, + { + "label": "c3", + "revision": "d98c98fcfb", + "library_sha256": "9f7b4dccf195ed7b88a30c8cd337f5d069882c049ec7ac632744fac60c8933f3" + }, + { + "label": "c3-traces", + "command": [ + "python3", + "/tmp/inet-txop-fingerprint-update/trace.py", + "c3" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining", + "exit_status": 0, + "log": "/tmp/inet-txop-fingerprint-update/c3-traces.log" + }, + { + "label": "c3", + "command": [ + "./fingerprinttest", + "-d", + "-t", + "8", + "-m", + "((showcases/wireless/(aggregation|blockack|fragmentation|qos|txop)|examples/(adhoc/qos|wireless/(qos|mactest)))/)" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/fingerprint", + "exit_status": 1, + "log": "/tmp/inet-txop-fingerprint-update/c3.log" + }, + { + "label": "c4-build", + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining", + "exit_status": 0, + "log": "/tmp/inet-txop-fingerprint-update/c4-build.log" + }, + { + "label": "c4", + "revision": "c419a07251", + "library_sha256": "319b48aeac19e566411c37749d5c11bb70ba3f4fd1759a877dbdf4fe3d0dfb04" + }, + { + "label": "c4-traces", + "command": [ + "python3", + "/tmp/inet-txop-fingerprint-update/trace.py", + "c4" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining", + "exit_status": 0, + "log": "/tmp/inet-txop-fingerprint-update/c4-traces.log" + }, + { + "label": "c4", + "command": [ + "./fingerprinttest", + "-d", + "-t", + "8", + "-m", + "((showcases/wireless/(aggregation|blockack|fragmentation|qos|txop)|examples/(adhoc/qos|wireless/(qos|mactest)))/)" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/fingerprint", + "exit_status": 1, + "log": "/tmp/inet-txop-fingerprint-update/c4.log" + }, + { + "label": "restored-build", + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining", + "exit_status": 0, + "log": "/tmp/inet-txop-fingerprint-update/restored-build.log" + } + ], + "head_library_sha256": "1de36100640807565d8456334072201ff3f412a3e5fbfe28e0376a5e0fc57bf2", + "c4_saved_library_sha256": "319b48aeac19e566411c37749d5c11bb70ba3f4fd1759a877dbdf4fe3d0dfb04", + "c4_approved_launcher": "#!/bin/sh\nexec /home/user/omnetpp-6.4.0aipre2/bin/opp_run_dbg -l /tmp/inet-txop-fingerprint-update/c4-library/INET -x 'inet.applications.voipstream;inet.emulation;inet.examples.emulation;inet.examples.voipstream;inet.linklayer.configurator.gatescheduling.z3;inet.showcases.emulation;inet.showcases.visualizer.osg;inet.transportlayer.tcp_lwip;inet.validation.tsn;inet.visualizer.osg' -n /home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/src:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/validation:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tests/networks:/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/tutorials: --image-path=/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/images \"$@\"\n\n", + "c4_approved_csv": "/showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf, PASS, wireless Ipv4\n/showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf, PASS, wireless Ipv4\n/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, d7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf, PASS, wireless Ipv4\n/showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf, PASS, wireless Ipv4\n/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf, PASS, wireless adhoc Ipv4\n/examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf, PASS, wireless adhoc Ipv4\n/examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf, PASS, wireless\n/examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf, PASS, wireless Ipv4\n/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;761d-e145/tyf, PASS, wireless Ipv4\n/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, 5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf, PASS, wireless Ipv4\n", + "source_equivalence": [ + { + "original": "a8557bc6513a5c48bebdd0ce11923fefbe71b1b7", + "amended": "ac7109fb42df21c0fc33ea01b9b34e7d1c4dd4a5", + "source_tree": "8c902ca5b4694a4a2aebadfffee15aec9acf593f", + "test_definitions_equal": true + }, + { + "original": "9c4bf543d8039e82d7217d19a757ca73dff8e5e4", + "amended": "01d95368a6dd08daa314aae1eedd7bcada87db6d", + "source_tree": "08c68cae1fda6e863a77360688d2373693fff55b", + "test_definitions_equal": true + }, + { + "original": "04b2e32c659336117e81fc3d579667d6ce135c61", + "amended": "57f454d86a9b93a7ab7b8c4276e48460d229f903", + "source_tree": "1c1b29139b06edf1b21b3858d55eaba26786c6b6", + "test_definitions_equal": true + }, + { + "original": "d98c98fcfb08b223ed6b88482493e87f0ed274b3", + "amended": "f9ac9ed3a901b6099448b6fa3a1ccd32aa163673", + "source_tree": "fb866d5bd53c5a76d7bbaa1d6312113d4baad2ac", + "test_definitions_equal": true + }, + { + "original": "c419a072519da0cc402d0285e255ee9ac72aa6e6", + "amended": "25d9c94ddacc53fd7cba4544d7b79523039ccc6a", + "source_tree": "600bed39f9f23cc00ef3e53a9a00b45aae115f0c", + "test_definitions_equal": true + }, + { + "original": "a6c85b80ba735641b2e4b5386563fab34dc92a78", + "amended": "e01bb3bd5aba46711e3f657ed92c8feeb18e9654", + "source_tree": "da6d4e06c3e106bfd8a6eabf53428b88a5300176", + "test_definitions_equal": true + } + ], + "inherited_commit": "f4d63d184087c904d745d9fe6a15305fdcec41ed", + "c4_approved": { + "command": [ + "./fingerprinttest", + "-d", + "-t", + "8", + "-e", + "/tmp/inet-txop-fingerprint-update/c4-run", + "-m", + "(showcases|examples)/", + "/tmp/inet-txop-fingerprint-update/c4-verification.csv" + ], + "status": 0, + "rows": 10 + }, + "final": { + "command": [ + "./fingerprinttest", + "-d", + "-t", + "8", + "-m", + "((showcases/wireless/(aggregation|blockack|fragmentation|qos|txop)|examples/(adhoc/qos|wireless/(qos|mactest)))/)", + "-l", + "/tmp/inet-txop-fingerprint-update/final-runner.log" + ], + "status": 0, + "rows": 25 + }, + "release_build": { + "command": [ + "make", + "MODE=release", + "-j8" + ], + "status": 0, + "library_sha256": "70436a0ffc1aa69d1a74059609e6cb1cd02035fa959fe12c95861dbebace6b2b" + }, + "base_approved": { + "command": [ + "./fingerprinttest", + "-d", + "-t", + "8", + "-e", + "/tmp/inet-txop-fingerprint-update/base", + "-m", + "(showcases|examples)/", + "/tmp/inet-txop-fingerprint-update/base-verification.csv" + ], + "status": 0, + "rows": 25, + "csv": "/examples/adhoc/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 5749-0281/tplx;f38a-cb93/~tNl;c2ed-b352/~tND;0eb8-3e3b/tyf, PASS, wireless adhoc Ipv4\n/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;f74f-a0c0/tyf, PASS, wireless adhoc Ipv4\n/examples/adhoc/qos/, -f omnetpp.ini -c MacQos -r 1, 10s, 4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;57c2-84bd/tyf, PASS, wireless adhoc Ipv4\n/examples/adhoc/qos/, -f omnetpp.ini -c Fragmentation, 10s, 2f2d-73b1/tplx;cc9e-d1a6/~tNl;e740-f7d4/~tND;97f7-655d/tyf, PASS, wireless adhoc Ipv4\n/examples/adhoc/qos/, -f omnetpp.ini -c MsduAggregation, 10s, 2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;734c-15d1/tyf, PASS, wireless adhoc Ipv4\n/examples/wireless/mactest/, -f omnetpp.ini -c MacEdca -r 0, 100s, 5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;24e0-2e48/tyf, PASS, wireless\n/examples/wireless/mactest/, -f omnetpp.ini -c MacDcf -r 0, 100s, 031d-548a/tplx;4db6-9460/~tNl;4c1d-35a0/~tND;3edc-eb8d/tyf, PASS, wireless\n/examples/wireless/qos/, -f omnetpp.ini -c MacNonQos -r 0, 10s, 0be7-a22e/tplx;5eb9-6cea/~tNl;87a5-11a1/~tND;b802-9992/tyf, PASS, wireless Ipv4\n/examples/wireless/qos/, -f omnetpp.ini -c MacQos -r 0, 10s, d929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;b06a-f098/tyf, PASS, wireless Ipv4\n/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithoutAggregation -r 0, 10s, 0473-f9d2/tplx;e92c-7352/~tNl;317d-aa4f/~tND;57cd-2e76/tyf, PASS, wireless Ipv4\n/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithRtsCts -r 0, 10s, e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;8cb9-109e/tyf, PASS, wireless Ipv4\n/examples/wireless/qos/, -f omnetpp.ini -c MacQosWithBlockAck -r 0, 10s, 6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;0db4-29ea/tyf, PASS, wireless Ipv4\n/showcases/wireless/aggregation/, -f omnetpp.ini -c NoAggregation -r 0, 1s, 21a4-c882/tplx;ecf2-6e33/~tNl;5d9e-8fdf/~tND;cb71-81f8/tyf, PASS, wireless Ipv4\n/showcases/wireless/aggregation/, -f omnetpp.ini -c Aggregation -r 0, 1s, 0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;6cdd-e65e/tyf, PASS, wireless Ipv4\n/showcases/wireless/aggregation/, -f omnetpp.ini -c VoicePriorityAggregation -r 0, 1s, 1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;c99f-3188/tyf, PASS, wireless Ipv4\n/showcases/wireless/blockack/, -f omnetpp.ini -c NoFragmentation -r 0, 1s, 9161-625d/tplx;6a02-09aa/~tNl;cbc0-3b0a/~tND, PASS, wireless Ipv4\n/showcases/wireless/blockack/, -f omnetpp.ini -c Fragmentation -r 0, 1s, 36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND, PASS, wireless Ipv4\n/showcases/wireless/blockack/, -f omnetpp.ini -c MixedTraffic -r 0, 1s, 351b-d4ba/tplx;5c1f-69a8/~tNl;6182-6da3/~tND, PASS, wireless Ipv4\n/showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFnofrag -r 0, 1s, 52b9-628f/tplx;3fec-74a2/~tNl;dbb5-67b0/~tND;8871-1dd1/tyf, PASS, wireless Ipv4\n/showcases/wireless/fragmentation/, -f omnetpp.ini -c DCFfrag -r 0, 1s, 8df2-40a3/tplx;dab9-5e8d/~tNl;2e7b-0729/~tND;74c3-9ba0/tyf, PASS, wireless Ipv4\n/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfrag -r 0, 1s, c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;e394-4985/tyf, PASS, wireless Ipv4\n/showcases/wireless/fragmentation/, -f omnetpp.ini -c HCFfragblockack -r 0, 1s, 2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;77f4-58c1/tyf, PASS, wireless Ipv4\n/showcases/wireless/qos/, -f omnetpp.ini -c NonQos -r 0, 10s, 5734-43a3/tplx;9c39-00a3/~tNl;03a9-2f02/~tND;34ac-bc95/tyf, PASS, wireless Ipv4\n/showcases/wireless/qos/, -f omnetpp.ini -c Qos -r 0, 10s, 2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;64d2-47e3/tyf, PASS, wireless Ipv4\n/showcases/wireless/txop/, -f omnetpp.ini -c General -r 0, 5s, ab91-87f3/tplx;f30c-6aa4/~tNl;6175-eb06/tyf, PASS, wireless Ipv4\n" + } +} diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/final.txt b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/final.txt new file mode 100644 index 00000000000..4b383222bba --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/final.txt @@ -0,0 +1,34 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFnofrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c NoFragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c MixedTraffic -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 ... : PASS +/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless ... : PASS +/examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless ... : PASS +/showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless adhoc Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 ... : PASS +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 ... : PASS + +---------------------------------------------------------------------- +Ran 25 tests in 295.496s + +OK + +Log has been saved to /tmp/inet-txop-fingerprint-update/final-runner.log +Test results equals to expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/forwarded-retry-base.pcapng b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/forwarded-retry-base.pcapng new file mode 100644 index 0000000000000000000000000000000000000000..75e03dbbbe8cfe478b8d80d8e2cff7a6e1368a2e GIT binary patch literal 27204 zcmd6v3v?C58OQgA5JD6PpooZ=29zpDLj>QHU?C<3k{~GWc*7$+3>bM+AO@-ef;_Ab z)I$h9A!tcOdB`h>#d<1~0%~nNTC`FX}Txz!8pd_U?t9KXw4`toRo&o4Xh^CsN(Ti z4@{ZbCG@idE5S;tv@f*ctwbvcRnXko#%L*lHGsm}W1madH%_U#G+_0@XLgj~;3g#F zlV$Or1}Xnez`&cF9%{*RT@Rms>Ayl#Odt>~6Pf^V2T0)f6AuaTo{h>9ans zY!d6TIak~ z#Wk!%wKZ_|nZ3A1WowCDo1dz#Zlvii!z#r!tVHc^_n&&-iEC8-<=eISY5%H3D-|Ev zQH2=bccDgn!SBo8KiE!ekF~>eN?D&ldz3YAY5t+vL&Ulv*3_0S%0*jvU2YLSXP`HB zx6VA@`>5ES%9duUMO%0qk>icE5h`DzZgeiJwFWpcQ!}T>U`vH)iwT$eQJ30MlMAz) z#Y>YPpWLOlWu;_`j>~AY94e<#_eOlf4oj(*6#F;wIK%VukQqCl5$$7b%Npvi#*9^v z_h_FFqi#Aru_IZT(}VVPfoeH-9m(4Cp=cYsQnoGdf@qtLU5VWrKUJ+u)WmksD#bOd zM2+pH+uH2KHM-ay`xj9++*VsXEQp*EKx_wJ+|Z1-7y3m$ek=R_B-*PH+i^F~pIj~4 zqKfTt2Sr=B72G0z4x&fad*1BM5C!#3X$#t;w(vH>u^sY5Wy_pHqAk2G<-&f#V!LP7 zZDaLZ)}cLW3vVelE-Ma;w$$WO0y|i2Z@Khr4?UM1Xph>W<3eNmsShK@wu3VTcA!Xe zNFLi6*%RA}tW>f64*H<>=~xBr4*4ndBSmZr^M*3}!nhi-ojL4_6C%4Hu9Wqii}tB) zI(F>Ngi6)*Nt)O$vr2IdD^X+n+7a7W?xOl<{V-dF{(gUvroZJ@DXw89YJaE3u<4+_ zzwS*m{Z&|{xQ3Oe{e7^b^u1X6+uBsqUzJsgYqb59@9&TwLw}R+XlC7k>)5d{Ak2f< zIt+#NR9VTgLSh0I999ArN?g5ct;T+9u~l2(yKc|_mh*IeXx}$kYvt&VYE2gh^xnVH zo7jp@xP8gof=YaetHvo7TOTY5PS)T1=QBxvA{&PQ>ssnB&h{w4h=eI!^YY1a>i$@s z4wd)NUkx^a$a6@_=Kd^VYn-#Db8-Z?i1iYSt+)JeuCLzKXV4$DmEVQP;}Bc-g~|=t z&8%1O4LfAbg=|d-*=qH%tTHwzr8IwZ98(-48z0|tp;bI>FB-5Dc~1|^p7sX@a2_FD zGhbv~2jLUt!S8+Kv5@lUaF>opGWv7w9p{0C5O|E1c>KZP5%3U4&r23{OVjh{51(qw zBalOQ#BCAwCpcHeU*J)X`gmgfwfn_*QR$-#dKo zoQI$EanWU+M~ObEcx)4R==X#uk3oHjKE%B2WM7tz1bqbTc$whFOPrN&6)(b7-sg`A ze=Elr%H}oE^2fvQDXb5SsFkoS${K_6Na;s-gmS;LpBIW3|L~}2wGk5`I?q$-qc41- zJmm2OH`FewcsWdY1h&w<9Y-G)cBKV<;MO3Yj(7FZpjm}gJZl5G@O*sP*s5<&y*>iD zl*bZBAFsDK`mV@Q#iI~)!{e=rN3zTV!y9;vk$C*h;o<4{GHhrbHaB(gvh)IY92aNfB=s|iO1^>k2o*K+tlY~Kd$F-MIP0MS^n6Jx?z2&c}U|e7FggBbb0Xk z7_?}|i>Ex=ZcX@wp2t5gfX9>hgoiSprpWV;dgRfdW4k$G4p8OO-SDZl`E*2o!b3UU zrr^d4`4kTZppPO~ANF{=kgX+IKJ_$zy!*%2U+DGm7<{5UOvc-hck6hh$@v3afyW4! z2OnQvb9glHGJg#D{9CLGboq1{e5x&vP6PBjr2K(hSMV6_^5FSnPhIdBdtm=hdLDz} zQ*C)94kSF3`6ErvAN9y%X6{EX>GMZ7_(XY_%*VD<9?JZYA;(J#TOUJQeeig}vu!(n z#CsVp<+t2`M-jSs`9|Vll0SCeL-nCv-}+~M`r5*Q#d>`lhfiUBn5}Pf@73|})BLpe zyMx}>^Oy~vYRlvAS{{CypH68pAIU(so=Y55dmiIZ*PWj#_k;X2-X;!ei5Hf1Jf6A$ z9zO~^RQo}G%BS;Q?KDi!BXuyRJ6&h zWQ}`6lr)KNh znM3tFBz;_F^BCyz;QH8I7d&QERXXEKG=01bpK8lv{4l~pnNKt1`Ds1I%gHA;-=xnU zPr;`!53~8lDS?M7pXSRv>QNu#y1e1+kA?O?RqOrK;gpAAK1JQ=`7|i!k2ZF^^mpTh z=Z|$xyd-#;KYG3R)l_}{I41Eh$)|fp5FW~S@l!tSc<%i)eY~82PqmGg`~u2D6)%3$ zM?sHs9rZls!ly6~vv}!sAK{^#e+1?HafKZ(`EI=M@uj*h;^m>Tl^^NjWfFX%JWS#x zJxF*c_doo^BiOF&5xqVN;1lIxvj1_0@=)pn0W0pGHn#OK($xpwKmDJh4^Q{ki$-L0 z((9vRp~%BTAIDHP`uI{Jk1u!w8~cU*TpoOUS?lm<uBBn#|HRBd6?)UXAI$?)JK_|KT>UdWV`y{`Queb zABkS(kLrn!exldMO!!23nCRn@B0UdDAMI@(SuPJAFFWgkN8aKM*?Jxs@Ts;u;>Qvm z%6RdUK0g1U{4ssJbcIiphe^Ebi-CuK^pSt*W~?T4`Qyw5@HjY*=tG%5mdoP{RuGtf z^p@g<{oyEkp555X{IT+9IoIjqbmn&<@n7vPzSxkAT-j}M7c_4zJk6sdwmmMBS zUgnRhe#%Eby7kKx_(bEyL?1a5^*p5U1uIPO$Z&b^`N#IU;IX{j!i^SZhK)ZD{MGUfv&jY0Z5X>v{BnPqpRI zwS@9ez5n5-d^&60oFjT31@I}%!|eIXPJxGNKiNOb=MinZt$@XRM=j z>zA$YiSjVXr*o$e9?JPxl|29GV(X)as}DXO!+U@Be9TjQEZ>od-3HzKqY^%ad6><| zlBQA~s`*&8%p=|Aaf`&`MTf`5UdGGi{Yq2xJZ^+fVIF4jvXk;qKCkqXK9;pFDAC8u zF@cBK_>wb?=tG%5{G^YBLq${cJZ8ctst=R=F?u@Tp&VbT*f!>z zd3ybzDt)}HfKQZ%$@-<&48kLVKBVpqK~bp8=c1id3>oyeH5%-U#91A^a6MsoI`jh-qvC(6Sl zUPhG?9uf2*<%0&2`dAL1C=U~T419?2h@cPu@VIxwv#a&` zmOuzp758pKG^?dLU$~3eOwr@%io7=~t}M>tii^qC8CWQT#CBq11;Jkn-uTY<>LP)dwG6 zHaYr8_A-CG)nag!ULViGC(6S_AK8x(9!h=qiAUv;#1I(VG41J97Q09PSnMbA_FIT(q!gD}*UBt`4eXBmzj}Z&tQ<#U@GnAVa z>v-hDQDF|z+~zUV<-y+pJL~Z9^nX@-)os&hJ&)1wskS_YarX@*YM#&M}W~ z{${B@e_Rir!aU5LDLt;`;ivqOzIJX5bBMPufJd9hi9VEbDnI3qoB@w4)9WJ>K85vR z_72A>%0rn?Q{?$aj-5YJ-2B1kA8$JOqlK6Aj|mHx#;~W;eyPaAWd5-pb)(Ne{KR8g ztEXew)A_5!!({%keHr1Q)JK}Ek33r+Z6$qdbo9~EOMNsyk{QFA{cHF{<0YCt{tp#p B4}kyx literal 0 HcmV?d00001 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/forwarded-retry-head.pcapng b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/forwarded-retry-head.pcapng new file mode 100644 index 0000000000000000000000000000000000000000..e6542f248da56faab4d72f80bacf2c0ed635df16 GIT binary patch literal 27204 zcmd6v3v?C58OQgA5RxbmKoJo!4JcKRh6uiqU?C<3k{~GWc*7$+3>bM+AO@-ef)K0^ z)I$iq30hK79`Xuev7QR0fLdFR79UhaIZ%&CDU|+aXYbx`CUfs(!r5f!oZZ|cJ2T(+ z+yD2?V>d}`+BC79Wm)}i?c6qiujib?e#X8Zf@1;>R${Ei*36=U$*K6<$ZBehE}D>e z|I}$+LqChN;;h6<`$8+$inkI`1^jjG z)~4*soN){-SXY*{bBerm?G$QuI}md#Y7} zYgmbDYv9b&dvJ}))?&LhKUH1XMAKioRf20+iQ3<;Klix<*Qol-vupFyzE$y73O=%< z3NgU%LXG%>-+uacETvwO?cd1b4A09$XYP1fw2!qdYpCNIGgd*~ zqkTSvx@q{tjwEGH58BrSs^#2uICJBNqHXL-*|xy*qHQ{M#ddG}RJAr<6Wc+n1lO<< zHMW~=ZMz58=wf@^Uq#(;TW$5QAaY6ou^oJ2eRJMk=ofkTt?c^~XsbY!3d(;*k7aH47ei$*f9h}Lq14Wuc z^4Lz#n$%8YrHbu$&~7u7%OhuJFh_lFBK{gqiIxQ3Oe{hb`kri1$a zdNkGaS7DXl8djqA_rdm(_iEGMmS&p%s;m-RqwTMJU&p*!^f%@9=GN`Fjvb2v!aRtr z!%$dHm6a?j#K&R5VZ~vg#MR5zYV5ZbTeStg@BZBHI8Wz?_I;DJR*wFt)^u?|@BPbt zh^^>^+n2;GsKl3;YMg3g>jTBXDf)Z=Tn6b+WaAKET}%DN*d7HKkuasJUOI7B-5<-- zq4FO3tHCA^c@9b0+?Ppgjd9j=PLALfv0iFp>rFqN?Wec(Y4k^J<#!?SIKkbT zbL(Y%!wy+Tc!QWoQ}sLsz^A(M z2xJo;F`I?`3C@-A7kD(FJ|16p^*%9PRQl)&pTazrI_u5s57XWd>xSlSR3FO(9^!rt z=iw)PTyRO3(V|Z(9$N(-`aL1aV{kvB4>2!0*_UM_K_3A-UM9Nn5@Y3AMT>Ej_xWSu z-^($EvUyFk{P7Tc3hM(SY9(xovc{l1lKT@Lq1^B6=Y`_MKRha0Z@@%|&hu3I=m(!D z4|#mS4Yi9ZUJg+nfz5Pp$I*v{U1>odxHZV96I^{XYF=R#&0dc#JRe^+wC>kSua7_u z<+0S!$LlSRyeqO)@hCvu@OZ1@ktFlL@CF`ZB_6+bcz8O#3?G(@%}rgrEISV##{?eY zoY#(*K(fpOAi$$Q;_y&tnLD zswtm>^4<0Xgwr%H+ zSTEzH{HE*hC_)!6-%318^2e^bsXo-}TmQ^YUt2V&NUx7$@F}bhv-NGxJvttKnxFQ0 zckugq9&_MRU3vUN%fnCe)2S^NAQ|Y^bMb@g&SO04y7N=zevqHW+xWq)@WPUg$CKy5 z<0pZKYCp(N`E>p(ormjrqzs|@FxwB>fx50fB8)H6{G*jUz6^247e4=Zr#{A)inckG zoJX|%praBGlksK!P#upvdAx0H^SImP!N*(JX^*#!y&P|6Oi#r+S~uQ)3ZKIH)NFk_ zYnYygq>oE%9)nySTpzpYgU8ION@skDrjM84Q(bvX7*2R7^J%&~KW)HxIq~?W8}#|( zN%$1zVK)CbDezF`(>$3+1L|XZ*EgK~vCtlGk}p9bap(bkTa0dBnT z{IS-FmpCu;NADNDo~F+qMV4!b2G^e#)nv&c2_jkC)@{sjl&omrr@9;>Az; z$nSZ!lb**s_!Q=07B9W;B|Mb#kD#1CF0h&)X6aTIl_cJKZAc-brQFo~CWqX`dXycEm%^a@)a{ak(Ue7dtf^wIjwJ6GuSQ3;=D z{xFG`1!D-02>OuLFAc~e;hMX!j@IpetcOpOhlxJ2#}Xb&eU!@iBgNK7ma7k*KVEV4 z5$|RGsGju5CwhI%f=`r(i9RkW)bo(^(ZS}C>GI(5vZFqD=jf1ExK9tXw~eJJxsnLNH=1%dfT zA1PkgAC9u;*$H0ekCng3zD6G}=in37he`g}J%R90#*3eLEZjM8wq75{;S=Ry5--Om z5*|u@q~oRw?>pcR0HBY2S08-7j(5IoeR%qOe^u*Kv3h-6exJz0L?2sF*PWj#-=`~+ z$J?uH9(`RNe7t3icpfi>H;i%Ksg1UOdPLx1_C8%k5#^zJU#ddpfe3~^dP_WBa(E8l)-O}x6O9)WePmD4^N_|DtT4eN-Q~gOAKU7KM_G&6J@h(6zcQoAoxUinB>zo_v?7D)`Wc8*w#mbyg&BhntLzQ^XLno>dK>A zG3B9p|HDuDboSc0hxI)2;ZvB0+4Gkj0uR-GvY+y)H6in)p2tyvhuMDe)CY(@l=F`& zIe*}dSme`NrF^>8$)^{1Ilc@i`1l9TBieXd0iVM9FnfNxbPD02%%^_hk#p`ZSV!yD zFI(Uff%hsT9p#>=JsOOo|Gu7^)y9%k{fgYr;5uk@2XmUqZ6*2l|H zfrr`nl0BX1LzzGPq>s3Rg;VuBX2B<_50m^cW(MJ*9AB#C@#Q)@UT$>bh0oXDu8(+m zYTe)}eY~uIPn3tr`la_w!Xtt{r1eV!@>tv>_e;G#Cc`Jn!$cqLXAvGsee9R>DgG@E z<{v#=eem(+c}E{jz09X40`r{bx6$Sw+3<<-FwsZz*@TBuAAaI-Z1q^@`F^zbgKmLO zl!u8vj#3^G^dZFy-r#~hy1V+|`D06c=%aUF!$E!iX!9G9hlxHuMO}A)OsNkH_~QDu z0iW-`wqjB%ef~(8Bl0lO#}?F$&SSqkzBHgd@>j1b)$=%V9y|`rB|Mbz@=rOR-fYK9 zH#c5*K3(I)OEWL?>7I{Y9ifkxbMT4g50iLVIFIm9#*3eLe3Dg#zs}OF=QhA6%EKgH zMwbvC5%eMD(_3tPq`Lax`E+xA=p(D!{15c{D1%RwhlxH0JxF*&(1(9`+_V0f)p~u* zhfkD;i9Y(45*|u@9GCNHFIyj7BzJ0yb7Nv4-LT$Tn`r(`)Q!F-^AnGGSG`!O&xwa69wwUKyO{7uQ2kFNE8ri^Uwi%7 zTI9sj@F|=F%$}hPdzA1{=71!bM}{3QSGw`Sb3l20#LJ+)t3K6_5ewl{n1|UjlpB`l zc;vxRVGhy4<}u9W!QTNpmA$be5_ zeVDz&agy>-=F?<({*i6xk7PH0@cGA^PX1`=<@{sfqGh$%)9J8G_(aKAGv^bnmi#7W<@QKDtG=2OZ D43iIl literal 0 HcmV?d00001 diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/head-before-update.txt b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/head-before-update.txt new file mode 100644 index 00000000000..41c821aa82a --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/head-before-update.txt @@ -0,0 +1,60 @@ +Hint: You may want to use the '-F tyf' option to exclude graphical (tyf) fingerprints, as they are not regularly kept up to date +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFnofrag -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c NoFragmentation -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf' +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'd7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf', expected: 'c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;335d-6687/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c MixedTraffic -r 0 wireless Ipv4 ... : PASS +/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '99bc-a74d/tplx;fffd-4625/~tNl;5543-fbef/~tND;821e-8bed/tyf', expected: '2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;6f6e-b101/tyf' +/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '9fd0-6388/tplx;22f5-8db8/~tNl;68cc-5669/~tND', expected: '36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND' +/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf' +/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf', expected: '1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;bd88-5ba6/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual 'c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf', expected: '5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;dfcf-4644/tyf' +/examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless ... : FAILED (should be PASS): some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf' +/showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '92af-e665/tplx;7960-ff7c/~tNl;0ec4-ff6b/tyf', expected: 'ab91-87f3/tplx;f30c-6aa4/~tNl;c87d-3f3a/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf' +/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf', expected: '2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;bda9-15d1/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless adhoc Ipv4 ... : PASS +/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf', expected: '2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;df04-18f7/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual 'a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf', expected: 'dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;2c1e-66e5/tyf' +/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '33e1-5ba7/tplx;f321-055c/~tNl;b439-5b70/~tND;5cb1-cbfe/tyf', expected: '4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;a587-3a4d/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '1906-1f5f/~tND;761d-e145/tyf', expected: '317d-aa4f/~tND;a4c3-19bf/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf', expected: 'd929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;9f3c-4512/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf', expected: 'e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;b2d6-1329/tyf' +/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 ... : FAILED (should be PASS): some fingerprint mismatch: actual '7866-b50d/tplx;cf3d-0664/~tNl;5912-f4f1/~tND;7ed5-dd85/tyf', expected: '6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;08b5-d005/tyf' + +Failures: + /showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual '74c3-9ba0/tyf', expected: 'f985-34fb/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'cb71-81f8/tyf', expected: '27f2-4a52/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'd7c1-fb92/tplx;b7b8-b4e1/~tNl;7035-d6cb/~tND;e791-f124/tyf', expected: 'c99f-354d/tplx;8e10-a3f0/~tNl;ac4b-3ba1/~tND;335d-6687/tyf') + /showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0 wireless Ipv4 (some fingerprint mismatch: actual '99bc-a74d/tplx;fffd-4625/~tNl;5543-fbef/~tND;821e-8bed/tyf', expected: '2597-1e2e/tplx;d269-c6ae/~tNl;2f5c-4cca/~tND;6f6e-b101/tyf') + /showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '9fd0-6388/tplx;22f5-8db8/~tNl;68cc-5669/~tND', expected: '36f4-5c22/tplx;66b0-94cd/~tNl;45f3-af4f/~tND') + /showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b7d0-1c67/tplx;d8f8-2120/~tNl;b2ba-0919/~tND;7c83-f2e4/tyf', expected: '0e94-675b/tplx;4545-c0de/~tNl;a778-2f83/~tND;95cc-1859/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation wireless adhoc Ipv4 (some fingerprint mismatch: actual '97f7-655d/tyf', expected: '33b7-00f9/tyf') + /showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '455e-1981/tplx;c6ed-de44/~tNl;6c9a-8f21/~tND;2267-c230/tyf', expected: '1ad6-ebce/tplx;cc40-e9c2/~tNl;5421-bc6d/~tND;bd88-5ba6/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0 wireless (some fingerprint mismatch: actual 'c4a0-ea53/tplx;9c3d-fe57/~tNl;ec7b-7e1e/~tND;b459-aecf/tyf', expected: '5635-3aae/tplx;c574-69b7/~tNl;bb83-14c4/~tND;dfcf-4644/tyf') + /examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0 wireless (some fingerprint mismatch: actual '3edc-eb8d/tyf', expected: 'f37f-cd48/tyf') + /showcases/wireless/txop/ -f omnetpp.ini -c General -r 0 wireless Ipv4 (some fingerprint mismatch: actual '92af-e665/tplx;7960-ff7c/~tNl;0ec4-ff6b/tyf', expected: 'ab91-87f3/tplx;f30c-6aa4/~tNl;c87d-3f3a/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '34ac-bc95/tyf', expected: '093e-1ca4/tyf') + /showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'c105-8907/tplx;f17b-f24c/~tNl;c055-873b/~tND;1c08-f8f1/tyf', expected: '2f30-f17c/tplx;0683-d978/~tNl;a879-de03/~tND;bda9-15d1/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation wireless adhoc Ipv4 (some fingerprint mismatch: actual 'e24a-3845/tplx;5509-e838/~tNl;636c-9cea/~tND;cc7a-9b26/tyf', expected: '2c80-6844/tplx;4e9e-cf86/~tNl;ea3d-e802/~tND;df04-18f7/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual 'b802-9992/tyf', expected: '6097-a429/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0 wireless adhoc Ipv4 (some fingerprint mismatch: actual 'a78c-7701/tplx;cedf-054d/~tNl;91a9-683f/~tND;f841-fef5/tyf', expected: 'dd36-1076/tplx;b703-3ef2/~tNl;e07d-2980/~tND;2c1e-66e5/tyf') + /examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1 wireless adhoc Ipv4 (some fingerprint mismatch: actual '33e1-5ba7/tplx;f321-055c/~tNl;b439-5b70/~tND;5cb1-cbfe/tyf', expected: '4fd2-bb56/tplx;ecaf-89f7/~tNl;9398-0fae/~tND;a587-3a4d/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0 wireless Ipv4 (some fingerprint mismatch: actual '1906-1f5f/~tND;761d-e145/tyf', expected: '317d-aa4f/~tND;a4c3-19bf/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0 wireless Ipv4 (some fingerprint mismatch: actual '0473-f9d2/tplx;e92c-7352/~tNl;1906-1f5f/~tND;4196-a696/tyf', expected: 'd929-5913/tplx;f602-4424/~tNl;f2fb-4d98/~tND;9f3c-4512/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0 wireless Ipv4 (some fingerprint mismatch: actual '5269-1e09/tplx;b291-6797/~tNl;0378-ab11/~tND;9b3b-150c/tyf', expected: 'e07a-4c5f/tplx;9f6c-7889/~tNl;29ea-169c/~tND;b2d6-1329/tyf') + /examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0 wireless Ipv4 (some fingerprint mismatch: actual '7866-b50d/tplx;cf3d-0664/~tNl;5912-f4f1/~tND;7ed5-dd85/tyf', expected: '6edb-0326/tplx;2a8a-50ee/~tNl;4301-882d/~tND;08b5-d005/tyf') +---------------------------------------------------------------------- +Ran 25 tests in 375.692s + +FAILED (failures=21) + +Check showcases.csv.UPDATED for updated fingerprints +Check examples.csv.UPDATED for updated fingerprints +Check showcases.csv.FAILED for failed fingerprints +Check examples.csv.FAILED for failed fingerprints +Log has been saved to fingerprinttest.out +Test results differ from expected results diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/manifest.json b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/manifest.json new file mode 100644 index 00000000000..8ed27920582 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/manifest.json @@ -0,0 +1,17 @@ +{ + "README.md": "063dfaa056c6059c7cc91f310fe8a478fd1470a253163897611405cd7800e8cd", + "base-approved.txt": "36399c0d4f855f0ab0273dc85dcc41980fc779a006ab72d7cb74d28890d2b6a7", + "base.txt": "9a64302a5eb7464669cac28849c875a7785317339a1b9b728f8cf27bebce602a", + "c3.txt": "af89cedf85ddb613780daefdf9fc5fa303fb0b8494310856b860b75340c8e373", + "c4-approved.txt": "c7bfe92e84b51a3613f67f0adf7b9735027c1ffcc22ad2fe88c49bb96a96d3de", + "c4.txt": "f0b31e0469b8cb5ccc74e27920f1e78c6d2936b3cc77d27dd1d507573cb4b890", + "commands.json": "75a321ee4851b296d555bacd2c068a040098e0527ec682a1e98545a58002a331", + "final.txt": "1ae868df3b9d758ab338ce2f407240b81f4b13bbcc8b0e5f5072efbbe2174260", + "forwarded-retry-base.pcapng": "c9b7058e5733fe82a875685080305081f25b92b249c4c0ee2a231ad2d6840165", + "forwarded-retry-head.pcapng": "e098cd836e8b1417906b6f316cf9afc2b947e692ef678457e6fbfae152332350", + "head-before-update.txt": "1b2fe820e3de3d762bd8a549e4bc253f49ebe2b1b7ea9b1f4a3e651af42b1987", + "pcap-commands.json": "a92fa03500c55d1d1a12602305c7a8aa6ecb304a860ccfcfb75e4a00d98e89ba", + "trace-commands.json": "7251fbdf7adc29c095115d68c4417f9b550875675588e05cf43d5cdf1447bf85", + "trace-excerpts.json": "a65db1f6406f9fe86b7ce0ada208902ca2bb13e59410eba79b764ad1de1fad5f", + "values.json": "d6441cad9152c1da0900dc5ec7f1ddb67c32f76bcca3187fc8d1c005dc0a6c82" +} diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/pcap-commands.json b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/pcap-commands.json new file mode 100644 index 00000000000..a1e69716ef7 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/pcap-commands.json @@ -0,0 +1,48 @@ +[ + { + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithoutAggregation", + "-r", + "0", + "--sim-time-limit=1.02s", + "--scalar-recording=false", + "--vector-recording=false", + "--cmdenv-express-mode=true", + "--**.fcsMode=\"computed\"", + "--**.checksumMode=\"computed\"", + "--**.numPcapRecorders=1", + "--**.pcapRecorder[*].verbose=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/pcap-base" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0 + }, + { + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithoutAggregation", + "-r", + "0", + "--sim-time-limit=1.02s", + "--scalar-recording=false", + "--vector-recording=false", + "--cmdenv-express-mode=true", + "--**.fcsMode=\"computed\"", + "--**.checksumMode=\"computed\"", + "--**.numPcapRecorders=1", + "--**.pcapRecorder[*].verbose=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/pcap-head" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0 + } +] \ No newline at end of file diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-commands.json b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-commands.json new file mode 100644 index 00000000000..1beeeb4a248 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-commands.json @@ -0,0 +1,1570 @@ +{ + "base": [ + { + "case": [ + "showcases/wireless/aggregation", + "VoicePriorityAggregation", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "VoicePriorityAggregation", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/aggregation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-base.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfrag", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfrag", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-base.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfragblockack", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfragblockack", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-base.elog" + }, + { + "case": [ + "showcases/wireless/qos", + "Qos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "Qos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-base.elog" + }, + { + "case": [ + "showcases/wireless/txop", + "General", + 0, + "20ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "General", + "-r", + "0", + "--sim-time-limit=20ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/txop", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-base.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-base.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 1, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "1", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-base.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MsduAggregation", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MsduAggregation", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-base.elog" + }, + { + "case": [ + "examples/wireless/mactest", + "MacEdca", + 0, + "6.1s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacEdca", + "-r", + "0", + "--sim-time-limit=6.1s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/mactest", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-base.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-base.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithoutAggregation", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithoutAggregation", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-base.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithRtsCts", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithRtsCts", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-base.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithBlockAck", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithBlockAck", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-base.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-base-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-base.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-base.elog" + } + ], + "c3": [ + { + "case": [ + "showcases/wireless/aggregation", + "VoicePriorityAggregation", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "VoicePriorityAggregation", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/aggregation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c3.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfrag", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfrag", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c3.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfragblockack", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfragblockack", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c3.elog" + }, + { + "case": [ + "showcases/wireless/qos", + "Qos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "Qos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c3.elog" + }, + { + "case": [ + "showcases/wireless/txop", + "General", + 0, + "20ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "General", + "-r", + "0", + "--sim-time-limit=20ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/txop", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c3.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c3.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 1, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "1", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c3.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MsduAggregation", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MsduAggregation", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c3.elog" + }, + { + "case": [ + "examples/wireless/mactest", + "MacEdca", + 0, + "1.5s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacEdca", + "-r", + "0", + "--sim-time-limit=1.5s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/mactest", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c3.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c3.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithoutAggregation", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithoutAggregation", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c3.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithRtsCts", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithRtsCts", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c3.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithBlockAck", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithBlockAck", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c3.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c3-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c3.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c3.elog" + } + ], + "c4": [ + { + "case": [ + "showcases/wireless/aggregation", + "VoicePriorityAggregation", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "VoicePriorityAggregation", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/aggregation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-c4.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfrag", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfrag", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-c4.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfragblockack", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfragblockack", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-c4.elog" + }, + { + "case": [ + "showcases/wireless/qos", + "Qos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "Qos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-c4.elog" + }, + { + "case": [ + "showcases/wireless/txop", + "General", + 0, + "20ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "General", + "-r", + "0", + "--sim-time-limit=20ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/txop", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-c4.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-c4.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 1, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "1", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-c4.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MsduAggregation", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MsduAggregation", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-c4.elog" + }, + { + "case": [ + "examples/wireless/mactest", + "MacEdca", + 0, + "6.1s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacEdca", + "-r", + "0", + "--sim-time-limit=6.1s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/mactest", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-c4.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-c4.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithoutAggregation", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithoutAggregation", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-c4.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithRtsCts", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithRtsCts", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-c4.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithBlockAck", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithBlockAck", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c4.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c4-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c4.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-c4.elog" + } + ], + "head": [ + { + "case": [ + "showcases/wireless/aggregation", + "VoicePriorityAggregation", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "VoicePriorityAggregation", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/aggregation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-aggregation-VoicePriorityAggregation-0-head.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfrag", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfrag", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfrag-0-head.elog" + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfragblockack", + 0, + "10ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "HCFfragblockack", + "-r", + "0", + "--sim-time-limit=10ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/fragmentation", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-fragmentation-HCFfragblockack-0-head.elog" + }, + { + "case": [ + "showcases/wireless/qos", + "Qos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "Qos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-qos-Qos-0-head.elog" + }, + { + "case": [ + "showcases/wireless/txop", + "General", + 0, + "20ms" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "General", + "-r", + "0", + "--sim-time-limit=20ms", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/showcases/wireless/txop", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/showcases-wireless-txop-General-0-head.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-0-head.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 1, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "1", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MacQos-1-head.elog" + }, + { + "case": [ + "examples/adhoc/qos", + "MsduAggregation", + 0, + "0.51s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MsduAggregation", + "-r", + "0", + "--sim-time-limit=0.51s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/adhoc/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-adhoc-qos-MsduAggregation-0-head.elog" + }, + { + "case": [ + "examples/wireless/mactest", + "MacEdca", + 0, + "1.5s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacEdca", + "-r", + "0", + "--sim-time-limit=1.5s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/mactest", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-mactest-MacEdca-0-head.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQos", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQos", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQos-0-head.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithoutAggregation", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithoutAggregation", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithoutAggregation-0-head.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithRtsCts", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithRtsCts", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithRtsCts-0-head.elog" + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithBlockAck", + 0, + "1.02s" + ], + "command": [ + "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/bin/inet", + "--debug", + "-u", + "Cmdenv", + "-c", + "MacQosWithBlockAck", + "-r", + "0", + "--sim-time-limit=1.02s", + "--cmdenv-express-mode=false", + "--**.cmdenv-log-level=debug", + "--record-eventlog=true", + "--eventlog-file=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-head.elog", + "--scalar-recording=false", + "--vector-recording=false", + "--result-dir=/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-head-results" + ], + "cwd": "/home/user/omnetpp_ws/inet-ieee80211-txop-admission-remaining/examples/wireless/qos", + "status": 0, + "log": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-head.log", + "eventlog": "/tmp/inet-txop-fingerprint-update/examples-wireless-qos-MacQosWithBlockAck-0-head.elog" + } + ] +} diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-excerpts.json b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-excerpts.json new file mode 100644 index 00000000000..facf62e4166 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/trace-excerpts.json @@ -0,0 +1,230 @@ +[ + { + "case": [ + "showcases/wireless/aggregation", + "VoicePriorityAggregation", + 0, + "10ms" + ], + "previous": "base", + "current": "c4", + "transmission_index": 2, + "before": { + "event": "** Event #60 t=0.00020061726 on UdpBasicAppData-1+UdpBasicAppData-2+UdpBasicAppData-3 (inet::Packet) in AggregationShowcase.host1.wlan[0].radio (Ieee80211Radio, id=63) 2% completed (2% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)UdpBasicAppData-1+UdpBasicAppData-2+UdpBasicAppData-3 (102 us 516 B) (inet::Packet)UdpBasicAppData-1+UdpBasicAppData-2+UdpBasicAppData-3 (516 B) (inet::SequenceChunk) length = 516 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 2, transmitterRadioId = 0, startTime = 0.00020061726, endTime = 0.00030261726, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000082, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #60 t=0.00020061726 on UdpBasicAppData-1 (inet::Packet) in AggregationShowcase.host1.wlan[0].radio (Ieee80211Radio, id=63) 2% completed (2% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)UdpBasicAppData-1 (54 us 192 B) (inet::Packet)UdpBasicAppData-1 (192 B) (inet::SequenceChunk) length = 192 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 2, transmitterRadioId = 0, startTime = 0.00020061726, endTime = 0.00025461726, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000034, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfrag", + 0, + "10ms" + ], + "previous": "base", + "current": "c4", + "transmission_index": 22, + "before": { + "event": "** Event #237 t=0.00345597088 on UdpBasicAppData-1-frag0 (inet::Packet) in FragmentationShowcase.wifiHost1.wlan[0].radio (Ieee80211Radio, id=30) 34% completed (34% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)UdpBasicAppData-1-frag0 (114 us 267 B) (inet::Packet)UdpBasicAppData-1-frag0 (267 B) (inet::SequenceChunk) length = 267 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 22, transmitterRadioId = 0, startTime = 0.00345597088, endTime = 0.00356997088, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000094, startPosition = (215, 99, 0) m, endPosition = (215, 99, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #244 t=0.00379597088 on UdpBasicAppData-1-frag0 (inet::Packet) in FragmentationShowcase.wifiHost1.wlan[0].radio (Ieee80211Radio, id=30) 37% completed (37% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)UdpBasicAppData-1-frag0 (114 us 267 B) (inet::Packet)UdpBasicAppData-1-frag0 (267 B) (inet::SequenceChunk) length = 267 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 22, transmitterRadioId = 0, startTime = 0.00379597088, endTime = 0.00390997088, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000094, startPosition = (215, 99, 0) m, endPosition = (215, 99, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "showcases/wireless/qos", + "Qos", + 0, + "1.02s" + ], + "previous": "base", + "current": "c4", + "transmission_index": 47, + "before": { + "event": "** Event #824 t=1.001525886924 on video-0+video-1 (inet::Packet) in QosShowcase.client.wlan[0].radio (Ieee80211Radio, id=241) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)video-0+video-1 (226 us 1353 B) (inet::Packet)video-0+video-1 (1353 B) (inet::SequenceChunk) length = 1353 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 47, transmitterRadioId = 2, startTime = 1.001525886924, endTime = 1.001751886924, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000206, startPosition = (200, 100, 0) m, endPosition = (200, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #824 t=1.001525886924 on video-0 (inet::Packet) in QosShowcase.client.wlan[0].radio (Ieee80211Radio, id=241) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)video-0 (126 us 678 B) (inet::Packet)video-0 (678 B) (inet::SequenceChunk) length = 678 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 47, transmitterRadioId = 2, startTime = 1.001525886924, endTime = 1.001651886924, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000106, startPosition = (200, 100, 0) m, endPosition = (200, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 0, + "0.51s" + ], + "previous": "base", + "current": "c4", + "transmission_index": 2, + "before": { + "event": "** Event #231 t=0.500541334256 on Voice-1+Voice-2+Voice-3-frag0 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=151) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-1+Voice-2+Voice-3-frag0 (530 us 1515 B) (inet::Packet)Voice-1+Voice-2+Voice-3-frag0 (1515 B) (inet::SequenceChunk) length = 1515 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 2, transmitterRadioId = 1, startTime = 0.500541334256, endTime = 0.501071334256, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.00051, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #231 t=0.500541334256 on Voice-1 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=151) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-1 (386 us 1083 B) (inet::Packet)Voice-1 (1083 B) (inet::SequenceChunk) length = 1083 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 2, transmitterRadioId = 1, startTime = 0.500541334256, endTime = 0.500927334256, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000366, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "examples/adhoc/qos", + "MsduAggregation", + 0, + "0.51s" + ], + "previous": "base", + "current": "c4", + "transmission_index": 4, + "before": { + "event": "** Event #92 t=0.500422668512 on Voice-2+Voice-3 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=147) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-2+Voice-3 (138 us 339 B) (inet::Packet)Voice-2+Voice-3 (339 B) (inet::SequenceChunk) length = 339 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 1, startTime = 0.500422668512, endTime = 0.500560668512, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000118, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #92 t=0.500422668512 on Voice-2 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=147) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-2 (86 us 183 B) (inet::Packet)Voice-2 (183 B) (inet::SequenceChunk) length = 183 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 1, startTime = 0.500422668512, endTime = 0.500508668512, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000066, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "examples/wireless/mactest", + "MacEdca", + 0, + "6.1s" + ], + "previous": "base", + "current": "c4", + "transmission_index": 92, + "before": { + "event": "** Event #1160 t=2.335881047819 on FTP-7-frag1 (inet::Packet) in MacTest.cliHost.wlan[0].radio (Ieee80211Radio, id=145) 38% completed (38% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)FTP-7-frag1 (50 us 75 B) (inet::Packet)FTP-7-frag1 (75 B) (inet::SequenceChunk) length = 75 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 92, transmitterRadioId = 1, startTime = 2.335881047819, endTime = 2.335931047819, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.00003, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #1159 t=2.335461047819 on FTP-7-frag1 (inet::Packet) in MacTest.cliHost.wlan[0].radio (Ieee80211Radio, id=145) 38% completed (38% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)FTP-7-frag1 (50 us 75 B) (inet::Packet)FTP-7-frag1 (75 B) (inet::SequenceChunk) length = 75 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 92, transmitterRadioId = 1, startTime = 2.335461047819, endTime = 2.335511047819, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.00003, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "examples/wireless/qos", + "MacQos", + 0, + "1.02s" + ], + "previous": "base", + "current": "c4", + "transmission_index": 51, + "before": { + "event": "** Event #843 t=1.002155302117 on Voice-0+Voice-1 (inet::Packet) in QosThroughput.ap.wlan[0].radio (Ieee80211Radio, id=18) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-0+Voice-1 (138 us 339 B) (inet::Packet)Voice-0+Voice-1 (339 B) (inet::SequenceChunk) length = 339 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 51, transmitterRadioId = 0, startTime = 1.002155302117, endTime = 1.002293302117, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000118, startPosition = (200, 200, 0) m, endPosition = (200, 200, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #843 t=1.002155302117 on Voice-0 (inet::Packet) in QosThroughput.ap.wlan[0].radio (Ieee80211Radio, id=18) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-0 (86 us 183 B) (inet::Packet)Voice-0 (183 B) (inet::SequenceChunk) length = 183 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 51, transmitterRadioId = 0, startTime = 1.002155302117, endTime = 1.002241302117, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000066, startPosition = (200, 200, 0) m, endPosition = (200, 200, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithRtsCts", + 0, + "1.02s" + ], + "previous": "base", + "current": "c4", + "transmission_index": 69, + "before": { + "event": "** Event #1091 t=1.003351712338 on WWW-0+WWW-1+WWW-2+WWW-3 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=240) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)WWW-0+WWW-1+WWW-2+WWW-3 (242 us 651 B) (inet::Packet)WWW-0+WWW-1+WWW-2+WWW-3 (651 B) (inet::SequenceChunk) length = 651 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 69, transmitterRadioId = 2, startTime = 1.003351712338, endTime = 1.003593712338, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000222, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #1091 t=1.003351712338 on WWW-0 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=240) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)WWW-0 (86 us 183 B) (inet::Packet)WWW-0 (183 B) (inet::SequenceChunk) length = 183 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 69, transmitterRadioId = 2, startTime = 1.003351712338, endTime = 1.003437712338, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000066, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "showcases/wireless/fragmentation", + "HCFfragblockack", + 0, + "10ms" + ], + "previous": "c4", + "current": "head", + "transmission_index": 31, + "before": { + "event": "** Event #330 t=0.004589367968 on BasicBlockAckReq (inet::Packet) in FragmentationShowcase.wifiHost1.wlan[0].radio (Ieee80211Radio, id=30) 45% completed (45% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)BasicBlockAckReq (38 us 39 B) (inet::Packet)BasicBlockAckReq (39 B) (inet::SequenceChunk) length = 39 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 31, transmitterRadioId = 0, startTime = 0.004589367968, endTime = 0.004627367968, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000018, startPosition = (215, 99, 0) m, endPosition = (215, 99, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #336 t=0.004773367968 on BasicBlockAckReq (inet::Packet) in FragmentationShowcase.wifiHost1.wlan[0].radio (Ieee80211Radio, id=30) 47% completed (47% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)BasicBlockAckReq (38 us 39 B) (inet::Packet)BasicBlockAckReq (39 B) (inet::SequenceChunk) length = 39 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 31, transmitterRadioId = 0, startTime = 0.004773367968, endTime = 0.004811367968, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000018, startPosition = (215, 99, 0) m, endPosition = (215, 99, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "showcases/wireless/txop", + "General", + 0, + "20ms" + ], + "previous": "c4", + "current": "head", + "transmission_index": 12, + "before": { + "event": "** Event #426 t=0.003836408613 on small-1+small-2 (inet::Packet) in TxopShowcase.host1.wlan[0].radio (Ieee80211Radio, id=64) 19% completed (19% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)small-1+small-2 (874 us 2547 B) (inet::Packet)small-1+small-2 (2547 B) (inet::SequenceChunk) length = 2547 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 12, transmitterRadioId = 0, startTime = 0.003836408613, endTime = 0.004710408613, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000854, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #426 t=0.003836408613 on small-1 (inet::Packet) in TxopShowcase.host1.wlan[0].radio (Ieee80211Radio, id=64) 19% completed (19% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)small-1 (450 us 1275 B) (inet::Packet)small-1 (1275 B) (inet::SequenceChunk) length = 1275 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 12, transmitterRadioId = 0, startTime = 0.003836408613, endTime = 0.004286408613, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.00043, startPosition = (288, 110, 0) m, endPosition = (288, 110, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "examples/adhoc/qos", + "MacQos", + 1, + "0.51s" + ], + "previous": "c4", + "current": "head", + "transmission_index": 4, + "before": { + "event": "** Event #402 t=0.501082668512 on FTP-0 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=153) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)FTP-0 (386 us 1083 B) (inet::Packet)FTP-0 (1083 B) (inet::SequenceChunk) length = 1083 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 1, startTime = 0.501082668512, endTime = 0.501468668512, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000366, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #371 t=0.500942668512 on Video-1 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=153) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Video-1 (386 us 1083 B) (inet::Packet)Video-1 (1083 B) (inet::SequenceChunk) length = 1083 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 4, transmitterRadioId = 1, startTime = 0.500942668512, endTime = 0.501328668512, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000366, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + }, + { + "case": [ + "examples/wireless/qos", + "MacQosWithBlockAck", + 0, + "1.02s" + ], + "previous": "c4", + "current": "head", + "transmission_index": 51, + "before": { + "event": "** Event #845 t=1.002106830386 on Voice-0+Voice-1 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=244) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-0+Voice-1 (138 us 339 B) (inet::Packet)Voice-0+Voice-1 (339 B) (inet::SequenceChunk) length = 339 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 51, transmitterRadioId = 2, startTime = 1.002106830386, endTime = 1.002244830386, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000118, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + }, + "after": { + "event": "** Event #845 t=1.002106830386 on Voice-0 (inet::Packet) in QosThroughput.cliHost.wlan[0].radio (Ieee80211Radio, id=244) 98% completed (98% total)", + "transmission": "[INFO]\tTransmission started: (inet::physicallayer::WirelessSignal)Voice-0 (86 us 183 B) (inet::Packet)Voice-0 (183 B) (inet::SequenceChunk) length = 183 B WHOLE as Ieee80211Transmission, mode = { Ieee80211ErpOfdmMode }, channel = { Ieee80211Channel, channelNumber = 0 }, id = 51, transmitterRadioId = 2, startTime = 1.002106830386, endTime = 1.002192830386, preambleDuration = 0.000016, headerDuration = 0.000004, dataDuration = 0.000066, startPosition = (100, 100, 0) m, endPosition = (100, 100, 0) m, startOrientation = (1, 0, 0, 0), endOrientation = (1, 0, 0, 0)" + } + } +] diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/values.json b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/values.json new file mode 100644 index 00000000000..cb1b235a490 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/fingerprints-20261019/values.json @@ -0,0 +1,783 @@ +[ + { + "case": "/showcases/wireless/aggregation/ -f omnetpp.ini -c NoAggregation -r 0", + "file": "showcases.csv", + "old": [ + "21a4-c882/tplx", + "ecf2-6e33/~tNl", + "5d9e-8fdf/~tND", + "27f2-4a52/tyf" + ], + "base": [ + "21a4-c882/tplx", + "ecf2-6e33/~tNl", + "5d9e-8fdf/~tND", + "cb71-81f8/tyf" + ], + "c3": [ + "21a4-c882/tplx", + "ecf2-6e33/~tNl", + "5d9e-8fdf/~tND", + "cb71-81f8/tyf" + ], + "c4": [ + "21a4-c882/tplx", + "ecf2-6e33/~tNl", + "5d9e-8fdf/~tND", + "cb71-81f8/tyf" + ], + "head": [ + "21a4-c882/tplx", + "ecf2-6e33/~tNl", + "5d9e-8fdf/~tND", + "cb71-81f8/tyf" + ], + "owners": [ + "inherited" + ] + }, + { + "case": "/showcases/wireless/aggregation/ -f omnetpp.ini -c Aggregation -r 0", + "file": "showcases.csv", + "old": [ + "0e94-675b/tplx", + "4545-c0de/~tNl", + "a778-2f83/~tND", + "95cc-1859/tyf" + ], + "base": [ + "0e94-675b/tplx", + "4545-c0de/~tNl", + "a778-2f83/~tND", + "6cdd-e65e/tyf" + ], + "c3": [ + "0e94-675b/tplx", + "4545-c0de/~tNl", + "a778-2f83/~tND", + "6cdd-e65e/tyf" + ], + "c4": [ + "b7d0-1c67/tplx", + "d8f8-2120/~tNl", + "b2ba-0919/~tND", + "7c83-f2e4/tyf" + ], + "head": [ + "b7d0-1c67/tplx", + "d8f8-2120/~tNl", + "b2ba-0919/~tND", + "7c83-f2e4/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/showcases/wireless/aggregation/ -f omnetpp.ini -c VoicePriorityAggregation -r 0", + "file": "showcases.csv", + "old": [ + "1ad6-ebce/tplx", + "cc40-e9c2/~tNl", + "5421-bc6d/~tND", + "bd88-5ba6/tyf" + ], + "base": [ + "1ad6-ebce/tplx", + "cc40-e9c2/~tNl", + "5421-bc6d/~tND", + "c99f-3188/tyf" + ], + "c3": [ + "1ad6-ebce/tplx", + "cc40-e9c2/~tNl", + "5421-bc6d/~tND", + "c99f-3188/tyf" + ], + "c4": [ + "455e-1981/tplx", + "c6ed-de44/~tNl", + "6c9a-8f21/~tND", + "2267-c230/tyf" + ], + "head": [ + "455e-1981/tplx", + "c6ed-de44/~tNl", + "6c9a-8f21/~tND", + "2267-c230/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/showcases/wireless/blockack/ -f omnetpp.ini -c Fragmentation -r 0", + "file": "showcases.csv", + "old": [ + "36f4-5c22/tplx", + "66b0-94cd/~tNl", + "45f3-af4f/~tND" + ], + "base": [ + "36f4-5c22/tplx", + "66b0-94cd/~tNl", + "45f3-af4f/~tND" + ], + "c3": [ + "36f4-5c22/tplx", + "66b0-94cd/~tNl", + "45f3-af4f/~tND" + ], + "c4": [ + "36f4-5c22/tplx", + "66b0-94cd/~tNl", + "45f3-af4f/~tND" + ], + "head": [ + "9fd0-6388/tplx", + "22f5-8db8/~tNl", + "68cc-5669/~tND" + ], + "owners": [ + "C5" + ] + }, + { + "case": "/showcases/wireless/fragmentation/ -f omnetpp.ini -c DCFfrag -r 0", + "file": "showcases.csv", + "old": [ + "8df2-40a3/tplx", + "dab9-5e8d/~tNl", + "2e7b-0729/~tND", + "f985-34fb/tyf" + ], + "base": [ + "8df2-40a3/tplx", + "dab9-5e8d/~tNl", + "2e7b-0729/~tND", + "74c3-9ba0/tyf" + ], + "c3": [ + "8df2-40a3/tplx", + "dab9-5e8d/~tNl", + "2e7b-0729/~tND", + "74c3-9ba0/tyf" + ], + "c4": [ + "8df2-40a3/tplx", + "dab9-5e8d/~tNl", + "2e7b-0729/~tND", + "74c3-9ba0/tyf" + ], + "head": [ + "8df2-40a3/tplx", + "dab9-5e8d/~tNl", + "2e7b-0729/~tND", + "74c3-9ba0/tyf" + ], + "owners": [ + "inherited" + ] + }, + { + "case": "/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfrag -r 0", + "file": "showcases.csv", + "old": [ + "c99f-354d/tplx", + "8e10-a3f0/~tNl", + "ac4b-3ba1/~tND", + "335d-6687/tyf" + ], + "base": [ + "c99f-354d/tplx", + "8e10-a3f0/~tNl", + "ac4b-3ba1/~tND", + "e394-4985/tyf" + ], + "c3": [ + "c99f-354d/tplx", + "8e10-a3f0/~tNl", + "ac4b-3ba1/~tND", + "e394-4985/tyf" + ], + "c4": [ + "d7c1-fb92/tplx", + "b7b8-b4e1/~tNl", + "7035-d6cb/~tND", + "e791-f124/tyf" + ], + "head": [ + "d7c1-fb92/tplx", + "b7b8-b4e1/~tNl", + "7035-d6cb/~tND", + "e791-f124/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/showcases/wireless/fragmentation/ -f omnetpp.ini -c HCFfragblockack -r 0", + "file": "showcases.csv", + "old": [ + "2597-1e2e/tplx", + "d269-c6ae/~tNl", + "2f5c-4cca/~tND", + "6f6e-b101/tyf" + ], + "base": [ + "2597-1e2e/tplx", + "d269-c6ae/~tNl", + "2f5c-4cca/~tND", + "77f4-58c1/tyf" + ], + "c3": [ + "2597-1e2e/tplx", + "d269-c6ae/~tNl", + "2f5c-4cca/~tND", + "77f4-58c1/tyf" + ], + "c4": [ + "2597-1e2e/tplx", + "d269-c6ae/~tNl", + "2f5c-4cca/~tND", + "77f4-58c1/tyf" + ], + "head": [ + "99bc-a74d/tplx", + "fffd-4625/~tNl", + "5543-fbef/~tND", + "821e-8bed/tyf" + ], + "owners": [ + "inherited", + "C5" + ] + }, + { + "case": "/showcases/wireless/qos/ -f omnetpp.ini -c NonQos -r 0", + "file": "showcases.csv", + "old": [ + "5734-43a3/tplx", + "9c39-00a3/~tNl", + "03a9-2f02/~tND", + "093e-1ca4/tyf" + ], + "base": [ + "5734-43a3/tplx", + "9c39-00a3/~tNl", + "03a9-2f02/~tND", + "34ac-bc95/tyf" + ], + "c3": [ + "5734-43a3/tplx", + "9c39-00a3/~tNl", + "03a9-2f02/~tND", + "34ac-bc95/tyf" + ], + "c4": [ + "5734-43a3/tplx", + "9c39-00a3/~tNl", + "03a9-2f02/~tND", + "34ac-bc95/tyf" + ], + "head": [ + "5734-43a3/tplx", + "9c39-00a3/~tNl", + "03a9-2f02/~tND", + "34ac-bc95/tyf" + ], + "owners": [ + "inherited" + ] + }, + { + "case": "/showcases/wireless/qos/ -f omnetpp.ini -c Qos -r 0", + "file": "showcases.csv", + "old": [ + "2f30-f17c/tplx", + "0683-d978/~tNl", + "a879-de03/~tND", + "bda9-15d1/tyf" + ], + "base": [ + "2f30-f17c/tplx", + "0683-d978/~tNl", + "a879-de03/~tND", + "64d2-47e3/tyf" + ], + "c3": [ + "2f30-f17c/tplx", + "0683-d978/~tNl", + "a879-de03/~tND", + "64d2-47e3/tyf" + ], + "c4": [ + "c105-8907/tplx", + "f17b-f24c/~tNl", + "c055-873b/~tND", + "1c08-f8f1/tyf" + ], + "head": [ + "c105-8907/tplx", + "f17b-f24c/~tNl", + "c055-873b/~tND", + "1c08-f8f1/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/showcases/wireless/txop/ -f omnetpp.ini -c General -r 0", + "file": "showcases.csv", + "old": [ + "ab91-87f3/tplx", + "f30c-6aa4/~tNl", + "c87d-3f3a/tyf" + ], + "base": [ + "ab91-87f3/tplx", + "f30c-6aa4/~tNl", + "6175-eb06/tyf" + ], + "c3": [ + "ab91-87f3/tplx", + "f30c-6aa4/~tNl", + "6175-eb06/tyf" + ], + "c4": [ + "ab91-87f3/tplx", + "f30c-6aa4/~tNl", + "6175-eb06/tyf" + ], + "head": [ + "92af-e665/tplx", + "7960-ff7c/~tNl", + "0ec4-ff6b/tyf" + ], + "owners": [ + "inherited", + "C5" + ] + }, + { + "case": "/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 0", + "file": "examples.csv", + "old": [ + "dd36-1076/tplx", + "b703-3ef2/~tNl", + "e07d-2980/~tND", + "2c1e-66e5/tyf" + ], + "base": [ + "dd36-1076/tplx", + "b703-3ef2/~tNl", + "e07d-2980/~tND", + "f74f-a0c0/tyf" + ], + "c3": [ + "dd36-1076/tplx", + "b703-3ef2/~tNl", + "e07d-2980/~tND", + "f74f-a0c0/tyf" + ], + "c4": [ + "a78c-7701/tplx", + "cedf-054d/~tNl", + "91a9-683f/~tND", + "f841-fef5/tyf" + ], + "head": [ + "a78c-7701/tplx", + "cedf-054d/~tNl", + "91a9-683f/~tND", + "f841-fef5/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/examples/adhoc/qos/ -f omnetpp.ini -c MacQos -r 1", + "file": "examples.csv", + "old": [ + "4fd2-bb56/tplx", + "ecaf-89f7/~tNl", + "9398-0fae/~tND", + "a587-3a4d/tyf" + ], + "base": [ + "4fd2-bb56/tplx", + "ecaf-89f7/~tNl", + "9398-0fae/~tND", + "57c2-84bd/tyf" + ], + "c3": [ + "4fd2-bb56/tplx", + "ecaf-89f7/~tNl", + "9398-0fae/~tND", + "57c2-84bd/tyf" + ], + "c4": [ + "4fd2-bb56/tplx", + "ecaf-89f7/~tNl", + "9398-0fae/~tND", + "57c2-84bd/tyf" + ], + "head": [ + "33e1-5ba7/tplx", + "f321-055c/~tNl", + "b439-5b70/~tND", + "5cb1-cbfe/tyf" + ], + "owners": [ + "inherited", + "C5" + ] + }, + { + "case": "/examples/adhoc/qos/ -f omnetpp.ini -c Fragmentation", + "file": "examples.csv", + "old": [ + "2f2d-73b1/tplx", + "cc9e-d1a6/~tNl", + "e740-f7d4/~tND", + "33b7-00f9/tyf" + ], + "base": [ + "2f2d-73b1/tplx", + "cc9e-d1a6/~tNl", + "e740-f7d4/~tND", + "97f7-655d/tyf" + ], + "c3": [ + "2f2d-73b1/tplx", + "cc9e-d1a6/~tNl", + "e740-f7d4/~tND", + "97f7-655d/tyf" + ], + "c4": [ + "2f2d-73b1/tplx", + "cc9e-d1a6/~tNl", + "e740-f7d4/~tND", + "97f7-655d/tyf" + ], + "head": [ + "2f2d-73b1/tplx", + "cc9e-d1a6/~tNl", + "e740-f7d4/~tND", + "97f7-655d/tyf" + ], + "owners": [ + "inherited" + ] + }, + { + "case": "/examples/adhoc/qos/ -f omnetpp.ini -c MsduAggregation", + "file": "examples.csv", + "old": [ + "2c80-6844/tplx", + "4e9e-cf86/~tNl", + "ea3d-e802/~tND", + "df04-18f7/tyf" + ], + "base": [ + "2c80-6844/tplx", + "4e9e-cf86/~tNl", + "ea3d-e802/~tND", + "734c-15d1/tyf" + ], + "c3": [ + "2c80-6844/tplx", + "4e9e-cf86/~tNl", + "ea3d-e802/~tND", + "734c-15d1/tyf" + ], + "c4": [ + "e24a-3845/tplx", + "5509-e838/~tNl", + "636c-9cea/~tND", + "cc7a-9b26/tyf" + ], + "head": [ + "e24a-3845/tplx", + "5509-e838/~tNl", + "636c-9cea/~tND", + "cc7a-9b26/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/examples/wireless/mactest/ -f omnetpp.ini -c MacEdca -r 0", + "file": "examples.csv", + "old": [ + "5635-3aae/tplx", + "c574-69b7/~tNl", + "bb83-14c4/~tND", + "dfcf-4644/tyf" + ], + "base": [ + "5635-3aae/tplx", + "c574-69b7/~tNl", + "bb83-14c4/~tND", + "24e0-2e48/tyf" + ], + "c3": [ + "5635-3aae/tplx", + "c574-69b7/~tNl", + "bb83-14c4/~tND", + "24e0-2e48/tyf" + ], + "c4": [ + "c4a0-ea53/tplx", + "9c3d-fe57/~tNl", + "ec7b-7e1e/~tND", + "b459-aecf/tyf" + ], + "head": [ + "c4a0-ea53/tplx", + "9c3d-fe57/~tNl", + "ec7b-7e1e/~tND", + "b459-aecf/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/examples/wireless/mactest/ -f omnetpp.ini -c MacDcf -r 0", + "file": "examples.csv", + "old": [ + "031d-548a/tplx", + "4db6-9460/~tNl", + "4c1d-35a0/~tND", + "f37f-cd48/tyf" + ], + "base": [ + "031d-548a/tplx", + "4db6-9460/~tNl", + "4c1d-35a0/~tND", + "3edc-eb8d/tyf" + ], + "c3": [ + "031d-548a/tplx", + "4db6-9460/~tNl", + "4c1d-35a0/~tND", + "3edc-eb8d/tyf" + ], + "c4": [ + "031d-548a/tplx", + "4db6-9460/~tNl", + "4c1d-35a0/~tND", + "3edc-eb8d/tyf" + ], + "head": [ + "031d-548a/tplx", + "4db6-9460/~tNl", + "4c1d-35a0/~tND", + "3edc-eb8d/tyf" + ], + "owners": [ + "inherited" + ] + }, + { + "case": "/examples/wireless/qos/ -f omnetpp.ini -c MacNonQos -r 0", + "file": "examples.csv", + "old": [ + "0be7-a22e/tplx", + "5eb9-6cea/~tNl", + "87a5-11a1/~tND", + "6097-a429/tyf" + ], + "base": [ + "0be7-a22e/tplx", + "5eb9-6cea/~tNl", + "87a5-11a1/~tND", + "b802-9992/tyf" + ], + "c3": [ + "0be7-a22e/tplx", + "5eb9-6cea/~tNl", + "87a5-11a1/~tND", + "b802-9992/tyf" + ], + "c4": [ + "0be7-a22e/tplx", + "5eb9-6cea/~tNl", + "87a5-11a1/~tND", + "b802-9992/tyf" + ], + "head": [ + "0be7-a22e/tplx", + "5eb9-6cea/~tNl", + "87a5-11a1/~tND", + "b802-9992/tyf" + ], + "owners": [ + "inherited" + ] + }, + { + "case": "/examples/wireless/qos/ -f omnetpp.ini -c MacQos -r 0", + "file": "examples.csv", + "old": [ + "d929-5913/tplx", + "f602-4424/~tNl", + "f2fb-4d98/~tND", + "9f3c-4512/tyf" + ], + "base": [ + "d929-5913/tplx", + "f602-4424/~tNl", + "f2fb-4d98/~tND", + "b06a-f098/tyf" + ], + "c3": [ + "d929-5913/tplx", + "f602-4424/~tNl", + "f2fb-4d98/~tND", + "b06a-f098/tyf" + ], + "c4": [ + "0473-f9d2/tplx", + "e92c-7352/~tNl", + "1906-1f5f/~tND", + "4196-a696/tyf" + ], + "head": [ + "0473-f9d2/tplx", + "e92c-7352/~tNl", + "1906-1f5f/~tND", + "4196-a696/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithoutAggregation -r 0", + "file": "examples.csv", + "old": [ + "0473-f9d2/tplx", + "e92c-7352/~tNl", + "317d-aa4f/~tND", + "a4c3-19bf/tyf" + ], + "base": [ + "0473-f9d2/tplx", + "e92c-7352/~tNl", + "317d-aa4f/~tND", + "57cd-2e76/tyf" + ], + "c3": [ + "0473-f9d2/tplx", + "e92c-7352/~tNl", + "317d-aa4f/~tND", + "57cd-2e76/tyf" + ], + "c4": [ + "0473-f9d2/tplx", + "e92c-7352/~tNl", + "1906-1f5f/~tND", + "761d-e145/tyf" + ], + "head": [ + "0473-f9d2/tplx", + "e92c-7352/~tNl", + "1906-1f5f/~tND", + "761d-e145/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithRtsCts -r 0", + "file": "examples.csv", + "old": [ + "e07a-4c5f/tplx", + "9f6c-7889/~tNl", + "29ea-169c/~tND", + "b2d6-1329/tyf" + ], + "base": [ + "e07a-4c5f/tplx", + "9f6c-7889/~tNl", + "29ea-169c/~tND", + "8cb9-109e/tyf" + ], + "c3": [ + "e07a-4c5f/tplx", + "9f6c-7889/~tNl", + "29ea-169c/~tND", + "8cb9-109e/tyf" + ], + "c4": [ + "5269-1e09/tplx", + "b291-6797/~tNl", + "0378-ab11/~tND", + "9b3b-150c/tyf" + ], + "head": [ + "5269-1e09/tplx", + "b291-6797/~tNl", + "0378-ab11/~tND", + "9b3b-150c/tyf" + ], + "owners": [ + "inherited", + "C4" + ] + }, + { + "case": "/examples/wireless/qos/ -f omnetpp.ini -c MacQosWithBlockAck -r 0", + "file": "examples.csv", + "old": [ + "6edb-0326/tplx", + "2a8a-50ee/~tNl", + "4301-882d/~tND", + "08b5-d005/tyf" + ], + "base": [ + "6edb-0326/tplx", + "2a8a-50ee/~tNl", + "4301-882d/~tND", + "0db4-29ea/tyf" + ], + "c3": [ + "6edb-0326/tplx", + "2a8a-50ee/~tNl", + "4301-882d/~tND", + "0db4-29ea/tyf" + ], + "c4": [ + "6edb-0326/tplx", + "2a8a-50ee/~tNl", + "4301-882d/~tND", + "0db4-29ea/tyf" + ], + "head": [ + "7866-b50d/tplx", + "cf3d-0664/~tNl", + "5912-f4f1/~tND", + "7ed5-dd85/tyf" + ], + "owners": [ + "inherited", + "C5" + ] + } +] diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/observations.json b/plan/reproductions/ieee80211-txop-admission-remaining/observations.json new file mode 100644 index 00000000000..dd7d88091a8 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/observations.json @@ -0,0 +1,911 @@ +{ + "kind": "TXOP admission diagnostic observations", + "date": "2026-10-18", + "probe": "plan/reproductions/ieee80211-txop-admission-remaining/TxopAdmissionProbe.test", + "probe_sha256": "7dc84ca3bb0e8ff1b647590c0fad54a6796dc097bc67bd5ca134dd1a94ba7a1b", + "production_source_changes": false, + "build": { + "mode": "debug", + "inet_library_rebuilt": false, + "reason": "The diagnostic changes no compiled INET input. Each probe uses its checkout headers and library.", + "s5_commands": [ + "opp_test gen -v -w work TxopAdmissionProbe.test", + "opp_makemake -f --deep -lINET_dbg -L/home/user/omnetpp_ws/inet-compressed-blockack-s5/src -I/home/user/omnetpp_ws/inet-compressed-blockack-s5/src", + "make MODE=debug -j2" + ], + "current_makefile_command": "opp_makemake -f --deep -o TxopAdmissionProbe -lINET_dbg -L/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src -I/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src", + "s5_build_log": "/tmp/inet-txop-admission-remaining-20261018/s5-build.log", + "current_build_log": "/tmp/inet-txop-admission-remaining-20261018/current-build.log" + }, + "boundary_note": "Counts describe completion boundaries. DATA and ACK observations can refer to the same exchange.", + "scope": "Positive one-millisecond TXOPs, unfragmented unicast QoS DATA, zero propagation time. This probe is not a general standards oracle.", + "matching_s5_and_current_runs": [ + 0, + 5, + 6, + 7 + ], + "standards_lint_counts": { + "error": { + "unresolved-heading-ambiguity": 76 + }, + "info": { + "duplicate-label-candidates": 11473 + }, + "warning": { + "false-heading-candidate": 920, + "missing-parent": 68, + "oversized-node": 1, + "tiny-node": 10, + "unresolved-reference": 425 + } + }, + "txop_limit_reference_statuses": [ + { + "text": "10.6", + "status": "resolved", + "target": "ieee80211-2024:clause:10.6" + }, + { + "text": "10.3.2.10", + "status": "resolved", + "target": "ieee80211-2024:clause:10.3.2.10" + }, + { + "text": "10.30", + "status": "resolved", + "target": "ieee80211-2024:clause:10.30" + }, + { + "text": "10.35.5", + "status": "resolved", + "target": "ieee80211-2024:clause:10.35.5" + }, + { + "text": "26.7", + "status": "resolved", + "target": "ieee80211-2024:clause:26.7" + }, + { + "text": "10.41", + "status": "resolved", + "target": "ieee80211-2024:clause:10.41" + }, + { + "text": "10.31", + "status": "resolved", + "target": "ieee80211-2024:clause:10.31" + }, + { + "text": "10.4", + "status": "resolved", + "target": "ieee80211-2024:clause:10.4" + }, + { + "text": "10.2.7", + "status": "resolved", + "target": "ieee80211-2024:clause:10.2.7" + }, + { + "text": "10.23.4.2", + "status": "resolved", + "target": "ieee80211-2024:clause:10.23.4.2" + } + ], + "runs": [ + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 0, + "seed_set": 0, + "rate_mbps": 6, + "profile": "basic", + "protection": "single", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 0", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-0.log", + "raw_log_sha256": "0394c386c82ef4c069b2af6ed33f6b841a062e98495454d18bef5b86165eac89", + "observation_sha256": "ee6a55c7536f380b5046268695c4b2221c2f96bbe9646eb28f31eb68145b32f6", + "data_completions_beyond_bound": 30, + "ack_completions_beyond_bound": 7, + "maximum_excess_seconds": "0.001246", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001166", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000166", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001226", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000226", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "1", + "time": "1.003914", + "txopStart": "1.001728", + "bound": "1.002728", + "excess": "0.001186", + "count": "1", + "agreement": "1", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "ap", + "allocation": "0", + "time": "1.00625", + "txopStart": "1.004064", + "bound": "1.005064", + "excess": "0.001186", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "ap", + "allocation": "0", + "time": "1.00631", + "txopStart": "1.004064", + "bound": "1.005064", + "excess": "0.001246", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=16 agreedData=20 outsideData=1 aggregates=19 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=21 agreedData=10 outsideData=6 aggregates=14 delivered=30" + ] + }, + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 1, + "seed_set": 0, + "rate_mbps": 6, + "profile": "basic", + "protection": "multiple", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 1", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-1.log", + "raw_log_sha256": "495bdeafc740b01fa0086674ea0d6851e5aaab9c622f30eadd97d74dc1d6a99f", + "observation_sha256": "aefb424c5a7856b44eadc59a31ae31a216986c14c6c70ddcf5c28b511660f5b9", + "data_completions_beyond_bound": 29, + "ack_completions_beyond_bound": 6, + "maximum_excess_seconds": "0.001314", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001166", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000166", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001226", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000226", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "1", + "time": "1.004592", + "txopStart": "1.002406", + "bound": "1.003406", + "excess": "0.001186", + "count": "1", + "agreement": "1", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "ap", + "allocation": "0", + "time": "1.006928", + "txopStart": "1.004742", + "bound": "1.005742", + "excess": "0.001186", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "ap", + "allocation": "0", + "time": "1.006988", + "txopStart": "1.004742", + "bound": "1.005742", + "excess": "0.001246", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=16 agreedData=20 outsideData=1 aggregates=19 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=19 agreedData=17 outsideData=5 aggregates=20 delivered=30" + ] + }, + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 2, + "seed_set": 0, + "rate_mbps": 6, + "profile": "disabled", + "protection": "single", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 2", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-2.log", + "raw_log_sha256": "089c5294390b5e16f627b45f56d9a7adbfbe6479bcebbfccecf235b14a7aeff8", + "observation_sha256": "ade4456e66a1bc8e1397baf7c8a9e754c0c350bc411d5348dc85242a5d9e97ed", + "data_completions_beyond_bound": 31, + "ack_completions_beyond_bound": 31, + "maximum_excess_seconds": "0.001246", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001166", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000166", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001226", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000226", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "2", + "time": "1.004918", + "txopStart": "1.002732", + "bound": "1.003732", + "excess": "0.001186", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "2", + "time": "1.004978", + "txopStart": "1.002732", + "bound": "1.003732", + "excess": "0.001246", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=32 agreedData=0 outsideData=16 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=30 agreedData=0 outsideData=15 aggregates=15 delivered=30" + ] + }, + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 3, + "seed_set": 0, + "rate_mbps": 6, + "profile": "disabled", + "protection": "multiple", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 3", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-3.log", + "raw_log_sha256": "e5f050f3059fe847dafd2555ccf8d5ac0a7951dd8b319b34624d0b0a08f518be", + "observation_sha256": "23df505b9b389ce0a01850aa81ce497efcee3c806661ea6b975b0e1f348fe5fc", + "data_completions_beyond_bound": 32, + "ack_completions_beyond_bound": 32, + "maximum_excess_seconds": "0.001246", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001166", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000166", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001226", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000226", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "1", + "time": "1.003542", + "txopStart": "1.001356", + "bound": "1.002356", + "excess": "0.001186", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "1", + "time": "1.003602", + "txopStart": "1.001356", + "bound": "1.002356", + "excess": "0.001246", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=32 agreedData=0 outsideData=16 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=32 agreedData=0 outsideData=16 aggregates=14 delivered=30" + ] + }, + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 4, + "seed_set": 0, + "rate_mbps": 24, + "profile": "basic", + "protection": "single", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 4", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-4.log", + "raw_log_sha256": "8f483899979a9670ce1e7276da7e8f38fe34d707221aa88648962864957ddfd5", + "observation_sha256": "cdeea8a573af712129b650ee0ea07bd8b5fc2979a8dc077e35779437d7aee202", + "data_completions_beyond_bound": 2, + "ack_completions_beyond_bound": 0, + "maximum_excess_seconds": "0.00031", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "2", + "time": "1.01439", + "txopStart": "1.01308", + "bound": "1.01408", + "excess": "0.00031", + "count": "2", + "agreement": "1", + "aggregate": "1", + "retry": "1" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=2 agreedData=20 outsideData=1 aggregates=19 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=12 outsideData=4 aggregates=14 delivered=30" + ] + }, + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 5, + "seed_set": 0, + "rate_mbps": 24, + "profile": "basic", + "protection": "multiple", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 5", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-5.log", + "raw_log_sha256": "31c0c0192ab2ac64e98d5ea1838ec9dba9060968e4fbc52d4478eb0efb46dda3", + "observation_sha256": "e6ee063803800753deb132692935d756869fbc6590841f9731b8b19491595792", + "data_completions_beyond_bound": 14, + "ack_completions_beyond_bound": 0, + "maximum_excess_seconds": "0.000438", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "2", + "time": "1.004902", + "txopStart": "1.003592", + "bound": "1.004592", + "excess": "0.00031", + "count": "2", + "agreement": "1", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "ap", + "allocation": "15", + "time": "1.122", + "txopStart": "1.120942", + "bound": "1.121942", + "excess": "0.000058", + "count": "2", + "agreement": "1", + "aggregate": "0", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=7 agreedData=15 outsideData=1 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=7 agreedData=14 outsideData=2 aggregates=14 delivered=30" + ] + }, + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 6, + "seed_set": 0, + "rate_mbps": 24, + "profile": "disabled", + "protection": "single", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 6", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-6.log", + "raw_log_sha256": "97a514ecf561b1aba259036dadf4047f80709963e3a5260af967f9debd990e06", + "observation_sha256": "3297f24c781b986db12c5495d7e43d6314083a8353ac12f4f6ffb6ca90680b1e", + "data_completions_beyond_bound": 0, + "ack_completions_beyond_bound": 0, + "maximum_excess_seconds": "0", + "first_event_by_violation_class": [], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=16 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=16 aggregates=14 delivered=30" + ] + }, + { + "target": "s5", + "checkout": "/home/user/omnetpp_ws/inet-compressed-blockack-s5", + "revision": "1dd4ca23785b14b058693e9e20434a4257c3831f", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-compressed-blockack-s5/src/libINET_dbg.so", + "library_sha256": "dae587741f22406c701471c286dcffc03348f3f1f6c0f715c12ecd223ada0b23", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/work/TxopAdmissionProbe", + "configuration": "General", + "run": 7, + "seed_set": 0, + "rate_mbps": 24, + "profile": "disabled", + "protection": "multiple", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-compressed-blockack-s5/src' --check-signals=false -c General -r 7", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/run-7.log", + "raw_log_sha256": "edafa6a911ee186595a5730b425d0a95e591ab38ec661039d3e8cfd0c30e9991", + "observation_sha256": "292645837d3fe19a2a9ad28abe7f615256392a16d7f7ffc0dde9f49f4146818e", + "data_completions_beyond_bound": 16, + "ack_completions_beyond_bound": 16, + "maximum_excess_seconds": "0.000398", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "1", + "time": "1.001102", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000102", + "count": "2", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "1", + "time": "1.001146", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000146", + "count": "2", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "ap", + "allocation": "3", + "time": "1.005354", + "txopStart": "1.004252", + "bound": "1.005252", + "excess": "0.000102", + "count": "2", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "ap", + "allocation": "3", + "time": "1.005398", + "txopStart": "1.004252", + "bound": "1.005252", + "excess": "0.000146", + "count": "2", + "agreement": "0", + "aggregate": "0", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=16 agreedData=0 outsideData=16 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=16 agreedData=0 outsideData=16 aggregates=14 delivered=30" + ] + }, + { + "target": "a1-a7", + "checkout": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7", + "revision": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/libINET_dbg.so", + "library_sha256": "bc3595467d81df205051bc14f684b4e7ccae7c367c0efea7358fed1599efcaf7", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/current", + "configuration": "General", + "run": 0, + "seed_set": 0, + "rate_mbps": 6, + "profile": "basic", + "protection": "single", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src' --check-signals=false -c General -r 0", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/current-run-0.log", + "raw_log_sha256": "450279ae790acd669f63c33b4431054ed12133da5bd50455ef862fc695d59d95", + "observation_sha256": "ee6a55c7536f380b5046268695c4b2221c2f96bbe9646eb28f31eb68145b32f6", + "data_completions_beyond_bound": 30, + "ack_completions_beyond_bound": 7, + "maximum_excess_seconds": "0.001246", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001166", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000166", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "0", + "time": "1.001226", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000226", + "count": "1", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "1", + "time": "1.003914", + "txopStart": "1.001728", + "bound": "1.002728", + "excess": "0.001186", + "count": "1", + "agreement": "1", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "ap", + "allocation": "0", + "time": "1.00625", + "txopStart": "1.004064", + "bound": "1.005064", + "excess": "0.001186", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "ap", + "allocation": "0", + "time": "1.00631", + "txopStart": "1.004064", + "bound": "1.005064", + "excess": "0.001246", + "count": "1", + "agreement": "0", + "aggregate": "1", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=16 agreedData=20 outsideData=1 aggregates=19 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=21 agreedData=10 outsideData=6 aggregates=14 delivered=30" + ] + }, + { + "target": "a1-a7", + "checkout": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7", + "revision": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/libINET_dbg.so", + "library_sha256": "bc3595467d81df205051bc14f684b4e7ccae7c367c0efea7358fed1599efcaf7", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/current", + "configuration": "General", + "run": 5, + "seed_set": 0, + "rate_mbps": 24, + "profile": "basic", + "protection": "multiple", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src' --check-signals=false -c General -r 5", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/current-run-5.log", + "raw_log_sha256": "b996e2e88dc18d1c3f073b378df6c36845e11eee270f95c4cea926e48f1f36fc", + "observation_sha256": "e6ee063803800753deb132692935d756869fbc6590841f9731b8b19491595792", + "data_completions_beyond_bound": 14, + "ack_completions_beyond_bound": 0, + "maximum_excess_seconds": "0.000438", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "2", + "time": "1.004902", + "txopStart": "1.003592", + "bound": "1.004592", + "excess": "0.00031", + "count": "2", + "agreement": "1", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "ap", + "allocation": "15", + "time": "1.122", + "txopStart": "1.120942", + "bound": "1.121942", + "excess": "0.000058", + "count": "2", + "agreement": "1", + "aggregate": "0", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=7 agreedData=15 outsideData=1 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=7 agreedData=14 outsideData=2 aggregates=14 delivered=30" + ] + }, + { + "target": "a1-a7", + "checkout": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7", + "revision": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/libINET_dbg.so", + "library_sha256": "bc3595467d81df205051bc14f684b4e7ccae7c367c0efea7358fed1599efcaf7", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/current", + "configuration": "General", + "run": 6, + "seed_set": 0, + "rate_mbps": 24, + "profile": "disabled", + "protection": "single", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src' --check-signals=false -c General -r 6", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/current-run-6.log", + "raw_log_sha256": "cce2126db8a6155a4764e21f6592506b7a7dd24211cacc4094cfa2e0d1c24875", + "observation_sha256": "3297f24c781b986db12c5495d7e43d6314083a8353ac12f4f6ffb6ca90680b1e", + "data_completions_beyond_bound": 0, + "ack_completions_beyond_bound": 0, + "maximum_excess_seconds": "0", + "first_event_by_violation_class": [], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=16 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=0 agreedData=0 outsideData=16 aggregates=14 delivered=30" + ] + }, + { + "target": "a1-a7", + "checkout": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7", + "revision": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "mode": "debug", + "library": "/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src/libINET_dbg.so", + "library_sha256": "bc3595467d81df205051bc14f684b4e7ccae7c367c0efea7358fed1599efcaf7", + "working_directory": "/tmp/inet-txop-admission-remaining-20261018/current", + "configuration": "General", + "run": 7, + "seed_set": 0, + "rate_mbps": 24, + "profile": "disabled", + "protection": "multiple", + "command": "./TxopAdmissionProbe_dbg -u Cmdenv -n '.;/home/user/omnetpp_ws/inet-ieee80211-ampdu-implicit-blockack-a1-a7/src' --check-signals=false -c General -r 7", + "exit_code": 0, + "raw_log": "/tmp/inet-txop-admission-remaining-20261018/current-run-7.log", + "raw_log_sha256": "7b837b41be9aa7ffa8f9dbd29c39aa68e131160d60b8d617aab48caec706836e", + "observation_sha256": "292645837d3fe19a2a9ad28abe7f615256392a16d7f7ffc0dde9f49f4146818e", + "data_completions_beyond_bound": 16, + "ack_completions_beyond_bound": 16, + "maximum_excess_seconds": "0.000398", + "first_event_by_violation_class": [ + { + "boundary": "DATA-complete", + "node": "sta1", + "allocation": "1", + "time": "1.001102", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000102", + "count": "2", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "sta1", + "allocation": "1", + "time": "1.001146", + "txopStart": "1", + "bound": "1.001", + "excess": "0.000146", + "count": "2", + "agreement": "0", + "aggregate": "1", + "retry": "0" + }, + { + "boundary": "DATA-complete", + "node": "ap", + "allocation": "3", + "time": "1.005354", + "txopStart": "1.004252", + "bound": "1.005252", + "excess": "0.000102", + "count": "2", + "agreement": "0", + "aggregate": "0", + "retry": "0" + }, + { + "boundary": "ACK-complete", + "node": "ap", + "allocation": "3", + "time": "1.005398", + "txopStart": "1.004252", + "bound": "1.005252", + "excess": "0.000146", + "count": "2", + "agreement": "0", + "aggregate": "0", + "retry": "0" + } + ], + "summary_lines": [ + "SUMMARY node=^.sta1.wlan[0].mac.hcf invalidBoundaries=16 agreedData=0 outsideData=16 aggregates=14 delivered=30", + "SUMMARY node=^.ap.wlan[0].mac.hcf invalidBoundaries=16 agreedData=0 outsideData=16 aggregates=14 delivered=30" + ] + } + ] +} diff --git a/plan/reproductions/ieee80211-txop-admission-remaining/publication-20261019/verification.json b/plan/reproductions/ieee80211-txop-admission-remaining/publication-20261019/verification.json new file mode 100644 index 00000000000..766a1795765 --- /dev/null +++ b/plan/reproductions/ieee80211-txop-admission-remaining/publication-20261019/verification.json @@ -0,0 +1,257 @@ +{ + "date": "2026-10-19", + "dependency_head": "d841dc77db7d0b141bf31e5e215a0de9bb281957", + "source_head": "a6c85b80ba735641b2e4b5386563fab34dc92a78", + "upstream_master": "0f1458fbdc1379ad93ad6d7a04975e5607b26197", + "debug_library_sha256": "1de36100640807565d8456334072201ff3f412a3e5fbfe28e0376a5e0fc57bf2", + "release_library_sha256": "70436a0ffc1aa69d1a74059609e6cb1cd02035fa959fe12c95861dbebace6b2b", + "source_commits": [ + { + "commit": "a8557bc6513a5c48bebdd0ce11923fefbe71b1b7", + "label": "c1a", + "commands": [ + { + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c1a-0.log" + }, + { + "command": [ + "inet_run_unit_tests", + "-m", + "debug", + "-f", + "Ieee80211BoundedFragmentation_.*\\.test" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c1a-1.log" + } + ] + }, + { + "commit": "9c4bf543d8039e82d7217d19a757ca73dff8e5e4", + "label": "c1b", + "commands": [ + { + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c1b-0.log" + }, + { + "command": [ + "inet_run_module_tests", + "-m", + "debug", + "-f", + "Ieee80211PreparedQosFragments_.*\\.test" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c1b-1.log" + } + ] + }, + { + "commit": "04b2e32c659336117e81fc3d579667d6ce135c61", + "label": "c2", + "commands": [ + { + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c2-0.log" + }, + { + "command": [ + "inet_run_module_tests", + "-m", + "debug", + "-f", + "Ieee80211TxopMsduRecovery_.*\\.test" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c2-1.log" + } + ] + }, + { + "commit": "d98c98fcfb08b223ed6b88482493e87f0ed274b3", + "label": "c3", + "commands": [ + { + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c3-0.log" + }, + { + "command": [ + "inet_run_module_tests", + "-m", + "debug", + "-f", + "Ieee80211(CompressedBlockAckAdmission|CompressedBlockAckExchange|AmpduAdmission|AmpduPreparation|AmpduRecovery|AmpduExchange)_.*\\.test" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c3-1.log" + } + ] + }, + { + "commit": "c419a072519da0cc402d0285e255ee9ac72aa6e6", + "label": "c4", + "commands": [ + { + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c4-0.log" + }, + { + "command": [ + "inet_run_module_tests", + "-m", + "debug", + "-f", + "Ieee80211(TxopAdmission|CompressedBlockAckAdmission|HcfSingleProtection|HcfMultipleProtection|PreparedCancellation|HcfInternalCollision|HcfManagementRecovery)_.*\\.test" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c4-1.log" + } + ] + }, + { + "commit": "a6c85b80ba735641b2e4b5386563fab34dc92a78", + "label": "c5", + "commands": [ + { + "command": [ + "make", + "MODE=debug", + "-j8" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c5-0.log" + }, + { + "command": [ + "inet_run_module_tests", + "-m", + "debug", + "-f", + "Ieee80211(BasicTxopAdmission|BasicCompatibility|BlockAckFragmentRetirement|CompressedBlockAckAdmission|BlockAckVariant)_.*\\.test" + ], + "exit_status": 0, + "log": "/tmp/inet-txop-publication/c5-1.log" + } + ] + } + ], + "final_results": { + "debug_build": 0, + "release_build": 0, + "module_fixtures": 31, + "module_exit_status": 0, + "unit_fixtures": 4, + "unit_exit_status": 0, + "protocol_fixtures": 1, + "protocol_exit_status": 0, + "normal_ack_runs": 96, + "basic_runs": 36, + "onoe_runs": 16, + "onoe_exit_status": 0, + "aarf_runs": 16, + "aarf_exit_status": 0, + "fingerprint_rows": 3, + "fingerprint_exit_status": 1, + "baseline_updated": false + }, + "global_gates": { + "architecture": { + "exit_status": 1, + "identical_to_dependency_head": true, + "report_sha256": "1f8e91c0592212fad19fb2069d676af09c9d5f561420faa7c0e44aa50c7c1609" + }, + "naming": { + "exit_status": 1, + "identical_to_dependency_head": true, + "report_sha256": "b2e935923ba378056fbaa076fbbe63d6bfd773fbdc6265aae9be93f337d193f6" + }, + "interfaces": { + "exit_status": 1, + "identical_to_dependency_head": true, + "report_sha256": "39b80badfe3e5df49a17d16d96d34cdd42aa700d3ddeffb514ff0643dbbb1454" + }, + "source_seals": { + "exit_status": 0, + "report_sha256": "4d5110553efecb3ef3b5837e2c26e345ad8bdd3edeeaf3aab5502dc60769dc16" + } + }, + "topic_series_before_documentation": { + "exit_status": 0, + "notes": 1, + "report_sha256": "debb0050ce940ac673ea44cbd98587b3ef7cf0472cca80a5e49fb4ff615652fc" + }, + "mermaid_diagrams": { + "count": 3, + "syntax_status": "PASS", + "visual_rendering": "NOT_CHECKED" + }, + "logs": { + "base-architecture.log": "1f8e91c0592212fad19fb2069d676af09c9d5f561420faa7c0e44aa50c7c1609", + "base-interfaces.log": "39b80badfe3e5df49a17d16d96d34cdd42aa700d3ddeffb514ff0643dbbb1454", + "base-naming.log": "b2e935923ba378056fbaa076fbbe63d6bfd773fbdc6265aae9be93f337d193f6", + "base-seals.log": "4d5110553efecb3ef3b5837e2c26e345ad8bdd3edeeaf3aab5502dc60769dc16", + "base-series.log": "8d060412b0b92424128fa16f1fa3bf938754cd6a9d81e2e28f8a3c8f6bd8981d", + "c1a-0.log": "1f2faa3924a5aa6779e09c900ddd9a9b72dd873c46211ca42a55a200c332882e", + "c1a-1.log": "ec45171c7f35e9be4eb39edcae77093423a880f5153a7f3ce11b4a45d4ca2219", + "c1a-summary.log": "37145c70c8e529618c7761f80b2361ee9d3e9a0885831d720d92b5ee0a8a4e9f", + "c1b-0.log": "20a7036c026dfd58e5d9e6a4feb41971b0b92e5558c1982385c92d8e460dabf7", + "c1b-1.log": "cb08e83b35308fe5fbbeefc8045d56f96987907fa0e951ebeeb8393c9c8751f0", + "c1b-summary.log": "02f3dac5fde8f1c045efaa6f4a8baa3fcc7fc7e3132eaba2a1c9ab4d506850f5", + "c2-0.log": "aae51aedbc408ead1c42b1142057b6450a272dc18e95677dc2def5e492a16c1b", + "c2-1.log": "175705439a3657d2d58178783848d720e65c5a6e61a74b45e02d87f20a46be29", + "c2-summary.log": "f2f3b356a1e926f31df76b8d8a90ae5a05ba8d584a9d0fb39c41ba712ed75582", + "c3-0.log": "578ee061e6aa1f51812a89e7556134006a688d13a79ad01eb40f5d12c1286e5d", + "c3-1.log": "5c278d9dea9e9d8eb2b73140b2abeba33a74c4815f601773fd736074150185d3", + "c3-summary.log": "c649bc21aa30cabd67dc42a2202dddcf276346725eab6569bbb11dea7d68dc19", + "c4-0.log": "bf3385c2409635c546e8f4cc63363c4e3456bcbe0f3d3f08e62014ad76744f66", + "c4-1.log": "cb0c8ac58dbfacbacedbab402b60cca0a2ea98bfacee907bb77fdaf64d916354", + "c4-summary.log": "739beafcc6398ddecd1ac767c1808a7725fd8859b9789244540d0557ad4d93e3", + "c5-0.log": "1216ad1c52e1579b5e27731768a09f2e98f49837137cc11acff03326eef84571", + "c5-1.log": "2ace93cb53271260b107761050539ddc354f651ca8580246d48694af6b08af10", + "c5-summary.log": "870434f2dfe88de390f5dba849738d1057f5f65f033f9dd4a8e95046073010fa", + "description-check.log": "86ada05bf13cf158a3a787c44e056b1919bfb6776e29acc0a59704327af656c3", + "diagram-check.log": "bd898937b92390895905a2d2cd9b91abaafe851a448ab5a88701f33afa329f87", + "diagram-install.log": "068a3510ec890c74b50dbc89097705590968d452dc20dd019d73af0ae67df8d2", + "final-aarf.log": "e9bbf0f4c39c88751df4bb80393f92b67e5437563625cc3a5b957df1f2bfe59a", + "final-debug-build.log": "8986b95376e61c858871cdd4ad2b451bc4c4e22c2c4c4ab0c5b7d6814cfc6ace", + "final-fingerprints.log": "8af24dfa9dc3b8b395800867438f81ea30a3ce3199bc400f87b78f80fc073184", + "final-module.log": "a145de0f816274d475c1b69efae75d62c5967ca9ec9f64af077dc49f20177620", + "final-onoe.log": "1540cb1d60814f3adb2e8f84eac34a6ef3d7301f121623e1bee3c3f9b93a2eb5", + "final-protocol.log": "b37dc5c09d62b20ae5d73eb9b556cdd96762b17afad0bcd5abcfc68652e4a577", + "final-unit.log": "381839f9d8a318605feb534d9fdf657b6a2fc7d75b19ce24629d4810f38bae16", + "head-architecture.log": "1f8e91c0592212fad19fb2069d676af09c9d5f561420faa7c0e44aa50c7c1609", + "head-interfaces.log": "39b80badfe3e5df49a17d16d96d34cdd42aa700d3ddeffb514ff0643dbbb1454", + "head-naming.log": "b2e935923ba378056fbaa076fbbe63d6bfd773fbdc6265aae9be93f337d193f6", + "head-seals.log": "4d5110553efecb3ef3b5837e2c26e345ad8bdd3edeeaf3aab5502dc60769dc16", + "release-build.log": "3fa848ea586774c88c52b5ad3cef83f21156e39af11195f3f032859c201c991a", + "topic-series-pre-docs.log": "debb0050ce940ac673ea44cbd98587b3ef7cf0472cca80a5e49fb4ff615652fc" + } +}