From 899dd6d96f532b5dc07b81529370611f1391cf84 Mon Sep 17 00:00:00 2001 From: Joseph Hickey Date: Tue, 22 Jun 2021 09:04:39 -0400 Subject: [PATCH] Partial #596, UtAssert macros for MSG test Update MSG coverage test to use preferred macros --- .../msg/ut-coverage/test_cfe_msg_ccsdsext.c | 276 +++++++------- .../msg/ut-coverage/test_cfe_msg_ccsdspri.c | 342 +++++++++--------- .../msg/ut-coverage/test_cfe_msg_checksum.c | 64 ++-- modules/msg/ut-coverage/test_cfe_msg_fc.c | 66 ++-- modules/msg/ut-coverage/test_cfe_msg_init.c | 75 ++-- .../ut-coverage/test_cfe_msg_msgid_shared.c | 38 +- .../msg/ut-coverage/test_cfe_msg_msgid_v1.c | 88 ++--- .../msg/ut-coverage/test_cfe_msg_msgid_v2.c | 85 +++-- modules/msg/ut-coverage/test_cfe_msg_time.c | 70 ++-- 9 files changed, 551 insertions(+), 553 deletions(-) diff --git a/modules/msg/ut-coverage/test_cfe_msg_ccsdsext.c b/modules/msg/ut-coverage/test_cfe_msg_ccsdsext.c index 5a2ff4d45..146b34cab 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_ccsdsext.c +++ b/modules/msg/ut-coverage/test_cfe_msg_ccsdsext.c @@ -61,8 +61,8 @@ void Test_MSG_Init_Ext(void) /* Get msgid version by checking if msgid sets "has secondary" field*/ memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0))); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec)); is_v1 = !hassec; /* Set up return */ @@ -71,67 +71,67 @@ void Test_MSG_Init_Ext(void) UtPrintf("Set to all F's, msgid value = 0"); memset(&msg, 0xFF, sizeof(msg)); msgidval_exp = 0; - CFE_UtAssert_EQUAL(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg)), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg))); UT_DisplayPkt(&msg, 0); /* Default EDS version check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(&msg, &edsver), CFE_SUCCESS); - CFE_UtAssert_EQUAL(edsver, CFE_PLATFORM_EDSVER); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEDSVersion(&msg, &edsver)); + UtAssert_INT32_EQ(edsver, CFE_PLATFORM_EDSVER); /* Default subsystem check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(&msg, &subsys), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSubsystem(&msg, &subsys)); if (is_v1) - CFE_UtAssert_EQUAL(subsys, CFE_PLATFORM_DEFAULT_SUBSYS); + UtAssert_INT32_EQ(subsys, CFE_PLATFORM_DEFAULT_SUBSYS); else - CFE_UtAssert_EQUAL(subsys, CFE_PLATFORM_DEFAULT_SUBSYS & TEST_DEFAULT_SUBSYS_MASK); + UtAssert_INT32_EQ(subsys, CFE_PLATFORM_DEFAULT_SUBSYS & TEST_DEFAULT_SUBSYS_MASK); /* Default system check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(&msg, &system), CFE_SUCCESS); - CFE_UtAssert_EQUAL(system, sc_id); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSystem(&msg, &system)); + UtAssert_INT32_EQ(system, sc_id); /* Default endian check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(&msg, &endian), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEndian(&msg, &endian)); #if (CFE_PLATFORM_ENDIAN == CCSDS_LITTLE_ENDIAN) - CFE_UtAssert_EQUAL(endian, CFE_MSG_Endian_Little); + UtAssert_INT32_EQ(endian, CFE_MSG_Endian_Little); #else - CFE_UtAssert_EQUAL(endian, CFE_MSG_Endian_Big); + UtAssert_INT32_EQ(endian, CFE_MSG_Endian_Big); #endif /* Confirm the rest of the fields not already explicitly checked */ - CFE_UtAssert_EQUAL( + UtAssert_INT32_EQ( Test_MSG_Ext_NotZero(&msg) & ~(MSG_EDSVER_FLAG | MSG_ENDIAN_FLAG | MSG_SUBSYS_FLAG | MSG_SYSTEM_FLAG), 0); UtPrintf("Set to all 0, max msgid value"); memset(&msg, 0, sizeof(msg)); msgidval_exp = CFE_PLATFORM_SB_HIGHEST_VALID_MSGID; - CFE_UtAssert_EQUAL(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg)), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg))); UT_DisplayPkt(&msg, 0); /* Default EDS version check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(&msg, &edsver), CFE_SUCCESS); - CFE_UtAssert_EQUAL(edsver, CFE_PLATFORM_EDSVER); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEDSVersion(&msg, &edsver)); + UtAssert_INT32_EQ(edsver, CFE_PLATFORM_EDSVER); /* Default system check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(&msg, &system), CFE_SUCCESS); - CFE_UtAssert_EQUAL(system, sc_id); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSystem(&msg, &system)); + UtAssert_INT32_EQ(system, sc_id); /* Default endian check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(&msg, &endian), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEndian(&msg, &endian)); #if (CFE_PLATFORM_ENDIAN == CCSDS_LITTLE_ENDIAN) - CFE_UtAssert_EQUAL(endian, CFE_MSG_Endian_Little); + UtAssert_INT32_EQ(endian, CFE_MSG_Endian_Little); #else - CFE_UtAssert_EQUAL(endian, CFE_MSG_Endian_Big); + UtAssert_INT32_EQ(endian, CFE_MSG_Endian_Big); #endif /* Default subsystem check */ - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(&msg, &subsys), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSubsystem(&msg, &subsys)); if (is_v1) - CFE_UtAssert_EQUAL(subsys, CFE_PLATFORM_DEFAULT_SUBSYS); + UtAssert_INT32_EQ(subsys, CFE_PLATFORM_DEFAULT_SUBSYS); else - CFE_UtAssert_EQUAL(subsys, CFE_PLATFORM_DEFAULT_SUBSYS | ((msgidval_exp >> 8) & 0xFF)); + UtAssert_INT32_EQ(subsys, CFE_PLATFORM_DEFAULT_SUBSYS | ((msgidval_exp >> 8) & 0xFF)); /* Confirm the rest of the fields not already explicitly checked */ - CFE_UtAssert_EQUAL( + UtAssert_INT32_EQ( Test_MSG_Ext_NotZero(&msg) & ~(MSG_EDSVER_FLAG | MSG_ENDIAN_FLAG | MSG_SUBSYS_FLAG | MSG_SYSTEM_FLAG), 0); } @@ -144,33 +144,33 @@ void Test_MSG_EDSVersion(void) UtPrintf("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, TEST_EDSVER_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetEDSVersion(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetEDSVersion(&msg, TEST_EDSVER_MAX + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetEDSVersion(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetEDSVersion(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, TEST_EDSVER_MAX); + UtAssert_INT32_EQ(CFE_MSG_GetEDSVersion(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetEDSVersion(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetEDSVersion(&msg, TEST_EDSVER_MAX + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetEDSVersion(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_EDSVER_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_SetEDSVersion(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEDSVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, TEST_EDSVER_MAX); + CFE_UtAssert_SUCCESS(CFE_MSG_SetEDSVersion(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEDSVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == TEST_EDSVER_MAX) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_EDSVER_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_EDSVER_FLAG); } } @@ -178,19 +178,19 @@ void Test_MSG_EDSVersion(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetEDSVersion(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEDSVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetEDSVersion(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEDSVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEDSVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == 0) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_EDSVER_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_EDSVER_FLAG); } } } @@ -204,33 +204,33 @@ void Test_MSG_Endian(void) UtPrintf("Bad parameter tests, Null pointers and invalid (CFE_MSG_Endian_Invalid, CFE_MSG_Endian_Little + 1"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetEndian(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetEndian(&msg, CFE_MSG_Endian_Invalid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetEndian(&msg, CFE_MSG_Endian_Little + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetEndian(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, 0); + UtAssert_INT32_EQ(CFE_MSG_GetEndian(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetEndian(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetEndian(&msg, CFE_MSG_Endian_Invalid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetEndian(&msg, CFE_MSG_Endian_Little + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Endian_Little); - CFE_UtAssert_EQUAL(CFE_MSG_SetEndian(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEndian(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Endian_Little); + CFE_UtAssert_SUCCESS(CFE_MSG_SetEndian(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEndian(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_Endian_Little) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_ENDIAN_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_ENDIAN_FLAG); } } @@ -238,19 +238,19 @@ void Test_MSG_Endian(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Endian_Big); - CFE_UtAssert_EQUAL(CFE_MSG_SetEndian(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEndian(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Endian_Big); + CFE_UtAssert_SUCCESS(CFE_MSG_SetEndian(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetEndian(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetEndian(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_Endian_Big) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_ENDIAN_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_ENDIAN_FLAG); } } } @@ -264,33 +264,33 @@ void Test_MSG_PlaybackFlag(void) UtPrintf("Bad parameter tests, Null pointers and invalid (CFE_MSG_PlayFlag_Invalid, CFE_MSG_PlayFlag_Playback + 1"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetPlaybackFlag(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetPlaybackFlag(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetPlaybackFlag(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetPlaybackFlag(&msg, CFE_MSG_PlayFlag_Invalid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetPlaybackFlag(&msg, CFE_MSG_PlayFlag_Playback + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetPlaybackFlag(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, 0); + UtAssert_INT32_EQ(CFE_MSG_GetPlaybackFlag(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetPlaybackFlag(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetPlaybackFlag(&msg, CFE_MSG_PlayFlag_Invalid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetPlaybackFlag(&msg, CFE_MSG_PlayFlag_Playback + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_PlayFlag_Playback); - CFE_UtAssert_EQUAL(CFE_MSG_SetPlaybackFlag(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetPlaybackFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_PlayFlag_Playback); + CFE_UtAssert_SUCCESS(CFE_MSG_SetPlaybackFlag(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetPlaybackFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_PlayFlag_Playback) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_PBACK_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_PBACK_FLAG); } } @@ -298,19 +298,19 @@ void Test_MSG_PlaybackFlag(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_PlayFlag_Original); - CFE_UtAssert_EQUAL(CFE_MSG_SetPlaybackFlag(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetPlaybackFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_PlayFlag_Original); + CFE_UtAssert_SUCCESS(CFE_MSG_SetPlaybackFlag(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetPlaybackFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_PlayFlag_Original) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_PBACK_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_PBACK_FLAG); } } } @@ -324,33 +324,33 @@ void Test_MSG_Subsystem(void) UtPrintf("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, TEST_SUBSYS_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSubsystem(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetSubsystem(&msg, TEST_SUBSYS_MAX + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSubsystem(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetSubsystem(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, TEST_SUBSYS_MAX); + UtAssert_INT32_EQ(CFE_MSG_GetSubsystem(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSubsystem(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetSubsystem(&msg, TEST_SUBSYS_MAX + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSubsystem(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_SUBSYS_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_SetSubsystem(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSubsystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, TEST_SUBSYS_MAX); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSubsystem(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSubsystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == TEST_SUBSYS_MAX) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_SUBSYS_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_SUBSYS_FLAG); } } @@ -358,19 +358,19 @@ void Test_MSG_Subsystem(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSubsystem(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSubsystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSubsystem(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSubsystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSubsystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == 0) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_SUBSYS_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_SUBSYS_FLAG); } } } @@ -384,30 +384,30 @@ void Test_MSG_System(void) UtPrintf("Bad parameter tests, Null pointers"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, TEST_SYSTEM_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSystem(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetSystem(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, TEST_SYSTEM_MAX); + UtAssert_INT32_EQ(CFE_MSG_GetSystem(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSystem(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_SYSTEM_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_SetSystem(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, TEST_SYSTEM_MAX); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSystem(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == TEST_SYSTEM_MAX) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_SYSTEM_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_SYSTEM_FLAG); } } @@ -415,19 +415,19 @@ void Test_MSG_System(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSystem(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSystem(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSystem(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSystem(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == 0) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_SYSTEM_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_SYSTEM_FLAG); } } } diff --git a/modules/msg/ut-coverage/test_cfe_msg_ccsdspri.c b/modules/msg/ut-coverage/test_cfe_msg_ccsdspri.c index a98244e45..4bafd46ad 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_ccsdspri.c +++ b/modules/msg/ut-coverage/test_cfe_msg_ccsdspri.c @@ -50,37 +50,37 @@ void Test_MSG_Size(void) UtPrintf("Bad parameter tests, Null pointers and invalid (0, min valid - 1, max valid + 1, max)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(&msg, 0), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(&msg, TEST_MSG_SIZE_OFFSET - 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(&msg, 0xFFFF + TEST_MSG_SIZE_OFFSET + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(&msg, 0xFFFFFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetSize(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, 0); + UtAssert_INT32_EQ(CFE_MSG_GetSize(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSize(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetSize(&msg, 0), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSize(&msg, TEST_MSG_SIZE_OFFSET - 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSize(&msg, 0xFFFF + TEST_MSG_SIZE_OFFSET + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSize(&msg, 0xFFFFFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0xFFFF + TEST_MSG_SIZE_OFFSET); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSize(&msg, &actual)); + UtAssert_INT32_EQ(actual, 0xFFFF + TEST_MSG_SIZE_OFFSET); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSize(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSize(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == 0xFFFF + TEST_MSG_SIZE_OFFSET) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_LENGTH_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_LENGTH_FLAG); } } @@ -88,19 +88,19 @@ void Test_MSG_Size(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_MSG_SIZE_OFFSET); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSize(&msg, &actual)); + UtAssert_INT32_EQ(actual, TEST_MSG_SIZE_OFFSET); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSize(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSize(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == TEST_MSG_SIZE_OFFSET) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_LENGTH_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_LENGTH_FLAG); } } } @@ -114,33 +114,33 @@ void Test_MSG_Type(void) UtPrintf("Bad parameter tests, Null pointers and invalid (CFE_MSG_Type_Invalid, CFE_MSG_Type_Tlm + 1"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, CFE_MSG_Type_Invalid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetType(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, 0); + UtAssert_INT32_EQ(CFE_MSG_GetType(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetType(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Invalid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Type_Cmd); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Type_Cmd); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_Type_Cmd) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_TYPE_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_TYPE_FLAG); } } @@ -148,19 +148,19 @@ void Test_MSG_Type(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Type_Tlm); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Type_Tlm); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_Type_Tlm) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); } } } @@ -174,33 +174,33 @@ void Test_MSG_HeaderVersion(void) UtPrintf("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, TEST_CCSDSVER_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetHeaderVersion(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetHeaderVersion(&msg, TEST_CCSDSVER_MAX + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetHeaderVersion(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetHeaderVersion(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, TEST_CCSDSVER_MAX); + UtAssert_INT32_EQ(CFE_MSG_GetHeaderVersion(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetHeaderVersion(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetHeaderVersion(&msg, TEST_CCSDSVER_MAX + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetHeaderVersion(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_CCSDSVER_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_SetHeaderVersion(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, TEST_CCSDSVER_MAX); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHeaderVersion(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == TEST_CCSDSVER_MAX) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_HDRVER_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_HDRVER_FLAG); } } @@ -208,19 +208,19 @@ void Test_MSG_HeaderVersion(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetHeaderVersion(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHeaderVersion(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == 0) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_HDRVER_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_HDRVER_FLAG); } } } @@ -232,45 +232,45 @@ void Test_MSG_HasSecondaryHeader(void) UtPrintf("Bad parameter tests, Null pointers"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(NULL, false), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_GetHasSecondaryHeader(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetHasSecondaryHeader(NULL, false), CFE_MSG_BAD_ARGUMENT); UtPrintf("Set to all F's, true and false inputs"); memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, true); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &actual)); + CFE_UtAssert_TRUE(actual); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(&msg, true), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(&msg, true)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &actual)); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(&msg, false), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(&msg, false)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, false); - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &actual)); + CFE_UtAssert_FALSE(actual); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_HASSEC_FLAG); UtPrintf("Set to all 0, true and false inputs"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, false); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &actual)); + CFE_UtAssert_FALSE(actual); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(&msg, false), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(&msg, false)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, false); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &actual)); + CFE_UtAssert_FALSE(actual); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(&msg, true), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(&msg, true)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &actual)); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_HASSEC_FLAG); } void Test_MSG_ApId(void) @@ -282,33 +282,33 @@ void Test_MSG_ApId(void) UtPrintf("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, TEST_APID_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetApId(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetApId(&msg, TEST_APID_MAX + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetApId(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetApId(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, TEST_APID_MAX); + UtAssert_INT32_EQ(CFE_MSG_GetApId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetApId(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetApId(&msg, TEST_APID_MAX + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetApId(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_APID_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_SetApId(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &actual)); + UtAssert_INT32_EQ(actual, TEST_APID_MAX); + CFE_UtAssert_SUCCESS(CFE_MSG_SetApId(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == TEST_APID_MAX) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_APID_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_APID_FLAG); } } @@ -316,19 +316,19 @@ void Test_MSG_ApId(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetApId(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &actual)); + UtAssert_INT32_EQ(actual, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetApId(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == 0) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_APID_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG); } } } @@ -343,33 +343,33 @@ void Test_MSG_SegmentationFlag(void) UtPrintf("Bad parameter tests, Null pointers and invalid (*_Invalid, max valid + 1"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, CFE_MSG_SegFlag_Invalid); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSegmentationFlag(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetSegmentationFlag(&msg, CFE_MSG_SegFlag_Invalid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSegmentationFlag(&msg, CFE_MSG_SegFlag_Unsegmented + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetSegmentationFlag(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, CFE_MSG_SegFlag_Invalid); + UtAssert_INT32_EQ(CFE_MSG_GetSegmentationFlag(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSegmentationFlag(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetSegmentationFlag(&msg, CFE_MSG_SegFlag_Invalid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSegmentationFlag(&msg, CFE_MSG_SegFlag_Unsegmented + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_SegFlag_Unsegmented); - CFE_UtAssert_EQUAL(CFE_MSG_SetSegmentationFlag(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSegmentationFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_SegFlag_Unsegmented); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSegmentationFlag(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSegmentationFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_SegFlag_Unsegmented) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_SEGMENT_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_SEGMENT_FLAG); } } @@ -377,19 +377,19 @@ void Test_MSG_SegmentationFlag(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_SegFlag_Continue); - CFE_UtAssert_EQUAL(CFE_MSG_SetSegmentationFlag(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSegmentationFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_SegFlag_Continue); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSegmentationFlag(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSegmentationFlag(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == CFE_MSG_SegFlag_Continue) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_SEGMENT_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_SEGMENT_FLAG); } } } @@ -406,33 +406,33 @@ void Test_MSG_SequenceCount(void) UtPrintf("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSequenceCount(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, TEST_SEQUENCE_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_GetSequenceCount(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSequenceCount(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetSequenceCount(&msg, TEST_SEQUENCE_MAX + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSequenceCount(&msg, maxsc), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetSequenceCount(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, TEST_SEQUENCE_MAX); + UtAssert_INT32_EQ(CFE_MSG_GetSequenceCount(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSequenceCount(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetSequenceCount(&msg, TEST_SEQUENCE_MAX + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetSequenceCount(&msg, maxsc), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_SEQUENCE_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_SetSequenceCount(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSequenceCount(&msg, &actual)); + UtAssert_INT32_EQ(actual, TEST_SEQUENCE_MAX); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSequenceCount(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSequenceCount(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == TEST_SEQUENCE_MAX) { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_SEQUENCE_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_SEQUENCE_FLAG); } } @@ -440,27 +440,27 @@ void Test_MSG_SequenceCount(void) for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetSequenceCount(&msg, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSequenceCount(&msg, &actual)); + UtAssert_INT32_EQ(actual, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSequenceCount(&msg, input[i])); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSequenceCount(&msg, &actual)); + UtAssert_INT32_EQ(actual, input[i]); if (input[i] == 0) { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); } else { - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_SEQUENCE_FLAG); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_SEQUENCE_FLAG); } } UtPrintf("Fully exercise getting next sequence count"); - CFE_UtAssert_EQUAL(CFE_MSG_GetNextSequenceCount(0), 1); - CFE_UtAssert_EQUAL(CFE_MSG_GetNextSequenceCount(TEST_SEQUENCE_MAX / 2), (TEST_SEQUENCE_MAX / 2) + 1); - CFE_UtAssert_EQUAL(CFE_MSG_GetNextSequenceCount(TEST_SEQUENCE_MAX), 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetNextSequenceCount(maxsc), 0); + UtAssert_INT32_EQ(CFE_MSG_GetNextSequenceCount(0), 1); + UtAssert_INT32_EQ(CFE_MSG_GetNextSequenceCount(TEST_SEQUENCE_MAX / 2), (TEST_SEQUENCE_MAX / 2) + 1); + UtAssert_INT32_EQ(CFE_MSG_GetNextSequenceCount(TEST_SEQUENCE_MAX), 0); + UtAssert_INT32_EQ(CFE_MSG_GetNextSequenceCount(maxsc), 0); } /* diff --git a/modules/msg/ut-coverage/test_cfe_msg_checksum.c b/modules/msg/ut-coverage/test_cfe_msg_checksum.c index 0ac3f4c5b..e36e94144 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_checksum.c +++ b/modules/msg/ut-coverage/test_cfe_msg_checksum.c @@ -43,48 +43,48 @@ void Test_MSG_Checksum(void) UtPrintf("Bad parameter tests, Null pointers"); memset(&cmd, 0, sizeof(cmd)); actual = true; - CFE_UtAssert_EQUAL(CFE_MSG_GenerateChecksum(NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), 0); + UtAssert_INT32_EQ(CFE_MSG_GenerateChecksum(NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_ValidateChecksum(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(CFE_MSG_ValidateChecksum(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), 0); UtPrintf("Bad message, no secondary header"); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(CFE_MSG_GenerateChecksum(msgptr), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd)); + UtAssert_INT32_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(CFE_MSG_GenerateChecksum(msgptr), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); UtPrintf("Bad message, wrong type (telemetry)"); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Tlm), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(CFE_MSG_GenerateChecksum(msgptr), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Tlm)); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(msgptr, true)); + UtAssert_INT32_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(CFE_MSG_GenerateChecksum(msgptr), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); UtPrintf("Set to all F's, validate/generate/validate"); memset(&cmd, 0xFF, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(msgptr, sizeof(cmd)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, false); - CFE_UtAssert_EQUAL(CFE_MSG_GenerateChecksum(msgptr), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSize(msgptr, sizeof(cmd))); + CFE_UtAssert_SUCCESS(CFE_MSG_ValidateChecksum(msgptr, &actual)); + CFE_UtAssert_FALSE(actual); + CFE_UtAssert_SUCCESS(CFE_MSG_GenerateChecksum(msgptr)); UT_DisplayPkt(msgptr, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(Test_MSG_NotF(msgptr), MSG_LENGTH_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_ValidateChecksum(msgptr, &actual)); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(Test_MSG_NotF(msgptr), MSG_LENGTH_FLAG); UtPrintf("Set to all 0 except secheader and type, validate/generate/validate"); memset(&cmd, 0, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_SetSize(msgptr, sizeof(cmd)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, false); - CFE_UtAssert_EQUAL(CFE_MSG_GenerateChecksum(msgptr), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetSize(msgptr, sizeof(cmd))); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd)); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(msgptr, true)); + CFE_UtAssert_SUCCESS(CFE_MSG_ValidateChecksum(msgptr, &actual)); + CFE_UtAssert_FALSE(actual); + CFE_UtAssert_SUCCESS(CFE_MSG_GenerateChecksum(msgptr)); UT_DisplayPkt(msgptr, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, true); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_LENGTH_FLAG | MSG_HASSEC_FLAG | MSG_TYPE_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_ValidateChecksum(msgptr, &actual)); + CFE_UtAssert_TRUE(actual); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_LENGTH_FLAG | MSG_HASSEC_FLAG | MSG_TYPE_FLAG); } diff --git a/modules/msg/ut-coverage/test_cfe_msg_fc.c b/modules/msg/ut-coverage/test_cfe_msg_fc.c index 2652804f6..e9763e2c2 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_fc.c +++ b/modules/msg/ut-coverage/test_cfe_msg_fc.c @@ -49,57 +49,57 @@ void Test_MSG_FcnCode(void) UtPrintf("Bad parameter tests, Null pointers, invalid (max valid + 1, max)"); memset(&cmd, 0, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual, TEST_FCNCODE_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetFcnCode(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetFcnCode(msgptr, TEST_FCNCODE_MAX + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetFcnCode(msgptr, 0xFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), 0); + UtAssert_INT32_EQ(CFE_MSG_GetFcnCode(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual, TEST_FCNCODE_MAX); + UtAssert_INT32_EQ(CFE_MSG_GetFcnCode(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), 0); + UtAssert_INT32_EQ(CFE_MSG_SetFcnCode(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetFcnCode(msgptr, TEST_FCNCODE_MAX + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), 0); + UtAssert_INT32_EQ(CFE_MSG_SetFcnCode(msgptr, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), 0); UtPrintf("Bad message, no secondary header"); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetFcnCode(msgptr, 0), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd)); + UtAssert_INT32_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(actual, 0); + UtAssert_INT32_EQ(CFE_MSG_SetFcnCode(msgptr, 0), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); UtPrintf("Bad message, wrong type (telemetry)"); memset(&cmd, 0, sizeof(cmd)); actual = TEST_FCNCODE_MAX; - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetFcnCode(msgptr, 0), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(msgptr, true)); + UtAssert_INT32_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(actual, 0); + UtAssert_INT32_EQ(CFE_MSG_SetFcnCode(msgptr, 0), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&cmd, 0xFF, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, TEST_FCNCODE_MAX); - CFE_UtAssert_EQUAL(CFE_MSG_SetFcnCode(msgptr, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetFcnCode(msgptr, &actual)); + UtAssert_INT32_EQ(actual, TEST_FCNCODE_MAX); + CFE_UtAssert_SUCCESS(CFE_MSG_SetFcnCode(msgptr, input[i])); UT_DisplayPkt(msgptr, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); - CFE_UtAssert_EQUAL(Test_MSG_NotF(msgptr), 0); + CFE_UtAssert_SUCCESS(CFE_MSG_GetFcnCode(msgptr, &actual)); + UtAssert_INT32_EQ(actual, input[i]); + UtAssert_INT32_EQ(Test_MSG_NotF(msgptr), 0); } UtPrintf("Set to all 0, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&cmd, 0, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetFcnCode(msgptr, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd)); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(msgptr, true)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetFcnCode(msgptr, &actual)); + UtAssert_INT32_EQ(actual, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetFcnCode(msgptr, input[i])); UT_DisplayPkt(msgptr, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, input[i]); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG | MSG_TYPE_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetFcnCode(msgptr, &actual)); + UtAssert_INT32_EQ(actual, input[i]); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG | MSG_TYPE_FLAG); } } diff --git a/modules/msg/ut-coverage/test_cfe_msg_init.c b/modules/msg/ut-coverage/test_cfe_msg_init.c index 9746ca7e5..2efeee5cf 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_init.c +++ b/modules/msg/ut-coverage/test_cfe_msg_init.c @@ -54,76 +54,75 @@ void Test_MSG_Init(void) bool is_v1; UtPrintf("Bad parameter tests, Null pointer, invalid size, invalid msgid"); - CFE_UtAssert_EQUAL(CFE_MSG_Init(NULL, CFE_SB_ValueToMsgId(0), sizeof(cmd)), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(0), 0), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL( - CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), sizeof(cmd)), - CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(-1), sizeof(cmd)), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_Init(NULL, CFE_SB_ValueToMsgId(0), sizeof(cmd)), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(0), 0), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), sizeof(cmd)), + CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(-1), sizeof(cmd)), CFE_MSG_BAD_ARGUMENT); UtPrintf("Set to all F's, msgid value = 0"); memset(&cmd, 0xFF, sizeof(cmd)); msgidval_exp = 0; - CFE_UtAssert_EQUAL(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(cmd)), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(cmd))); UT_DisplayPkt(&cmd.Msg, 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&cmd.Msg, &msgid_act), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid_act), msgidval_exp); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(&cmd.Msg, &size), CFE_SUCCESS); - CFE_UtAssert_EQUAL(size, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(&cmd.Msg, &segflag), CFE_SUCCESS); - CFE_UtAssert_EQUAL(segflag, CFE_MSG_SegFlag_Unsegmented); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&cmd.Msg, &msgid_act)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid_act), msgidval_exp); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSize(&cmd.Msg, &size)); + CFE_UtAssert_MEMOFFSET_EQ(size, sizeof(cmd)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSegmentationFlag(&cmd.Msg, &segflag)); + UtAssert_INT32_EQ(segflag, CFE_MSG_SegFlag_Unsegmented); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&cmd.Msg, &apid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(&cmd.Msg, &hdrver), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&cmd.Msg, &hassec), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&cmd.Msg, &apid)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&cmd.Msg, &hdrver)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&cmd.Msg, &hassec)); /* A zero msgid will set hassec to false for v1 */ is_v1 = !hassec; if (!is_v1) { - CFE_UtAssert_EQUAL(apid, CFE_PLATFORM_DEFAULT_APID & TEST_DEFAULT_APID_MASK); - CFE_UtAssert_EQUAL(hdrver, CFE_MISSION_CCSDSVER); + UtAssert_INT32_EQ(apid, CFE_PLATFORM_DEFAULT_APID & TEST_DEFAULT_APID_MASK); + UtAssert_INT32_EQ(hdrver, CFE_MISSION_CCSDSVER); } else { - CFE_UtAssert_EQUAL(apid, 0); - CFE_UtAssert_EQUAL(hdrver, 0); + UtAssert_INT32_EQ(apid, 0); + UtAssert_INT32_EQ(hdrver, 0); } /* Confirm the rest of the fields not already explicitly checked */ - CFE_UtAssert_EQUAL(Test_MSG_Pri_NotZero(&cmd.Msg) & ~(MSG_APID_FLAG | MSG_HDRVER_FLAG | MSG_HASSEC_FLAG), + UtAssert_UINT32_EQ(Test_MSG_Pri_NotZero(&cmd.Msg) & ~(MSG_APID_FLAG | MSG_HDRVER_FLAG | MSG_HASSEC_FLAG), MSG_LENGTH_FLAG | MSG_SEGMENT_FLAG); UtPrintf("Set to all 0, max msgid value"); memset(&cmd, 0, sizeof(cmd)); msgidval_exp = CFE_PLATFORM_SB_HIGHEST_VALID_MSGID; - CFE_UtAssert_EQUAL(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(cmd)), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_Init(&cmd.Msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(cmd))); UT_DisplayPkt(&cmd.Msg, 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&cmd.Msg, &msgid_act), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid_act), msgidval_exp); - CFE_UtAssert_EQUAL(CFE_MSG_GetSize(&cmd.Msg, &size), CFE_SUCCESS); - CFE_UtAssert_EQUAL(size, sizeof(cmd)); - CFE_UtAssert_EQUAL(CFE_MSG_GetSegmentationFlag(&cmd.Msg, &segflag), CFE_SUCCESS); - CFE_UtAssert_EQUAL(segflag, CFE_MSG_SegFlag_Unsegmented); - - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&cmd.Msg, &apid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetHeaderVersion(&cmd.Msg, &hdrver), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&cmd.Msg, &hassec), CFE_SUCCESS); - CFE_UtAssert_EQUAL(hassec, true); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&cmd.Msg, &msgid_act)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid_act), msgidval_exp); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSize(&cmd.Msg, &size)); + UtAssert_INT32_EQ(size, sizeof(cmd)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetSegmentationFlag(&cmd.Msg, &segflag)); + UtAssert_INT32_EQ(segflag, CFE_MSG_SegFlag_Unsegmented); + + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&cmd.Msg, &apid)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&cmd.Msg, &hdrver)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&cmd.Msg, &hassec)); + CFE_UtAssert_TRUE(hassec); if (!is_v1) { - CFE_UtAssert_EQUAL(apid & TEST_DEFAULT_APID_MASK, CFE_PLATFORM_DEFAULT_APID & TEST_DEFAULT_APID_MASK); - CFE_UtAssert_EQUAL(hdrver, CFE_MISSION_CCSDSVER); + UtAssert_INT32_EQ(apid & TEST_DEFAULT_APID_MASK, CFE_PLATFORM_DEFAULT_APID & TEST_DEFAULT_APID_MASK); + UtAssert_INT32_EQ(hdrver, CFE_MISSION_CCSDSVER); } else { - CFE_UtAssert_EQUAL(apid, 0x7FF); - CFE_UtAssert_EQUAL(hdrver, 0); + UtAssert_INT32_EQ(apid, 0x7FF); + UtAssert_INT32_EQ(hdrver, 0); } - CFE_UtAssert_EQUAL(Test_MSG_Pri_NotZero(&cmd.Msg) & ~MSG_HDRVER_FLAG, + UtAssert_UINT32_EQ(Test_MSG_Pri_NotZero(&cmd.Msg) & ~MSG_HDRVER_FLAG, MSG_APID_FLAG | MSG_HASSEC_FLAG | MSG_TYPE_FLAG | MSG_LENGTH_FLAG | MSG_SEGMENT_FLAG); } diff --git a/modules/msg/ut-coverage/test_cfe_msg_msgid_shared.c b/modules/msg/ut-coverage/test_cfe_msg_msgid_shared.c index 42e4eda4a..c6ae6fede 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_msgid_shared.c +++ b/modules/msg/ut-coverage/test_cfe_msg_msgid_shared.c @@ -42,32 +42,32 @@ void Test_MSG_GetTypeFromMsgId(void) UtPrintf("Bad parameter tests, Null pointer"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetTypeFromMsgId(msgid, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetTypeFromMsgId(msgid, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set to all F's, test cmd and tlm"); memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(CFE_PLATFORM_SB_HIGHEST_VALID_MSGID)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Type_Tlm); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(CFE_PLATFORM_SB_HIGHEST_VALID_MSGID))); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetTypeFromMsgId(msgid, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Type_Tlm); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, CFE_MSG_Type_Cmd), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Type_Cmd); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(&msg, CFE_MSG_Type_Cmd)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetTypeFromMsgId(msgid, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Type_Cmd); UtPrintf("Set to all 0, test cmd and tlm"); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, CFE_MSG_Type_Cmd), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Type_Cmd); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(&msg, CFE_MSG_Type_Cmd)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetTypeFromMsgId(msgid, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Type_Cmd); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual, CFE_MSG_Type_Tlm); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetTypeFromMsgId(msgid, &actual)); + UtAssert_INT32_EQ(actual, CFE_MSG_Type_Tlm); } /* diff --git a/modules/msg/ut-coverage/test_cfe_msg_msgid_v1.c b/modules/msg/ut-coverage/test_cfe_msg_msgid_v1.c index 1b02582a2..8a0a6a5ae 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_msgid_v1.c +++ b/modules/msg/ut-coverage/test_cfe_msg_msgid_v1.c @@ -43,62 +43,62 @@ void Test_MSG_MsgId(void) UtPrintf("Bad parameter tests, Null pointers and invalid (max valid + 1)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(NULL, &msgid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 1); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(NULL, msgid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_INVALID_MSG_ID), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetMsgId(NULL, &msgid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 1); + UtAssert_INT32_EQ(CFE_MSG_GetMsgId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(NULL, msgid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_INVALID_MSG_ID), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set msg to all F's, set msgid to 0 and verify"); memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 0xFFFF); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, 0), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 0xFFFF); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, 0)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 0); - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_HDRVER_FLAG | MSG_APID_FLAG | MSG_TYPE_FLAG | MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_HDRVER_FLAG | MSG_APID_FLAG | MSG_TYPE_FLAG | MSG_HASSEC_FLAG); UtPrintf("Set msg to all 0, set msgid to max and verify"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), CFE_PLATFORM_SB_HIGHEST_VALID_MSGID); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | MSG_HASSEC_FLAG); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(apid, TEST_MAX_APID); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &type), CFE_SUCCESS); - CFE_UtAssert_EQUAL(type, CFE_MSG_Type_Cmd); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec), CFE_SUCCESS); - CFE_UtAssert_EQUAL(hassec, true); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), CFE_PLATFORM_SB_HIGHEST_VALID_MSGID); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &apid)); + UtAssert_INT32_EQ(apid, TEST_MAX_APID); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &type)); + UtAssert_INT32_EQ(type, CFE_MSG_Type_Cmd); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec)); + CFE_UtAssert_TRUE(hassec); UtPrintf("Set ApId msgid bits only and verify"); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(TEST_MAX_APID)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_APID_FLAG); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(apid, TEST_MAX_APID); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(TEST_MAX_APID))); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &apid)); + UtAssert_INT32_EQ(apid, TEST_MAX_APID); UtPrintf("Set has secondary header bit only and verify"); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x0800)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_HASSEC_FLAG); - CFE_UtAssert_EQUAL(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec), CFE_SUCCESS); - CFE_UtAssert_EQUAL(hassec, true); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x0800))); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec)); + CFE_UtAssert_TRUE(hassec); UtPrintf("Set type msgid bit only and verify"); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x1000)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &type), CFE_SUCCESS); - CFE_UtAssert_EQUAL(type, CFE_MSG_Type_Cmd); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x1000))); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &type)); + UtAssert_INT32_EQ(type, CFE_MSG_Type_Cmd); } diff --git a/modules/msg/ut-coverage/test_cfe_msg_msgid_v2.c b/modules/msg/ut-coverage/test_cfe_msg_msgid_v2.c index 489bf2942..1787fb420 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_msgid_v2.c +++ b/modules/msg/ut-coverage/test_cfe_msg_msgid_v2.c @@ -51,67 +51,66 @@ void Test_MSG_MsgId(void) UtPrintf("Bad parameter tests, Null pointers and invalid (max valid + 1)"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(NULL, &msgid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 1); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(NULL, msgid), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_INVALID_MSG_ID), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, 0xFFFFFFFF), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_GetMsgId(NULL, &msgid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 1); + UtAssert_INT32_EQ(CFE_MSG_GetMsgId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(NULL, msgid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_INVALID_MSG_ID), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, 0xFFFFFFFF), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), 0); UtPrintf("Set msg to all F's, set msgid to 0 and verify"); memset(&msg, 0xFF, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 0xFFFF); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, 0), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 0xFFFF); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, 0)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 0); - CFE_UtAssert_EQUAL(Test_MSG_NotF(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | local_subsys_flag); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 0); + UtAssert_INT32_EQ(Test_MSG_NotF(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | local_subsys_flag); UtPrintf("Set msg to all 0, set msgid to max and verify"); memset(&msg, 0, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID)); UT_DisplayPkt(&msg, sizeof(msg)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(msgid), CFE_PLATFORM_SB_HIGHEST_VALID_MSGID); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | local_subsys_flag); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(apid, 0x7F); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &type), CFE_SUCCESS); - CFE_UtAssert_EQUAL(type, CFE_MSG_Type_Cmd); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(CFE_SB_MsgIdToValue(msgid), CFE_PLATFORM_SB_HIGHEST_VALID_MSGID); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | local_subsys_flag); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &apid)); + UtAssert_INT32_EQ(apid, 0x7F); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &type)); + UtAssert_INT32_EQ(type, CFE_MSG_Type_Cmd); if (CFE_MSG_GetSubsystem(&msg, &subsystem) != CFE_MSG_NOT_IMPLEMENTED) { - CFE_UtAssert_EQUAL(subsystem, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID >> 8); + UtAssert_INT32_EQ(subsystem, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID >> 8); } UtPrintf("Set ApId msgid bits only and verify"); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x007F)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_APID_FLAG); - CFE_UtAssert_EQUAL(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(apid, 0x007F); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x007F))); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetApId(&msg, &apid)); + UtAssert_INT32_EQ(apid, 0x007F); UtPrintf("Set type msgid bit only and verify"); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x0080)), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); - CFE_UtAssert_EQUAL(CFE_MSG_GetType(&msg, &type), CFE_SUCCESS); - CFE_UtAssert_EQUAL(type, CFE_MSG_Type_Cmd); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x0080))); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetType(&msg, &type)); + UtAssert_INT32_EQ(type, CFE_MSG_Type_Cmd); UtPrintf("Set subsystem msgid bits only and verify"); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0xFF00 & CFE_PLATFORM_SB_HIGHEST_VALID_MSGID)), - CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(&msg), local_subsys_flag); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0xFF00 & CFE_PLATFORM_SB_HIGHEST_VALID_MSGID))); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgId(&msg, &msgid)); + UtAssert_INT32_EQ(Test_MSG_NotZero(&msg), local_subsys_flag); if (CFE_MSG_GetSubsystem(&msg, &subsystem) != CFE_MSG_NOT_IMPLEMENTED) { - CFE_UtAssert_EQUAL(subsystem, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID >> 8); + UtAssert_INT32_EQ(subsystem, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID >> 8); } } diff --git a/modules/msg/ut-coverage/test_cfe_msg_time.c b/modules/msg/ut-coverage/test_cfe_msg_time.c index aad867738..05d3317a6 100644 --- a/modules/msg/ut-coverage/test_cfe_msg_time.c +++ b/modules/msg/ut-coverage/test_cfe_msg_time.c @@ -44,55 +44,55 @@ void Test_MSG_Time(void) UtPrintf("Bad parameter tests, Null pointers, no secondary header"); memset(&tlm, 0, sizeof(tlm)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(NULL, &actual), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(actual.Seconds, 0xFFFFFFFF); - CFE_UtAssert_EQUAL(actual.Subseconds, 0xFFFFFFFF); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgTime(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgTime(msgptr, actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), 0); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(actual.Seconds, 0); - CFE_UtAssert_EQUAL(actual.Subseconds, 0); + UtAssert_INT32_EQ(CFE_MSG_GetMsgTime(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(actual.Seconds, 0xFFFFFFFF); + UtAssert_INT32_EQ(actual.Subseconds, 0xFFFFFFFF); + UtAssert_INT32_EQ(CFE_MSG_GetMsgTime(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), 0); + UtAssert_INT32_EQ(CFE_MSG_SetMsgTime(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetMsgTime(msgptr, actual), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), 0); + UtAssert_INT32_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(actual.Seconds, 0); + UtAssert_INT32_EQ(actual.Subseconds, 0); UtPrintf("Bad message, wrong type (command)"); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgTime(msgptr, actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); - CFE_UtAssert_EQUAL(actual.Seconds, 0); - CFE_UtAssert_EQUAL(actual.Subseconds, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd)); + UtAssert_INT32_EQ(CFE_MSG_SetMsgTime(msgptr, actual), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); + UtAssert_INT32_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + UtAssert_INT32_EQ(actual.Seconds, 0); + UtAssert_INT32_EQ(actual.Subseconds, 0); UtPrintf("Set to all F's, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&tlm, 0xFF, sizeof(tlm)); - CFE_UtAssert_EQUAL(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Tlm), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual.Seconds, 0xFFFFFFFF); - CFE_UtAssert_EQUAL(actual.Subseconds, 0xFFFF0000); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgTime(msgptr, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Tlm)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgTime(msgptr, &actual)); + UtAssert_INT32_EQ(actual.Seconds, 0xFFFFFFFF); + UtAssert_INT32_EQ(actual.Subseconds, 0xFFFF0000); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgTime(msgptr, input[i])); UT_DisplayPkt(msgptr, sizeof(tlm)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual.Seconds, input[i].Seconds); - CFE_UtAssert_EQUAL(actual.Subseconds, input[i].Subseconds & 0xFFFF0000); - CFE_UtAssert_EQUAL(Test_MSG_NotF(msgptr), MSG_TYPE_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgTime(msgptr, &actual)); + UtAssert_INT32_EQ(actual.Seconds, input[i].Seconds); + UtAssert_INT32_EQ(actual.Subseconds, input[i].Subseconds & 0xFFFF0000); + UtAssert_INT32_EQ(Test_MSG_NotF(msgptr), MSG_TYPE_FLAG); } UtPrintf("Set to all 0, various valid inputs"); for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) { memset(&tlm, 0, sizeof(tlm)); - CFE_UtAssert_EQUAL(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual.Seconds, 0); - CFE_UtAssert_EQUAL(actual.Subseconds, 0); - CFE_UtAssert_EQUAL(CFE_MSG_SetMsgTime(msgptr, input[i]), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(msgptr, true)); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgTime(msgptr, &actual)); + UtAssert_INT32_EQ(actual.Seconds, 0); + UtAssert_INT32_EQ(actual.Subseconds, 0); + CFE_UtAssert_SUCCESS(CFE_MSG_SetMsgTime(msgptr, input[i])); UT_DisplayPkt(msgptr, sizeof(tlm)); - CFE_UtAssert_EQUAL(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); - CFE_UtAssert_EQUAL(actual.Seconds, input[i].Seconds); - CFE_UtAssert_EQUAL(actual.Subseconds, input[i].Subseconds & 0xFFFF0000); - CFE_UtAssert_EQUAL(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); + CFE_UtAssert_SUCCESS(CFE_MSG_GetMsgTime(msgptr, &actual)); + UtAssert_INT32_EQ(actual.Seconds, input[i].Seconds); + UtAssert_INT32_EQ(actual.Subseconds, input[i].Subseconds & 0xFFFF0000); + UtAssert_INT32_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); } }