From 29354352610e7f9897bce0e42fc370a17e156f27 Mon Sep 17 00:00:00 2001 From: Abtin Keshavarzian Date: Thu, 24 Oct 2024 03:34:22 -0700 Subject: [PATCH] [core] update enum checks to use compile-time static counter utility (#10852) This commit updates the `static_assert` checks for `enum` values within all core modules to use the recently added compile-time static counter and its related helper utility macros. --- src/core/backbone_router/bbr_leader.cpp | 28 +++--- src/core/backbone_router/bbr_local.cpp | 10 ++- .../multicast_listeners_table.cpp | 10 ++- src/core/border_router/routing_manager.cpp | 44 +++++++--- src/core/common/message.cpp | 12 ++- src/core/common/settings.cpp | 53 ++++++----- src/core/instance/instance.hpp | 1 + src/core/meshcop/commissioner.cpp | 10 ++- src/core/meshcop/joiner.cpp | 16 ++-- src/core/meshcop/secure_transport.cpp | 16 ++-- src/core/net/dns_dso.cpp | 48 ++++++---- src/core/net/dnssd_server.cpp | 16 ++-- src/core/net/ip6.cpp | 12 ++- src/core/net/nat64_translator.cpp | 12 ++- src/core/net/srp_client.cpp | 88 ++++++++++++------- src/core/net/srp_server.cpp | 26 ++++-- src/core/radio/trel_link.cpp | 12 ++- src/core/thread/address_resolver.cpp | 30 ++++--- src/core/thread/link_quality.cpp | 12 ++- src/core/thread/mle.cpp | 57 +++++++----- src/core/thread/mle_types.cpp | 27 ++++-- src/core/thread/neighbor.cpp | 20 +++-- src/core/thread/network_data_publisher.cpp | 14 +-- src/core/thread/uri_paths.cpp | 84 +++++++++--------- src/core/utils/slaac_address.cpp | 10 ++- src/core/utils/static_counter.hpp | 2 + 26 files changed, 421 insertions(+), 249 deletions(-) diff --git a/src/core/backbone_router/bbr_leader.cpp b/src/core/backbone_router/bbr_leader.cpp index 369925c6d..d455e6f2c 100644 --- a/src/core/backbone_router/bbr_leader.cpp +++ b/src/core/backbone_router/bbr_leader.cpp @@ -106,12 +106,16 @@ const char *Leader::StateToString(State aState) "Unchanged", // (5) kStateUnchanged }; - static_assert(0 == kStateNone, "kStateNone value is incorrect"); - static_assert(1 == kStateAdded, "kStateAdded value is incorrect"); - static_assert(2 == kStateRemoved, "kStateRemoved value is incorrect"); - static_assert(3 == kStateToTriggerRereg, "kStateToTriggerRereg value is incorrect"); - static_assert(4 == kStateRefreshed, "kStateRefreshed value is incorrect"); - static_assert(5 == kStateUnchanged, "kStateUnchanged value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateNone); + ValidateNextEnum(kStateAdded); + ValidateNextEnum(kStateRemoved); + ValidateNextEnum(kStateToTriggerRereg); + ValidateNextEnum(kStateRefreshed); + ValidateNextEnum(kStateUnchanged); + }; return kStateStrings[aState]; } @@ -125,10 +129,14 @@ const char *Leader::DomainPrefixEventToString(DomainPrefixEvent aEvent) "Unchanged", // (3) kDomainPrefixUnchanged }; - static_assert(0 == kDomainPrefixAdded, "kDomainPrefixAdded value is incorrect"); - static_assert(1 == kDomainPrefixRemoved, "kDomainPrefixRemoved value is incorrect"); - static_assert(2 == kDomainPrefixRefreshed, "kDomainPrefixRefreshed value is incorrect"); - static_assert(3 == kDomainPrefixUnchanged, "kDomainPrefixUnchanged value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kDomainPrefixAdded); + ValidateNextEnum(kDomainPrefixRemoved); + ValidateNextEnum(kDomainPrefixRefreshed); + ValidateNextEnum(kDomainPrefixUnchanged); + }; return kEventStrings[aEvent]; } diff --git a/src/core/backbone_router/bbr_local.cpp b/src/core/backbone_router/bbr_local.cpp index 9cb8503ee..2f5e20f12 100644 --- a/src/core/backbone_router/bbr_local.cpp +++ b/src/core/backbone_router/bbr_local.cpp @@ -449,9 +449,13 @@ const char *Local::ActionToString(Action aAction) "Remove", // (2) kActionRemove }; - static_assert(0 == kActionSet, "kActionSet value is incorrect"); - static_assert(1 == kActionAdd, "kActionAdd value is incorrect"); - static_assert(2 == kActionRemove, "kActionRemove value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kActionSet); + ValidateNextEnum(kActionAdd); + ValidateNextEnum(kActionRemove); + }; return kActionStrings[aAction]; } diff --git a/src/core/backbone_router/multicast_listeners_table.cpp b/src/core/backbone_router/multicast_listeners_table.cpp index 6998da71d..e66e21dc1 100644 --- a/src/core/backbone_router/multicast_listeners_table.cpp +++ b/src/core/backbone_router/multicast_listeners_table.cpp @@ -142,9 +142,13 @@ void MulticastListenersTable::Log(Action aAction, "Expire", // (2) kExpire }; - static_assert(0 == kAdd, "kAdd value is incorrect"); - static_assert(1 == kRemove, "kRemove value is incorrect"); - static_assert(2 == kExpire, "kExpire value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kAdd); + ValidateNextEnum(kRemove); + ValidateNextEnum(kExpire); + }; LogDebg("%s %s expire %lu: %s", kActionStrings[aAction], aAddress.ToString().AsCString(), ToUlong(aExpireTime.GetValue()), ErrorToString(aError)); diff --git a/src/core/border_router/routing_manager.cpp b/src/core/border_router/routing_manager.cpp index b3ebf8743..5f7916ba4 100644 --- a/src/core/border_router/routing_manager.cpp +++ b/src/core/border_router/routing_manager.cpp @@ -893,9 +893,13 @@ const char *RoutingManager::RouterAdvOriginToString(RouterAdvOrigin aRaOrigin) "(this BR other sw entity)", // (2) kThisBrOtherEntity }; - static_assert(0 == kAnotherRouter, "kAnotherRouter value is incorrect"); - static_assert(1 == kThisBrRoutingManager, "kThisBrRoutingManager value is incorrect"); - static_assert(2 == kThisBrOtherEntity, "kThisBrOtherEntity value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kAnotherRouter); + ValidateNextEnum(kThisBrRoutingManager); + ValidateNextEnum(kThisBrOtherEntity); + }; return kOriginStrings[aRaOrigin]; } @@ -3010,10 +3014,14 @@ const char *RoutingManager::OnLinkPrefixManager::StateToString(State aState) "Deprecating", // (3) kDeprecating }; - static_assert(0 == kIdle, "kIdle value is incorrect"); - static_assert(1 == kPublishing, "kPublishing value is incorrect"); - static_assert(2 == kAdvertising, "kAdvertising value is incorrect"); - static_assert(3 == kDeprecating, "kDeprecating value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kIdle); + ValidateNextEnum(kPublishing); + ValidateNextEnum(kAdvertising); + ValidateNextEnum(kDeprecating); + }; return kStateStrings[aState]; } @@ -3493,9 +3501,13 @@ const char *RoutingManager::RoutePublisher::StateToString(State aState) "ula", // (2) kPublishUla }; - static_assert(0 == kDoNotPublish, "kDoNotPublish value is incorrect"); - static_assert(1 == kPublishDefault, "kPublishDefault value is incorrect"); - static_assert(2 == kPublishUla, "kPublishUla value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kDoNotPublish); + ValidateNextEnum(kPublishDefault); + ValidateNextEnum(kPublishUla); + }; return kStateStrings[aState]; } @@ -4204,10 +4216,14 @@ const char *RoutingManager::PdPrefixManager::StateToString(State aState) "Idle", // (3) kIdle }; - static_assert(0 == kDhcp6PdStateDisabled, "kDhcp6PdStateDisabled value is incorrect"); - static_assert(1 == kDhcp6PdStateStopped, "kDhcp6PdStateStopped value is incorrect"); - static_assert(2 == kDhcp6PdStateRunning, "kDhcp6PdStateRunning value is incorrect"); - static_assert(3 == kDhcp6PdStateIdle, "kDhcp6PdStateIdle value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kDhcp6PdStateDisabled); + ValidateNextEnum(kDhcp6PdStateStopped); + ValidateNextEnum(kDhcp6PdStateRunning); + ValidateNextEnum(kDhcp6PdStateIdle); + }; return kStateStrings[aState]; } diff --git a/src/core/common/message.cpp b/src/core/common/message.cpp index c08d9a541..044cf8948 100644 --- a/src/core/common/message.cpp +++ b/src/core/common/message.cpp @@ -363,10 +363,14 @@ const char *Message::PriorityToString(Priority aPriority) "net", // (3) kPriorityNet }; - static_assert(kPriorityLow == 0, "kPriorityLow value is incorrect"); - static_assert(kPriorityNormal == 1, "kPriorityNormal value is incorrect"); - static_assert(kPriorityHigh == 2, "kPriorityHigh value is incorrect"); - static_assert(kPriorityNet == 3, "kPriorityNet value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kPriorityLow); + ValidateNextEnum(kPriorityNormal); + ValidateNextEnum(kPriorityHigh); + ValidateNextEnum(kPriorityNet); + }; return kPriorityStrings[aPriority]; } diff --git a/src/core/common/settings.cpp b/src/core/common/settings.cpp index 14fbf0099..f9368d40c 100644 --- a/src/core/common/settings.cpp +++ b/src/core/common/settings.cpp @@ -129,15 +129,19 @@ const char *SettingsBase::ActionToString(Action aAction) #endif }; - static_assert(0 == kActionRead, "kActionRead value is incorrect"); - static_assert(1 == kActionSave, "kActionSave value is incorrect"); - static_assert(2 == kActionResave, "kActionResave value is incorrect"); - static_assert(3 == kActionDelete, "kActionDelete value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kActionRead); + ValidateNextEnum(kActionSave); + ValidateNextEnum(kActionResave); + ValidateNextEnum(kActionDelete); #if OPENTHREAD_FTD - static_assert(4 == kActionAdd, "kActionAdd value is incorrect"); - static_assert(5 == kActionRemove, "kActionRemove value is incorrect"); - static_assert(6 == kActionDeleteAll, "kActionDeleteAll value is incorrect"); + ValidateNextEnum(kActionAdd); + ValidateNextEnum(kActionRemove); + ValidateNextEnum(kActionDeleteAll); #endif + }; return kActionStrings[aAction]; } @@ -167,19 +171,28 @@ const char *SettingsBase::KeyToString(Key aKey) "BorderAgentId" // (17) kKeyBorderAgentId }; - static_assert(1 == kKeyActiveDataset, "kKeyActiveDataset value is incorrect"); - static_assert(2 == kKeyPendingDataset, "kKeyPendingDataset value is incorrect"); - static_assert(3 == kKeyNetworkInfo, "kKeyNetworkInfo value is incorrect"); - static_assert(4 == kKeyParentInfo, "kKeyParentInfo value is incorrect"); - static_assert(5 == kKeyChildInfo, "kKeyChildInfo value is incorrect"); - static_assert(7 == kKeySlaacIidSecretKey, "kKeySlaacIidSecretKey value is incorrect"); - static_assert(8 == kKeyDadInfo, "kKeyDadInfo value is incorrect"); - static_assert(11 == kKeySrpEcdsaKey, "kKeySrpEcdsaKey value is incorrect"); - static_assert(12 == kKeySrpClientInfo, "kKeySrpClientInfo value is incorrect"); - static_assert(13 == kKeySrpServerInfo, "kKeySrpServerInfo value is incorrect"); - static_assert(15 == kKeyBrUlaPrefix, "kKeyBrUlaPrefix value is incorrect"); - static_assert(16 == kKeyBrOnLinkPrefixes, "kKeyBrOnLinkPrefixes is incorrect"); - static_assert(17 == kKeyBorderAgentId, "kKeyBorderAgentId is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + SkipNextEnum(); + ValidateNextEnum(kKeyActiveDataset); + ValidateNextEnum(kKeyPendingDataset); + ValidateNextEnum(kKeyNetworkInfo); + ValidateNextEnum(kKeyParentInfo); + ValidateNextEnum(kKeyChildInfo); + SkipNextEnum(); + ValidateNextEnum(kKeySlaacIidSecretKey); + ValidateNextEnum(kKeyDadInfo); + SkipNextEnum(); + SkipNextEnum(); + ValidateNextEnum(kKeySrpEcdsaKey); + ValidateNextEnum(kKeySrpClientInfo); + ValidateNextEnum(kKeySrpServerInfo); + SkipNextEnum(); + ValidateNextEnum(kKeyBrUlaPrefix); + ValidateNextEnum(kKeyBrOnLinkPrefixes); + ValidateNextEnum(kKeyBorderAgentId); + }; static_assert(kLastKey == kKeyBorderAgentId, "kLastKey is not valid"); diff --git a/src/core/instance/instance.hpp b/src/core/instance/instance.hpp index 188609b4b..c3e0cf11f 100644 --- a/src/core/instance/instance.hpp +++ b/src/core/instance/instance.hpp @@ -66,6 +66,7 @@ #include "radio/radio.hpp" #include "utils/otns.hpp" #include "utils/power_calibration.hpp" +#include "utils/static_counter.hpp" #if OPENTHREAD_FTD || OPENTHREAD_MTD #include "backbone_router/backbone_tmf.hpp" diff --git a/src/core/meshcop/commissioner.cpp b/src/core/meshcop/commissioner.cpp index 1b27a8a52..9e7cd8c32 100644 --- a/src/core/meshcop/commissioner.cpp +++ b/src/core/meshcop/commissioner.cpp @@ -1117,9 +1117,13 @@ const char *Commissioner::StateToString(State aState) "active", // (2) kStateActive }; - static_assert(kStateDisabled == 0, "kStateDisabled value is incorrect"); - static_assert(kStatePetition == 1, "kStatePetition value is incorrect"); - static_assert(kStateActive == 2, "kStateActive value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateDisabled); + ValidateNextEnum(kStatePetition); + ValidateNextEnum(kStateActive); + }; return kStateStrings[aState]; } diff --git a/src/core/meshcop/joiner.cpp b/src/core/meshcop/joiner.cpp index 9bcc840c5..056804849 100644 --- a/src/core/meshcop/joiner.cpp +++ b/src/core/meshcop/joiner.cpp @@ -597,12 +597,16 @@ const char *Joiner::StateToString(State aState) "Joined", // (5) kStateJoined }; - static_assert(kStateIdle == 0, "kStateIdle value is incorrect"); - static_assert(kStateDiscover == 1, "kStateDiscover value is incorrect"); - static_assert(kStateConnect == 2, "kStateConnect value is incorrect"); - static_assert(kStateConnected == 3, "kStateConnected value is incorrect"); - static_assert(kStateEntrust == 4, "kStateEntrust value is incorrect"); - static_assert(kStateJoined == 5, "kStateJoined value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateIdle); + ValidateNextEnum(kStateDiscover); + ValidateNextEnum(kStateConnect); + ValidateNextEnum(kStateConnected); + ValidateNextEnum(kStateEntrust); + ValidateNextEnum(kStateJoined); + }; return kStateStrings[aState]; } diff --git a/src/core/meshcop/secure_transport.cpp b/src/core/meshcop/secure_transport.cpp index 96171c8a2..99581ffad 100644 --- a/src/core/meshcop/secure_transport.cpp +++ b/src/core/meshcop/secure_transport.cpp @@ -1215,12 +1215,16 @@ const char *SecureTransport::StateToString(State aState) "CloseNotify", // (5) kStateCloseNotify }; - static_assert(0 == kStateClosed, "kStateClosed valid is incorrect"); - static_assert(1 == kStateOpen, "kStateOpen valid is incorrect"); - static_assert(2 == kStateInitializing, "kStateInitializing valid is incorrect"); - static_assert(3 == kStateConnecting, "kStateConnecting valid is incorrect"); - static_assert(4 == kStateConnected, "kStateConnected valid is incorrect"); - static_assert(5 == kStateCloseNotify, "kStateCloseNotify valid is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateClosed); + ValidateNextEnum(kStateOpen); + ValidateNextEnum(kStateInitializing); + ValidateNextEnum(kStateConnecting); + ValidateNextEnum(kStateConnected); + ValidateNextEnum(kStateCloseNotify); + }; return kStateStrings[aState]; } diff --git a/src/core/net/dns_dso.cpp b/src/core/net/dns_dso.cpp index 4ffeaed8d..bfbd4dcee 100644 --- a/src/core/net/dns_dso.cpp +++ b/src/core/net/dns_dso.cpp @@ -1303,11 +1303,15 @@ const char *Dso::Connection::StateToString(State aState) "SessionEstablished", // (4) kStateSessionEstablished, }; - static_assert(0 == kStateDisconnected, "kStateDisconnected value is incorrect"); - static_assert(1 == kStateConnecting, "kStateConnecting value is incorrect"); - static_assert(2 == kStateConnectedButSessionless, "kStateConnectedButSessionless value is incorrect"); - static_assert(3 == kStateEstablishingSession, "kStateEstablishingSession value is incorrect"); - static_assert(4 == kStateSessionEstablished, "kStateSessionEstablished value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateDisconnected); + ValidateNextEnum(kStateConnecting); + ValidateNextEnum(kStateConnectedButSessionless); + ValidateNextEnum(kStateEstablishingSession); + ValidateNextEnum(kStateSessionEstablished); + }; return kStateStrings[aState]; } @@ -1320,9 +1324,13 @@ const char *Dso::Connection::MessageTypeToString(MessageType aMessageType) "Unidirectional", // (2) kUnidirectionalMessage }; - static_assert(0 == kRequestMessage, "kRequestMessage value is incorrect"); - static_assert(1 == kResponseMessage, "kResponseMessage value is incorrect"); - static_assert(2 == kUnidirectionalMessage, "kUnidirectionalMessage value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kRequestMessage); + ValidateNextEnum(kResponseMessage); + ValidateNextEnum(kUnidirectionalMessage); + }; return kMessageTypeStrings[aMessageType]; } @@ -1342,16 +1350,20 @@ const char *Dso::Connection::DisconnectReasonToString(DisconnectReason aReason) "Unknown", // (9) kReasonUnknown }; - static_assert(0 == kReasonFailedToConnect, "kReasonFailedToConnect value is incorrect"); - static_assert(1 == kReasonResponseTimeout, "kReasonResponseTimeout value is incorrect"); - static_assert(2 == kReasonPeerDoesNotSupportDso, "kReasonPeerDoesNotSupportDso value is incorrect"); - static_assert(3 == kReasonPeerClosed, "kReasonPeerClosed value is incorrect"); - static_assert(4 == kReasonPeerAborted, "kReasonPeerAborted value is incorrect"); - static_assert(5 == kReasonInactivityTimeout, "kReasonInactivityTimeout value is incorrect"); - static_assert(6 == kReasonKeepAliveTimeout, "kReasonKeepAliveTimeout value is incorrect"); - static_assert(7 == kReasonServerRetryDelayRequest, "kReasonServerRetryDelayRequest value is incorrect"); - static_assert(8 == kReasonPeerMisbehavior, "kReasonPeerMisbehavior value is incorrect"); - static_assert(9 == kReasonUnknown, "kReasonUnknown value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kReasonFailedToConnect); + ValidateNextEnum(kReasonResponseTimeout); + ValidateNextEnum(kReasonPeerDoesNotSupportDso); + ValidateNextEnum(kReasonPeerClosed); + ValidateNextEnum(kReasonPeerAborted); + ValidateNextEnum(kReasonInactivityTimeout); + ValidateNextEnum(kReasonKeepAliveTimeout); + ValidateNextEnum(kReasonServerRetryDelayRequest); + ValidateNextEnum(kReasonPeerMisbehavior); + ValidateNextEnum(kReasonUnknown); + }; return kDisconnectReasonStrings[aReason]; } diff --git a/src/core/net/dnssd_server.cpp b/src/core/net/dnssd_server.cpp index 31c085351..67c8c41c3 100644 --- a/src/core/net/dnssd_server.cpp +++ b/src/core/net/dnssd_server.cpp @@ -737,12 +737,16 @@ const char *Server::Response::QueryTypeToString(QueryType aType) "A", // (5) kAQuery }; - static_assert(0 == kPtrQuery, "kPtrQuery value is incorrect"); - static_assert(1 == kSrvQuery, "kSrvQuery value is incorrect"); - static_assert(2 == kTxtQuery, "kTxtQuery value is incorrect"); - static_assert(3 == kSrvTxtQuery, "kSrvTxtQuery value is incorrect"); - static_assert(4 == kAaaaQuery, "kAaaaQuery value is incorrect"); - static_assert(5 == kAQuery, "kAQuery value is incorrect"); + struct EumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kPtrQuery); + ValidateNextEnum(kSrvQuery); + ValidateNextEnum(kTxtQuery); + ValidateNextEnum(kSrvTxtQuery); + ValidateNextEnum(kAaaaQuery); + ValidateNextEnum(kAQuery); + }; return kTypeNames[aType]; } diff --git a/src/core/net/ip6.cpp b/src/core/net/ip6.cpp index c6f028c0f..8ccb3c7ee 100644 --- a/src/core/net/ip6.cpp +++ b/src/core/net/ip6.cpp @@ -1488,10 +1488,14 @@ const char *Ip6::EcnToString(Ecn aEcn) "ce", // (3) kEcnMarked (Congestion Encountered) }; - static_assert(0 == kEcnNotCapable, "kEcnNotCapable value is incorrect"); - static_assert(1 == kEcnCapable1, "kEcnCapable1 value is incorrect"); - static_assert(2 == kEcnCapable0, "kEcnCapable0 value is incorrect"); - static_assert(3 == kEcnMarked, "kEcnMarked value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kEcnNotCapable); + ValidateNextEnum(kEcnCapable1); + ValidateNextEnum(kEcnCapable0); + ValidateNextEnum(kEcnMarked); + }; return kEcnStrings[aEcn]; } diff --git a/src/core/net/nat64_translator.cpp b/src/core/net/nat64_translator.cpp index 7541f22e0..c1ffa733b 100644 --- a/src/core/net/nat64_translator.cpp +++ b/src/core/net/nat64_translator.cpp @@ -51,10 +51,14 @@ const char *StateToString(State aState) "Active", }; - static_assert(0 == kStateDisabled, "kStateDisabled value is incorrect"); - static_assert(1 == kStateNotRunning, "kStateNotRunning value is incorrect"); - static_assert(2 == kStateIdle, "kStateIdle value is incorrect"); - static_assert(3 == kStateActive, "kStateActive value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateDisabled); + ValidateNextEnum(kStateNotRunning); + ValidateNextEnum(kStateIdle); + ValidateNextEnum(kStateActive); + }; return kStateString[aState]; } diff --git a/src/core/net/srp_client.cpp b/src/core/net/srp_client.cpp index 91a8d9aa8..b7150ff7f 100644 --- a/src/core/net/srp_client.cpp +++ b/src/core/net/srp_client.cpp @@ -181,12 +181,16 @@ const uint32_t Client::TxJitter::kMaxJitters[] = { void Client::TxJitter::Request(Reason aReason) { - static_assert(0 == kOnDeviceReboot, "kOnDeviceReboot value is incorrect"); - static_assert(1 == kOnServerStart, "kOnServerStart value is incorrect"); - static_assert(2 == kOnServerRestart, "kOnServerRestart value is incorrect"); - static_assert(3 == kOnServerSwitch, "kOnServerSwitch value is incorrect"); - static_assert(4 == kOnSlaacAddrAdd, "kOnSlaacAddrAdd value is incorrect"); - static_assert(5 == kOnSlaacAddrRemove, "kOnSlaacAddrRemove value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kOnDeviceReboot); + ValidateNextEnum(kOnServerStart); + ValidateNextEnum(kOnServerRestart); + ValidateNextEnum(kOnServerSwitch); + ValidateNextEnum(kOnSlaacAddrAdd); + ValidateNextEnum(kOnSlaacAddrRemove); + }; uint32_t maxJitter = kMaxJitters[aReason]; @@ -246,12 +250,16 @@ const char *Client::TxJitter::ReasonToString(Reason aReason) "OnSlaacAddrRemove", // (5) kOnSlaacAddrRemove }; - static_assert(0 == kOnDeviceReboot, "kOnDeviceReboot value is incorrect"); - static_assert(1 == kOnServerStart, "kOnServerStart value is incorrect"); - static_assert(2 == kOnServerRestart, "kOnServerRestart value is incorrect"); - static_assert(3 == kOnServerSwitch, "kOnServerSwitch value is incorrect"); - static_assert(4 == kOnSlaacAddrAdd, "kOnSlaacAddrAdd value is incorrect"); - static_assert(5 == kOnSlaacAddrRemove, "kOnSlaacAddrRemove value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kOnDeviceReboot); + ValidateNextEnum(kOnServerStart); + ValidateNextEnum(kOnServerRestart); + ValidateNextEnum(kOnServerSwitch); + ValidateNextEnum(kOnSlaacAddrAdd); + ValidateNextEnum(kOnSlaacAddrRemove); + }; return kReasonStrings[aReason]; } @@ -315,12 +323,16 @@ const char *Client::AutoStart::StateToString(State aState) "Unicast", // (5) kSelectedUnicast }; - static_assert(0 == kDisabled, "kDisabled value is incorrect"); - static_assert(1 == kFirstTimeSelecting, "kFirstTimeSelecting value is incorrect"); - static_assert(2 == kReselecting, "kReselecting value is incorrect"); - static_assert(3 == kSelectedUnicastPreferred, "kSelectedUnicastPreferred value is incorrect"); - static_assert(4 == kSelectedAnycast, "kSelectedAnycast value is incorrect"); - static_assert(5 == kSelectedUnicast, "kSelectedUnicast value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kDisabled); + ValidateNextEnum(kFirstTimeSelecting); + ValidateNextEnum(kReselecting); + ValidateNextEnum(kSelectedUnicastPreferred); + ValidateNextEnum(kSelectedAnycast); + ValidateNextEnum(kSelectedUnicast); + }; return kStateStrings[aState]; } @@ -359,22 +371,26 @@ Client::Client(Instance &aInstance) , mGuardTimer(aInstance) #endif { - mHostInfo.Init(); - // The `Client` implementation uses different constant array of // `ItemState` to define transitions between states in `Pause()`, // `Stop()`, `SendUpdate`, and `ProcessResponse()`, or to convert // an `ItemState` to string. Here, we assert that the enumeration // values are correct. - static_assert(kToAdd == 0, "kToAdd value is not correct"); - static_assert(kAdding == 1, "kAdding value is not correct"); - static_assert(kToRefresh == 2, "kToRefresh value is not correct"); - static_assert(kRefreshing == 3, "kRefreshing value is not correct"); - static_assert(kToRemove == 4, "kToRemove value is not correct"); - static_assert(kRemoving == 5, "kRemoving value is not correct"); - static_assert(kRegistered == 6, "kRegistered value is not correct"); - static_assert(kRemoved == 7, "kRemoved value is not correct"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kToAdd); + ValidateNextEnum(kAdding); + ValidateNextEnum(kToRefresh); + ValidateNextEnum(kRefreshing); + ValidateNextEnum(kToRemove); + ValidateNextEnum(kRemoving); + ValidateNextEnum(kRegistered); + ValidateNextEnum(kRemoved); + }; + + mHostInfo.Init(); } Error Client::Start(const Ip6::SockAddr &aServerSockAddr, Requester aRequester) @@ -2554,12 +2570,16 @@ const char *Client::StateToString(State aState) "ToRetry", // kStateToRetry (5) }; - static_assert(kStateStopped == 0, "kStateStopped value is not correct"); - static_assert(kStatePaused == 1, "kStatePaused value is not correct"); - static_assert(kStateToUpdate == 2, "kStateToUpdate value is not correct"); - static_assert(kStateUpdating == 3, "kStateUpdating value is not correct"); - static_assert(kStateUpdated == 4, "kStateUpdated value is not correct"); - static_assert(kStateToRetry == 5, "kStateToRetry value is not correct"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateStopped); + ValidateNextEnum(kStatePaused); + ValidateNextEnum(kStateToUpdate); + ValidateNextEnum(kStateUpdating); + ValidateNextEnum(kStateUpdated); + ValidateNextEnum(kStateToRetry); + }; return kStateStrings[aState]; } diff --git a/src/core/net/srp_server.cpp b/src/core/net/srp_server.cpp index a673f90a5..cfa703325 100644 --- a/src/core/net/srp_server.cpp +++ b/src/core/net/srp_server.cpp @@ -1719,8 +1719,12 @@ const char *Server::AddressModeToString(AddressMode aMode) "anycast", // (1) kAddressModeAnycast }; - static_assert(kAddressModeUnicast == 0, "kAddressModeUnicast value is incorrect"); - static_assert(kAddressModeAnycast == 1, "kAddressModeAnycast value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kAddressModeUnicast); + ValidateNextEnum(kAddressModeAnycast); + }; return kAddressModeStrings[aMode]; } @@ -1931,13 +1935,17 @@ void Server::Service::Log(Action aAction) const "KEY LEASE expired for", // (6) kKeyLeaseExpired }; - static_assert(0 == kAddNew, "kAddNew value is incorrect"); - static_assert(1 == kUpdateExisting, "kUpdateExisting value is incorrect"); - static_assert(2 == kKeepUnchanged, "kKeepUnchanged value is incorrect"); - static_assert(3 == kRemoveButRetainName, "kRemoveButRetainName value is incorrect"); - static_assert(4 == kFullyRemove, "kFullyRemove value is incorrect"); - static_assert(5 == kLeaseExpired, "kLeaseExpired value is incorrect"); - static_assert(6 == kKeyLeaseExpired, "kKeyLeaseExpired value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kAddNew); + ValidateNextEnum(kUpdateExisting); + ValidateNextEnum(kKeepUnchanged); + ValidateNextEnum(kRemoveButRetainName); + ValidateNextEnum(kFullyRemove); + ValidateNextEnum(kLeaseExpired); + ValidateNextEnum(kKeyLeaseExpired); + }; // We only log if the `Service` is marked as committed. This // ensures that temporary `Service` entries associated with a diff --git a/src/core/radio/trel_link.cpp b/src/core/radio/trel_link.cpp index 63030d83a..4b29151d5 100644 --- a/src/core/radio/trel_link.cpp +++ b/src/core/radio/trel_link.cpp @@ -471,10 +471,14 @@ const char *Link::StateToString(State aState) "Transmit", // (3) kStateTransmit }; - static_assert(0 == kStateDisabled, "kStateDisabled value is incorrect"); - static_assert(1 == kStateSleep, "kStateSleep value is incorrect"); - static_assert(2 == kStateReceive, "kStateReceive value is incorrect"); - static_assert(3 == kStateTransmit, "kStateTransmit value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateDisabled); + ValidateNextEnum(kStateSleep); + ValidateNextEnum(kStateReceive); + ValidateNextEnum(kStateTransmit); + }; return kStateStrings[aState]; } diff --git a/src/core/thread/address_resolver.cpp b/src/core/thread/address_resolver.cpp index 959651051..44729e8d0 100644 --- a/src/core/thread/address_resolver.cpp +++ b/src/core/thread/address_resolver.cpp @@ -1091,18 +1091,26 @@ void AddressResolver::LogCacheEntryChange(EntryChange aChange, "removing eid", // (7) kReasonRemovingEid }; - static_assert(0 == kEntryAdded, "kEntryAdded value is incorrect"); - static_assert(1 == kEntryUpdated, "kEntryUpdated value is incorrect"); - static_assert(2 == kEntryRemoved, "kEntryRemoved value is incorrect"); + struct ChangeEnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kEntryAdded); + ValidateNextEnum(kEntryUpdated); + ValidateNextEnum(kEntryRemoved); + }; - static_assert(0 == kReasonQueryRequest, "kReasonQueryRequest value is incorrect"); - static_assert(1 == kReasonSnoop, "kReasonSnoop value is incorrect"); - static_assert(2 == kReasonReceivedNotification, "kReasonReceivedNotification value is incorrect"); - static_assert(3 == kReasonRemovingRouterId, "kReasonRemovingRouterId value is incorrect"); - static_assert(4 == kReasonRemovingRloc16, "kReasonRemovingRloc16 value is incorrect"); - static_assert(5 == kReasonReceivedIcmpDstUnreachNoRoute, "kReasonReceivedIcmpDstUnreachNoRoute value is incorrect"); - static_assert(6 == kReasonEvictingForNewEntry, "kReasonEvictingForNewEntry value is incorrect"); - static_assert(7 == kReasonRemovingEid, "kReasonRemovingEid value is incorrect"); + struct ReasonEnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kReasonQueryRequest); + ValidateNextEnum(kReasonSnoop); + ValidateNextEnum(kReasonReceivedNotification); + ValidateNextEnum(kReasonRemovingRouterId); + ValidateNextEnum(kReasonRemovingRloc16); + ValidateNextEnum(kReasonReceivedIcmpDstUnreachNoRoute); + ValidateNextEnum(kReasonEvictingForNewEntry); + ValidateNextEnum(kReasonRemovingEid); + }; LogInfo("Cache entry %s: %s, 0x%04x%s%s - %s", kChangeStrings[aChange], aEntry.GetTarget().ToString().AsCString(), aEntry.GetRloc16(), (aList == nullptr) ? "" : ", list:", ListToString(aList), kReasonStrings[aReason]); diff --git a/src/core/thread/link_quality.cpp b/src/core/thread/link_quality.cpp index 738062dad..88ba7910e 100644 --- a/src/core/thread/link_quality.cpp +++ b/src/core/thread/link_quality.cpp @@ -225,10 +225,14 @@ uint8_t CostForLinkQuality(LinkQuality aLinkQuality) kCostForLinkQuality3, // Link cost for `kLinkQuality3` (3). }; - static_assert(kLinkQuality0 == 0, "kLinkQuality0 is invalid"); - static_assert(kLinkQuality1 == 1, "kLinkQuality1 is invalid"); - static_assert(kLinkQuality2 == 2, "kLinkQuality2 is invalid"); - static_assert(kLinkQuality3 == 3, "kLinkQuality3 is invalid"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kLinkQuality0); + ValidateNextEnum(kLinkQuality1); + ValidateNextEnum(kLinkQuality2); + ValidateNextEnum(kLinkQuality3); + }; uint8_t cost = Mle::kMaxRouteCost; diff --git a/src/core/thread/mle.cpp b/src/core/thread/mle.cpp index b2bd0a57d..dd8b03511 100644 --- a/src/core/thread/mle.cpp +++ b/src/core/thread/mle.cpp @@ -3979,10 +3979,14 @@ const char *Mle::MessageActionToString(MessageAction aAction) "Remove Delayed", // (3) kMessageRemoveDelayed }; - static_assert(kMessageSend == 0, "kMessageSend value is incorrect"); - static_assert(kMessageReceive == 1, "kMessageReceive value is incorrect"); - static_assert(kMessageDelay == 2, "kMessageDelay value is incorrect"); - static_assert(kMessageRemoveDelayed == 3, "kMessageRemoveDelayed value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kMessageSend); + ValidateNextEnum(kMessageReceive); + ValidateNextEnum(kMessageDelay); + ValidateNextEnum(kMessageRemoveDelayed); + }; return kMessageActionStrings[aAction]; } @@ -4030,10 +4034,9 @@ const char *Mle::MessageTypeToString(MessageType aType) #endif }; - struct MessageTypeChecker + struct EnumCheck { InitEnumValidatorCounter(); - ValidateNextEnum(kTypeAdvertisement); ValidateNextEnum(kTypeAnnounce); ValidateNextEnum(kTypeChildIdRequest); @@ -4130,11 +4133,15 @@ const char *Mle::AttachModeToString(AttachMode aMode) "BetterParent", // (4) kBetterParent }; - static_assert(kAnyPartition == 0, "kAnyPartition value is incorrect"); - static_assert(kSamePartition == 1, "kSamePartition value is incorrect"); - static_assert(kBetterPartition == 2, "kBetterPartition value is incorrect"); - static_assert(kDowngradeToReed == 3, "kDowngradeToReed value is incorrect"); - static_assert(kBetterParent == 4, "kBetterParent value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kAnyPartition); + ValidateNextEnum(kSamePartition); + ValidateNextEnum(kBetterPartition); + ValidateNextEnum(kDowngradeToReed); + ValidateNextEnum(kBetterParent); + }; return kAttachModeStrings[aMode]; } @@ -4150,12 +4157,16 @@ const char *Mle::AttachStateToString(AttachState aState) "ChildIdReq", // (5) kAttachStateChildIdRequest }; - static_assert(kAttachStateIdle == 0, "kAttachStateIdle value is incorrect"); - static_assert(kAttachStateProcessAnnounce == 1, "kAttachStateProcessAnnounce value is incorrect"); - static_assert(kAttachStateStart == 2, "kAttachStateStart value is incorrect"); - static_assert(kAttachStateParentRequest == 3, "kAttachStateParentRequest value is incorrect"); - static_assert(kAttachStateAnnounce == 4, "kAttachStateAnnounce value is incorrect"); - static_assert(kAttachStateChildIdRequest == 5, "kAttachStateChildIdRequest value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kAttachStateIdle); + ValidateNextEnum(kAttachStateProcessAnnounce); + ValidateNextEnum(kAttachStateStart); + ValidateNextEnum(kAttachStateParentRequest); + ValidateNextEnum(kAttachStateAnnounce); + ValidateNextEnum(kAttachStateChildIdRequest); + }; return kAttachStateStrings[aState]; } @@ -4169,10 +4180,14 @@ const char *Mle::ReattachStateToString(ReattachState aState) "reattaching with Pending Dataset", // (3) kReattachPending }; - static_assert(kReattachStop == 0, "kReattachStop value is incorrect"); - static_assert(kReattachStart == 1, "kReattachStart value is incorrect"); - static_assert(kReattachActive == 2, "kReattachActive value is incorrect"); - static_assert(kReattachPending == 3, "kReattachPending value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kReattachStop); + ValidateNextEnum(kReattachStart); + ValidateNextEnum(kReattachActive); + ValidateNextEnum(kReattachPending); + }; return kReattachStateStrings[aState]; } diff --git a/src/core/thread/mle_types.cpp b/src/core/thread/mle_types.cpp index 9d61bbe12..f94aa203c 100644 --- a/src/core/thread/mle_types.cpp +++ b/src/core/thread/mle_types.cpp @@ -37,6 +37,7 @@ #include "common/code_utils.hpp" #include "common/message.hpp" #include "common/random.hpp" +#include "utils/static_counter.hpp" namespace ot { namespace Mle { @@ -99,10 +100,14 @@ uint8_t DeviceProperties::CalculateLeaderWeight(void) const kPowerExternalUnstableInc, // (3) kPowerSupplyExternalUnstable }; - static_assert(0 == kPowerSupplyBattery, "kPowerSupplyBattery value is incorrect"); - static_assert(1 == kPowerSupplyExternal, "kPowerSupplyExternal value is incorrect"); - static_assert(2 == kPowerSupplyExternalStable, "kPowerSupplyExternalStable value is incorrect"); - static_assert(3 == kPowerSupplyExternalUnstable, "kPowerSupplyExternalUnstable value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kPowerSupplyBattery); + ValidateNextEnum(kPowerSupplyExternal); + ValidateNextEnum(kPowerSupplyExternalStable); + ValidateNextEnum(kPowerSupplyExternalUnstable); + }; uint8_t weight = kBaseWeight; PowerSupply powerSupply = MapEnum(mPowerSupply); @@ -195,11 +200,15 @@ const char *RoleToString(DeviceRole aRole) "leader", // (4) kRoleLeader }; - static_assert(kRoleDisabled == 0, "kRoleDisabled value is incorrect"); - static_assert(kRoleDetached == 1, "kRoleDetached value is incorrect"); - static_assert(kRoleChild == 2, "kRoleChild value is incorrect"); - static_assert(kRoleRouter == 3, "kRoleRouter value is incorrect"); - static_assert(kRoleLeader == 4, "kRoleLeader value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kRoleDisabled); + ValidateNextEnum(kRoleDetached); + ValidateNextEnum(kRoleChild); + ValidateNextEnum(kRoleRouter); + ValidateNextEnum(kRoleLeader); + }; return (aRole < GetArrayLength(kRoleStrings)) ? kRoleStrings[aRole] : "invalid"; } diff --git a/src/core/thread/neighbor.cpp b/src/core/thread/neighbor.cpp index 3b11fbd5a..804ed4cfa 100644 --- a/src/core/thread/neighbor.cpp +++ b/src/core/thread/neighbor.cpp @@ -241,14 +241,18 @@ const char *Neighbor::StateToString(State aState) "Valid", // (7) kStateValid }; - static_assert(0 == kStateInvalid, "kStateInvalid value is incorrect"); - static_assert(1 == kStateRestored, "kStateRestored value is incorrect"); - static_assert(2 == kStateParentRequest, "kStateParentRequest value is incorrect"); - static_assert(3 == kStateParentResponse, "kStateParentResponse value is incorrect"); - static_assert(4 == kStateChildIdRequest, "kStateChildIdRequest value is incorrect"); - static_assert(5 == kStateLinkRequest, "kStateLinkRequest value is incorrect"); - static_assert(6 == kStateChildUpdateRequest, "kStateChildUpdateRequest value is incorrect"); - static_assert(7 == kStateValid, "kStateValid value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kStateInvalid); + ValidateNextEnum(kStateRestored); + ValidateNextEnum(kStateParentRequest); + ValidateNextEnum(kStateParentResponse); + ValidateNextEnum(kStateChildIdRequest); + ValidateNextEnum(kStateLinkRequest); + ValidateNextEnum(kStateChildUpdateRequest); + ValidateNextEnum(kStateValid); + }; return kStateStrings[aState]; } diff --git a/src/core/thread/network_data_publisher.cpp b/src/core/thread/network_data_publisher.cpp index 946d34567..3977ad194 100644 --- a/src/core/thread/network_data_publisher.cpp +++ b/src/core/thread/network_data_publisher.cpp @@ -470,11 +470,15 @@ const char *Publisher::Entry::StateToString(State aState) "Removing", // (4) kRemoving }; - static_assert(0 == kNoEntry, "kNoEntry value is not correct"); - static_assert(1 == kToAdd, "kToAdd value is not correct"); - static_assert(2 == kAdding, "kAdding value is not correct"); - static_assert(3 == kAdded, "kAdded value is not correct"); - static_assert(4 == kRemoving, "kRemoving value is not correct"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kNoEntry); + ValidateNextEnum(kToAdd); + ValidateNextEnum(kAdding); + ValidateNextEnum(kAdded); + ValidateNextEnum(kRemoving); + }; return kStateStrings[aState]; } diff --git a/src/core/thread/uri_paths.cpp b/src/core/thread/uri_paths.cpp index b203eb014..765718d31 100644 --- a/src/core/thread/uri_paths.cpp +++ b/src/core/thread/uri_paths.cpp @@ -97,46 +97,50 @@ static constexpr Entry kEntries[] = { static_assert(BinarySearch::IsSorted(kEntries), "kEntries is not sorted"); -static_assert(0 == kUriAddressError, "kUriAddressError (`a/ae`) is invalid"); -static_assert(1 == kUriAddressNotify, "kUriAddressNotify (`a/an`) is invalid"); -static_assert(2 == kUriAddressQuery, "kUriAddressQuery (`a/aq`) is invalid"); -static_assert(3 == kUriAddressRelease, "kUriAddressRelease (`a/ar`) is invalid"); -static_assert(4 == kUriAddressSolicit, "kUriAddressSolicit (`a/as`) is invalid"); -static_assert(5 == kUriServerData, "kUriServerData (`a/sd`) is invalid"); -static_assert(6 == kUriAnycastLocate, "kUriAnycastLocate (`a/yl`) is invalid"); -static_assert(7 == kUriBackboneAnswer, "kUriBackboneAnswer (`b/ba`) is invalid"); -static_assert(8 == kUriBackboneMlr, "kUriBackboneMlr (`b/bmr`) is invalid"); -static_assert(9 == kUriBackboneQuery, "kUriBackboneQuery (`b/bq`) is invalid"); -static_assert(10 == kUriAnnounceBegin, "kUriAnnounceBegin (`c/ab`) is invalid"); -static_assert(11 == kUriActiveGet, "kUriActiveGet (`c/ag`) is invalid"); -static_assert(12 == kUriActiveReplace, "kUriActiveReplace (`c/ar`) is invalid"); -static_assert(13 == kUriActiveSet, "kUriActiveSet (`c/as`) is invalid"); -static_assert(14 == kUriCommissionerKeepAlive, "kUriCommissionerKeepAlive (`c/ca`) is invalid"); -static_assert(15 == kUriCommissionerGet, "kUriCommissionerGet (`c/cg`) is invalid"); -static_assert(16 == kUriCommissionerPetition, "kUriCommissionerPetition (`c/cp`) is invalid"); -static_assert(17 == kUriCommissionerSet, "kUriCommissionerSet (`c/cs`) is invalid"); -static_assert(18 == kUriDatasetChanged, "kUriDatasetChanged (`c/dc`) is invalid"); -static_assert(19 == kUriEnergyReport, "kUriEnergyReport (`c/er`) is invalid"); -static_assert(20 == kUriEnergyScan, "kUriEnergyScan (`c/es`) is invalid"); -static_assert(21 == kUriJoinerEntrust, "kUriJoinerEntrust (`c/je`) is invalid"); -static_assert(22 == kUriJoinerFinalize, "kUriJoinerFinalize (`c/jf`) is invalid"); -static_assert(23 == kUriLeaderKeepAlive, "kUriLeaderKeepAlive (`c/la`) is invalid"); -static_assert(24 == kUriLeaderPetition, "kUriLeaderPetition (`c/lp`) is invalid"); -static_assert(25 == kUriPanIdConflict, "kUriPanIdConflict (`c/pc`) is invalid"); -static_assert(26 == kUriPendingGet, "kUriPendingGet (`c/pg`) is invalid"); -static_assert(27 == kUriPanIdQuery, "kUriPanIdQuery (`c/pq`) is invalid"); -static_assert(28 == kUriPendingSet, "kUriPendingSet (`c/ps`) is invalid"); -static_assert(29 == kUriRelayRx, "kUriRelayRx (`c/rx`) is invalid"); -static_assert(30 == kUriRelayTx, "kUriRelayTx (`c/tx`) is invalid"); -static_assert(31 == kUriProxyRx, "kUriProxyRx (`c/ur`) is invalid"); -static_assert(32 == kUriProxyTx, "kUriProxyTx (`c/ut`) is invalid"); -static_assert(33 == kUriDiagnosticGetAnswer, "kUriDiagnosticGetAnswer (`d/da`) is invalid"); -static_assert(34 == kUriDiagnosticGetRequest, "kUriDiagnosticGetRequest (`d/dg`) is invalid"); -static_assert(35 == kUriDiagnosticGetQuery, "kUriDiagnosticGetQuery (`d/dq`) is invalid"); -static_assert(36 == kUriDiagnosticReset, "kUriDiagnosticReset (`d/dr`) is invalid"); -static_assert(37 == kUriDuaRegistrationNotify, "kUriDuaRegistrationNotify (`n/dn`) is invalid"); -static_assert(38 == kUriDuaRegistrationRequest, "kUriDuaRegistrationRequest (`n/dr`) is invalid"); -static_assert(39 == kUriMlr, "kUriMlr (`n/mr`) is invalid"); +struct UriEnumCheck +{ + InitEnumValidatorCounter(); + ValidateNextEnum(kUriAddressError); + ValidateNextEnum(kUriAddressNotify); + ValidateNextEnum(kUriAddressQuery); + ValidateNextEnum(kUriAddressRelease); + ValidateNextEnum(kUriAddressSolicit); + ValidateNextEnum(kUriServerData); + ValidateNextEnum(kUriAnycastLocate); + ValidateNextEnum(kUriBackboneAnswer); + ValidateNextEnum(kUriBackboneMlr); + ValidateNextEnum(kUriBackboneQuery); + ValidateNextEnum(kUriAnnounceBegin); + ValidateNextEnum(kUriActiveGet); + ValidateNextEnum(kUriActiveReplace); + ValidateNextEnum(kUriActiveSet); + ValidateNextEnum(kUriCommissionerKeepAlive); + ValidateNextEnum(kUriCommissionerGet); + ValidateNextEnum(kUriCommissionerPetition); + ValidateNextEnum(kUriCommissionerSet); + ValidateNextEnum(kUriDatasetChanged); + ValidateNextEnum(kUriEnergyReport); + ValidateNextEnum(kUriEnergyScan); + ValidateNextEnum(kUriJoinerEntrust); + ValidateNextEnum(kUriJoinerFinalize); + ValidateNextEnum(kUriLeaderKeepAlive); + ValidateNextEnum(kUriLeaderPetition); + ValidateNextEnum(kUriPanIdConflict); + ValidateNextEnum(kUriPendingGet); + ValidateNextEnum(kUriPanIdQuery); + ValidateNextEnum(kUriPendingSet); + ValidateNextEnum(kUriRelayRx); + ValidateNextEnum(kUriRelayTx); + ValidateNextEnum(kUriProxyRx); + ValidateNextEnum(kUriProxyTx); + ValidateNextEnum(kUriDiagnosticGetAnswer); + ValidateNextEnum(kUriDiagnosticGetRequest); + ValidateNextEnum(kUriDiagnosticGetQuery); + ValidateNextEnum(kUriDiagnosticReset); + ValidateNextEnum(kUriDuaRegistrationNotify); + ValidateNextEnum(kUriDuaRegistrationRequest); + ValidateNextEnum(kUriMlr); +}; } // namespace UriList diff --git a/src/core/utils/slaac_address.cpp b/src/core/utils/slaac_address.cpp index 3164d8593..b00f6334d 100644 --- a/src/core/utils/slaac_address.cpp +++ b/src/core/utils/slaac_address.cpp @@ -467,9 +467,13 @@ void Slaac::LogAddress(Action aAction, const SlaacAddress &aAddress) "Deprecating", // (2) kDeprecating }; - static_assert(kAdding == 0, "kAdding value is incorrect"); - static_assert(kRemoving == 1, "kRemoving value is incorrect"); - static_assert(kDeprecating == 2, "kDeprecating value is incorrect"); + struct EnumCheck + { + InitEnumValidatorCounter(); + ValidateNextEnum(kAdding); + ValidateNextEnum(kRemoving); + ValidateNextEnum(kDeprecating); + }; LogInfo("%s %s", kActionStrings[aAction], aAddress.GetAddress().ToString().AsCString()); } diff --git a/src/core/utils/static_counter.hpp b/src/core/utils/static_counter.hpp index 3c0713ab6..b688ff6ea 100644 --- a/src/core/utils/static_counter.hpp +++ b/src/core/utils/static_counter.hpp @@ -61,6 +61,8 @@ public: static_assert(kEnumartor == StaticCounterValue(), #kEnumartor " value is incorrect"); \ StaticCounterIncr() +#define SkipNextEnum() StaticCounterIncr() + } // namespace ot #endif // OT_UTILS_STATIC_COUNTER_HPP_