diff --git a/.clang-tidy b/.clang-tidy index a31de1d2..837fbf13 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -84,14 +84,15 @@ CheckOptions: - { key: readability-identifier-naming.EnumCase, value: CamelCase } - { key: readability-identifier-naming.EnumPrefix, value: SolidSyslog } - # Tier 1 — public enum constants on named (tagged) enums: SolidSyslogClass_Constant. - # Anonymous enums (Tier 1 public macro-equivalents and Tier 2 file-scope - # named-constant idiom) use SCREAMING_SNAKE — that is the project's macro - # shape and is accepted via the IgnoredRegexp below. Decided in S10.12; see - # docs/NAMING.md "Anonymous-enum named-constant idiom". - - { key: readability-identifier-naming.EnumConstantCase, value: aNy_CasE } - - { key: readability-identifier-naming.EnumConstantPrefix, value: SolidSyslog } - - { key: readability-identifier-naming.EnumConstantIgnoredRegexp, value: '^[A-Z][A-Z0-9_]*$' } + # Enum constants — SCREAMING_SNAKE tree-wide, no exceptions. + # Tagged public enums: SOLIDSYSLOG_CLASS_MEMBER + # Anonymous public enums: SOLIDSYSLOG_NAME (e.g. SOLIDSYSLOG_STREAM_SENDER_SIZE) + # Anonymous TU-local: NAME (e.g. IPV4_HEADER_BYTES) + # Single rule, mechanically enforced. SOLIDSYSLOG_ prefix on public sites + # is enforced by review + cppcheck-misra 5.4 distinctness (clang-tidy + # cannot distinguish public from TU-local enum constants syntactically). + # Decided in S10.22; see docs/NAMING.md "Enum constants". + - { key: readability-identifier-naming.EnumConstantCase, value: UPPER_CASE } # Tier 1 — public typedefs (enum / function-pointer only per NAMING.md): # SolidSyslogClass or SolidSyslogClass_Fn diff --git a/Bdd/Targets/FreeRtos/main.c b/Bdd/Targets/FreeRtos/main.c index c1032b61..98d5466b 100644 --- a/Bdd/Targets/FreeRtos/main.c +++ b/Bdd/Targets/FreeRtos/main.c @@ -144,8 +144,8 @@ static uint16_t port = (uint16_t) BDD_TARGET_UDP_PORT; static uint32_t endpointVersion = 0U; static struct SolidSyslogMessage testMessage = { - .Facility = SolidSyslogFacility_Local0, - .Severity = SolidSyslogSeverity_Informational, + .Facility = SOLIDSYSLOG_FACILITY_LOCAL0, + .Severity = SOLIDSYSLOG_SEVERITY_INFORMATIONAL, .MessageId = messageId, .Msg = msg, }; @@ -170,7 +170,7 @@ enum }; static SolidSyslogCircularBufferStorage - bufferStorage[SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE(BDD_TARGET_BUFFER_MESSAGES)]; + bufferStorage[SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE(BDD_TARGET_BUFFER_MESSAGES)]; static SolidSyslogFreeRtosMutexStorage mutexStorage; /* Lifecycle mutex serialises SolidSyslog_Service against the rebuild path @@ -537,13 +537,13 @@ static enum SolidSyslogDiscardPolicy MapDiscardPolicy(const char* policy) { if (strcmp(policy, "newest") == 0) { - return SolidSyslogDiscardPolicy_Newest; + return SOLIDSYSLOG_DISCARD_POLICY_NEWEST; } if (strcmp(policy, "halt") == 0) { - return SolidSyslogDiscardPolicy_Halt; + return SOLIDSYSLOG_DISCARD_POLICY_HALT; } - return SolidSyslogDiscardPolicy_Oldest; + return SOLIDSYSLOG_DISCARD_POLICY_OLDEST; } static void OnStoreFull(void* context) diff --git a/Bdd/Targets/Linux/BddTargetCommandLine.c b/Bdd/Targets/Linux/BddTargetCommandLine.c index 738c6625..a0bb1009 100644 --- a/Bdd/Targets/Linux/BddTargetCommandLine.c +++ b/Bdd/Targets/Linux/BddTargetCommandLine.c @@ -39,8 +39,8 @@ static bool IsValidDiscardPolicy(const char* policy) int BddTargetCommandLine_Parse(int argc, char* argv[], struct BddTargetOptions* options) { - options->Facility = SolidSyslogFacility_Local0; - options->Severity = SolidSyslogSeverity_Informational; + options->Facility = SOLIDSYSLOG_FACILITY_LOCAL0; + options->Severity = SOLIDSYSLOG_SEVERITY_INFORMATIONAL; options->MessageId = NULL; options->Msg = NULL; options->AppName = NULL; diff --git a/Bdd/Targets/Linux/main.c b/Bdd/Targets/Linux/main.c index e2afd0a2..81e998ab 100644 --- a/Bdd/Targets/Linux/main.c +++ b/Bdd/Targets/Linux/main.c @@ -113,13 +113,13 @@ static enum SolidSyslogDiscardPolicy MapDiscardPolicy(const char* policy) { if (strcmp(policy, "newest") == 0) { - return SolidSyslogDiscardPolicy_Newest; + return SOLIDSYSLOG_DISCARD_POLICY_NEWEST; } if (strcmp(policy, "halt") == 0) { - return SolidSyslogDiscardPolicy_Halt; + return SOLIDSYSLOG_DISCARD_POLICY_HALT; } - return SolidSyslogDiscardPolicy_Oldest; + return SOLIDSYSLOG_DISCARD_POLICY_OLDEST; } static volatile bool haltExit; diff --git a/Bdd/Targets/Windows/BddTargetWindows.c b/Bdd/Targets/Windows/BddTargetWindows.c index f95070f2..5d20d068 100644 --- a/Bdd/Targets/Windows/BddTargetWindows.c +++ b/Bdd/Targets/Windows/BddTargetWindows.c @@ -67,7 +67,7 @@ static const char* const THRESHOLD_MARKER_PATH = "Bdd/output/solidsyslog_thresho static SolidSyslogWinsockTcpStreamStorage tcpStreamStorage; static SolidSyslogStreamSenderStorage tcpSenderStorage; static SolidSyslogCircularBufferStorage - bufferStorage[SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE(BDD_TARGET_BUFFER_MESSAGES)]; + bufferStorage[SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE(BDD_TARGET_BUFFER_MESSAGES)]; static SolidSyslogWindowsMutexStorage mutexStorage; static SolidSyslogWindowsAtomicCounterStorage counterStorage; static volatile bool shutdownFlag; @@ -136,13 +136,13 @@ static enum SolidSyslogDiscardPolicy MapDiscardPolicy(const char* policy) { if (strcmp(policy, "newest") == 0) { - return SolidSyslogDiscardPolicy_Newest; + return SOLIDSYSLOG_DISCARD_POLICY_NEWEST; } if (strcmp(policy, "halt") == 0) { - return SolidSyslogDiscardPolicy_Halt; + return SOLIDSYSLOG_DISCARD_POLICY_HALT; } - return SolidSyslogDiscardPolicy_Oldest; + return SOLIDSYSLOG_DISCARD_POLICY_OLDEST; } static volatile bool haltExit; diff --git a/Bdd/Targets/Windows/BddTargetWindowsCommandLine.c b/Bdd/Targets/Windows/BddTargetWindowsCommandLine.c index a4d8a5f1..e638be5f 100644 --- a/Bdd/Targets/Windows/BddTargetWindowsCommandLine.c +++ b/Bdd/Targets/Windows/BddTargetWindowsCommandLine.c @@ -38,8 +38,8 @@ static bool ParsePositiveSize(const char* text, size_t* out) void BddTargetWindowsCommandLine_Parse(int argc, char* argv[], struct BddTargetWindowsOptions* options) { - options->Facility = SolidSyslogFacility_Local0; - options->Severity = SolidSyslogSeverity_Informational; + options->Facility = SOLIDSYSLOG_FACILITY_LOCAL0; + options->Severity = SOLIDSYSLOG_SEVERITY_INFORMATIONAL; options->Transport = "udp"; options->MessageId = NULL; options->Msg = NULL; diff --git a/Core/Interface/SolidSyslogBlockStore.h b/Core/Interface/SolidSyslogBlockStore.h index fd71f371..a44521d0 100644 --- a/Core/Interface/SolidSyslogBlockStore.h +++ b/Core/Interface/SolidSyslogBlockStore.h @@ -16,9 +16,9 @@ EXTERN_C_BEGIN enum SolidSyslogDiscardPolicy { - SolidSyslogDiscardPolicy_Oldest, - SolidSyslogDiscardPolicy_Newest, - SolidSyslogDiscardPolicy_Halt + SOLIDSYSLOG_DISCARD_POLICY_OLDEST, + SOLIDSYSLOG_DISCARD_POLICY_NEWEST, + SOLIDSYSLOG_DISCARD_POLICY_HALT }; typedef void (*SolidSyslogStoreFullCallback)(void* context); @@ -50,13 +50,13 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_BLOCKSTORE_STORAGE_SIZE = + SOLIDSYSLOG_BLOCK_STORE_STORAGE_SIZE = (sizeof(intptr_t) * 32U) + SOLIDSYSLOG_MAX_MESSAGE_SIZE + SOLIDSYSLOG_MAX_INTEGRITY_SIZE + 16U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_BLOCKSTORE_STORAGE_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_BLOCK_STORE_STORAGE_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogBlockStoreStorage; struct SolidSyslogStore* SolidSyslogBlockStore_Create( diff --git a/Core/Interface/SolidSyslogCircularBuffer.h b/Core/Interface/SolidSyslogCircularBuffer.h index 48e4ea04..0b5fcd99 100644 --- a/Core/Interface/SolidSyslogCircularBuffer.h +++ b/Core/Interface/SolidSyslogCircularBuffer.h @@ -17,19 +17,19 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_CIRCULARBUFFER_OVERHEAD = 7, - SOLIDSYSLOG_CIRCULARBUFFER_HEADER_BYTES = sizeof(uint16_t) + SOLIDSYSLOG_CIRCULAR_BUFFER_OVERHEAD = 7, + SOLIDSYSLOG_CIRCULAR_BUFFER_HEADER_BYTES = sizeof(uint16_t) }; /* NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -- cannot compute array size as a constexpr in C */ -#define SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE_BYTES(ringBytes) \ - (SOLIDSYSLOG_CIRCULARBUFFER_OVERHEAD + \ +#define SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE_BYTES(ringBytes) \ + (SOLIDSYSLOG_CIRCULAR_BUFFER_OVERHEAD + \ (((ringBytes) + sizeof(SolidSyslogCircularBufferStorage) - 1U) / sizeof(SolidSyslogCircularBufferStorage))) /* NOLINTNEXTLINE(cppcoreguidelines-macro-usage) -- cannot compute array size as a constexpr in C */ -#define SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE(maxMessages) \ - SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE_BYTES( \ - (size_t) (maxMessages) * (SOLIDSYSLOG_MAX_MESSAGE_SIZE + SOLIDSYSLOG_CIRCULARBUFFER_HEADER_BYTES) \ +#define SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE(maxMessages) \ + SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE_BYTES( \ + (size_t) (maxMessages) * (SOLIDSYSLOG_MAX_MESSAGE_SIZE + SOLIDSYSLOG_CIRCULAR_BUFFER_HEADER_BYTES) \ ) struct SolidSyslogBuffer* SolidSyslogCircularBuffer_Create( diff --git a/Core/Interface/SolidSyslogDatagram.h b/Core/Interface/SolidSyslogDatagram.h index 24ab5290..94ff5113 100644 --- a/Core/Interface/SolidSyslogDatagram.h +++ b/Core/Interface/SolidSyslogDatagram.h @@ -17,9 +17,9 @@ EXTERN_C_BEGIN * collapse it into Failed. */ enum SolidSyslogDatagramSendResult { - SolidSyslogDatagramSendResult_Sent, - SolidSyslogDatagramSendResult_Oversize, - SolidSyslogDatagramSendResult_Failed + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED }; bool SolidSyslogDatagram_Open(struct SolidSyslogDatagram * datagram); diff --git a/Core/Interface/SolidSyslogFileBlockDevice.h b/Core/Interface/SolidSyslogFileBlockDevice.h index 9c86e54a..4959d4ab 100644 --- a/Core/Interface/SolidSyslogFileBlockDevice.h +++ b/Core/Interface/SolidSyslogFileBlockDevice.h @@ -12,12 +12,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_FILEBLOCKDEVICE_STORAGE_SIZE = sizeof(intptr_t) * 16U + SOLIDSYSLOG_FILE_BLOCK_DEVICE_STORAGE_SIZE = sizeof(intptr_t) * 16U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_FILEBLOCKDEVICE_STORAGE_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_FILE_BLOCK_DEVICE_STORAGE_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogFileBlockDeviceStorage; /* The driver caches at most one open SolidSyslogFile handle, re-pointed only when the diff --git a/Core/Interface/SolidSyslogPrival.h b/Core/Interface/SolidSyslogPrival.h index 690a2fac..51a04c64 100644 --- a/Core/Interface/SolidSyslogPrival.h +++ b/Core/Interface/SolidSyslogPrival.h @@ -7,42 +7,42 @@ EXTERN_C_BEGIN enum SolidSyslogFacility { - SolidSyslogFacility_Kern = 0, - SolidSyslogFacility_User = 1, - SolidSyslogFacility_Mail = 2, - SolidSyslogFacility_Daemon = 3, - SolidSyslogFacility_Auth = 4, - SolidSyslogFacility_Syslog = 5, - SolidSyslogFacility_Lpr = 6, - SolidSyslogFacility_News = 7, - SolidSyslogFacility_Uucp = 8, - SolidSyslogFacility_Cron = 9, - SolidSyslogFacility_AuthPriv = 10, - SolidSyslogFacility_Ftp = 11, - SolidSyslogFacility_Ntp = 12, - SolidSyslogFacility_Audit = 13, - SolidSyslogFacility_Alert = 14, - SolidSyslogFacility_Clock = 15, - SolidSyslogFacility_Local0 = 16, - SolidSyslogFacility_Local1 = 17, - SolidSyslogFacility_Local2 = 18, - SolidSyslogFacility_Local3 = 19, - SolidSyslogFacility_Local4 = 20, - SolidSyslogFacility_Local5 = 21, - SolidSyslogFacility_Local6 = 22, - SolidSyslogFacility_Local7 = 23 + SOLIDSYSLOG_FACILITY_KERN = 0, + SOLIDSYSLOG_FACILITY_USER = 1, + SOLIDSYSLOG_FACILITY_MAIL = 2, + SOLIDSYSLOG_FACILITY_DAEMON = 3, + SOLIDSYSLOG_FACILITY_AUTH = 4, + SOLIDSYSLOG_FACILITY_SYSLOG = 5, + SOLIDSYSLOG_FACILITY_LPR = 6, + SOLIDSYSLOG_FACILITY_NEWS = 7, + SOLIDSYSLOG_FACILITY_UUCP = 8, + SOLIDSYSLOG_FACILITY_CRON = 9, + SOLIDSYSLOG_FACILITY_AUTH_PRIV = 10, + SOLIDSYSLOG_FACILITY_FTP = 11, + SOLIDSYSLOG_FACILITY_NTP = 12, + SOLIDSYSLOG_FACILITY_AUDIT = 13, + SOLIDSYSLOG_FACILITY_ALERT = 14, + SOLIDSYSLOG_FACILITY_CLOCK = 15, + SOLIDSYSLOG_FACILITY_LOCAL0 = 16, + SOLIDSYSLOG_FACILITY_LOCAL1 = 17, + SOLIDSYSLOG_FACILITY_LOCAL2 = 18, + SOLIDSYSLOG_FACILITY_LOCAL3 = 19, + SOLIDSYSLOG_FACILITY_LOCAL4 = 20, + SOLIDSYSLOG_FACILITY_LOCAL5 = 21, + SOLIDSYSLOG_FACILITY_LOCAL6 = 22, + SOLIDSYSLOG_FACILITY_LOCAL7 = 23 }; enum SolidSyslogSeverity { - SolidSyslogSeverity_Emergency = 0, - SolidSyslogSeverity_Alert = 1, - SolidSyslogSeverity_Critical = 2, - SolidSyslogSeverity_Error = 3, - SolidSyslogSeverity_Warning = 4, - SolidSyslogSeverity_Notice = 5, - SolidSyslogSeverity_Informational = 6, - SolidSyslogSeverity_Debug = 7 + SOLIDSYSLOG_SEVERITY_EMERGENCY = 0, + SOLIDSYSLOG_SEVERITY_ALERT = 1, + SOLIDSYSLOG_SEVERITY_CRITICAL = 2, + SOLIDSYSLOG_SEVERITY_ERROR = 3, + SOLIDSYSLOG_SEVERITY_WARNING = 4, + SOLIDSYSLOG_SEVERITY_NOTICE = 5, + SOLIDSYSLOG_SEVERITY_INFORMATIONAL = 6, + SOLIDSYSLOG_SEVERITY_DEBUG = 7 }; EXTERN_C_END diff --git a/Core/Interface/SolidSyslogTransport.h b/Core/Interface/SolidSyslogTransport.h index 1eb4da67..05eb7b5f 100644 --- a/Core/Interface/SolidSyslogTransport.h +++ b/Core/Interface/SolidSyslogTransport.h @@ -10,8 +10,8 @@ enum enum SolidSyslogTransport { - SolidSyslogTransport_Udp, - SolidSyslogTransport_Tcp + SOLIDSYSLOG_TRANSPORT_UDP, + SOLIDSYSLOG_TRANSPORT_TCP }; #endif /* SOLIDSYSLOGTRANSPORT_H */ diff --git a/Core/Source/BlockSequence.c b/Core/Source/BlockSequence.c index 500606ca..b2d59f14 100644 --- a/Core/Source/BlockSequence.c +++ b/Core/Source/BlockSequence.c @@ -229,12 +229,12 @@ static inline bool BlockSequence_BlockIsFull(const struct BlockSequence* blockSe static inline bool BlockSequence_StoreIsFull(const struct BlockSequence* blockSequence) { return (BlockSequence_BlockCount(blockSequence) >= blockSequence->MaxBlocks) && - (blockSequence->DiscardPolicy != SolidSyslogDiscardPolicy_Oldest); + (blockSequence->DiscardPolicy != SOLIDSYSLOG_DISCARD_POLICY_OLDEST); } static inline void BlockSequence_NotifyStoreFull(struct BlockSequence* blockSequence) { - if ((blockSequence->DiscardPolicy == SolidSyslogDiscardPolicy_Halt) && !blockSequence->Halted) + if ((blockSequence->DiscardPolicy == SOLIDSYSLOG_DISCARD_POLICY_HALT) && !blockSequence->Halted) { blockSequence->Halted = true; diff --git a/Core/Source/SolidSyslog.c b/Core/Source/SolidSyslog.c index 74cd9217..a191bdaf 100644 --- a/Core/Source/SolidSyslog.c +++ b/Core/Source/SolidSyslog.c @@ -135,11 +135,11 @@ void SolidSyslog_Create(const struct SolidSyslogConfig* config) { if (instanceInitialised) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_CREATE_ALREADY_INITIALISED); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_CREATE_ALREADY_INITIALISED); } else if (config == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_CONFIG); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_CONFIG); } else { @@ -165,7 +165,7 @@ static void SolidSyslog_InstallBuffer(struct SolidSyslogBuffer* configured) { if (configured == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_BUFFER); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_BUFFER); } else { @@ -177,7 +177,7 @@ static void SolidSyslog_InstallSender(struct SolidSyslogSender* configured) { if (configured == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_SENDER); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_SENDER); } else { @@ -189,7 +189,7 @@ static void SolidSyslog_InstallStore(struct SolidSyslogStore* configured) { if (configured == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_STORE); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_CREATE_NULL_STORE); } else { @@ -301,7 +301,7 @@ void SolidSyslog_Log(const struct SolidSyslogMessage* message) { if (message == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_LOG_NULL_MESSAGE); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_LOG_NULL_MESSAGE); } else { @@ -347,7 +347,7 @@ static inline uint8_t SolidSyslog_MakePrival(const struct SolidSyslogMessage* me { uint8_t f = (uint8_t) message->Facility; uint8_t s = (uint8_t) message->Severity; - uint8_t prival = SolidSyslog_CombineFacilityAndSeverity(SolidSyslogFacility_Syslog, SolidSyslogSeverity_Error); + uint8_t prival = SolidSyslog_CombineFacilityAndSeverity(SOLIDSYSLOG_FACILITY_SYSLOG, SOLIDSYSLOG_SEVERITY_ERROR); if (SolidSyslog_PrivalComponentsAreValid(f, s)) { @@ -369,12 +369,12 @@ static inline bool SolidSyslog_PrivalComponentsAreValid(uint8_t facility, uint8_ static inline bool SolidSyslog_FacilityIsValid(uint8_t facility) { - return facility <= (uint8_t) SolidSyslogFacility_Local7; + return facility <= (uint8_t) SOLIDSYSLOG_FACILITY_LOCAL7; } static inline bool SolidSyslog_SeverityIsValid(uint8_t severity) { - return severity <= (uint8_t) SolidSyslogSeverity_Debug; + return severity <= (uint8_t) SOLIDSYSLOG_SEVERITY_DEBUG; } static inline void SolidSyslog_FormatTimestamp(struct SolidSyslogFormatter* f, SolidSyslogClockFunction clock) @@ -598,7 +598,7 @@ static void SolidSyslog_NilBufferWrite(struct SolidSyslogBuffer* base, const voi if (nilBufferReportArmed) { nilBufferReportArmed = false; - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_NIL_BUFFER_USED); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_NIL_BUFFER_USED); } } @@ -626,7 +626,7 @@ static bool SolidSyslog_NilSenderSend(struct SolidSyslogSender* base, const void if (nilSenderReportArmed) { nilSenderReportArmed = false; - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_NIL_SENDER_USED); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_NIL_SENDER_USED); } return true; } diff --git a/Core/Source/SolidSyslogBlockStore.c b/Core/Source/SolidSyslogBlockStore.c index 4edbb08c..fced2459 100644 --- a/Core/Source/SolidSyslogBlockStore.c +++ b/Core/Source/SolidSyslogBlockStore.c @@ -33,7 +33,7 @@ struct SolidSyslogBlockStore SOLIDSYSLOG_STATIC_ASSERT( sizeof(struct SolidSyslogBlockStore) <= sizeof(SolidSyslogBlockStoreStorage), - "SOLIDSYSLOG_BLOCKSTORE_STORAGE_SIZE is too small for struct SolidSyslogBlockStore" + "SOLIDSYSLOG_BLOCK_STORE_STORAGE_SIZE is too small for struct SolidSyslogBlockStore" ); static const struct SolidSyslogBlockStore DEFAULT_INSTANCE = {0}; diff --git a/Core/Source/SolidSyslogCircularBuffer.c b/Core/Source/SolidSyslogCircularBuffer.c index fc62bf7b..d679f1b2 100644 --- a/Core/Source/SolidSyslogCircularBuffer.c +++ b/Core/Source/SolidSyslogCircularBuffer.c @@ -12,7 +12,7 @@ enum { - HEADER_BYTES = SOLIDSYSLOG_CIRCULARBUFFER_HEADER_BYTES + HEADER_BYTES = SOLIDSYSLOG_CIRCULAR_BUFFER_HEADER_BYTES }; struct SolidSyslogCircularBuffer @@ -28,8 +28,8 @@ struct SolidSyslogCircularBuffer SOLIDSYSLOG_STATIC_ASSERT( sizeof(struct SolidSyslogCircularBuffer) == - (SOLIDSYSLOG_CIRCULARBUFFER_OVERHEAD * sizeof(SolidSyslogCircularBufferStorage)), - "SOLIDSYSLOG_CIRCULARBUFFER_OVERHEAD does not match struct layout" + (SOLIDSYSLOG_CIRCULAR_BUFFER_OVERHEAD * sizeof(SolidSyslogCircularBufferStorage)), + "SOLIDSYSLOG_CIRCULAR_BUFFER_OVERHEAD does not match struct layout" ); static bool CircularBuffer_Read(struct SolidSyslogBuffer* base, void* data, size_t maxSize, size_t* bytesRead); diff --git a/Core/Source/SolidSyslogFileBlockDevice.c b/Core/Source/SolidSyslogFileBlockDevice.c index fcb482e3..4b5f9b71 100644 --- a/Core/Source/SolidSyslogFileBlockDevice.c +++ b/Core/Source/SolidSyslogFileBlockDevice.c @@ -53,7 +53,7 @@ struct SolidSyslogFileBlockDevice SOLIDSYSLOG_STATIC_ASSERT( sizeof(struct SolidSyslogFileBlockDevice) <= sizeof(SolidSyslogFileBlockDeviceStorage), - "SOLIDSYSLOG_FILEBLOCKDEVICE_STORAGE_SIZE is too small for struct SolidSyslogFileBlockDevice" + "SOLIDSYSLOG_FILE_BLOCK_DEVICE_STORAGE_SIZE is too small for struct SolidSyslogFileBlockDevice" ); /* vtable — forward-declared because Create wires them before their definitions */ diff --git a/Core/Source/SolidSyslogMetaSd.c b/Core/Source/SolidSyslogMetaSd.c index 142049b1..19c63e82 100644 --- a/Core/Source/SolidSyslogMetaSd.c +++ b/Core/Source/SolidSyslogMetaSd.c @@ -35,11 +35,11 @@ struct SolidSyslogStructuredData* SolidSyslogMetaSd_Create(const struct SolidSys struct SolidSyslogStructuredData* result = &nilMetaSd; if (config == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Warning, SOLIDSYSLOG_ERROR_MSG_METASD_CREATE_NULL_CONFIG); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, SOLIDSYSLOG_ERROR_MSG_METASD_CREATE_NULL_CONFIG); } else if (config->Counter == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Warning, SOLIDSYSLOG_ERROR_MSG_METASD_CREATE_NULL_COUNTER); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, SOLIDSYSLOG_ERROR_MSG_METASD_CREATE_NULL_COUNTER); } else { diff --git a/Core/Source/SolidSyslogStreamSender.c b/Core/Source/SolidSyslogStreamSender.c index f2780f85..4b7458d7 100644 --- a/Core/Source/SolidSyslogStreamSender.c +++ b/Core/Source/SolidSyslogStreamSender.c @@ -166,7 +166,7 @@ static bool StreamSender_ResolveDestination(struct SolidSyslogStreamSender* self return SolidSyslogResolver_Resolve( self->Config.Resolver, - SolidSyslogTransport_Tcp, + SOLIDSYSLOG_TRANSPORT_TCP, SolidSyslogFormatter_AsFormattedBuffer(hostFormatter), endpoint.Port, addr diff --git a/Core/Source/SolidSyslogUdpSender.c b/Core/Source/SolidSyslogUdpSender.c index a587cbae..b687b082 100644 --- a/Core/Source/SolidSyslogUdpSender.c +++ b/Core/Source/SolidSyslogUdpSender.c @@ -80,19 +80,19 @@ static bool UdpSender_IsValidConfig(const struct SolidSyslogUdpSenderConfig* con bool valid = false; if (config == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_CONFIG); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_CONFIG); } else if (config->Resolver == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_RESOLVER); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_RESOLVER); } else if (config->Datagram == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_DATAGRAM); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_DATAGRAM); } else if (config->Endpoint == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_ENDPOINT); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_CREATE_NULL_ENDPOINT); } else { @@ -124,7 +124,7 @@ static bool UdpSender_Send(struct SolidSyslogSender* base, const void* buffer, s bool result = false; if (buffer == NULL) { - SolidSyslog_Error(SolidSyslogSeverity_Error, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_SEND_NULL_BUFFER); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, SOLIDSYSLOG_ERROR_MSG_UDPSENDER_SEND_NULL_BUFFER); } else { @@ -213,7 +213,7 @@ static bool UdpSender_ResolveDestination(struct SolidSyslogUdpSender* self, cons { return SolidSyslogResolver_Resolve( self->Config.Resolver, - SolidSyslogTransport_Udp, + SOLIDSYSLOG_TRANSPORT_UDP, host, port, UdpSender_Address(self) @@ -235,11 +235,11 @@ static inline bool UdpSender_TransmitDatagram(struct SolidSyslogUdpSender* self, { enum SolidSyslogDatagramSendResult result = SolidSyslogDatagram_SendTo(self->Config.Datagram, buffer, size, UdpSender_Address(self)); - if (result == SolidSyslogDatagramSendResult_Oversize) + if (result == SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE) { result = UdpSender_RetryAfterOversize(self, buffer, size); } - return result == SolidSyslogDatagramSendResult_Sent; + return result == SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT; } static inline enum SolidSyslogDatagramSendResult UdpSender_RetryAfterOversize( @@ -253,15 +253,15 @@ static inline enum SolidSyslogDatagramSendResult UdpSender_RetryAfterOversize( size_t trimmed = SolidSyslogUdpPayload_TrimToCodepointBoundary((const uint8_t*) buffer, clipLimit); /* Default SENT swallows trimmed == 0 (path can't carry the message) so the * Service algorithm doesn't loop on an undeliverable. */ - enum SolidSyslogDatagramSendResult result = SolidSyslogDatagramSendResult_Sent; + enum SolidSyslogDatagramSendResult result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT; if (trimmed > 0U) { result = SolidSyslogDatagram_SendTo(self->Config.Datagram, buffer, trimmed, UdpSender_Address(self)); - if (result == SolidSyslogDatagramSendResult_Oversize) + if (result == SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE) { /* Retry still OVERSIZE means the kernel disagrees with its own * MaxPayload — swallow for the same reason. */ - result = SolidSyslogDatagramSendResult_Sent; + result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT; } } return result; diff --git a/DEVLOG.md b/DEVLOG.md index d07290bd..4905acb3 100644 --- a/DEVLOG.md +++ b/DEVLOG.md @@ -1,5 +1,94 @@ # Dev Log +## 2026-05-17 — S10.22 Enum naming convention restoration (#390) + +Convention-restoration story raised after the S10.16 review surfaced +drift in the enum-constant naming rule. S10.07 introduced +`SolidSyslog_` (project-prefix-PascalCase) for +tagged-enum constants. S10.12 then carved out SCREAMING_SNAKE for the +anonymous-enum named-constant idiom because mechanical PascalCase'ing +101 anonymous-enum constants would be cosmetic churn against a +type-safe macro replacement. The carve-out was pragmatic at the time +but introduced a two-class system that's not mechanically enforceable +— only per-site judgement separates "tagged enum constant +(PascalCase)" from "macro-replacement enum constant (SCREAMING)". By +S10.16 the boundary was drifting; the review surfaced a third hybrid +form (`Class_DEFAULT_INSTANCE` for static-template names) that nobody +had decided on. + +S10.22 collapses to **one rule**: all enum constants are +SCREAMING_SNAKE, with the project prefix on public sites. The split +is removed. + +### Decisions locked in + +- All enum constants → `SCREAMING_SNAKE`. Tagged or anonymous, public + or TU-local. +- Word boundaries: snake-separate at every CamelCase boundary in the + source identifier. `DatagramSendResult` → `DATAGRAM_SEND_RESULT`, + `AuthPriv` → `AUTH_PRIV`. Trailing digits stay glued + (`Local0` → `LOCAL0`, matching POSIX `LOG_LOCAL0`). +- Project prefix: `SOLIDSYSLOG_` on public sites; bare SCREAMING on + TU-local anonymous-enum constants (`IPV4_HEADER_BYTES` etc.). +- `.clang-tidy` `EnumConstantCase` → `UPPER_CASE` only. Dropped both + `EnumConstantPrefix` and the `EnumConstantIgnoredRegexp` escape. + One rule, no exceptions. +- `NAMING.md` "Enum constants" section replaces the old "Public enum + constants" + "Anonymous-enum named-constant idiom" pair. Quick-ref + table updated. Historical S10.07/S10.12 split documented as + superseded. + +### Sweep — 8 commits, all gates green between + +1. `SolidSyslogFacility_*` → `SOLIDSYSLOG_FACILITY_*` (24 constants, 10 files) +2. `SolidSyslogSeverity_*` → `SOLIDSYSLOG_SEVERITY_*` (8, 18 files) +3. `SolidSyslogDiscardPolicy_*` → `SOLIDSYSLOG_DISCARD_POLICY_*` (3, 9 files) +4. `SolidSyslogDatagramSendResult_*` → `SOLIDSYSLOG_DATAGRAM_SEND_RESULT_*` (3, 12 files) +5. `SolidSyslogTransport_*` → `SOLIDSYSLOG_TRANSPORT_*` (2, 9 files) +6. Glued storage-SIZE constants → snake (11 renames, 28 files): + `CIRCULARBUFFER` → `CIRCULAR_BUFFER`, `STDATOMICCOUNTER` → + `STD_ATOMIC_COUNTER`, etc. This second pass was the price of + committing to "snake at every CamelCase boundary" — pre-existing + class-segment-glued macros (`SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE`) + were inconsistent with the rule we were adopting. +7. `.clang-tidy` + `NAMING.md` single-rule update. +8. clang-format follow-up — 2 files needed reformat after the rename + (a CHECK_REPORTED_ERROR macro's `\` continuation column shifted, + and one initializer line went over 120 cols and reflowed). + +### Verification + +- 1115 tests pass under debug + clang-debug + sanitize. +- Coverage 99.6% lines / 99.0% functions — no change. +- `analyze-tidy` clean — zero enum-case warnings under the new + `UPPER_CASE` rule. +- `analyze-cppcheck` + cppcheck-misra histograms match `main` exactly + (87 unsuppressed findings across 8 rules, identical counts) — zero + regression introduced by the sweep. + +### Why now, not later + +The alternative was to land S10.16–S10.19 per-group stories with the +mixed convention then sweep once at the end. That would have meant +re-litigating the enum-naming question in every per-group review and +churning every touched file twice. Doing S10.22 first costs one large +mechanical PR; deferring it would have cost four small re-decisions +plus the final sweep. + +### Deferred / out of scope + +- **Static *variable* naming** (the `instance` / `DEFAULT_INSTANCE` / + `NIL_SENDER` family). Those are objects, not enum constants; the + convention question is real but separate. Per-group stories + (S10.16 onwards) will hit them on touch. +- The S10.16 senders conformance work resumes once this lands. + +### Open questions + +- None — S10.22 was self-contained. + +--- + ## 2026-05-17 — S10.15 Structured Data conformance (#387) Fourth per-group conformance story in E10. Cleared all warning-mode diff --git a/Platform/Atomics/Interface/SolidSyslogStdAtomicCounter.h b/Platform/Atomics/Interface/SolidSyslogStdAtomicCounter.h index 1839dc7f..c1dff74c 100644 --- a/Platform/Atomics/Interface/SolidSyslogStdAtomicCounter.h +++ b/Platform/Atomics/Interface/SolidSyslogStdAtomicCounter.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_STDATOMICCOUNTER_SIZE = sizeof(intptr_t) * 2U + SOLIDSYSLOG_STD_ATOMIC_COUNTER_SIZE = sizeof(intptr_t) * 2U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_STDATOMICCOUNTER_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_STD_ATOMIC_COUNTER_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogStdAtomicCounterStorage; struct SolidSyslogAtomicCounter* SolidSyslogStdAtomicCounter_Create(SolidSyslogStdAtomicCounterStorage * storage); diff --git a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosDatagram.h b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosDatagram.h index 0509a5c0..3d6932e5 100644 --- a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosDatagram.h +++ b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosDatagram.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_FREERTOSDATAGRAM_SIZE = sizeof(intptr_t) * 8U + SOLIDSYSLOG_FREE_RTOS_DATAGRAM_SIZE = sizeof(intptr_t) * 8U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_FREERTOSDATAGRAM_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_FREE_RTOS_DATAGRAM_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogFreeRtosDatagramStorage; struct SolidSyslogDatagram* SolidSyslogFreeRtosDatagram_Create(SolidSyslogFreeRtosDatagramStorage * storage); diff --git a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosMutex.h b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosMutex.h index 91f960a6..1d09d2d6 100644 --- a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosMutex.h +++ b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosMutex.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_FREERTOSMUTEX_SIZE = sizeof(intptr_t) * 20U + SOLIDSYSLOG_FREE_RTOS_MUTEX_SIZE = sizeof(intptr_t) * 20U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_FREERTOSMUTEX_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_FREE_RTOS_MUTEX_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogFreeRtosMutexStorage; struct SolidSyslogMutex* SolidSyslogFreeRtosMutex_Create(SolidSyslogFreeRtosMutexStorage * storage); diff --git a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosStaticResolver.h b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosStaticResolver.h index 482ddd88..a8dbf745 100644 --- a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosStaticResolver.h +++ b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosStaticResolver.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_FREERTOSSTATICRESOLVER_SIZE = sizeof(intptr_t) * 4U + SOLIDSYSLOG_FREE_RTOS_STATIC_RESOLVER_SIZE = sizeof(intptr_t) * 4U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_FREERTOSSTATICRESOLVER_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_FREE_RTOS_STATIC_RESOLVER_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogFreeRtosStaticResolverStorage; struct SolidSyslogResolver* SolidSyslogFreeRtosStaticResolver_Create( diff --git a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosTcpStream.h b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosTcpStream.h index dc04dd09..5b9a8666 100644 --- a/Platform/FreeRtos/Interface/SolidSyslogFreeRtosTcpStream.h +++ b/Platform/FreeRtos/Interface/SolidSyslogFreeRtosTcpStream.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_FREERTOSTCPSTREAM_SIZE = sizeof(intptr_t) * 8U + SOLIDSYSLOG_FREE_RTOS_TCP_STREAM_SIZE = sizeof(intptr_t) * 8U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_FREERTOSTCPSTREAM_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_FREE_RTOS_TCP_STREAM_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogFreeRtosTcpStreamStorage; struct SolidSyslogStream* SolidSyslogFreeRtosTcpStream_Create(SolidSyslogFreeRtosTcpStreamStorage * storage); diff --git a/Platform/FreeRtos/Source/SolidSyslogFreeRtosDatagram.c b/Platform/FreeRtos/Source/SolidSyslogFreeRtosDatagram.c index dce37e79..729d25e5 100644 --- a/Platform/FreeRtos/Source/SolidSyslogFreeRtosDatagram.c +++ b/Platform/FreeRtos/Source/SolidSyslogFreeRtosDatagram.c @@ -22,8 +22,8 @@ struct SolidSyslogFreeRtosDatagram }; SOLIDSYSLOG_STATIC_ASSERT( - sizeof(FreeRtosDatagram) <= SOLIDSYSLOG_FREERTOSDATAGRAM_SIZE, - "SOLIDSYSLOG_FREERTOSDATAGRAM_SIZE is too small for SolidSyslogFreeRtosDatagram layout" + sizeof(FreeRtosDatagram) <= SOLIDSYSLOG_FREE_RTOS_DATAGRAM_SIZE, + "SOLIDSYSLOG_FREE_RTOS_DATAGRAM_SIZE is too small for SolidSyslogFreeRtosDatagram layout" ); /* Time the calling task yields after issuing an ARP probe so the IP task can @@ -100,7 +100,7 @@ static enum SolidSyslogDatagramSendResult FreeRtosDatagram_SendTo( ) { FreeRtosDatagram* self = FreeRtosDatagram_SelfFromBase(base); - enum SolidSyslogDatagramSendResult result = SolidSyslogDatagramSendResult_Failed; + enum SolidSyslogDatagramSendResult result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED; if (FreeRtosDatagram_IsOpen(self)) { const struct freertos_sockaddr* dest = SolidSyslogAddress_AsConstFreertosSockaddr(addr); @@ -108,7 +108,7 @@ static enum SolidSyslogDatagramSendResult FreeRtosDatagram_SendTo( int32_t sent = FreeRTOS_sendto(self->Socket, buffer, size, 0, dest, sizeof(*dest)); if (sent > 0) { - result = SolidSyslogDatagramSendResult_Sent; + result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT; } } return result; diff --git a/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutex.c b/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutex.c index 3370fd7c..28ff2429 100644 --- a/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutex.c +++ b/Platform/FreeRtos/Source/SolidSyslogFreeRtosMutex.c @@ -19,8 +19,8 @@ struct SolidSyslogFreeRtosMutex }; SOLIDSYSLOG_STATIC_ASSERT( - sizeof(FreeRtosMutex) <= SOLIDSYSLOG_FREERTOSMUTEX_SIZE, - "SOLIDSYSLOG_FREERTOSMUTEX_SIZE is too small for SolidSyslogFreeRtosMutex layout" + sizeof(FreeRtosMutex) <= SOLIDSYSLOG_FREE_RTOS_MUTEX_SIZE, + "SOLIDSYSLOG_FREE_RTOS_MUTEX_SIZE is too small for SolidSyslogFreeRtosMutex layout" ); static void FreeRtosMutex_Lock(struct SolidSyslogMutex* base); diff --git a/Platform/FreeRtos/Source/SolidSyslogFreeRtosStaticResolver.c b/Platform/FreeRtos/Source/SolidSyslogFreeRtosStaticResolver.c index 9f80aa87..13212b3d 100644 --- a/Platform/FreeRtos/Source/SolidSyslogFreeRtosStaticResolver.c +++ b/Platform/FreeRtos/Source/SolidSyslogFreeRtosStaticResolver.c @@ -17,8 +17,8 @@ struct SolidSyslogFreeRtosStaticResolver }; SOLIDSYSLOG_STATIC_ASSERT( - sizeof(FreeRtosStaticResolver) <= SOLIDSYSLOG_FREERTOSSTATICRESOLVER_SIZE, - "SOLIDSYSLOG_FREERTOSSTATICRESOLVER_SIZE is too small for SolidSyslogFreeRtosStaticResolver layout" + sizeof(FreeRtosStaticResolver) <= SOLIDSYSLOG_FREE_RTOS_STATIC_RESOLVER_SIZE, + "SOLIDSYSLOG_FREE_RTOS_STATIC_RESOLVER_SIZE is too small for SolidSyslogFreeRtosStaticResolver layout" ); static bool FreeRtosStaticResolver_Resolve( diff --git a/Platform/FreeRtos/Source/SolidSyslogFreeRtosTcpStream.c b/Platform/FreeRtos/Source/SolidSyslogFreeRtosTcpStream.c index d54e8039..a99ea25b 100644 --- a/Platform/FreeRtos/Source/SolidSyslogFreeRtosTcpStream.c +++ b/Platform/FreeRtos/Source/SolidSyslogFreeRtosTcpStream.c @@ -78,8 +78,8 @@ static SolidSyslogSsize FreeRtosTcpStream_ReceiveOrCloseOnFailure(FreeRtosTcpStr static void FreeRtosTcpStream_CloseSocket(FreeRtosTcpStream* self); SOLIDSYSLOG_STATIC_ASSERT( - sizeof(FreeRtosTcpStream) <= SOLIDSYSLOG_FREERTOSTCPSTREAM_SIZE, - "SOLIDSYSLOG_FREERTOSTCPSTREAM_SIZE is too small for SolidSyslogFreeRtosTcpStream layout" + sizeof(FreeRtosTcpStream) <= SOLIDSYSLOG_FREE_RTOS_TCP_STREAM_SIZE, + "SOLIDSYSLOG_FREE_RTOS_TCP_STREAM_SIZE is too small for SolidSyslogFreeRtosTcpStream layout" ); static const FreeRtosTcpStream DEFAULT_INSTANCE = { diff --git a/Platform/Posix/Interface/SolidSyslogPosixMutex.h b/Platform/Posix/Interface/SolidSyslogPosixMutex.h index 6305ef92..1d9c5a52 100644 --- a/Platform/Posix/Interface/SolidSyslogPosixMutex.h +++ b/Platform/Posix/Interface/SolidSyslogPosixMutex.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_POSIXMUTEX_SIZE = sizeof(intptr_t) * 10U + SOLIDSYSLOG_POSIX_MUTEX_SIZE = sizeof(intptr_t) * 10U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_POSIXMUTEX_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_POSIX_MUTEX_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogPosixMutexStorage; struct SolidSyslogMutex* SolidSyslogPosixMutex_Create(SolidSyslogPosixMutexStorage * storage); diff --git a/Platform/Posix/Source/SolidSyslogGetAddrInfoResolver.c b/Platform/Posix/Source/SolidSyslogGetAddrInfoResolver.c index 4bae192b..74ad459b 100644 --- a/Platform/Posix/Source/SolidSyslogGetAddrInfoResolver.c +++ b/Platform/Posix/Source/SolidSyslogGetAddrInfoResolver.c @@ -79,7 +79,7 @@ static int GetAddrInfoResolver_MapTransport(enum SolidSyslogTransport transport) { int socktype = SOCK_DGRAM; - if (transport == SolidSyslogTransport_Tcp) + if (transport == SOLIDSYSLOG_TRANSPORT_TCP) { socktype = SOCK_STREAM; } diff --git a/Platform/Posix/Source/SolidSyslogPosixDatagram.c b/Platform/Posix/Source/SolidSyslogPosixDatagram.c index 4246db54..9d30381a 100644 --- a/Platform/Posix/Source/SolidSyslogPosixDatagram.c +++ b/Platform/Posix/Source/SolidSyslogPosixDatagram.c @@ -89,18 +89,18 @@ static enum SolidSyslogDatagramSendResult PosixDatagram_SendTo( ) { struct SolidSyslogPosixDatagram* self = PosixDatagram_SelfFromBase(base); - enum SolidSyslogDatagramSendResult result = SolidSyslogDatagramSendResult_Failed; + enum SolidSyslogDatagramSendResult result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED; if (PosixDatagram_ConnectIfNeeded(self, addr)) { const struct sockaddr_in* sin = SolidSyslogAddress_AsConstSockaddrIn(addr); ssize_t sent = sendto(self->Fd, buffer, size, 0, (const struct sockaddr*) sin, sizeof(*sin)); if (sent >= 0) { - result = SolidSyslogDatagramSendResult_Sent; + result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT; } else if (errno == EMSGSIZE) { - result = SolidSyslogDatagramSendResult_Oversize; + result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE; } else { diff --git a/Platform/Posix/Source/SolidSyslogPosixMutex.c b/Platform/Posix/Source/SolidSyslogPosixMutex.c index 75901f88..b90c43be 100644 --- a/Platform/Posix/Source/SolidSyslogPosixMutex.c +++ b/Platform/Posix/Source/SolidSyslogPosixMutex.c @@ -13,8 +13,8 @@ struct SolidSyslogPosixMutex }; SOLIDSYSLOG_STATIC_ASSERT( - sizeof(struct SolidSyslogPosixMutex) <= SOLIDSYSLOG_POSIXMUTEX_SIZE, - "SOLIDSYSLOG_POSIXMUTEX_SIZE is too small for SolidSyslogPosixMutex layout" + sizeof(struct SolidSyslogPosixMutex) <= SOLIDSYSLOG_POSIX_MUTEX_SIZE, + "SOLIDSYSLOG_POSIX_MUTEX_SIZE is too small for SolidSyslogPosixMutex layout" ); static void PosixMutex_Lock(struct SolidSyslogMutex* base); diff --git a/Platform/Windows/Interface/SolidSyslogWindowsAtomicCounter.h b/Platform/Windows/Interface/SolidSyslogWindowsAtomicCounter.h index d9b66399..9cd64ca9 100644 --- a/Platform/Windows/Interface/SolidSyslogWindowsAtomicCounter.h +++ b/Platform/Windows/Interface/SolidSyslogWindowsAtomicCounter.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_WINDOWSATOMICCOUNTER_SIZE = sizeof(intptr_t) * 2U + SOLIDSYSLOG_WINDOWS_ATOMIC_COUNTER_SIZE = sizeof(intptr_t) * 2U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_WINDOWSATOMICCOUNTER_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_WINDOWS_ATOMIC_COUNTER_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogWindowsAtomicCounterStorage; struct SolidSyslogAtomicCounter* SolidSyslogWindowsAtomicCounter_Create( diff --git a/Platform/Windows/Interface/SolidSyslogWindowsMutex.h b/Platform/Windows/Interface/SolidSyslogWindowsMutex.h index a5b846c5..2d517cb0 100644 --- a/Platform/Windows/Interface/SolidSyslogWindowsMutex.h +++ b/Platform/Windows/Interface/SolidSyslogWindowsMutex.h @@ -11,12 +11,12 @@ EXTERN_C_BEGIN enum { - SOLIDSYSLOG_WINDOWSMUTEX_SIZE = sizeof(intptr_t) * 10U + SOLIDSYSLOG_WINDOWS_MUTEX_SIZE = sizeof(intptr_t) * 10U }; typedef struct { - intptr_t slots[(SOLIDSYSLOG_WINDOWSMUTEX_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; + intptr_t slots[(SOLIDSYSLOG_WINDOWS_MUTEX_SIZE + sizeof(intptr_t) - 1U) / sizeof(intptr_t)]; } SolidSyslogWindowsMutexStorage; struct SolidSyslogMutex* SolidSyslogWindowsMutex_Create(SolidSyslogWindowsMutexStorage * storage); diff --git a/Platform/Windows/Source/SolidSyslogWindowsMutex.c b/Platform/Windows/Source/SolidSyslogWindowsMutex.c index 840700e8..16e46319 100644 --- a/Platform/Windows/Source/SolidSyslogWindowsMutex.c +++ b/Platform/Windows/Source/SolidSyslogWindowsMutex.c @@ -13,8 +13,8 @@ struct SolidSyslogWindowsMutex }; SOLIDSYSLOG_STATIC_ASSERT( - sizeof(struct SolidSyslogWindowsMutex) <= SOLIDSYSLOG_WINDOWSMUTEX_SIZE, - "SOLIDSYSLOG_WINDOWSMUTEX_SIZE is too small for SolidSyslogWindowsMutex layout" + sizeof(struct SolidSyslogWindowsMutex) <= SOLIDSYSLOG_WINDOWS_MUTEX_SIZE, + "SOLIDSYSLOG_WINDOWS_MUTEX_SIZE is too small for SolidSyslogWindowsMutex layout" ); static void WindowsMutex_Lock(struct SolidSyslogMutex* base); diff --git a/Platform/Windows/Source/SolidSyslogWinsockDatagram.c b/Platform/Windows/Source/SolidSyslogWinsockDatagram.c index fe398637..141ce8a8 100644 --- a/Platform/Windows/Source/SolidSyslogWinsockDatagram.c +++ b/Platform/Windows/Source/SolidSyslogWinsockDatagram.c @@ -127,7 +127,7 @@ static enum SolidSyslogDatagramSendResult WinsockDatagram_SendTo( ) { struct SolidSyslogWinsockDatagram* self = WinsockDatagram_SelfFromBase(base); - enum SolidSyslogDatagramSendResult result = SolidSyslogDatagramSendResult_Failed; + enum SolidSyslogDatagramSendResult result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED; if (WinsockDatagram_ConnectIfNeeded(self, addr)) { const struct sockaddr_in* sin = SolidSyslogAddress_AsConstSockaddrIn(addr); @@ -141,11 +141,11 @@ static enum SolidSyslogDatagramSendResult WinsockDatagram_SendTo( ); if (sent != SOCKET_ERROR) { - result = SolidSyslogDatagramSendResult_Sent; + result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT; } else if (WSAGetLastError() == WSAEMSGSIZE) { - result = SolidSyslogDatagramSendResult_Oversize; + result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE; } else { diff --git a/Platform/Windows/Source/SolidSyslogWinsockResolver.c b/Platform/Windows/Source/SolidSyslogWinsockResolver.c index 04428648..280c551e 100644 --- a/Platform/Windows/Source/SolidSyslogWinsockResolver.c +++ b/Platform/Windows/Source/SolidSyslogWinsockResolver.c @@ -94,7 +94,7 @@ static int WinsockResolver_MapTransport(enum SolidSyslogTransport transport) { int socktype = SOCK_DGRAM; - if (transport == SolidSyslogTransport_Tcp) + if (transport == SOLIDSYSLOG_TRANSPORT_TCP) { socktype = SOCK_STREAM; } diff --git a/Tests/Bdd/Targets/BddTargetServiceThreadTest.cpp b/Tests/Bdd/Targets/BddTargetServiceThreadTest.cpp index 19affffd..a283d01e 100644 --- a/Tests/Bdd/Targets/BddTargetServiceThreadTest.cpp +++ b/Tests/Bdd/Targets/BddTargetServiceThreadTest.cpp @@ -86,7 +86,7 @@ TEST_GROUP(BddTargetServiceThread) static void Log() { - SolidSyslogMessage message = {SolidSyslogFacility_Local0, SolidSyslogSeverity_Informational, nullptr, nullptr}; + SolidSyslogMessage message = {SOLIDSYSLOG_FACILITY_LOCAL0, SOLIDSYSLOG_SEVERITY_INFORMATIONAL, nullptr, nullptr}; SolidSyslog_Log(&message); } }; diff --git a/Tests/Bdd/Targets/BddTargetWindowsCommandLineTest.cpp b/Tests/Bdd/Targets/BddTargetWindowsCommandLineTest.cpp index a9bd2510..61d296d1 100644 --- a/Tests/Bdd/Targets/BddTargetWindowsCommandLineTest.cpp +++ b/Tests/Bdd/Targets/BddTargetWindowsCommandLineTest.cpp @@ -19,7 +19,7 @@ TEST(BddTargetWindowsCommandLine, DefaultFacilityIsLocal0) char arg0[] = "test"; char* argv[] = {arg0, nullptr}; Parse(1, argv); - LONGS_EQUAL(SolidSyslogFacility_Local0, options.Facility); + LONGS_EQUAL(SOLIDSYSLOG_FACILITY_LOCAL0, options.Facility); } TEST(BddTargetWindowsCommandLine, DefaultSeverityIsInfo) @@ -27,7 +27,7 @@ TEST(BddTargetWindowsCommandLine, DefaultSeverityIsInfo) char arg0[] = "test"; char* argv[] = {arg0, nullptr}; Parse(1, argv); - LONGS_EQUAL(SolidSyslogSeverity_Informational, options.Severity); + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_INFORMATIONAL, options.Severity); } TEST(BddTargetWindowsCommandLine, DefaultMessageIdIsNull) @@ -130,7 +130,7 @@ TEST(BddTargetWindowsCommandLine, UnknownFlagIsIgnored) char arg2[] = "value"; char* argv[] = {arg0, arg1, arg2, nullptr}; Parse(3, argv); - LONGS_EQUAL(SolidSyslogFacility_Local0, options.Facility); + LONGS_EQUAL(SOLIDSYSLOG_FACILITY_LOCAL0, options.Facility); POINTERS_EQUAL(nullptr, options.MessageId); } @@ -140,7 +140,7 @@ TEST(BddTargetWindowsCommandLine, FacilityFlagWithoutValueIsIgnored) char arg1[] = "--facility"; char* argv[] = {arg0, arg1, nullptr}; Parse(2, argv); - LONGS_EQUAL(SolidSyslogFacility_Local0, options.Facility); + LONGS_EQUAL(SOLIDSYSLOG_FACILITY_LOCAL0, options.Facility); } TEST(BddTargetWindowsCommandLine, DefaultAppNameIsNull) diff --git a/Tests/BlockSequenceTest.cpp b/Tests/BlockSequenceTest.cpp index dc6a3590..ee25c9ec 100644 --- a/Tests/BlockSequenceTest.cpp +++ b/Tests/BlockSequenceTest.cpp @@ -163,7 +163,7 @@ TEST_GROUP(BlockSequenceScan) config.BlockDevice = &fakeDevice.Base; config.MaxBlockSize = 1000; config.MaxBlocks = 99; - config.DiscardPolicy = SolidSyslogDiscardPolicy_Oldest; + config.DiscardPolicy = SOLIDSYSLOG_DISCARD_POLICY_OLDEST; BlockSequence_Init(&sequence, &config); } }; @@ -251,7 +251,7 @@ TEST_GROUP(BlockSequenceRotation) config.BlockDevice = &fakeDevice.Base; config.MaxBlockSize = ROTATION_BLOCK_SIZE; config.MaxBlocks = 99; - config.DiscardPolicy = SolidSyslogDiscardPolicy_Oldest; + config.DiscardPolicy = SOLIDSYSLOG_DISCARD_POLICY_OLDEST; BlockSequence_Init(&sequence, &config); BlockSequence_Open(&sequence); /* cold start: Acquire(0) */ diff --git a/Tests/DatagramFake.c b/Tests/DatagramFake.c index 838f80f9..43523d1e 100644 --- a/Tests/DatagramFake.c +++ b/Tests/DatagramFake.c @@ -42,7 +42,7 @@ struct SolidSyslogDatagram* DatagramFake_Create(void) fake->Base.Close = Close; for (int i = 0; i < DATAGRAMFAKE_MAX_SEND_CALLS; i++) { - fake->SendResults[i] = SolidSyslogDatagramSendResult_Sent; + fake->SendResults[i] = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT; } return &fake->Base; } @@ -123,7 +123,7 @@ static enum SolidSyslogDatagramSendResult SendTo( { struct DatagramFake* fake = (struct DatagramFake*) self; int idx = fake->SendCallCount; - enum SolidSyslogDatagramSendResult result = SolidSyslogDatagramSendResult_Failed; + enum SolidSyslogDatagramSendResult result = SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED; (void) addr; if (idx < DATAGRAMFAKE_MAX_SEND_CALLS) { diff --git a/Tests/DatagramFake.h b/Tests/DatagramFake.h index 134cface..3eb35294 100644 --- a/Tests/DatagramFake.h +++ b/Tests/DatagramFake.h @@ -16,7 +16,7 @@ EXTERN_C_BEGIN void DatagramFake_Destroy(struct SolidSyslogDatagram * datagram); /* Per-call SendTo result (0-based). Calls beyond the configured slots - * return SolidSyslogDatagramSendResult_Sent by default. */ + * return SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT by default. */ void DatagramFake_SetSendResult( struct SolidSyslogDatagram * datagram, int callIndex, diff --git a/Tests/DatagramFakeTest.cpp b/Tests/DatagramFakeTest.cpp index 7fba552e..3cb7df4d 100644 --- a/Tests/DatagramFakeTest.cpp +++ b/Tests/DatagramFakeTest.cpp @@ -46,22 +46,22 @@ TEST(DatagramFake, SendDefaultsToSent) { const char payload[] = "hi"; LONGS_EQUAL( - SolidSyslogDatagramSendResult_Sent, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT, SolidSyslogDatagram_SendTo(datagram, payload, sizeof(payload), nullptr) ); } TEST(DatagramFake, SendReturnsConfiguredResultPerCall) { - DatagramFake_SetSendResult(datagram, 0, SolidSyslogDatagramSendResult_Oversize); - DatagramFake_SetSendResult(datagram, 1, SolidSyslogDatagramSendResult_Failed); + DatagramFake_SetSendResult(datagram, 0, SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + DatagramFake_SetSendResult(datagram, 1, SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED); const char payload[] = "hi"; LONGS_EQUAL( - SolidSyslogDatagramSendResult_Oversize, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE, SolidSyslogDatagram_SendTo(datagram, payload, sizeof(payload), nullptr) ); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Failed, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, SolidSyslogDatagram_SendTo(datagram, payload, sizeof(payload), nullptr) ); } diff --git a/Tests/FreeRtos/SolidSyslogFreeRtosDatagramTest.cpp b/Tests/FreeRtos/SolidSyslogFreeRtosDatagramTest.cpp index 12a74b89..63afb770 100644 --- a/Tests/FreeRtos/SolidSyslogFreeRtosDatagramTest.cpp +++ b/Tests/FreeRtos/SolidSyslogFreeRtosDatagramTest.cpp @@ -89,7 +89,7 @@ TEST(SolidSyslogFreeRtosDatagram, MaxPayloadReturnsIpv6SafeDefault) TEST(SolidSyslogFreeRtosDatagram, SendToFailsBeforeOpen) { enum SolidSyslogDatagramSendResult result = SolidSyslogDatagram_SendTo(datagram, "x", 1, addr); - LONGS_EQUAL(SolidSyslogDatagramSendResult_Failed, result); + LONGS_EQUAL(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, result); CALLED_FAKE(FreeRtosSocketsFake_Sendto, NEVER); } @@ -97,7 +97,7 @@ TEST(SolidSyslogFreeRtosDatagram, SendToFailsWhenSendtoErrors) { SolidSyslogDatagram_Open(datagram); FreeRtosSocketsFake_SetSendtoFails(true); - LONGS_EQUAL(SolidSyslogDatagramSendResult_Failed, SolidSyslogDatagram_SendTo(datagram, "x", 1, addr)); + LONGS_EQUAL(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, SolidSyslogDatagram_SendTo(datagram, "x", 1, addr)); } TEST(SolidSyslogFreeRtosDatagram, CloseClosesSocket) @@ -113,7 +113,7 @@ TEST(SolidSyslogFreeRtosDatagram, SendToFailsAfterClose) SolidSyslogDatagram_Open(datagram); SolidSyslogDatagram_Close(datagram); enum SolidSyslogDatagramSendResult result = SolidSyslogDatagram_SendTo(datagram, "x", 1, addr); - LONGS_EQUAL(SolidSyslogDatagramSendResult_Failed, result); + LONGS_EQUAL(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, result); CALLED_FAKE(FreeRtosSocketsFake_Sendto, NEVER); } @@ -155,7 +155,7 @@ TEST(SolidSyslogFreeRtosDatagram, SendToSendsBufferToDestinationAfterOpen) enum SolidSyslogDatagramSendResult result = SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr); - LONGS_EQUAL(SolidSyslogDatagramSendResult_Sent, result); + LONGS_EQUAL(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT, result); CALLED_FAKE(FreeRtosSocketsFake_Sendto, ONCE); POINTERS_EQUAL(FreeRtosSocketsFake_LastSocketReturned(), FreeRtosSocketsFake_LastSendtoSocket()); POINTERS_EQUAL(TEST_MESSAGE, FreeRtosSocketsFake_LastSendtoBuffer()); diff --git a/Tests/FreeRtos/SolidSyslogFreeRtosStaticResolverTest.cpp b/Tests/FreeRtos/SolidSyslogFreeRtosStaticResolverTest.cpp index 8435e9cf..31c7f6da 100644 --- a/Tests/FreeRtos/SolidSyslogFreeRtosStaticResolverTest.cpp +++ b/Tests/FreeRtos/SolidSyslogFreeRtosStaticResolverTest.cpp @@ -28,7 +28,7 @@ TEST_GROUP(SolidSyslogFreeRtosStaticResolver) addr = SolidSyslogAddress_FromStorage(&addrStorage); } - bool Resolve(const char* host = IGNORED_HOST, uint16_t port = TEST_PORT, enum SolidSyslogTransport transport = SolidSyslogTransport_Udp) + bool Resolve(const char* host = IGNORED_HOST, uint16_t port = TEST_PORT, enum SolidSyslogTransport transport = SOLIDSYSLOG_TRANSPORT_UDP) { return SolidSyslogResolver_Resolve(resolver, transport, host, port, addr); } @@ -89,11 +89,11 @@ TEST(SolidSyslogFreeRtosStaticResolver, ResolveProducesSameIpv4ForAnyHostString) TEST(SolidSyslogFreeRtosStaticResolver, ResolveProducesSameIpv4ForUdpAndTcpTransport) { - Resolve(IGNORED_HOST, TEST_PORT, SolidSyslogTransport_Udp); + Resolve(IGNORED_HOST, TEST_PORT, SOLIDSYSLOG_TRANSPORT_UDP); uint32_t udpIpv4 = Result()->sin_address.ulIP_IPv4; addrStorage = {}; - Resolve(IGNORED_HOST, TEST_PORT, SolidSyslogTransport_Tcp); + Resolve(IGNORED_HOST, TEST_PORT, SOLIDSYSLOG_TRANSPORT_TCP); LONGS_EQUAL(udpIpv4, Result()->sin_address.ulIP_IPv4); } diff --git a/Tests/SolidSyslogBlockStoreDrainOrderingTest.cpp b/Tests/SolidSyslogBlockStoreDrainOrderingTest.cpp index 1b78e01b..8873a248 100644 --- a/Tests/SolidSyslogBlockStoreDrainOrderingTest.cpp +++ b/Tests/SolidSyslogBlockStoreDrainOrderingTest.cpp @@ -223,7 +223,7 @@ TEST_GROUP_BASE(ServiceDrainInterleave, DrainTestFixtureBase) * reproducer; CircularBuffer is FIFO so all messages are retained * until Service drains them (unlike BufferFake which only keeps * the last one). */ - SolidSyslogCircularBufferStorage bufferStorage[SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE(16)] = {}; + SolidSyslogCircularBufferStorage bufferStorage[SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE(16)] = {}; SolidSyslogBlockStoreStorage storeStorage = {}; struct SolidSyslogStore* store = nullptr; struct SolidSyslogMutex* mutex = nullptr; @@ -306,7 +306,7 @@ TEST(ServiceDrainInterleave, DiscardNewestDoesNotLetNewestBypassOldestOnRecovery /*maxBlocks=*/2, /*maxBlockSize=*/200 /*will clamp up*/, /*payloadSize=*/SOLIDSYSLOG_MAX_MESSAGE_SIZE - 100U, - SolidSyslogDiscardPolicy_Newest + SOLIDSYSLOG_DISCARD_POLICY_NEWEST }; Setup(cfg); @@ -377,7 +377,8 @@ TEST(ServiceDrainInterleave, DiscardNewestDoesNotLetNewestBypassOldestOnRecovery * we have the bug in our hands. */ TEST(BlockStoreDrainOrdering, OutageDrainProducesAscendingSequenceIds) { - DrainTestConfig cfg = {/*maxBlocks=*/2, /*maxBlockSize=*/200, /*payloadSize=*/64, SolidSyslogDiscardPolicy_Newest}; + DrainTestConfig cfg = + {/*maxBlocks=*/2, /*maxBlockSize=*/200, /*payloadSize=*/64, SOLIDSYSLOG_DISCARD_POLICY_NEWEST}; CreateStore(cfg); /* Pre-outage send + drain — mirrors `When the client sends a message` diff --git a/Tests/SolidSyslogBlockStorePosixTest.cpp b/Tests/SolidSyslogBlockStorePosixTest.cpp index 539266bb..e2c77530 100644 --- a/Tests/SolidSyslogBlockStorePosixTest.cpp +++ b/Tests/SolidSyslogBlockStorePosixTest.cpp @@ -69,7 +69,7 @@ TEST_GROUP(SolidSyslogBlockStorePosix) config.BlockDevice = device; config.MaxBlockSize = maxBlockSize; config.MaxBlocks = maxBlocks; - config.DiscardPolicy = SolidSyslogDiscardPolicy_Oldest; + config.DiscardPolicy = SOLIDSYSLOG_DISCARD_POLICY_OLDEST; // cppcheck-suppress unreadVariable -- used across TEST_GROUP methods; cppcheck does not model CppUTest macros store = SolidSyslogBlockStore_Create(&storeStorage, &config); } diff --git a/Tests/SolidSyslogBlockStoreTest.cpp b/Tests/SolidSyslogBlockStoreTest.cpp index 149bbf60..e0c95499 100644 --- a/Tests/SolidSyslogBlockStoreTest.cpp +++ b/Tests/SolidSyslogBlockStoreTest.cpp @@ -41,7 +41,7 @@ static const struct SolidSyslogBlockStoreConfig DEFAULT_CONFIG = { nullptr, TEST_MAX_BLOCK_SIZE, TEST_MAX_BLOCKS, - SolidSyslogDiscardPolicy_Oldest, + SOLIDSYSLOG_DISCARD_POLICY_OLDEST, nullptr, nullptr, nullptr, @@ -709,7 +709,7 @@ TEST_GROUP_BASE(SolidSyslogBlockStoreRotation, BlockDeviceTestBase) teardownBlockDeviceFakes(); } - void CreateWithMaxBlockSize(size_t maxBlockSize, enum SolidSyslogDiscardPolicy policy = SolidSyslogDiscardPolicy_Oldest, + void CreateWithMaxBlockSize(size_t maxBlockSize, enum SolidSyslogDiscardPolicy policy = SOLIDSYSLOG_DISCARD_POLICY_OLDEST, size_t maxBlocks = 2, SolidSyslogStoreFullCallback onStoreFull = nullptr, void* storeFullContext = nullptr) { @@ -880,7 +880,7 @@ TEST(SolidSyslogBlockStoreRotation, DiscardOldestDrainYieldsOnlySurvivingRecords TEST(SolidSyslogBlockStoreRotation, DiscardNewestReturnsFalseWhenAtMaxFiles) { - CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SolidSyslogDiscardPolicy_Newest); + CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SOLIDSYSLOG_DISCARD_POLICY_NEWEST); WriteMaxMsg(); /* file 00 */ WriteMaxMsg(); /* file 01 — now at maxBlocks=2 */ @@ -898,7 +898,7 @@ static void StoreFullCallback(void* context) TEST(SolidSyslogBlockStoreRotation, HaltInvokesCallbackWhenStoreFull) { StoreFullCallbackCallCount = 0; - CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SolidSyslogDiscardPolicy_Halt, 2, StoreFullCallback); + CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SOLIDSYSLOG_DISCARD_POLICY_HALT, 2, StoreFullCallback); WriteMaxMsg(); /* file 00 */ WriteMaxMsg(); /* file 01 — now at maxBlocks=2 */ @@ -909,7 +909,7 @@ TEST(SolidSyslogBlockStoreRotation, HaltInvokesCallbackWhenStoreFull) TEST(SolidSyslogBlockStoreRotation, HaltWithNullCallbackDoesNotCrash) { - CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SolidSyslogDiscardPolicy_Halt); + CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SOLIDSYSLOG_DISCARD_POLICY_HALT); WriteMaxMsg(); /* file 00 */ WriteMaxMsg(); /* file 01 — now at maxBlocks=2 */ @@ -919,7 +919,7 @@ TEST(SolidSyslogBlockStoreRotation, HaltWithNullCallbackDoesNotCrash) TEST(SolidSyslogBlockStoreRotation, HaltSetsIsHaltedTrue) { - CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SolidSyslogDiscardPolicy_Halt); + CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SOLIDSYSLOG_DISCARD_POLICY_HALT); WriteMaxMsg(); /* file 00 */ WriteMaxMsg(); /* file 01 — now at maxBlocks=2 */ @@ -932,7 +932,7 @@ TEST(SolidSyslogBlockStoreRotation, HaltSetsIsHaltedTrue) TEST(SolidSyslogBlockStoreRotation, DiscardNewestDoesNotInvokeCallback) { StoreFullCallbackCallCount = 0; - CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SolidSyslogDiscardPolicy_Newest, 2, StoreFullCallback); + CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SOLIDSYSLOG_DISCARD_POLICY_NEWEST, 2, StoreFullCallback); WriteMaxMsg(); /* file 00 */ WriteMaxMsg(); /* file 01 — now at maxBlocks=2 */ @@ -952,7 +952,7 @@ static void CountStoreFullInvocations(void* context) TEST(SolidSyslogBlockStoreRotation, HaltOnStoreFullFiresOncePerRisingEdge) { CountStoreFullInvocationsCallCount = 0; - CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SolidSyslogDiscardPolicy_Halt, 2, CountStoreFullInvocations); + CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SOLIDSYSLOG_DISCARD_POLICY_HALT, 2, CountStoreFullInvocations); WriteMaxMsg(); /* file 00 */ WriteMaxMsg(); /* file 01 — now at maxBlocks=2 */ @@ -982,7 +982,7 @@ TEST(SolidSyslogBlockStoreRotation, OnStoreFullReceivesConfiguredContext) CreateWithMaxBlockSize( ONE_MAX_MSG_RECORD, - SolidSyslogDiscardPolicy_Halt, + SOLIDSYSLOG_DISCARD_POLICY_HALT, 2, StoreFullCallbackCapturingContext, &sentinel @@ -1093,7 +1093,7 @@ TEST(SolidSyslogBlockStoreRotation, ResumeFindsUnsentInClosedReadBlockWhenWriteB * records past WritePosition (== size of the partially-filled write block). */ static const size_t THREE_MAX_MSG_RECORDS = 3 * ONE_MAX_MSG_RECORD; - CreateWithMaxBlockSize(THREE_MAX_MSG_RECORDS, SolidSyslogDiscardPolicy_Oldest, /* maxBlocks */ 3); + CreateWithMaxBlockSize(THREE_MAX_MSG_RECORDS, SOLIDSYSLOG_DISCARD_POLICY_OLDEST, /* maxBlocks */ 3); char msg[SOLIDSYSLOG_MAX_MESSAGE_SIZE]; for (char i = 0; i < 4; i++) @@ -1113,7 +1113,7 @@ TEST(SolidSyslogBlockStoreRotation, ResumeFindsUnsentInClosedReadBlockWhenWriteB /* records 0, 1 in block 0 marked sent; record 2 still unsent */ SolidSyslogBlockStore_Destroy(store); - CreateWithMaxBlockSize(THREE_MAX_MSG_RECORDS, SolidSyslogDiscardPolicy_Oldest, 3); + CreateWithMaxBlockSize(THREE_MAX_MSG_RECORDS, SOLIDSYSLOG_DISCARD_POLICY_OLDEST, 3); memset(buf, 0, sizeof(buf)); SolidSyslogStore_ReadNextUnsent(store, buf, sizeof(buf), &bytesRead); @@ -1224,7 +1224,7 @@ TEST(SolidSyslogBlockStoreRotation, MaxFilesAtUpperLimit) MAX_FILES = 99 }; - CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SolidSyslogDiscardPolicy_Oldest, MAX_FILES); + CreateWithMaxBlockSize(ONE_MAX_MSG_RECORD, SOLIDSYSLOG_DISCARD_POLICY_OLDEST, MAX_FILES); /* Fill all 99 files */ for (int i = 0; i < MAX_FILES; i++) @@ -1786,7 +1786,7 @@ TEST_GROUP_BASE(SolidSyslogBlockStoreCapacity, BlockDeviceTestBase) // NOLINTNEXTLINE(bugprone-easily-swappable-parameters) -- maxBlockSize is a byte size, maxBlocks is a count; distinct semantics void CreateWithCapacity(size_t maxBlockSize, size_t maxBlocks, - enum SolidSyslogDiscardPolicy policy = SolidSyslogDiscardPolicy_Oldest) + enum SolidSyslogDiscardPolicy policy = SOLIDSYSLOG_DISCARD_POLICY_OLDEST) { struct SolidSyslogBlockStoreConfig config = MakeConfig(device); config.MaxBlockSize = maxBlockSize; @@ -1848,7 +1848,7 @@ TEST(SolidSyslogBlockStoreCapacity, GetUsedBytesCountsClosedBlocksAtFullSize) LONGS_EQUAL(ONE_MAX_MSG_RECORD + ONE_MAX_MSG_RECORD, SolidSyslogStore_GetUsedBytes(store)); } -/* Given a full store with SolidSyslogDiscardPolicy_Oldest, +/* Given a full store with SOLIDSYSLOG_DISCARD_POLICY_OLDEST, * When the oldest block is discarded, * Then GetUsedBytes drops by one block size. */ TEST(SolidSyslogBlockStoreCapacity, GetUsedBytesDropsOnDiscardOldest) @@ -1865,14 +1865,14 @@ TEST(SolidSyslogBlockStoreCapacity, GetUsedBytesDropsOnDiscardOldest) LONGS_EQUAL(ONE_MAX_MSG_RECORD + TEST_DATA_LEN + TEST_RECORD_OVERHEAD, SolidSyslogStore_GetUsedBytes(store)); } -/* Given a store at capacity with SolidSyslogDiscardPolicy_Halt, +/* Given a store at capacity with SOLIDSYSLOG_DISCARD_POLICY_HALT, * When a Write fails for size, * Then GetUsedBytes returns total even when the active block has slack. */ TEST(SolidSyslogBlockStoreCapacity, GetUsedBytesIsStickyAtTotalAfterSizeFailure) { /* maxBlockSize larger than one max-msg record so the active block has slack. */ static const size_t SLACK = 100; - CreateWithCapacity(ONE_MAX_MSG_RECORD + SLACK, 2, SolidSyslogDiscardPolicy_Halt); + CreateWithCapacity(ONE_MAX_MSG_RECORD + SLACK, 2, SOLIDSYSLOG_DISCARD_POLICY_HALT); WriteMaxMsg(); /* block 0: SLACK bytes slack */ WriteMaxMsg(); /* block 1: SLACK bytes slack, at maxBlocks */ @@ -1969,7 +1969,7 @@ TEST(SolidSyslogBlockStoreCapacityThreshold, ReArmsAfterFallingEdgeOnDiscardOlde struct SolidSyslogBlockStoreConfig config = MakeConfig(device); config.MaxBlockSize = TWO_RECORDS; config.MaxBlocks = 2; - config.DiscardPolicy = SolidSyslogDiscardPolicy_Oldest; + config.DiscardPolicy = SOLIDSYSLOG_DISCARD_POLICY_OLDEST; config.GetCapacityThreshold = ReturnsConfiguredThreshold; config.OnThresholdCrossed = CountThresholdCrossings; /* Threshold sits between 3 and 4 records: 4-records crosses, 3-records is below. */ @@ -2063,7 +2063,7 @@ static void RecordStoreFullFireOrder(void* context) storeFullFireOrder = ++nextFireOrder; } -/* Given threshold = 100% (total bytes) and SolidSyslogDiscardPolicy_Halt, +/* Given threshold = 100% (total bytes) and SOLIDSYSLOG_DISCARD_POLICY_HALT, * When a Write fails for size and engages the sticky 100% bit, * Then onThresholdCrossed fires before onStoreFull on that same Write. */ TEST(SolidSyslogBlockStoreCapacityThreshold, AtFullCapacityWithHaltThresholdFiresBeforeStoreFull) @@ -2081,7 +2081,7 @@ TEST(SolidSyslogBlockStoreCapacityThreshold, AtFullCapacityWithHaltThresholdFire struct SolidSyslogBlockStoreConfig config = MakeConfig(device); config.MaxBlockSize = MAX_MSG_RECORD + SLACK; config.MaxBlocks = 2; - config.DiscardPolicy = SolidSyslogDiscardPolicy_Halt; + config.DiscardPolicy = SOLIDSYSLOG_DISCARD_POLICY_HALT; config.OnStoreFull = RecordStoreFullFireOrder; config.GetCapacityThreshold = ReturnsConfiguredThreshold; config.OnThresholdCrossed = RecordThresholdFireOrder; @@ -2112,7 +2112,7 @@ TEST(SolidSyslogBlockStoreCapacityThreshold, StickyHundredPercentDoesNotRefireTh struct SolidSyslogBlockStoreConfig config = MakeConfig(device); config.MaxBlockSize = MAX_MSG_RECORD + SLACK; config.MaxBlocks = 2; - config.DiscardPolicy = SolidSyslogDiscardPolicy_Halt; + config.DiscardPolicy = SOLIDSYSLOG_DISCARD_POLICY_HALT; config.GetCapacityThreshold = ReturnsConfiguredThreshold; config.OnThresholdCrossed = CountThresholdCrossings; thresholdReturnValue = 2 * (MAX_MSG_RECORD + SLACK); diff --git a/Tests/SolidSyslogCircularBufferTest.cpp b/Tests/SolidSyslogCircularBufferTest.cpp index 59bf1ff2..a35967e6 100644 --- a/Tests/SolidSyslogCircularBufferTest.cpp +++ b/Tests/SolidSyslogCircularBufferTest.cpp @@ -15,7 +15,7 @@ enum // clang-format off TEST_GROUP(SolidSyslogCircularBuffer) { - SolidSyslogCircularBufferStorage storage[SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE(TEST_MAX_MESSAGES)]; + SolidSyslogCircularBufferStorage storage[SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE(TEST_MAX_MESSAGES)]; struct SolidSyslogBuffer* buffer = nullptr; char readData[SOLIDSYSLOG_MAX_MESSAGE_SIZE]; // cppcheck-suppress variableScope -- member of TEST_GROUP; scope managed by CppUTest macro @@ -170,7 +170,7 @@ TEST(SolidSyslogCircularBuffer, WriteExceedingMaxMessageSizeIsDropped) // clang-format off TEST_GROUP(SolidSyslogCircularBufferMutex) { - SolidSyslogCircularBufferStorage storage[SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE(TEST_MAX_MESSAGES)]; + SolidSyslogCircularBufferStorage storage[SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE(TEST_MAX_MESSAGES)]; struct SolidSyslogBuffer* buffer = nullptr; char readData[SOLIDSYSLOG_MAX_MESSAGE_SIZE]; // cppcheck-suppress variableScope -- member of TEST_GROUP; scope managed by CppUTest macro @@ -217,7 +217,7 @@ enum // clang-format off TEST_GROUP(SolidSyslogCircularBufferSmallRing) { - SolidSyslogCircularBufferStorage storage[SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE_BYTES(SMALL_RING_BYTES)]; + SolidSyslogCircularBufferStorage storage[SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE_BYTES(SMALL_RING_BYTES)]; struct SolidSyslogBuffer* buffer = nullptr; char readData[SMALL_RING_BYTES]; // cppcheck-suppress variableScope -- member of TEST_GROUP; scope managed by CppUTest macro diff --git a/Tests/SolidSyslogErrorTest.cpp b/Tests/SolidSyslogErrorTest.cpp index d3ff55b7..fc54e167 100644 --- a/Tests/SolidSyslogErrorTest.cpp +++ b/Tests/SolidSyslogErrorTest.cpp @@ -24,17 +24,17 @@ TEST_GROUP(SolidSyslogError) TEST(SolidSyslogError, ErrorWithDefaultHandlerDoesNotCrash) { - SolidSyslog_Error(SolidSyslogSeverity_Error, "test message"); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, "test message"); } TEST(SolidSyslogError, InstalledHandlerReceivesSeverityMessageAndContext) { ErrorHandlerFake_Install(&sentinel); - SolidSyslog_Error(SolidSyslogSeverity_Warning, "warning message"); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_WARNING, "warning message"); CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); - LONGS_EQUAL(SolidSyslogSeverity_Warning, ErrorHandlerFake_LastSeverity()); + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); STRCMP_EQUAL("warning message", ErrorHandlerFake_LastMessage()); POINTERS_EQUAL(&sentinel, ErrorHandlerFake_LastContext()); } @@ -44,7 +44,7 @@ TEST(SolidSyslogError, SetErrorHandlerWithNullHandlerRestoresDefault) ErrorHandlerFake_Install(&sentinel); SolidSyslog_SetErrorHandler(nullptr, &sentinel); - SolidSyslog_Error(SolidSyslogSeverity_Error, "should not be observed"); + SolidSyslog_Error(SOLIDSYSLOG_SEVERITY_ERROR, "should not be observed"); CHECK_NOTHING_REPORTED(); } diff --git a/Tests/SolidSyslogGetAddrInfoResolverTest.cpp b/Tests/SolidSyslogGetAddrInfoResolverTest.cpp index 7ab969af..4cf99346 100644 --- a/Tests/SolidSyslogGetAddrInfoResolverTest.cpp +++ b/Tests/SolidSyslogGetAddrInfoResolverTest.cpp @@ -38,7 +38,7 @@ TEST_GROUP(SolidSyslogGetAddrInfoResolver) SolidSyslogGetAddrInfoResolver_Destroy(); } - bool Resolve(const char* host, uint16_t port, enum SolidSyslogTransport transport = SolidSyslogTransport_Udp) + bool Resolve(const char* host, uint16_t port, enum SolidSyslogTransport transport = SOLIDSYSLOG_TRANSPORT_UDP) { struct SolidSyslogAddress* address = SolidSyslogAddress_FromStorage(&resultStorage); return SolidSyslogResolver_Resolve(resolver, transport, host, port, address); @@ -94,13 +94,13 @@ TEST(SolidSyslogGetAddrInfoResolver, GetAddrInfoCalledWithHostArgument) TEST(SolidSyslogGetAddrInfoResolver, UdpTransportPassesDatagramSocktype) { - Resolve(TEST_HOST, TEST_PORT, SolidSyslogTransport_Udp); + Resolve(TEST_HOST, TEST_PORT, SOLIDSYSLOG_TRANSPORT_UDP); LONGS_EQUAL(SOCK_DGRAM, SocketFake_LastGetAddrInfoSocktype()); } TEST(SolidSyslogGetAddrInfoResolver, TcpTransportPassesStreamSocktype) { - Resolve(TEST_HOST, TEST_PORT, SolidSyslogTransport_Tcp); + Resolve(TEST_HOST, TEST_PORT, SOLIDSYSLOG_TRANSPORT_TCP); LONGS_EQUAL(SOCK_STREAM, SocketFake_LastGetAddrInfoSocktype()); } diff --git a/Tests/SolidSyslogMetaSdTest.cpp b/Tests/SolidSyslogMetaSdTest.cpp index 90291ef3..ce9257cf 100644 --- a/Tests/SolidSyslogMetaSdTest.cpp +++ b/Tests/SolidSyslogMetaSdTest.cpp @@ -272,7 +272,7 @@ TEST(SolidSyslogMetaSd, CreateWithNullConfigReportsWarning) recreateWith(nullptr); CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); - LONGS_EQUAL(SolidSyslogSeverity_Warning, ErrorHandlerFake_LastSeverity()); + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); STRCMP_EQUAL("SolidSyslogMetaSd_Create called with NULL config", ErrorHandlerFake_LastMessage()); } @@ -282,6 +282,6 @@ TEST(SolidSyslogMetaSd, CreateWithNullCounterReportsWarning) recreate(); CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); - LONGS_EQUAL(SolidSyslogSeverity_Warning, ErrorHandlerFake_LastSeverity()); + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_WARNING, ErrorHandlerFake_LastSeverity()); STRCMP_EQUAL("SolidSyslogMetaSd_Create config.Counter is NULL", ErrorHandlerFake_LastMessage()); } diff --git a/Tests/SolidSyslogPosixDatagramTest.cpp b/Tests/SolidSyslogPosixDatagramTest.cpp index 5244bba7..0308a271 100644 --- a/Tests/SolidSyslogPosixDatagramTest.cpp +++ b/Tests/SolidSyslogPosixDatagramTest.cpp @@ -146,7 +146,7 @@ TEST(SolidSyslogPosixDatagram, SendToReturnsSentOnSuccess) { SolidSyslogDatagram_Open(datagram); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Sent, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } @@ -156,7 +156,7 @@ TEST(SolidSyslogPosixDatagram, SendToReturnsFailedOnSendtoFailure) SolidSyslogDatagram_Open(datagram); SocketFake_SetSendtoFails(true); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Failed, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } @@ -213,7 +213,7 @@ TEST(SolidSyslogPosixDatagram, SendToReturnsOversizeOnEmsgsize) SolidSyslogDatagram_Open(datagram); SocketFake_FailNextSendtoWithErrno(EMSGSIZE); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Oversize, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } @@ -247,7 +247,7 @@ TEST(SolidSyslogPosixDatagram, SendToReturnsFailedWhenConnectFails) SolidSyslogDatagram_Open(datagram); SocketFake_SetConnectFails(true); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Failed, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } diff --git a/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp b/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp index df4e9408..2afd53c6 100644 --- a/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp +++ b/Tests/SolidSyslogPosixMessageQueueBufferTest.cpp @@ -105,7 +105,7 @@ TEST(SolidSyslogPosixMessageQueueBuffer, ServiceSendsMessageWrittenViaLog) SolidSyslogConfig config = {buffer, fakeSender, nullptr, nullptr, nullptr, nullptr, nullStore, nullptr, 0}; SolidSyslog_Create(&config); - SolidSyslogMessage message = {SolidSyslogFacility_Local0, SolidSyslogSeverity_Informational, nullptr, nullptr}; + SolidSyslogMessage message = {SOLIDSYSLOG_FACILITY_LOCAL0, SOLIDSYSLOG_SEVERITY_INFORMATIONAL, nullptr, nullptr}; SolidSyslog_Log(&message); SolidSyslog_Service(); CALLED_FAKE_ON(SenderFake_Send, fakeSender, ONCE); diff --git a/Tests/SolidSyslogPrivalTest.cpp b/Tests/SolidSyslogPrivalTest.cpp index 984627ba..ef443485 100644 --- a/Tests/SolidSyslogPrivalTest.cpp +++ b/Tests/SolidSyslogPrivalTest.cpp @@ -5,40 +5,40 @@ TEST_GROUP(SolidSyslogPrival){}; TEST(SolidSyslogPrival, FacilityEnumValuesMatchRfc5424) { - LONGS_EQUAL(0, SolidSyslogFacility_Kern); - LONGS_EQUAL(1, SolidSyslogFacility_User); - LONGS_EQUAL(2, SolidSyslogFacility_Mail); - LONGS_EQUAL(3, SolidSyslogFacility_Daemon); - LONGS_EQUAL(4, SolidSyslogFacility_Auth); - LONGS_EQUAL(5, SolidSyslogFacility_Syslog); - LONGS_EQUAL(6, SolidSyslogFacility_Lpr); - LONGS_EQUAL(7, SolidSyslogFacility_News); - LONGS_EQUAL(8, SolidSyslogFacility_Uucp); - LONGS_EQUAL(9, SolidSyslogFacility_Cron); - LONGS_EQUAL(10, SolidSyslogFacility_AuthPriv); - LONGS_EQUAL(11, SolidSyslogFacility_Ftp); - LONGS_EQUAL(12, SolidSyslogFacility_Ntp); - LONGS_EQUAL(13, SolidSyslogFacility_Audit); - LONGS_EQUAL(14, SolidSyslogFacility_Alert); - LONGS_EQUAL(15, SolidSyslogFacility_Clock); - LONGS_EQUAL(16, SolidSyslogFacility_Local0); - LONGS_EQUAL(17, SolidSyslogFacility_Local1); - LONGS_EQUAL(18, SolidSyslogFacility_Local2); - LONGS_EQUAL(19, SolidSyslogFacility_Local3); - LONGS_EQUAL(20, SolidSyslogFacility_Local4); - LONGS_EQUAL(21, SolidSyslogFacility_Local5); - LONGS_EQUAL(22, SolidSyslogFacility_Local6); - LONGS_EQUAL(23, SolidSyslogFacility_Local7); + LONGS_EQUAL(0, SOLIDSYSLOG_FACILITY_KERN); + LONGS_EQUAL(1, SOLIDSYSLOG_FACILITY_USER); + LONGS_EQUAL(2, SOLIDSYSLOG_FACILITY_MAIL); + LONGS_EQUAL(3, SOLIDSYSLOG_FACILITY_DAEMON); + LONGS_EQUAL(4, SOLIDSYSLOG_FACILITY_AUTH); + LONGS_EQUAL(5, SOLIDSYSLOG_FACILITY_SYSLOG); + LONGS_EQUAL(6, SOLIDSYSLOG_FACILITY_LPR); + LONGS_EQUAL(7, SOLIDSYSLOG_FACILITY_NEWS); + LONGS_EQUAL(8, SOLIDSYSLOG_FACILITY_UUCP); + LONGS_EQUAL(9, SOLIDSYSLOG_FACILITY_CRON); + LONGS_EQUAL(10, SOLIDSYSLOG_FACILITY_AUTH_PRIV); + LONGS_EQUAL(11, SOLIDSYSLOG_FACILITY_FTP); + LONGS_EQUAL(12, SOLIDSYSLOG_FACILITY_NTP); + LONGS_EQUAL(13, SOLIDSYSLOG_FACILITY_AUDIT); + LONGS_EQUAL(14, SOLIDSYSLOG_FACILITY_ALERT); + LONGS_EQUAL(15, SOLIDSYSLOG_FACILITY_CLOCK); + LONGS_EQUAL(16, SOLIDSYSLOG_FACILITY_LOCAL0); + LONGS_EQUAL(17, SOLIDSYSLOG_FACILITY_LOCAL1); + LONGS_EQUAL(18, SOLIDSYSLOG_FACILITY_LOCAL2); + LONGS_EQUAL(19, SOLIDSYSLOG_FACILITY_LOCAL3); + LONGS_EQUAL(20, SOLIDSYSLOG_FACILITY_LOCAL4); + LONGS_EQUAL(21, SOLIDSYSLOG_FACILITY_LOCAL5); + LONGS_EQUAL(22, SOLIDSYSLOG_FACILITY_LOCAL6); + LONGS_EQUAL(23, SOLIDSYSLOG_FACILITY_LOCAL7); } TEST(SolidSyslogPrival, SeverityEnumValuesMatchRfc5424) { - LONGS_EQUAL(0, SolidSyslogSeverity_Emergency); - LONGS_EQUAL(1, SolidSyslogSeverity_Alert); - LONGS_EQUAL(2, SolidSyslogSeverity_Critical); - LONGS_EQUAL(3, SolidSyslogSeverity_Error); - LONGS_EQUAL(4, SolidSyslogSeverity_Warning); - LONGS_EQUAL(5, SolidSyslogSeverity_Notice); - LONGS_EQUAL(6, SolidSyslogSeverity_Informational); - LONGS_EQUAL(7, SolidSyslogSeverity_Debug); + LONGS_EQUAL(0, SOLIDSYSLOG_SEVERITY_EMERGENCY); + LONGS_EQUAL(1, SOLIDSYSLOG_SEVERITY_ALERT); + LONGS_EQUAL(2, SOLIDSYSLOG_SEVERITY_CRITICAL); + LONGS_EQUAL(3, SOLIDSYSLOG_SEVERITY_ERROR); + LONGS_EQUAL(4, SOLIDSYSLOG_SEVERITY_WARNING); + LONGS_EQUAL(5, SOLIDSYSLOG_SEVERITY_NOTICE); + LONGS_EQUAL(6, SOLIDSYSLOG_SEVERITY_INFORMATIONAL); + LONGS_EQUAL(7, SOLIDSYSLOG_SEVERITY_DEBUG); } diff --git a/Tests/SolidSyslogTest.cpp b/Tests/SolidSyslogTest.cpp index 4dff6eba..7fa9526e 100644 --- a/Tests/SolidSyslogTest.cpp +++ b/Tests/SolidSyslogTest.cpp @@ -371,7 +371,7 @@ TEST_GROUP(SolidSyslog) config = {buffer, nullptr, nullptr, StringFake_GetHostname, StringFake_GetAppName, StringFake_GetProcessId, store, nullptr, 0}; SolidSyslog_Create(&config); // cppcheck-suppress unreadVariable -- read via Log() through &message; cppcheck does not model CppUTest macros - message = {SolidSyslogFacility_Local0, SolidSyslogSeverity_Informational, nullptr, nullptr}; + message = {SOLIDSYSLOG_FACILITY_LOCAL0, SOLIDSYSLOG_SEVERITY_INFORMATIONAL, nullptr, nullptr}; } void teardown() override @@ -418,42 +418,42 @@ TEST(SolidSyslog, PriValIs134) TEST(SolidSyslog, FacilityAppearsInPrival) { - message.Facility = SolidSyslogFacility_News; + message.Facility = SOLIDSYSLOG_FACILITY_NEWS; Log(); CHECK_PRIVAL("<62>"); } TEST(SolidSyslog, SeverityAppearsInPrival) { - message.Severity = SolidSyslogSeverity_Critical; + message.Severity = SOLIDSYSLOG_SEVERITY_CRITICAL; Log(); CHECK_PRIVAL("<130>"); } TEST(SolidSyslog, LowestFacilityProducesCorrectPrival) { - message.Facility = SolidSyslogFacility_Kern; + message.Facility = SOLIDSYSLOG_FACILITY_KERN; Log(); CHECK_PRIVAL("<6>"); } TEST(SolidSyslog, HighestFacilityProducesCorrectPrival) { - message.Facility = SolidSyslogFacility_Local7; + message.Facility = SOLIDSYSLOG_FACILITY_LOCAL7; Log(); CHECK_PRIVAL("<190>"); } TEST(SolidSyslog, LowestSeverityProducesCorrectPrival) { - message.Severity = SolidSyslogSeverity_Emergency; + message.Severity = SOLIDSYSLOG_SEVERITY_EMERGENCY; Log(); CHECK_PRIVAL("<128>"); } TEST(SolidSyslog, HighestSeverityProducesCorrectPrival) { - message.Severity = SolidSyslogSeverity_Debug; + message.Severity = SOLIDSYSLOG_SEVERITY_DEBUG; Log(); CHECK_PRIVAL("<135>"); } @@ -468,7 +468,7 @@ TEST(SolidSyslog, OutOfRangeFacilityProducesErrorPrival) TEST(SolidSyslog, OutOfRangeSeverityProducesErrorPrival) { - enum SolidSyslogSeverity invalid = SolidSyslogSeverity_Debug; + enum SolidSyslogSeverity invalid = SOLIDSYSLOG_SEVERITY_DEBUG; // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange) -- intentionally testing out-of-range input invalid = static_cast(static_cast(invalid) + 1); message.Severity = invalid; @@ -1261,8 +1261,8 @@ TEST(SolidSyslog, AllFieldsAtMaxLengthProducesValidMessage) config.Clock = StubClock; SolidSyslog_Destroy(); SolidSyslog_Create(&config); - message.Facility = SolidSyslogFacility_Local7; - message.Severity = SolidSyslogSeverity_Debug; + message.Facility = SOLIDSYSLOG_FACILITY_LOCAL7; + message.Severity = SOLIDSYSLOG_SEVERITY_DEBUG; Log(); CHECK_PRIVAL("<191>"); CHECK_TIMESTAMP("9999-12-31T23:59:59.999999+14:00"); @@ -1542,7 +1542,7 @@ TEST_GROUP(SolidSyslogServiceEagerDrain) void setup() override { static SolidSyslogCircularBufferStorage bufferStorage[ - SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE_BYTES(BUFFER_BYTES)]; + SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE_BYTES(BUFFER_BYTES)]; fakeSender = SenderFake_Create(); circularBuffer = SolidSyslogCircularBuffer_Create( @@ -1641,7 +1641,7 @@ TEST_GROUP(SolidSyslogLifecycle) { SolidSyslog_Destroy(); // cppcheck-suppress unreadVariable -- read via Log() in tests; cppcheck does not model CppUTest macros - message = {SolidSyslogFacility_Local0, SolidSyslogSeverity_Informational, nullptr, nullptr}; + message = {SOLIDSYSLOG_FACILITY_LOCAL0, SOLIDSYSLOG_SEVERITY_INFORMATIONAL, nullptr, nullptr}; // cppcheck-suppress unreadVariable -- read via validConfig() in tests; cppcheck does not model CppUTest macros sender = SenderFake_Create(); // cppcheck-suppress unreadVariable -- read via validConfig() in tests; cppcheck does not model CppUTest macros diff --git a/Tests/SolidSyslogUdpSenderTest.cpp b/Tests/SolidSyslogUdpSenderTest.cpp index 8f44943e..9d7a936a 100644 --- a/Tests/SolidSyslogUdpSenderTest.cpp +++ b/Tests/SolidSyslogUdpSenderTest.cpp @@ -591,8 +591,8 @@ TEST(SolidSyslogUdpSenderRetry, SuccessfulSendDoesNotQueryMaxPayload) TEST(SolidSyslogUdpSenderRetry, OversizeQueriesMaxPayloadAndRetries) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Sent); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT); maxPayload(3); Send(); CALLED_DATAGRAM_MAX_PAYLOAD(ONCE); @@ -601,8 +601,8 @@ TEST(SolidSyslogUdpSenderRetry, OversizeQueriesMaxPayloadAndRetries) TEST(SolidSyslogUdpSenderRetry, OversizeRetryTrimsBufferToMaxPayload) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Sent); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT); maxPayload(3); Send(); LONGS_EQUAL(3, retrySendSize()); @@ -610,8 +610,8 @@ TEST(SolidSyslogUdpSenderRetry, OversizeRetryTrimsBufferToMaxPayload) TEST(SolidSyslogUdpSenderRetry, OversizeRetrySucceedsReturnsTrue) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Sent); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT); maxPayload(3); CHECK_TRUE(Send()); } @@ -621,8 +621,8 @@ TEST(SolidSyslogUdpSenderRetry, OversizeRetrySucceedsReturnsTrue) TEST(SolidSyslogUdpSenderRetry, OversizeRetryWalksBackToCodepointBoundary) { const uint8_t payload[] = {0x61, 0x62, 0xC3, 0xA9}; - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Sent); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT); maxPayload(3); Send(payload, sizeof(payload)); LONGS_EQUAL(2, retrySendSize()); @@ -634,16 +634,16 @@ TEST(SolidSyslogUdpSenderRetry, OversizeRetryWalksBackToCodepointBoundary) * Swallow: drop the message and return true so the caller moves on. */ TEST(SolidSyslogUdpSenderRetry, DoubleOversizeReturnsTrueToAvoidPermanentLoop) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Oversize); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); maxPayload(3); CHECK_TRUE(Send()); } TEST(SolidSyslogUdpSenderRetry, DoubleOversizeDoesNotSendThird) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Oversize); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); maxPayload(3); Send(); CALLED_DATAGRAM_SEND(TWICE); @@ -651,7 +651,7 @@ TEST(SolidSyslogUdpSenderRetry, DoubleOversizeDoesNotSendThird) TEST(SolidSyslogUdpSenderRetry, ZeroMaxPayloadSkipsRetrySend) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); maxPayload(0); Send(); CALLED_DATAGRAM_SEND(ONCE); @@ -662,7 +662,7 @@ TEST(SolidSyslogUdpSenderRetry, ZeroMaxPayloadSkipsRetrySend) * Service algorithm discards rather than retrying forever. */ TEST(SolidSyslogUdpSenderRetry, ZeroMaxPayloadReturnsTrueToAvoidPermanentLoop) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); maxPayload(0); CHECK_TRUE(Send()); } @@ -672,8 +672,8 @@ TEST(SolidSyslogUdpSenderRetry, ZeroMaxPayloadReturnsTrueToAvoidPermanentLoop) * Buffered/Service algorithm keeps the message for retry. */ TEST(SolidSyslogUdpSenderRetry, RetryFailedNonOversizeReturnsFalse) { - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Failed); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED); maxPayload(3); CHECK_FALSE(Send()); } @@ -685,8 +685,8 @@ TEST(SolidSyslogUdpSenderRetry, MaxPayloadLargerThanMessageCapsTrimToMessageSize * the original message. The trim must cap at the message size to * avoid reading past the buffer. */ const uint8_t payload[] = {0x61, 0x62, 0x63}; - firstSendReturns(SolidSyslogDatagramSendResult_Oversize); - retrySendReturns(SolidSyslogDatagramSendResult_Sent); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE); + retrySendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT); maxPayload(9999); Send(payload, sizeof(payload)); LONGS_EQUAL(sizeof(payload), retrySendSize()); @@ -694,7 +694,7 @@ TEST(SolidSyslogUdpSenderRetry, MaxPayloadLargerThanMessageCapsTrimToMessageSize TEST(SolidSyslogUdpSenderRetry, NonOversizeFailureDoesNotRetry) { - firstSendReturns(SolidSyslogDatagramSendResult_Failed); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED); Send(); CALLED_DATAGRAM_SEND(ONCE); CALLED_DATAGRAM_MAX_PAYLOAD(NEVER); @@ -702,7 +702,7 @@ TEST(SolidSyslogUdpSenderRetry, NonOversizeFailureDoesNotRetry) TEST(SolidSyslogUdpSenderRetry, NonOversizeFailureReturnsFalse) { - firstSendReturns(SolidSyslogDatagramSendResult_Failed); + firstSendReturns(SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED); CHECK_FALSE(Send()); } diff --git a/Tests/SolidSyslogWinsockDatagramTest.cpp b/Tests/SolidSyslogWinsockDatagramTest.cpp index e814521d..deb29881 100644 --- a/Tests/SolidSyslogWinsockDatagramTest.cpp +++ b/Tests/SolidSyslogWinsockDatagramTest.cpp @@ -150,7 +150,7 @@ TEST(SolidSyslogWinsockDatagram, SendToReturnsSentOnSuccess) { SolidSyslogDatagram_Open(datagram); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Sent, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_SENT, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } @@ -160,7 +160,7 @@ TEST(SolidSyslogWinsockDatagram, SendToReturnsFailedOnSendtoFailure) SolidSyslogDatagram_Open(datagram); WinsockFake_SetSendtoFails(true); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Failed, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } @@ -217,7 +217,7 @@ TEST(SolidSyslogWinsockDatagram, SendToReturnsOversizeOnWsaemsgsize) SolidSyslogDatagram_Open(datagram); WinsockFake_FailNextSendtoWithLastError(WSAEMSGSIZE); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Oversize, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_OVERSIZE, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } @@ -227,7 +227,7 @@ TEST(SolidSyslogWinsockDatagram, SendToReturnsFailedWhenConnectFails) SolidSyslogDatagram_Open(datagram); WinsockFake_SetConnectFails(true); LONGS_EQUAL( - SolidSyslogDatagramSendResult_Failed, + SOLIDSYSLOG_DATAGRAM_SEND_RESULT_FAILED, SolidSyslogDatagram_SendTo(datagram, TEST_MESSAGE, TEST_MESSAGE_LEN, addr) ); } diff --git a/Tests/SolidSyslogWinsockResolverTest.cpp b/Tests/SolidSyslogWinsockResolverTest.cpp index 1cc6879c..84753684 100644 --- a/Tests/SolidSyslogWinsockResolverTest.cpp +++ b/Tests/SolidSyslogWinsockResolverTest.cpp @@ -38,7 +38,7 @@ TEST_GROUP(SolidSyslogWinsockResolver) SolidSyslogWinsockResolver_Destroy(); } - bool Resolve(const char* host, uint16_t port, enum SolidSyslogTransport transport = SolidSyslogTransport_Udp) + bool Resolve(const char* host, uint16_t port, enum SolidSyslogTransport transport = SOLIDSYSLOG_TRANSPORT_UDP) { struct SolidSyslogAddress* address = SolidSyslogAddress_FromStorage(&resultStorage); return SolidSyslogResolver_Resolve(resolver, transport, host, port, address); @@ -94,13 +94,13 @@ TEST(SolidSyslogWinsockResolver, GetAddrInfoCalledWithHostArgument) TEST(SolidSyslogWinsockResolver, UdpTransportPassesDatagramSocktype) { - Resolve(TEST_HOST, TEST_PORT, SolidSyslogTransport_Udp); + Resolve(TEST_HOST, TEST_PORT, SOLIDSYSLOG_TRANSPORT_UDP); LONGS_EQUAL(SOCK_DGRAM, WinsockFake_LastGetAddrInfoSocktype()); } TEST(SolidSyslogWinsockResolver, TcpTransportPassesStreamSocktype) { - Resolve(TEST_HOST, TEST_PORT, SolidSyslogTransport_Tcp); + Resolve(TEST_HOST, TEST_PORT, SOLIDSYSLOG_TRANSPORT_TCP); LONGS_EQUAL(SOCK_STREAM, WinsockFake_LastGetAddrInfoSocktype()); } diff --git a/Tests/Support/ErrorHandlerFake.c b/Tests/Support/ErrorHandlerFake.c index b62b11ed..783ebde3 100644 --- a/Tests/Support/ErrorHandlerFake.c +++ b/Tests/Support/ErrorHandlerFake.c @@ -20,7 +20,7 @@ static void Handle(void* context, enum SolidSyslogSeverity severity, const char* void ErrorHandlerFake_Install(void* context) { handleCallCount = 0; - lastSeverity = SolidSyslogSeverity_Debug; + lastSeverity = SOLIDSYSLOG_SEVERITY_DEBUG; lastMessage = NULL; lastContext = NULL; SolidSyslog_SetErrorHandler(Handle, context); diff --git a/Tests/Support/ErrorHandlerFake.h b/Tests/Support/ErrorHandlerFake.h index b91c14d0..9a90a3eb 100644 --- a/Tests/Support/ErrorHandlerFake.h +++ b/Tests/Support/ErrorHandlerFake.h @@ -23,12 +23,12 @@ EXTERN_C_END * Callers must bring CALLED_FAKE / ONCE / NEVER into scope with * `using namespace CososoTesting;` (existing convention in this codebase). */ // NOLINTBEGIN(cppcoreguidelines-macro-usage,cppcoreguidelines-avoid-do-while) -- macros preserve __FILE__/__LINE__ in test failure output -#define CHECK_REPORTED_ERROR(expectedMessage) \ - do \ - { \ - CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ - LONGS_EQUAL(SolidSyslogSeverity_Error, ErrorHandlerFake_LastSeverity()); \ - STRCMP_EQUAL((expectedMessage), ErrorHandlerFake_LastMessage()); \ +#define CHECK_REPORTED_ERROR(expectedMessage) \ + do \ + { \ + CALLED_FAKE(ErrorHandlerFake_Handle, ONCE); \ + LONGS_EQUAL(SOLIDSYSLOG_SEVERITY_ERROR, ErrorHandlerFake_LastSeverity()); \ + STRCMP_EQUAL((expectedMessage), ErrorHandlerFake_LastMessage()); \ } while (0) #define CHECK_NOTHING_REPORTED() CALLED_FAKE(ErrorHandlerFake_Handle, NEVER) diff --git a/docs/NAMING.md b/docs/NAMING.md index 11b2bfdf..592dfb2e 100644 --- a/docs/NAMING.md +++ b/docs/NAMING.md @@ -109,13 +109,12 @@ struct SolidSyslogSecurityPolicy /* ... */ }; -/* Public enum constants follow the same prefix rule. PascalCase - * (rather than SCREAMING_SNAKE) is what disambiguates them from - * macros (rule 5.5). */ +/* Public enum constants — SCREAMING_SNAKE with the project prefix. + * Single rule for tagged and anonymous enums tree-wide. */ enum SolidSyslogSeverity { - SolidSyslogSeverity_Emergency = 0, - SolidSyslogSeverity_Alert = 1, + SOLIDSYSLOG_SEVERITY_EMERGENCY = 0, + SOLIDSYSLOG_SEVERITY_ALERT = 1, /* ... */ }; ``` @@ -541,39 +540,59 @@ pressure from rule 5.4.) **Exceptions:** CppUTest's `TEST`, `TEST_GROUP`, `CHECK_*`, `LONGS_EQUAL`, etc. are used unmodified — see Tests below. -### Anonymous-enum named-constant idiom +### Enum constants -`enum { NAME = value };` (an enum with no tag) is the project's -type-safe alternative to `#define` for integer constants. The form is -distinct from tagged enums (Tier 1 `SolidSyslog` tags with -`SolidSyslog_Constant` members) in both shape and purpose — an -anonymous enum is a macro replacement, not a public type. +All enum constants — tagged or anonymous, public or TU-local — are +`SCREAMING_SNAKE`. One rule, mechanically enforced by clang-tidy +(`EnumConstantCase: UPPER_CASE`, no exceptions). ```c -/* Public, in a header — Tier 1 macro-equivalent */ +/* Tagged public enum — Tier 1 type with named members */ +enum SolidSyslogSeverity +{ + SOLIDSYSLOG_SEVERITY_EMERGENCY = 0, + SOLIDSYSLOG_SEVERITY_ALERT = 1, + /* ... */ +}; + +/* Anonymous public enum — Tier 1 macro-equivalent */ enum { - SOLIDSYSLOG_CIRCULARBUFFER_OVERHEAD = 7, - SOLIDSYSLOG_CIRCULARBUFFER_HEADER_BYTES = sizeof(uint16_t) + SOLIDSYSLOG_CIRCULAR_BUFFER_OVERHEAD = 7, + SOLIDSYSLOG_CIRCULAR_BUFFER_HEADER_BYTES = sizeof(uint16_t) }; -/* File-scope, in a .c — Tier 2 macro-equivalent */ +/* Anonymous TU-local enum — Tier 2 macro-equivalent */ enum { - HEADER_BYTES = SOLIDSYSLOG_CIRCULARBUFFER_HEADER_BYTES + HEADER_BYTES = SOLIDSYSLOG_CIRCULAR_BUFFER_HEADER_BYTES }; ``` -Casing follows the **macro** convention, not the enum-constant -convention: `SOLIDSYSLOG_*` for public sites, bare `SCREAMING_SNAKE` -for file-scope sites. clang-tidy's `EnumConstantIgnoredRegexp` accepts -this shape so the rule for tagged-enum constants -(`SolidSyslog_Constant`) stays tight without forcing rename of -the macro-replacement form. - -MISRA rule 2.4 (unused tag declarations) cppcheck-fires on anonymous -enums even though they have no tag. The project-wide deviation **D.010** -covers all such sites — see `docs/misra-deviations.md#d010`. +**Word boundaries.** Snake-separate at every CamelCase boundary in the +source identifier (`DatagramSendResult` → `DATAGRAM_SEND_RESULT`, +`AuthPriv` → `AUTH_PRIV`). Trailing digits stay glued to the preceding +word (`Local0` → `LOCAL0`). + +**Project prefix.** Public sites (anywhere visible outside a single +TU) carry `SOLIDSYSLOG_`. TU-local anonymous-enum constants +(`IPV4_HEADER_BYTES`, `UINT32_MAX_DECIMAL_DIGITS`) don't. clang-tidy +cannot distinguish public from TU-local enum constants syntactically; +the prefix rule for public sites is enforced by review and by +cppcheck-misra rule 5.4 distinctness. + +The anonymous-enum named-constant idiom is itself unchanged — it's +still the project's type-safe alternative to `#define` for integer +constants, distinct in shape from tagged enums in purpose if not in +casing. MISRA rule 2.4 (unused tag declarations) cppcheck-fires on +anonymous enums; the project-wide deviation **D.010** covers all such +sites — see `docs/misra-deviations.md#d010`. + +This single-rule convention replaces the S10.07/S10.12 split where +tagged-enum constants used `SolidSyslog_Constant` (PascalCase, +class-scoped) and anonymous-enum constants used SCREAMING_SNAKE. The +split was hard to enforce mechanically (only judgement separated the +two cases) and was drifting in S10.16; S10.22 collapsed it. --- @@ -643,7 +662,7 @@ struct SolidSyslogBuffer /* Core/Interface/SolidSyslogCircularBuffer.h ---------------------------- */ -#define SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE_BYTES(bytes) /* ... */ +#define SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE_BYTES(bytes) /* ... */ typedef size_t SolidSyslogCircularBufferStorage; @@ -742,7 +761,7 @@ static inline bool CircularBuffer_IsEmpty(const struct SolidSyslogCircularBuffer | Public function | `SolidSyslogClass_Function` | `SolidSyslogBuffer_Append` | | Public struct tag | `SolidSyslogClass` | `struct SolidSyslogBuffer` | | Public enum type | `SolidSyslogClass` | `enum SolidSyslogSeverity` | -| Public enum constant | `SolidSyslogClass_Constant` | `SolidSyslogSeverity_Emergency` | +| Public enum constant | `SOLIDSYSLOG_CLASS_CONSTANT` | `SOLIDSYSLOG_SEVERITY_EMERGENCY` | | Public macro | `SOLIDSYSLOG_SCREAMING_SNAKE` | `SOLIDSYSLOG_MAXIMUM_RECORD_LENGTH` | | Public typedef (enum/fn-pointer only) | `SolidSyslogClass` / `SolidSyslogClass_Fn` | `SolidSyslogTransport_SendFn` | | Static function | `Class_Function` | `Buffer_WriteMagic` | diff --git a/docs/misra-conformance.md b/docs/misra-conformance.md index 072c021e..9faf79e1 100644 --- a/docs/misra-conformance.md +++ b/docs/misra-conformance.md @@ -84,7 +84,7 @@ following verdicts: | Kind | Count | Top sites | Verdict | Rationale | Owner | |------|------:|-----------|---------|-----------|-------| -| **enum constant** | 252 → 101 *(named enums landed in S10.07; anonymous-enum idiom unchanged)* | `SolidSyslogPrival.h` (128 — `SOLIDSYSLOG_FACILITY_*`, `SOLIDSYSLOG_SEVERITY_*`), `SolidSyslogTransport.h` (24), `SolidSyslogBlockStore.h` (12) | **Mixed** | `docs/NAMING.md` already specifies `SolidSyslogClass_Constant` form (e.g. `SolidSyslogSeverity_Emergency`) for *tagged* enums — renamed across the tree in five per-enum slices on `feat/s10-07-enum-rename`. The remaining 101 findings are the anonymous-`enum { … };` named-constant idiom (`SOLIDSYSLOG_ADDRESS_SIZE`, `SOLIDSYSLOG_MAX_HOST_SIZE`, `INVALID_FD`, …) — functionally macros, currently classified by clang-tidy as enum constants and so flagged by the prefix/case rules. Needs its own verdict: either re-classify as macro-equivalent and tighten the relevant `.clang-tidy` regex, or rename to a class-prefixed PascalCase form. Loose thread surfaced during S10.07 verification; carried into the S10.07-sibling or its own ticket. | **S10.07** (named enums); follow-up for anonymous-enum idiom | +| **enum constant** | 252 → 101 *(named enums landed in S10.07; anonymous-enum idiom unchanged)* | `SolidSyslogPrival.h` (128 — `SOLIDSYSLOG_FACILITY_*`, `SOLIDSYSLOG_SEVERITY_*`), `SolidSyslogTransport.h` (24), `SolidSyslogBlockStore.h` (12) | **Mixed** | `docs/NAMING.md` already specifies `SolidSyslogClass_Constant` form (e.g. `SOLIDSYSLOG_SEVERITY_EMERGENCY`) for *tagged* enums — renamed across the tree in five per-enum slices on `feat/s10-07-enum-rename`. The remaining 101 findings are the anonymous-`enum { … };` named-constant idiom (`SOLIDSYSLOG_ADDRESS_SIZE`, `SOLIDSYSLOG_MAX_HOST_SIZE`, `INVALID_FD`, …) — functionally macros, currently classified by clang-tidy as enum constants and so flagged by the prefix/case rules. Needs its own verdict: either re-classify as macro-equivalent and tighten the relevant `.clang-tidy` regex, or rename to a class-prefixed PascalCase form. Loose thread surfaced during S10.07 verification; carried into the S10.07-sibling or its own ticket. | **S10.07** (named enums); follow-up for anonymous-enum idiom | | **member** | 128 → 186 → 0 *(post Tier 4 re-statement; sweep landed in S10.09)* | Pre-change: `SolidSyslog*Definition.h` headers (vtable function-pointer members in PascalCase). Post-change: ~186 data members in lowerCamelCase across `SolidSyslog*Config`, impl structs, helper structs, and test fakes. | **Disable original + Fix — landed in S10.09** | The original 128 findings were all vtable function-pointer members in PascalCase, flagged because Tier 4 was previously `lowerCamelCase`. **Tier 4 was re-stated in S10.05 to `PascalCase` for all members** — a single rule with no member-kind exception. `.clang-tidy` flipped to `MemberCase: CamelCase`. The 128 vtable warnings disappeared and **S10.09 cleared the 186 lowerCamelCase data-member warnings** with a per-cluster sweep (Formatter → storage → buffer → sender impls → sender Configs + fakes → SD → sync/atomics → top-level public structs + impl `struct SolidSyslog`). `analyze-tidy` reports zero `readability-identifier-naming` member findings post-S10.09. | landed in **S10.09** | | **global function** | 12 → 0 *(post Tier 1 second-shape addition)* | `SolidSyslogError.h` (8 — `SolidSyslog_SetErrorHandler`, `SolidSyslog_Error`), `SolidSyslog.h` (2 — `SolidSyslog_Log`, `SolidSyslog_Service`), `SolidSyslogConfig.h` (2 — `SolidSyslog_Create`, `SolidSyslog_Destroy`) | **Disable + landed in S10.05** | All six unique function names follow the form `SolidSyslog_` — the library-level API entry points. **NAMING.md Tier 1 was re-stated in this story** to recognise `SolidSyslog_` as a first-class shape for whole-library operations (alongside `SolidSyslog_` for class-scoped ones). `.clang-tidy` gained a `GlobalFunctionIgnoredRegexp` of `^SolidSyslog_[A-Z][A-Za-z0-9]*$` to accept the shape. The 12 warnings vanished in this commit. | NAMING.md + `.clang-tidy` landed here | | **enum** | 8 → 0 *(landed in S10.07)* | `SolidSyslogPrival.h` (8 — `SolidSyslog_Facility`, `SolidSyslog_Severity`) | **Fix — landed in S10.07** | Enum tag names should be `SolidSyslogFacility` and `SolidSyslogSeverity` (no underscore) per NAMING.md Tier 1 struct/enum rule. The underscore is residue. Renamed alongside the enum constants in the same per-enum slices. | **S10.07** | @@ -134,7 +134,7 @@ Each row carries the cppcheck addon's count. The verdict reflects how the rule s | **10.8** | 2 → 0 *(landed in S10.10)* | Composite-expression cast to wider essential type | `SolidSyslog.c` (2) | **Fix — landed in S10.10** | Hoisted the `(uint32_t)` cast to the top of `SolidSyslog_FormatNonZeroUtcOffset` so the hours/minutes split uses `uint32_t / 60U` and `% 60U` without casting a composite expression. | **S10.10** | | **18.7** (advisory) | 2 | Flexible array members shall not be declared | `SolidSyslogCircularBuffer.c` (1), `SolidSyslogFormatter.c` (1) | **Deviate** | Flexible array members are the storage mechanism for `SolidSyslogFormatter` and `SolidSyslogCircularBuffer` — they hold caller-supplied storage of variable size. Removing them would require copying or fixed-size buffers. Document as deviation. | **S10.06** (D.005) | | **1.4** (advisory) | 2 | Emergent language features shall not be used | `SolidSyslogStdAtomicU32.c` (1), `SolidSyslogWindowsAtomicU32.c` (1) | **Deviate** | C11 `` is the project's atomic primitive on POSIX/clang/gcc/modern MSVC; we deliberately use C11 here and the alternative (`InterlockedCompareExchange`) is selected at link time on legacy MSVC. Use of C11 atomics is intentional, not accidental. | **S10.06** (D.006) | -| **2.5** (advisory) | 2 → 0 *(landed in S10.10)* | Unused macro | `SolidSyslogCircularBuffer.h` (2) | **Deviate — landed in S10.10** | Audit verdict had been "delete them" — that was wrong. The two `SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE[_BYTES]` macros are part of the public API; their consumers live under `Tests/` (Consistency-only tier) and `Bdd/Targets/` (Out of scope), so cppcheck-misra cannot see the call sites. Captured as **D.012**. | **S10.10** | +| **2.5** (advisory) | 2 → 0 *(landed in S10.10)* | Unused macro | `SolidSyslogCircularBuffer.h` (2) | **Deviate — landed in S10.10** | Audit verdict had been "delete them" — that was wrong. The two `SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE[_BYTES]` macros are part of the public API; their consumers live under `Tests/` (Consistency-only tier) and `Bdd/Targets/` (Out of scope), so cppcheck-misra cannot see the call sites. Captured as **D.012**. | **S10.10** | | **3.1** | 1 → 0 *(landed in S10.10)* | `/* */` shall not contain comment-start sequence | `SolidSyslogCrc16.c` (1) | **Fix — landed in S10.10** | The Crc16 banner contained a `https://` URL — the `//` inside the `/* */` is a nested comment-start. Dropped the protocol prefix and rephrased the citation. | **S10.10** | | **7.1** | 1 → 0 *(landed in S10.10)* | Octal constants shall not be used | `SolidSyslogPosixMessageQueueBuffer.c` (1) | **Fix — landed in S10.10** | `0600` (Posix file mode) replaced with a named hex enum `OWNER_READ_WRITE = 0x180U` in the file-scope anonymous-enum block. | **S10.10** | | **21.6** | 1 | The Standard Library `stdio.h` shall not be used | `SolidSyslogWindowsFile.c` (1) | **Deviate** *(resolved in S10.06)* | `WindowsFile.c` includes `` solely for `SEEK_SET` / `SEEK_END` constants used by `_lseeki64` from ``; no stdio function or type is referenced. Captured as **D.009**. | landed in **S10.06** | diff --git a/docs/misra-deviations.md b/docs/misra-deviations.md index 89e629c8..086197f0 100644 --- a/docs/misra-deviations.md +++ b/docs/misra-deviations.md @@ -69,7 +69,7 @@ The Tier 1 naming scheme in `docs/NAMING.md` (form 30–40 character range — `SolidSyslogFreeRtosStaticResolver_Create` is 40, `SolidSyslogFreeRtosTcpStream_Destroy` is 36 — and a few public storage-size enums sit just below 40 (e.g. -`SOLIDSYSLOG_FREERTOSSTATICRESOLVER_SIZE`, 39). Strict 31-character +`SOLIDSYSLOG_FREE_RTOS_STATIC_RESOLVER_SIZE`, 39). Strict 31-character distinctness would either collapse identifier pairs that read identically up to a trailing word (`SolidSyslogFreeRtosStaticResolver_Create` vs `_Destroy`) into a @@ -793,8 +793,8 @@ Project owner — David Cozens. Recorded under ### Deviation `Core/Interface/SolidSyslogCircularBuffer.h` declares two function-like -macros — `SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE_BYTES` and -`SOLIDSYSLOG_CIRCULARBUFFER_STORAGE_SIZE` — that integrator code uses +macros — `SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE_BYTES` and +`SOLIDSYSLOG_CIRCULAR_BUFFER_STORAGE_SIZE` — that integrator code uses to size caller-supplied storage. cppcheck-misra runs only over the Strict tier (`Core/Source/`) and Pragmatic tier (`Platform/*/Source/`); the actual consumers live under `Tests/` (Consistency-only tier) and