diff --git a/.github/workflows/add-to-project.yml b/.github/workflows/add-to-project.yml
new file mode 100644
index 0000000..4142b77
--- /dev/null
+++ b/.github/workflows/add-to-project.yml
@@ -0,0 +1,13 @@
+name: Add Issue or PR to Project
+
+on:
+ issues:
+ types: [opened]
+ pull_request_target:
+ types: [opened, ready_for_review, converted_to_draft]
+
+jobs:
+ add-to-project:
+ name: Add issue or pull request to project
+ uses: nasa/cFS/.github/workflows/add-to-project-reusable.yml@dev
+ secrets: inherit
\ No newline at end of file
diff --git a/.github/workflows/build-documentation.yml b/.github/workflows/build-documentation.yml
index 109e1b5..f1c9310 100644
--- a/.github/workflows/build-documentation.yml
+++ b/.github/workflows/build-documentation.yml
@@ -1,4 +1,4 @@
-name: Build and Deploy Documentation
+name: Build Documentation
on:
push:
@@ -15,9 +15,8 @@ on:
jobs:
build-documentation:
name: Build and deploy cFS documents
- uses: nasa/cFS/.github/workflows/build-deploy-doc.yml@main
+ uses: nasa/cFS/.github/workflows/build-doc-reusable.yml@dev
with:
target: "[\"sc-usersguide\"]"
app-name: sc
- buildpdf: ${{ github.event_name == 'push' && contains(github.ref, 'main')}}
- deploy: ${{ github.event_name == 'push' && contains(github.ref, 'main')}}
+ buildpdf: ${{ github.event_name == 'push' && (contains(github.ref, 'main') || contains(github.ref, 'dev')) }}
diff --git a/.github/workflows/build-run-app.yml b/.github/workflows/build-run-app.yml
index b780d37..a3b6a58 100644
--- a/.github/workflows/build-run-app.yml
+++ b/.github/workflows/build-run-app.yml
@@ -11,8 +11,11 @@ on:
- reopened
- synchronize
workflow_dispatch:
+ schedule:
+ # 9:35 PM UTC every Sunday
+ - cron: '35 21 * * 0'
jobs:
build-run:
name: Build and run with startup msg verification
- uses: nasa/cFS/.github/workflows/build-run-app.yml@main
+ uses: nasa/cFS/.github/workflows/build-run-app-reusable.yml@dev
diff --git a/.github/workflows/codeql-build.yml b/.github/workflows/codeql-build.yml
index a6089a7..5cd3b49 100644
--- a/.github/workflows/codeql-build.yml
+++ b/.github/workflows/codeql-build.yml
@@ -15,11 +15,8 @@ on:
jobs:
codeql:
name: Codeql Analysis
- uses: nasa/cFS/.github/workflows/codeql-reusable.yml@main
+ uses: nasa/cFS/.github/workflows/codeql-reusable.yml@dev
with:
component-path: apps/sc
prep: 'make prep; make -C build/tools/elf2cfetbl'
make: 'make -C build/native/default_cpu1/apps/sc'
- setup: |
- cp ./cfe/cmake/Makefile.sample Makefile && cp -r ./cfe/cmake/sample_defs sample_defs
- sed -i "/list(APPEND MISSION_GLOBAL_APPLIST/a list(APPEND MISSION_GLOBAL_APPLIST sc)" sample_defs/targets.cmake
diff --git a/.github/workflows/format-check.yml b/.github/workflows/format-check.yml
index 441199a..a47839d 100644
--- a/.github/workflows/format-check.yml
+++ b/.github/workflows/format-check.yml
@@ -2,13 +2,18 @@ name: Format Check
# Run on all push and pull requests
on:
+ push:
+ branches:
+ - dev
+ - main
pull_request:
types:
- opened
- reopened
- synchronize
+ workflow_dispatch:
jobs:
format-check:
name: Run format check
- uses: nasa/cFS/.github/workflows/format-check.yml@main
+ uses: nasa/cFS/.github/workflows/format-check.yml@dev
diff --git a/.github/workflows/mcdc.yml b/.github/workflows/mcdc.yml
new file mode 100644
index 0000000..b7837b3
--- /dev/null
+++ b/.github/workflows/mcdc.yml
@@ -0,0 +1,20 @@
+name: MCDC Analysis
+
+on:
+ push:
+ branches:
+ - dev
+ - main
+ pull_request:
+ types:
+ - opened
+ - reopened
+ - synchronize
+ workflow_dispatch:
+
+jobs:
+ mcdc:
+ name: Run MCDC Analysis
+ uses: nasa/cFS/.github/workflows/mcdc-reusable.yml@dev
+ with:
+ app-name: 'sc'
\ No newline at end of file
diff --git a/.github/workflows/static-analysis.yml b/.github/workflows/static-analysis.yml
index 800c300..9c279a0 100644
--- a/.github/workflows/static-analysis.yml
+++ b/.github/workflows/static-analysis.yml
@@ -15,7 +15,5 @@ on:
jobs:
static-analysis:
- name: Run cppcheck
- uses: nasa/cFS/.github/workflows/static-analysis.yml@main
- with:
- strict-dir-list: './fsw'
+ name: Static Analysis
+ uses: nasa/cFS/.github/workflows/app-static-analysis-reusable.yml@dev
\ No newline at end of file
diff --git a/.github/workflows/unit-test-coverage.yml b/.github/workflows/unit-test-coverage.yml
index 5056711..137d4f2 100644
--- a/.github/workflows/unit-test-coverage.yml
+++ b/.github/workflows/unit-test-coverage.yml
@@ -15,4 +15,4 @@ on:
jobs:
unit-test-coverage:
name: Run unit test and coverage
- uses: nasa/cFS/.github/workflows/unit-test-coverage.yml@main
+ uses: nasa/cFS/.github/workflows/unit-test-coverage-reusable.yml@dev
diff --git a/config/default_sc_msgdefs.h b/config/default_sc_msgdefs.h
index 8ccf003..c40926f 100644
--- a/config/default_sc_msgdefs.h
+++ b/config/default_sc_msgdefs.h
@@ -150,7 +150,7 @@ typedef struct
uint8 CmdErrCtr; /**< \brief Counts Request Errors */
uint8 CmdCtr; /**< \brief Counts Ground Requests */
- uint8 Padding8; /**< \brief Structure padding */
+ uint8 Padding1; /**< \brief Structure padding */
uint16 SwitchPendFlag; /**< \brief Switch pending flag: 0 = NO, 1 = YES */
uint16 NumRtsActive; /**< \brief Number of RTSs currently active */
@@ -175,19 +175,21 @@ typedef struct
uint32 NextRtsWakeupCnt; /**< \brief Next RTS Command Absolute Wakeup Count */
uint32 NextAtsTime; /**< \brief Next ATS Command Time (seconds) */
- uint16 RtsExecutingStatus[(SC_NUMBER_OF_RTS + 15) / 16];
+ uint8 RtsExecutingStatusBits[(SC_NUMBER_OF_RTS + 7) / 8];
/**< \brief RTS executing status bit map where each uint16 represents 16 RTS numbers. Note: array
index numbers and bit numbers use base zero indexing, but RTS numbers use base one indexing. Thus,
the LSB (bit zero) of uint16 array index zero represents RTS number 1, and bit one of uint16 array
index zero represents RTS number 2, etc. If an RTS is IDLE, then the corresponding bit is zero.
If an RTS is EXECUTING, then the corresponding bit is one. */
- uint16 RtsDisabledStatus[(SC_NUMBER_OF_RTS + 15) / 16];
+ uint8 RtsDisabledStatusBits[(SC_NUMBER_OF_RTS + 7) / 8];
/**< \brief RTS disabled status bit map where each uint16 represents 16 RTS numbers. Note: array
index numbers and bit numbers use base zero indexing, but RTS numbers use base one indexing. Thus,
the LSB (bit zero) of uint16 array index zero represents RTS number 1, and bit one of uint16 array
index zero represents RTS number 2, etc. If an RTS is ENABLED, then the corresponding bit is zero.
If an RTS is DISABLED, then the corresponding bit is one. */
+
+ uint8 Padding2[2];
} SC_HkTlm_Payload_t;
/**\}*/
@@ -229,7 +231,7 @@ typedef struct
typedef struct
{
SC_AtsCont_Enum_t ContinueState; /**< \brief true or false, to continue ATS after a failure */
- uint16 Padding; /**< \brief Structure Padding */
+ uint8 Padding[3]; /**< \brief Structure Padding */
} SC_SetContinueAtsOnFailureCmd_Payload_t;
/**
diff --git a/eds/sc.xml b/eds/sc.xml
index adba2ba..a4ca86e 100644
--- a/eds/sc.xml
+++ b/eds/sc.xml
@@ -146,20 +146,20 @@
-
+
- Each BASE_TYPES/uint16 represents 16 RTS numbers.
+ Each entry represents 8 RTS numbers. Note: array
Note: array index numbers and bit numbers use base zero indexing, but RTS numbers use base one indexing.
- Thus, the LSB (bit zero) of BASE_TYPES/uint16 array index zero represents RTS number 1, and bit one of BASE_TYPES/uint16
+ Thus, the LSB (bit zero) of uint8 array index zero represents RTS number 1, and bit one of uint8
array index zero represents RTS number 2, etc. If an RTS is ENABLED, then the corresponding bit is zero.
If an RTS is DISABLED, then the corresponding bit is one.
-
+
- Each BASE_TYPES/uint16 represents 16 RTS numbers. Note: array
+ Each entry represents 8 RTS numbers. Note: array
index numbers and bit numbers use base zero indexing, but RTS numbers use base one indexing. Thus,
- the LSB (bit zero) of BASE_TYPES/uint16 array index zero represents RTS number 1, and bit one of BASE_TYPES/uint16 array
+ the LSB (bit zero) of uint8 array index zero represents RTS number 1, and bit one of uint8 array
index zero represents RTS number 2, etc. If an RTS is IDLE, then the corresponding bit is zero.
If an RTS is EXECUTING, then the corresponding bit is one.
@@ -187,7 +187,7 @@
-
+
diff --git a/fsw/inc/sc_fcncodes.h b/fsw/inc/sc_fcncodes.h
index 2056b34..4a20641 100644
--- a/fsw/inc/sc_fcncodes.h
+++ b/fsw/inc/sc_fcncodes.h
@@ -157,7 +157,7 @@
*
* \sa #SC_START_ATS_CC
*/
-#define SC_STOP_ATS_CC 3
+#define SC_STOP_ATS_CC 3
/**
* \brief Start an RTS
diff --git a/fsw/src/sc_app.c b/fsw/src/sc_app.c
index 6955017..7b8c2f8 100644
--- a/fsw/src/sc_app.c
+++ b/fsw/src/sc_app.c
@@ -120,7 +120,9 @@ void SC_AppMain(void)
if (Result != CFE_SUCCESS)
{
/* Send event describing reason for termination */
- CFE_EVS_SendEvent(SC_APP_EXIT_ERR_EID, CFE_EVS_EventType_ERROR, "App terminating, Result = 0x%08X",
+ CFE_EVS_SendEvent(SC_APP_EXIT_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "App terminating, Result = 0x%08X",
(unsigned int)Result);
/* In case cFE Event Services is not working */
@@ -165,7 +167,8 @@ CFE_Status_t SC_AppInit(void)
SC_AppData.NextCmdTime[SC_Process_RTP] = SC_MAX_WAKEUP_CNT;
/* Initialize the SC housekeeping packet */
- CFE_MSG_Init(CFE_MSG_PTR(SC_OperData.HkPacket.TelemetryHeader), CFE_SB_ValueToMsgId(SC_HK_TLM_MID),
+ CFE_MSG_Init(CFE_MSG_PTR(SC_OperData.HkPacket.TelemetryHeader),
+ CFE_SB_ValueToMsgId(SC_HK_TLM_MID),
sizeof(SC_HkTlm_t));
/* Select auto-exec RTS to start during first HK request */
@@ -190,7 +193,9 @@ CFE_Status_t SC_AppInit(void)
Result = CFE_SB_CreatePipe(&SC_OperData.CmdPipe, SC_PIPE_DEPTH, SC_CMD_PIPE_NAME);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_CR_PIPE_ERR_EID, CFE_EVS_EventType_ERROR, "Software Bus Create Pipe returned: 0x%08X",
+ CFE_EVS_SendEvent(SC_CR_PIPE_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Software Bus Create Pipe returned: 0x%08X",
(unsigned int)Result);
return Result;
}
@@ -199,8 +204,10 @@ CFE_Status_t SC_AppInit(void)
Result = CFE_SB_Subscribe(CFE_SB_ValueToMsgId(SC_SEND_HK_MID), SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_HK_ERR_EID, CFE_EVS_EventType_ERROR,
- "Software Bus subscribe to housekeeping returned: 0x%08X", (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_HK_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Software Bus subscribe to housekeeping returned: 0x%08X",
+ (unsigned int)Result);
return Result;
}
@@ -208,8 +215,10 @@ CFE_Status_t SC_AppInit(void)
Result = CFE_SB_Subscribe(CFE_SB_ValueToMsgId(SC_WAKEUP_MID), SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_ERR_EID, CFE_EVS_EventType_ERROR,
- "Software Bus subscribe to wakeup cycle returned: 0x%08X", (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Software Bus subscribe to wakeup cycle returned: 0x%08X",
+ (unsigned int)Result);
return Result;
}
@@ -217,8 +226,10 @@ CFE_Status_t SC_AppInit(void)
Result = CFE_SB_Subscribe(CFE_SB_ValueToMsgId(SC_CMD_MID), SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_CMD_ERR_EID, CFE_EVS_EventType_ERROR,
- "Software Bus subscribe to command returned: 0x%08X", (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Software Bus subscribe to command returned: 0x%08X",
+ (unsigned int)Result);
return Result;
}
@@ -230,8 +241,13 @@ CFE_Status_t SC_AppInit(void)
}
/* Send application startup event */
- CFE_EVS_SendEvent(SC_INIT_INF_EID, CFE_EVS_EventType_INFORMATION, "SC Initialized. Version %d.%d.%d.%d",
- SC_MAJOR_VERSION, SC_MINOR_VERSION, SC_REVISION, SC_MISSION_REV);
+ CFE_EVS_SendEvent(SC_INIT_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "SC Initialized. Version %d.%d.%d.%d",
+ SC_MAJOR_VERSION,
+ SC_MINOR_VERSION,
+ SC_REVISION,
+ SC_MISSION_REV);
return CFE_SUCCESS;
}
@@ -247,7 +263,7 @@ CFE_Status_t SC_InitTables(void)
CFE_Status_t Result;
int32 i;
int32 j;
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
SC_AtsCmdStatusEntry_t *StatusEntryPtr;
/* Must be able to register all tables with cFE Table Services */
@@ -342,15 +358,23 @@ CFE_Status_t SC_RegisterDumpOnlyTables(void)
CFE_Status_t Result;
char TableName[CFE_MISSION_TBL_MAX_NAME_LENGTH];
- CFE_TBL_Handle_t *TblHandlePtr[4] = {&SC_OperData.RtsInfoHandle, &SC_OperData.RtsCtrlBlckHandle,
- &SC_OperData.AtsInfoHandle, &SC_OperData.AtsCtrlBlckHandle};
- const char * Name[4] = {SC_RTSINFO_TABLE_NAME, SC_RTP_CTRL_TABLE_NAME, SC_ATSINFO_TABLE_NAME,
- SC_ATS_CTRL_TABLE_NAME};
- int32 TableSize[4] = {sizeof(SC_RtsInfoEntry_t) * SC_NUMBER_OF_RTS, sizeof(SC_RtpControlBlock_t),
- sizeof(SC_AtsInfoTable_t) * SC_NUMBER_OF_ATS, sizeof(SC_AtpControlBlock_t)};
- uint16 EventID[4] = {SC_REGISTER_RTS_INFO_TABLE_ERR_EID, SC_REGISTER_RTS_CTRL_BLK_TABLE_ERR_EID,
- SC_REGISTER_ATS_INFO_TABLE_ERR_EID, SC_REGISTER_ATS_CTRL_BLK_TABLE_ERR_EID};
- const char * Spec[4] = {"RTS info", "RTS control block", "ATS Info", "ATS control block"};
+ CFE_TBL_Handle_t *TblHandlePtr[4] = { &SC_OperData.RtsInfoHandle,
+ &SC_OperData.RtsCtrlBlckHandle,
+ &SC_OperData.AtsInfoHandle,
+ &SC_OperData.AtsCtrlBlckHandle };
+ const char *Name[4] = { SC_RTSINFO_TABLE_NAME,
+ SC_RTP_CTRL_TABLE_NAME,
+ SC_ATSINFO_TABLE_NAME,
+ SC_ATS_CTRL_TABLE_NAME };
+ int32 TableSize[4] = { sizeof(SC_RtsInfoEntry_t) * SC_NUMBER_OF_RTS,
+ sizeof(SC_RtpControlBlock_t),
+ sizeof(SC_AtsInfoTable_t) * SC_NUMBER_OF_ATS,
+ sizeof(SC_AtpControlBlock_t) };
+ uint16 EventID[4] = { SC_REGISTER_RTS_INFO_TABLE_ERR_EID,
+ SC_REGISTER_RTS_CTRL_BLK_TABLE_ERR_EID,
+ SC_REGISTER_ATS_INFO_TABLE_ERR_EID,
+ SC_REGISTER_ATS_CTRL_BLK_TABLE_ERR_EID };
+ const char *Spec[4] = { "RTS info", "RTS control block", "ATS Info", "ATS control block" };
uint16 TableOptions = (CFE_TBL_OPT_DEFAULT | CFE_TBL_OPT_SNGL_BUFFER | CFE_TBL_OPT_DUMP_ONLY);
for (i = 0; i < 4; i++)
@@ -359,8 +383,11 @@ CFE_Status_t SC_RegisterDumpOnlyTables(void)
Result = CFE_TBL_Register(TblHandlePtr[i], Name[i], TableSize[i], TableOptions, NULL);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(EventID[i], CFE_EVS_EventType_ERROR, "%s table register failed, returned: 0x%08X",
- Spec[i], (unsigned int)Result);
+ CFE_EVS_SendEvent(EventID[i],
+ CFE_EVS_EventType_ERROR,
+ "%s table register failed, returned: 0x%08X",
+ Spec[i],
+ (unsigned int)Result);
return Result;
}
}
@@ -371,13 +398,18 @@ CFE_Status_t SC_RegisterDumpOnlyTables(void)
/* SAD: No need to check snprintf return value; TableName's buffer is large enough to safely hold
* SC_ATS_CMD_STAT_TABLE_NAME with the added index */
snprintf(TableName, CFE_MISSION_TBL_MAX_NAME_LENGTH, "%s%d", SC_ATS_CMD_STAT_TABLE_NAME, i + 1);
- Result = CFE_TBL_Register(&SC_OperData.AtsCmdStatusHandle[i], TableName, SC_MAX_ATS_CMDS * sizeof(uint32),
- TableOptions, NULL);
+ Result = CFE_TBL_Register(&SC_OperData.AtsCmdStatusHandle[i],
+ TableName,
+ SC_MAX_ATS_CMDS * sizeof(uint32),
+ TableOptions,
+ NULL);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_REGISTER_ATS_CMD_STATUS_TABLE_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS command status table register failed for ATS %d, returned: 0x%08X", i + 1,
+ CFE_EVS_SendEvent(SC_REGISTER_ATS_CMD_STATUS_TABLE_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS command status table register failed for ATS %d, returned: 0x%08X",
+ i + 1,
(unsigned int)Result);
return Result;
}
@@ -393,15 +425,15 @@ CFE_Status_t SC_RegisterLoadableTables(void)
CFE_Status_t Result;
char TableName[CFE_MISSION_TBL_MAX_NAME_LENGTH];
- uint16 NumTables[2] = {SC_NUMBER_OF_RTS, SC_NUMBER_OF_ATS};
- const char * StrFormat[2] = {"%s%03d", "%s%d"};
- const char * Name[2] = {SC_RTS_TABLE_NAME, SC_ATS_TABLE_NAME};
- CFE_TBL_Handle_t *TblHandlePtr[2] = {SC_OperData.RtsTblHandle, SC_OperData.AtsTblHandle};
- int32 TableSize[2] = {SC_RTS_BUFF_SIZE32 * SC_BYTES_IN_WORD, SC_ATS_BUFF_SIZE32 * SC_BYTES_IN_WORD};
- uint16 TableOptions[2] = {(CFE_TBL_OPT_DEFAULT | CFE_TBL_OPT_SNGL_BUFFER), CFE_TBL_OPT_DBL_BUFFER};
- uint16 EventID[2] = {SC_REGISTER_RTS_TBL_ERR_EID, SC_REGISTER_ATS_TBL_ERR_EID};
- const char * Spec[2] = {"RTS", "ATS"};
- CFE_TBL_CallbackFuncPtr_t TblValidationFuncPtr[2] = {SC_ValidateRts, SC_ValidateAts};
+ uint16 NumTables[2] = { SC_NUMBER_OF_RTS, SC_NUMBER_OF_ATS };
+ const char *StrFormat[2] = { "%s%03d", "%s%d" };
+ const char *Name[2] = { SC_RTS_TABLE_NAME, SC_ATS_TABLE_NAME };
+ CFE_TBL_Handle_t *TblHandlePtr[2] = { SC_OperData.RtsTblHandle, SC_OperData.AtsTblHandle };
+ int32 TableSize[2] = { SC_RTS_BUFF_SIZE32 * SC_BYTES_IN_WORD, SC_ATS_BUFF_SIZE32 * SC_BYTES_IN_WORD };
+ uint16 TableOptions[2] = { (CFE_TBL_OPT_DEFAULT | CFE_TBL_OPT_SNGL_BUFFER), CFE_TBL_OPT_DBL_BUFFER };
+ uint16 EventID[2] = { SC_REGISTER_RTS_TBL_ERR_EID, SC_REGISTER_ATS_TBL_ERR_EID };
+ const char *Spec[2] = { "RTS", "ATS" };
+ CFE_TBL_CallbackFuncPtr_t TblValidationFuncPtr[2] = { SC_ValidateRts, SC_ValidateAts };
for (i = 0; i < 2; i++)
{
@@ -410,13 +442,19 @@ CFE_Status_t SC_RegisterLoadableTables(void)
/* SAD: No need to check snprintf return value; TableName's buffer is large enough to safely hold
* CFE_MISSION_TBL_MAX_NAME_LENGTH with the added table identifiers */
snprintf(TableName, CFE_MISSION_TBL_MAX_NAME_LENGTH, StrFormat[i], Name[i], j + 1);
- Result = CFE_TBL_Register(&TblHandlePtr[i][j], TableName, TableSize[i], TableOptions[i],
+ Result = CFE_TBL_Register(&TblHandlePtr[i][j],
+ TableName,
+ TableSize[i],
+ TableOptions[i],
TblValidationFuncPtr[i]);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(EventID[i], CFE_EVS_EventType_ERROR,
- "Table Registration Failed for %s %d, returned: 0x%08X", Spec[i], j + 1,
+ CFE_EVS_SendEvent(EventID[i],
+ CFE_EVS_EventType_ERROR,
+ "Table Registration Failed for %s %d, returned: 0x%08X",
+ Spec[i],
+ j + 1,
(unsigned int)Result);
return Result;
}
@@ -424,12 +462,17 @@ CFE_Status_t SC_RegisterLoadableTables(void)
}
/* Register loadable Append ATS table */
- Result = CFE_TBL_Register(&SC_OperData.AppendTblHandle, SC_APPEND_TABLE_NAME,
- SC_APPEND_BUFF_SIZE32 * SC_BYTES_IN_WORD, CFE_TBL_OPT_DBL_BUFFER, SC_ValidateAppend);
+ Result = CFE_TBL_Register(&SC_OperData.AppendTblHandle,
+ SC_APPEND_TABLE_NAME,
+ SC_APPEND_BUFF_SIZE32 * SC_BYTES_IN_WORD,
+ CFE_TBL_OPT_DBL_BUFFER,
+ SC_ValidateAppend);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_REGISTER_APPEND_TBL_ERR_EID, CFE_EVS_EventType_ERROR,
- "Append ATS Table Registration Failed, returned: 0x%08X", (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_REGISTER_APPEND_TBL_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Append ATS Table Registration Failed, returned: 0x%08X",
+ (unsigned int)Result);
return Result;
}
@@ -447,19 +490,27 @@ CFE_Status_t SC_GetDumpTablePointers(void)
int i;
CFE_Status_t Result;
- void ** TblAddr[4] = {(void **)&SC_OperData.RtsInfoTblAddr, (void **)&SC_OperData.RtsCtrlBlckAddr,
- (void **)&SC_OperData.AtsInfoTblAddr, (void **)&SC_OperData.AtsCtrlBlckAddr};
- CFE_TBL_Handle_t TblHandle[4] = {SC_OperData.RtsInfoHandle, SC_OperData.RtsCtrlBlckHandle,
- SC_OperData.AtsInfoHandle, SC_OperData.AtsCtrlBlckHandle};
- uint16 EventID[4] = {SC_GET_ADDRESS_RTS_INFO_ERR_EID, SC_GET_ADDRESS_RTS_CTRL_BLCK_ERR_EID,
- SC_GET_ADDRESS_ATS_INFO_ERR_EID, SC_GET_ADDRESS_ATS_CTRL_BLCK_ERR_EID};
+ void **TblAddr[4] = { (void **)&SC_OperData.RtsInfoTblAddr,
+ (void **)&SC_OperData.RtsCtrlBlckAddr,
+ (void **)&SC_OperData.AtsInfoTblAddr,
+ (void **)&SC_OperData.AtsCtrlBlckAddr };
+ CFE_TBL_Handle_t TblHandle[4] = { SC_OperData.RtsInfoHandle,
+ SC_OperData.RtsCtrlBlckHandle,
+ SC_OperData.AtsInfoHandle,
+ SC_OperData.AtsCtrlBlckHandle };
+ uint16 EventID[4] = { SC_GET_ADDRESS_RTS_INFO_ERR_EID,
+ SC_GET_ADDRESS_RTS_CTRL_BLCK_ERR_EID,
+ SC_GET_ADDRESS_ATS_INFO_ERR_EID,
+ SC_GET_ADDRESS_ATS_CTRL_BLCK_ERR_EID };
for (i = 0; i < 4; i++)
{
Result = CFE_TBL_GetAddress(TblAddr[i], TblHandle[i]);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(EventID[i], CFE_EVS_EventType_ERROR, "Table failed Getting Address, returned: 0x%08X",
+ CFE_EVS_SendEvent(EventID[i],
+ CFE_EVS_EventType_ERROR,
+ "Table failed Getting Address, returned: 0x%08X",
(unsigned int)Result);
return Result;
}
@@ -471,8 +522,10 @@ CFE_Status_t SC_GetDumpTablePointers(void)
Result = CFE_TBL_GetAddress((void **)&SC_OperData.AtsCmdStatusTblAddr[i], SC_OperData.AtsCmdStatusHandle[i]);
if (Result != CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_GET_ADDRESS_ATS_CMD_STAT_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS Cmd Status table for ATS %d failed Getting Address, returned: 0x%08X", i + 1,
+ CFE_EVS_SendEvent(SC_GET_ADDRESS_ATS_CMD_STAT_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS Cmd Status table for ATS %d failed Getting Address, returned: 0x%08X",
+ i + 1,
(unsigned int)Result);
return Result;
}
@@ -499,8 +552,11 @@ CFE_Status_t SC_GetLoadTablePointers(void)
if ((Result != CFE_TBL_ERR_NEVER_LOADED) && (Result != CFE_TBL_INFO_UPDATED))
{
- CFE_EVS_SendEvent(SC_GET_ADDRESS_ATS_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS table %d failed Getting Address, returned: 0x%08X", i + 1, (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_GET_ADDRESS_ATS_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS table %d failed Getting Address, returned: 0x%08X",
+ i + 1,
+ (unsigned int)Result);
return Result;
}
}
@@ -510,8 +566,10 @@ CFE_Status_t SC_GetLoadTablePointers(void)
if ((Result != CFE_TBL_ERR_NEVER_LOADED) && (Result != CFE_TBL_INFO_UPDATED))
{
- CFE_EVS_SendEvent(SC_GET_ADDRESS_APPEND_ERR_EID, CFE_EVS_EventType_ERROR,
- "Append ATS table failed Getting Address, returned: 0x%08X", (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_GET_ADDRESS_APPEND_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Append ATS table failed Getting Address, returned: 0x%08X",
+ (unsigned int)Result);
return Result;
}
@@ -522,8 +580,11 @@ CFE_Status_t SC_GetLoadTablePointers(void)
if ((Result != CFE_TBL_ERR_NEVER_LOADED) && (Result != CFE_TBL_INFO_UPDATED))
{
- CFE_EVS_SendEvent(SC_GET_ADDRESS_RTS_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS table %d failed Getting Address, returned: 0x%08X", i + 1, (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_GET_ADDRESS_RTS_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS table %d failed Getting Address, returned: 0x%08X",
+ i + 1,
+ (unsigned int)Result);
return Result;
}
@@ -566,14 +627,20 @@ void SC_LoadDefaultTables(void)
NotLoadedCount++;
/* send an event for each failed load */
- CFE_EVS_SendEvent(SC_RTS_LOAD_FAIL_DBG_EID, CFE_EVS_EventType_DEBUG,
- "RTS table %d failed to load, returned: 0x%08lX", (int)RtsIndex, (unsigned long)Status);
+ CFE_EVS_SendEvent(SC_RTS_LOAD_FAIL_DBG_EID,
+ CFE_EVS_EventType_DEBUG,
+ "RTS table %d failed to load, returned: 0x%08lX",
+ (int)RtsIndex,
+ (unsigned long)Status);
}
}
/* Display startup RTS not loaded count */
- CFE_EVS_SendEvent(SC_RTS_LOAD_FAIL_COUNT_INFO_EID, CFE_EVS_EventType_INFORMATION,
- "RTS table files not loaded at initialization = %d of %d", (int)NotLoadedCount, SC_NUMBER_OF_RTS);
+ CFE_EVS_SendEvent(SC_RTS_LOAD_FAIL_COUNT_INFO_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "RTS table files not loaded at initialization = %d of %d",
+ (int)NotLoadedCount,
+ SC_NUMBER_OF_RTS);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -586,11 +653,16 @@ void SC_RegisterManageCmds(void)
{
int32 i;
- CFE_TBL_Handle_t TblHandles[5] = {SC_OperData.RtsInfoHandle, SC_OperData.RtsCtrlBlckHandle,
- SC_OperData.AtsInfoHandle, SC_OperData.AtsCtrlBlckHandle,
- SC_OperData.AppendTblHandle};
- uint32 params[5] = {SC_TBL_ID_RTS_INFO, SC_TBL_ID_RTP_CTRL, SC_TBL_ID_ATS_INFO, SC_TBL_ID_ATP_CTRL,
- SC_TBL_ID_APPEND};
+ CFE_TBL_Handle_t TblHandles[5] = { SC_OperData.RtsInfoHandle,
+ SC_OperData.RtsCtrlBlckHandle,
+ SC_OperData.AtsInfoHandle,
+ SC_OperData.AtsCtrlBlckHandle,
+ SC_OperData.AppendTblHandle };
+ uint32 params[5] = { SC_TBL_ID_RTS_INFO,
+ SC_TBL_ID_RTP_CTRL,
+ SC_TBL_ID_ATS_INFO,
+ SC_TBL_ID_ATP_CTRL,
+ SC_TBL_ID_APPEND };
for (i = 0; i < 5; i++)
{
@@ -600,18 +672,24 @@ void SC_RegisterManageCmds(void)
for (i = 0; i < SC_NUMBER_OF_ATS; i++)
{
/* Register for ATS cmd status table manage request commands */
- CFE_TBL_NotifyByMessage(SC_OperData.AtsCmdStatusHandle[i], CFE_SB_ValueToMsgId(SC_CMD_MID), SC_MANAGE_TABLE_CC,
+ CFE_TBL_NotifyByMessage(SC_OperData.AtsCmdStatusHandle[i],
+ CFE_SB_ValueToMsgId(SC_CMD_MID),
+ SC_MANAGE_TABLE_CC,
SC_TBL_ID_ATS_CMD_0 + i);
/* Register for ATS table manage request commands */
- CFE_TBL_NotifyByMessage(SC_OperData.AtsTblHandle[i], CFE_SB_ValueToMsgId(SC_CMD_MID), SC_MANAGE_TABLE_CC,
+ CFE_TBL_NotifyByMessage(SC_OperData.AtsTblHandle[i],
+ CFE_SB_ValueToMsgId(SC_CMD_MID),
+ SC_MANAGE_TABLE_CC,
SC_TBL_ID_ATS_0 + i);
}
for (i = 0; i < SC_NUMBER_OF_RTS; i++)
{
/* Register for RTS table manage request commands */
- CFE_TBL_NotifyByMessage(SC_OperData.RtsTblHandle[i], CFE_SB_ValueToMsgId(SC_CMD_MID), SC_MANAGE_TABLE_CC,
+ CFE_TBL_NotifyByMessage(SC_OperData.RtsTblHandle[i],
+ CFE_SB_ValueToMsgId(SC_CMD_MID),
+ SC_MANAGE_TABLE_CC,
SC_TBL_ID_RTS_0 + i);
}
}
diff --git a/fsw/src/sc_app.h b/fsw/src/sc_app.h
index 842a8bf..ff45db4 100644
--- a/fsw/src/sc_app.h
+++ b/fsw/src/sc_app.h
@@ -218,7 +218,7 @@ void SC_RegisterManageCmds(void);
#define SC_DUP_TEST_UNUSED -1 /**< \brief Unused marking for duplicate test */
-#define SC_INVALID_CMD_NUMBER ((SC_CommandNum_t) {0}) /**< \brief Invalid command number */
+#define SC_INVALID_CMD_NUMBER ((SC_CommandNum_t) { 0 }) /**< \brief Invalid command number */
#define SC_ROUND_UP_BYTES 3 /**< \brief Round up to word length (in bytes) */
@@ -245,13 +245,13 @@ typedef struct
CFE_SB_PipeId_t CmdPipe; /**< \brief Command pipe ID */
CFE_TBL_Handle_t AtsTblHandle[SC_NUMBER_OF_ATS]; /**< \brief Table handles for all ATS tables */
- uint32 * AtsTblAddr[SC_NUMBER_OF_ATS]; /**< \brief Table Addresses for all ATS tables */
+ uint32 *AtsTblAddr[SC_NUMBER_OF_ATS]; /**< \brief Table Addresses for all ATS tables */
CFE_TBL_Handle_t AppendTblHandle; /**< \brief Table handle for Append ATS table */
- uint32 * AppendTblAddr; /**< \brief Table Address for Append ATS table */
+ uint32 *AppendTblAddr; /**< \brief Table Address for Append ATS table */
CFE_TBL_Handle_t RtsTblHandle[SC_NUMBER_OF_RTS]; /**< \brief Table handles for all RTS tables */
- uint32 * RtsTblAddr[SC_NUMBER_OF_RTS]; /**< \brief Table addresses for all RTS tables */
+ uint32 *RtsTblAddr[SC_NUMBER_OF_RTS]; /**< \brief Table addresses for all RTS tables */
CFE_TBL_Handle_t AtsInfoHandle; /**< \brief Table handle the for ATS Info Table */
SC_AtsInfoTable_t *AtsInfoTblAddr; /**< \brief Table address for the ATS Info Table*/
diff --git a/fsw/src/sc_atsrq.c b/fsw/src/sc_atsrq.c
index e6cbbf2..a8e09ff 100644
--- a/fsw/src/sc_atsrq.c
+++ b/fsw/src/sc_atsrq.c
@@ -76,8 +76,10 @@ CFE_Status_t SC_StartAtsCmd(const SC_StartAtsCmd_t *Cmd)
/* increment the command request counter */
SC_OperData.HkPacket.Payload.CmdCtr++;
- CFE_EVS_SendEvent(SC_STARTATS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION,
- "ATS %c Execution Started", SC_IDX_AS_CHAR(AtsIndex));
+ CFE_EVS_SendEvent(SC_STARTATS_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "ATS %c Execution Started",
+ SC_IDX_AS_CHAR(AtsIndex));
}
else
{ /* could not start the ats, all commands were skipped */
@@ -91,8 +93,10 @@ CFE_Status_t SC_StartAtsCmd(const SC_StartAtsCmd_t *Cmd)
else
{ /* the ats didn't have any commands in it */
- CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR,
- "Start ATS Rejected: ATS %c Not Loaded", SC_IDX_AS_CHAR(AtsIndex));
+ CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_LDED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Start ATS Rejected: ATS %c Not Loaded",
+ SC_IDX_AS_CHAR(AtsIndex));
/* increment the command request error counter */
SC_OperData.HkPacket.Payload.CmdErrCtr++;
@@ -102,7 +106,8 @@ CFE_Status_t SC_StartAtsCmd(const SC_StartAtsCmd_t *Cmd)
else
{ /* the ATS is being used */
- CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_IDLE_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_IDLE_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Start ATS Rejected: ATP is not Idle");
/* increment the command request error counter */
SC_OperData.HkPacket.Payload.CmdErrCtr++;
@@ -112,8 +117,10 @@ CFE_Status_t SC_StartAtsCmd(const SC_StartAtsCmd_t *Cmd)
else
{ /* the specified ATS id is not valid */
- CFE_EVS_SendEvent(SC_STARTATS_CMD_INVLD_ID_ERR_EID, CFE_EVS_EventType_ERROR,
- "Start ATS %u Rejected: Invalid ATS ID", SC_IDNUM_AS_UINT(AtsNum));
+ CFE_EVS_SendEvent(SC_STARTATS_CMD_INVLD_ID_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Start ATS %u Rejected: Invalid ATS ID",
+ SC_IDNUM_AS_UINT(AtsNum));
/* increment the command request error counter */
SC_OperData.HkPacket.Payload.CmdErrCtr++;
@@ -142,7 +149,9 @@ CFE_Status_t SC_StopAtsCmd(const SC_StopAtsCmd_t *Cmd)
if (Result == CFE_SUCCESS)
{
- CFE_EVS_SendEvent(SC_STOPATS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, "ATS %c stopped",
+ CFE_EVS_SendEvent(SC_STOPATS_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "ATS %c stopped",
SC_IDX_AS_CHAR(SC_AtsNumToIndex(SC_OperData.AtsCtrlBlckAddr->CurrAtsNum)));
}
else
@@ -168,7 +177,7 @@ CFE_Status_t SC_StopAtsCmd(const SC_StopAtsCmd_t *Cmd)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
bool SC_BeginAts(SC_AtsIndex_t AtsIndex, uint16 TimeOffset)
{
- SC_AtsEntryHeader_t * Entry; /* ATS table entry pointer */
+ SC_AtsEntryHeader_t *Entry; /* ATS table entry pointer */
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec; /* ATS entry location in table */
SC_AbsTimeTag_t ListCmdTime = 0; /* list entry execution time */
SC_SeqIndex_t TimeIndex; /* the current time buffer index */
@@ -176,14 +185,16 @@ bool SC_BeginAts(SC_AtsIndex_t AtsIndex, uint16 TimeOffset)
bool ReturnCode;
SC_AbsTimeTag_t TimeToStartAts; /* the REAL time to start the ATS */
uint16 CmdsSkipped = 0;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
/* validate ATS array index */
if (!SC_AtsIndexIsValid(AtsIndex))
{
- CFE_EVS_SendEvent(SC_BEGINATS_INVLD_INDEX_ERR_EID, CFE_EVS_EventType_ERROR,
- "Begin ATS error: invalid ATS index %u", SC_IDX_AS_UINT(AtsIndex));
+ CFE_EVS_SendEvent(SC_BEGINATS_INVLD_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Begin ATS error: invalid ATS index %u",
+ SC_IDX_AS_UINT(AtsIndex));
return false;
}
@@ -211,9 +222,9 @@ bool SC_BeginAts(SC_AtsIndex_t AtsIndex, uint16 TimeOffset)
/* then get the entry index from the cmd index table */
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, CmdIndex);
/* then get a pointer to the ATS entry data */
- Entry = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
+ Entry = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
/* then get cmd execution time from the ATS entry */
- ListCmdTime = SC_GetAtsEntryTime(Entry);
+ ListCmdTime = SC_GetAtsEntryTime(Entry);
/* compare ATS start time to this list entry time */
if (SC_CompareAbsTime(TimeToStartAts, ListCmdTime))
@@ -237,7 +248,8 @@ bool SC_BeginAts(SC_AtsIndex_t AtsIndex, uint16 TimeOffset)
*/
if (!SC_IDX_WITHIN_LIMIT(TimeIndex, AtsInfoPtr->NumberOfCommands))
{
- CFE_EVS_SendEvent(SC_ATS_SKP_ALL_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_ATS_SKP_ALL_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"All ATS commands were skipped, ATS stopped");
/* stop the ats */
@@ -257,7 +269,9 @@ bool SC_BeginAts(SC_AtsIndex_t AtsIndex, uint16 TimeOffset)
SC_OperData.AtsCtrlBlckAddr->TimeIndexPtr = TimeIndex;
/* send an event for number of commands skipped */
- CFE_EVS_SendEvent(SC_ATS_ERR_SKP_DBG_EID, CFE_EVS_EventType_DEBUG, "ATS started, skipped %d commands",
+ CFE_EVS_SendEvent(SC_ATS_ERR_SKP_DBG_EID,
+ CFE_EVS_EventType_DEBUG,
+ "ATS started, skipped %d commands",
CmdsSkipped);
/*
** Set the next command time for the ATP
@@ -312,8 +326,8 @@ CFE_Status_t SC_SwitchAtsCmd(const SC_SwitchAtsCmd_t *Cmd)
SC_AtsInfoTable_t *AtsInfoPtr;
/* make sure that an ATS is running on the ATP */
- if (SC_AtsNumIsValid(SC_OperData.AtsCtrlBlckAddr->CurrAtsNum) &&
- SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING)
+ if (SC_AtsNumIsValid(SC_OperData.AtsCtrlBlckAddr->CurrAtsNum)
+ && SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING)
{
/* get the ATS to switch to */
NewAtsIndex = SC_ToggleAtsIndex();
@@ -333,7 +347,8 @@ CFE_Status_t SC_SwitchAtsCmd(const SC_SwitchAtsCmd_t *Cmd)
else
{ /* the other ATS does not have any commands in it */
- CFE_EVS_SendEvent(SC_SWITCH_ATS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_SWITCH_ATS_CMD_NOT_LDED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Switch ATS Failure: Destination ATS Not Loaded");
/* update command error counter */
@@ -399,8 +414,10 @@ void SC_ServiceSwitchPend(void)
{
SC_OperData.AtsCtrlBlckAddr->AtpState = SC_Status_EXECUTING;
- CFE_EVS_SendEvent(SC_ATS_SERVICE_SWTCH_INF_EID, CFE_EVS_EventType_INFORMATION,
- "ATS Switched from %c to %c", SC_IDX_AS_CHAR(OldAtsIndex),
+ CFE_EVS_SendEvent(SC_ATS_SERVICE_SWTCH_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "ATS Switched from %c to %c",
+ SC_IDX_AS_CHAR(OldAtsIndex),
SC_IDX_AS_CHAR(NewAtsIndex));
} /* end if */
@@ -408,7 +425,8 @@ void SC_ServiceSwitchPend(void)
else
{ /* the other ATS does not have any commands in it */
- CFE_EVS_SendEvent(SC_SERVICE_SWITCH_ATS_CMD_LDED_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_SERVICE_SWITCH_ATS_CMD_LDED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Switch ATS Failure: Destination ATS is empty");
} /* end if */
}
@@ -417,7 +435,8 @@ void SC_ServiceSwitchPend(void)
/* this should only happen if the switch flag gets */
/* corrupted some how */
- CFE_EVS_SendEvent(SC_ATS_SERVICE_SWITCH_IDLE_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_ATS_SERVICE_SWITCH_IDLE_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Switch ATS Rejected: ATP is idle");
} /* end if */
@@ -462,8 +481,11 @@ bool SC_InlineSwitch(void)
{
SC_OperData.AtsCtrlBlckAddr->AtpState = SC_Status_STARTING;
- CFE_EVS_SendEvent(SC_ATS_INLINE_SWTCH_INF_EID, CFE_EVS_EventType_INFORMATION, "ATS Switched from %c to %c",
- SC_IDX_AS_CHAR(OldAtsIndex), SC_IDX_AS_CHAR(NewAtsIndex));
+ CFE_EVS_SendEvent(SC_ATS_INLINE_SWTCH_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "ATS Switched from %c to %c",
+ SC_IDX_AS_CHAR(OldAtsIndex),
+ SC_IDX_AS_CHAR(NewAtsIndex));
/*
** Update the command counter and return code
@@ -484,7 +506,8 @@ bool SC_InlineSwitch(void)
}
else
{ /* the other ATS does not have any commands in it */
- CFE_EVS_SendEvent(SC_ATS_INLINE_SWTCH_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_ATS_INLINE_SWTCH_NOT_LDED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Switch ATS Failure: Destination ATS Not Loaded");
/*
** update the ATS error counter
@@ -507,7 +530,7 @@ bool SC_InlineSwitch(void)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
CFE_Status_t SC_JumpAtsCmd(const SC_JumpAtsCmd_t *Cmd)
{
- SC_AtsEntryHeader_t * Entry; /* ATS table entry pointer */
+ SC_AtsEntryHeader_t *Entry; /* ATS table entry pointer */
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec; /* ATS entry location in table */
SC_AbsTimeTag_t JumpTime; /* the time to jump to in the ATS */
SC_AbsTimeTag_t ListCmdTime; /* list entry execution time */
@@ -517,8 +540,8 @@ CFE_Status_t SC_JumpAtsCmd(const SC_JumpAtsCmd_t *Cmd)
char TimeBuffer[CFE_TIME_PRINTED_STRING_SIZE];
CFE_TIME_SysTime_t NewTime;
uint16 NumSkipped;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
if (SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING)
{
@@ -548,9 +571,9 @@ CFE_Status_t SC_JumpAtsCmd(const SC_JumpAtsCmd_t *Cmd)
/* then get the entry index from the cmd index table */
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, CmdIndex);
/* then get a pointer to the ATS entry data */
- Entry = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
+ Entry = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
/* then get cmd execution time from the ATS entry */
- ListCmdTime = SC_GetAtsEntryTime(Entry);
+ ListCmdTime = SC_GetAtsEntryTime(Entry);
/* compare ATS jump time to this list entry time */
if (SC_CompareAbsTime(JumpTime, ListCmdTime))
@@ -575,8 +598,10 @@ CFE_Status_t SC_JumpAtsCmd(const SC_JumpAtsCmd_t *Cmd)
else
{
/* jump time is less than or equal to this list entry */
- CFE_EVS_SendEvent(SC_JUMPATS_CMD_LIST_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Jump Cmd: Jump time less than or equal to list entry %u", SC_IDX_AS_UINT(CmdIndex));
+ CFE_EVS_SendEvent(SC_JUMPATS_CMD_LIST_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Jump Cmd: Jump time less than or equal to list entry %u",
+ SC_IDX_AS_UINT(CmdIndex));
break;
}
}
@@ -586,7 +611,8 @@ CFE_Status_t SC_JumpAtsCmd(const SC_JumpAtsCmd_t *Cmd)
*/
if (!SC_IDX_WITHIN_LIMIT(TimeIndex, AtsInfoPtr->NumberOfCommands))
{
- CFE_EVS_SendEvent(SC_JUMPATS_CMD_STOPPED_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_JUMPATS_CMD_STOPPED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Jump Cmd: All ATS commands were skipped, ATS stopped");
SC_OperData.HkPacket.Payload.CmdErrCtr++;
@@ -616,13 +642,17 @@ CFE_Status_t SC_JumpAtsCmd(const SC_JumpAtsCmd_t *Cmd)
CFE_TIME_Print((char *)&TimeBuffer, NewTime);
- CFE_EVS_SendEvent(SC_JUMP_ATS_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Next ATS command time in the ATP was set to %s", TimeBuffer);
+ CFE_EVS_SendEvent(SC_JUMP_ATS_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Next ATS command time in the ATP was set to %s",
+ TimeBuffer);
if (NumSkipped > 0)
{
/* We skipped come commands, but not all of them */
- CFE_EVS_SendEvent(SC_JUMP_ATS_SKIPPED_DBG_EID, CFE_EVS_EventType_DEBUG,
- "Jump Cmd: Skipped %d ATS commands", NumSkipped);
+ CFE_EVS_SendEvent(SC_JUMP_ATS_SKIPPED_DBG_EID,
+ CFE_EVS_EventType_DEBUG,
+ "Jump Cmd: Skipped %d ATS commands",
+ NumSkipped);
}
} /* end if */
@@ -654,8 +684,10 @@ CFE_Status_t SC_ContinueAtsOnFailureCmd(const SC_ContinueAtsOnFailureCmd_t *Cmd)
{
SC_OperData.HkPacket.Payload.CmdErrCtr++;
- CFE_EVS_SendEvent(SC_CONT_CMD_ERR_EID, CFE_EVS_EventType_ERROR,
- "Continue ATS On Failure command failed, invalid state: %lu", (unsigned long)State);
+ CFE_EVS_SendEvent(SC_CONT_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Continue ATS On Failure command failed, invalid state: %lu",
+ (unsigned long)State);
}
else
{
@@ -663,8 +695,10 @@ CFE_Status_t SC_ContinueAtsOnFailureCmd(const SC_ContinueAtsOnFailureCmd_t *Cmd)
SC_OperData.HkPacket.Payload.CmdCtr++;
- CFE_EVS_SendEvent(SC_CONT_CMD_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Continue-ATS-On-Failure command, State: %lu", (unsigned long)State);
+ CFE_EVS_SendEvent(SC_CONT_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Continue-ATS-On-Failure command, State: %lu",
+ (unsigned long)State);
}
return CFE_SUCCESS;
@@ -685,7 +719,9 @@ CFE_Status_t SC_AppendAtsCmd(const SC_AppendAtsCmd_t *Cmd)
/* invalid target ATS selection */
SC_OperData.HkPacket.Payload.CmdErrCtr++;
- CFE_EVS_SendEvent(SC_APPEND_CMD_ARG_ERR_EID, CFE_EVS_EventType_ERROR, "Append ATS error: invalid ATS ID = %u",
+ CFE_EVS_SendEvent(SC_APPEND_CMD_ARG_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Append ATS error: invalid ATS ID = %u",
SC_IDNUM_AS_UINT(Cmd->Payload.AtsNum));
return CFE_SUCCESS;
@@ -700,7 +736,9 @@ CFE_Status_t SC_AppendAtsCmd(const SC_AppendAtsCmd_t *Cmd)
/* target ATS table is empty */
SC_OperData.HkPacket.Payload.CmdErrCtr++;
- CFE_EVS_SendEvent(SC_APPEND_CMD_TGT_ERR_EID, CFE_EVS_EventType_ERROR, "Append ATS %c error: ATS table is empty",
+ CFE_EVS_SendEvent(SC_APPEND_CMD_TGT_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Append ATS %c error: ATS table is empty",
SC_IDX_AS_CHAR(AtsIndex));
}
else if (SC_OperData.HkPacket.Payload.AppendEntryCount == 0)
@@ -708,17 +746,22 @@ CFE_Status_t SC_AppendAtsCmd(const SC_AppendAtsCmd_t *Cmd)
/* append table is empty */
SC_OperData.HkPacket.Payload.CmdErrCtr++;
- CFE_EVS_SendEvent(SC_APPEND_CMD_SRC_ERR_EID, CFE_EVS_EventType_ERROR,
- "Append ATS %c error: Append table is empty", SC_IDX_AS_CHAR(AtsIndex));
+ CFE_EVS_SendEvent(SC_APPEND_CMD_SRC_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Append ATS %c error: Append table is empty",
+ SC_IDX_AS_CHAR(AtsIndex));
}
else if ((AtsInfoPtr->AtsSize + SC_AppData.AppendWordCount) > SC_ATS_BUFF_SIZE32)
{
/* not enough room in ATS buffer for Append table data */
SC_OperData.HkPacket.Payload.CmdErrCtr++;
- CFE_EVS_SendEvent(SC_APPEND_CMD_FIT_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_APPEND_CMD_FIT_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Append ATS %c error: ATS size = %d, Append size = %d, ATS buffer = %d",
- SC_IDX_AS_CHAR(AtsIndex), (int)AtsInfoPtr->AtsSize, SC_AppData.AppendWordCount,
+ SC_IDX_AS_CHAR(AtsIndex),
+ (int)AtsInfoPtr->AtsSize,
+ SC_AppData.AppendWordCount,
SC_ATS_BUFF_SIZE32);
}
else
@@ -732,8 +775,10 @@ CFE_Status_t SC_AppendAtsCmd(const SC_AppendAtsCmd_t *Cmd)
/* increment command success counter */
SC_OperData.HkPacket.Payload.CmdCtr++;
- CFE_EVS_SendEvent(SC_APPEND_CMD_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Append ATS %c command: %d ATS entries appended", SC_IDX_AS_CHAR(AtsIndex),
+ CFE_EVS_SendEvent(SC_APPEND_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Append ATS %c command: %d ATS entries appended",
+ SC_IDX_AS_CHAR(AtsIndex),
SC_OperData.HkPacket.Payload.AppendEntryCount);
}
diff --git a/fsw/src/sc_cmds.c b/fsw/src/sc_cmds.c
index d59a3a5..57e2687 100644
--- a/fsw/src/sc_cmds.c
+++ b/fsw/src/sc_cmds.c
@@ -58,12 +58,12 @@ void SC_ProcessAtpCmd(void)
SC_CommandIndex_t CmdIndex; /* ATS command index */
CFE_Status_t Result;
bool AbortATS = false;
- SC_AtsEntry_t * EntryPtr;
+ SC_AtsEntry_t *EntryPtr;
CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID;
CFE_MSG_FcnCode_t CommandCode = 0;
bool ChecksumValid;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec; /* ATS entry location in table */
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
/*
** The following conditions must be met before the ATS command will be
@@ -73,8 +73,8 @@ void SC_ProcessAtpCmd(void)
** 3.) The atp is currently EXECUTING
*/
- if ((SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING) &&
- (!SC_CompareAbsTime(SC_AppData.NextCmdTime[SC_Process_ATP], SC_AppData.CurrentTime)))
+ if ((SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING)
+ && (!SC_CompareAbsTime(SC_AppData.NextCmdTime[SC_Process_ATP], SC_AppData.CurrentTime)))
{
/*
** Get a pointer to the next ats command
@@ -170,9 +170,11 @@ void SC_ProcessAtpCmd(void)
SC_OperData.HkPacket.Payload.LastAtsErrSeq = SC_OperData.AtsCtrlBlckAddr->CurrAtsNum;
SC_OperData.HkPacket.Payload.LastAtsErrCmd = SC_OperData.AtsCtrlBlckAddr->CmdNumber;
- CFE_EVS_SendEvent(SC_ATS_DIST_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_ATS_DIST_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"ATS Command Distribution Failed, Cmd Number: %u, SB returned: 0x%08X",
- SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber), (unsigned int)Result);
+ SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber),
+ (unsigned int)Result);
/* Mark this ATS for abortion */
AbortATS = true;
@@ -184,7 +186,8 @@ void SC_ProcessAtpCmd(void)
/*
** Send an event message to report the invalid command status
*/
- CFE_EVS_SendEvent(SC_ATS_CHKSUM_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_ATS_CHKSUM_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"ATS Command Failed Checksum: Command #%u Skipped",
SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber));
/*
@@ -214,7 +217,8 @@ void SC_ProcessAtpCmd(void)
** Send an event message to report the invalid command status
*/
- CFE_EVS_SendEvent(SC_ATS_MSMTCH_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_ATS_MSMTCH_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"ATS Command Number Mismatch: Command Skipped, expected: %u received: %u",
SC_IDNUM_AS_UINT(SC_CommandIndexToNum(CmdIndex)),
SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber));
@@ -241,7 +245,8 @@ void SC_ProcessAtpCmd(void)
/*
** Send an event message to report the invalid command status
*/
- CFE_EVS_SendEvent(SC_ATS_SKP_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_ATS_SKP_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Invalid ATS Command Status: Command Skipped, Status: %lu",
(unsigned long)StatusEntryPtr->Status);
/*
@@ -287,7 +292,7 @@ void SC_ProcessAtpCmd(void)
void SC_ProcessRtpCommand(void)
{
- SC_RtsEntry_t * EntryPtr; /* a pointer to an RTS entry header */
+ SC_RtsEntry_t *EntryPtr; /* a pointer to an RTS entry header */
SC_RtsIndex_t RtsIndex; /* the RTS index for the cmd */
SC_EntryOffset_t CmdOffset; /* the location of the cmd */
CFE_Status_t Result;
@@ -310,8 +315,8 @@ void SC_ProcessRtpCommand(void)
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- if ((SC_AppData.NextCmdTime[SC_Process_RTP] <= SC_AppData.CurrentWakeupCount) &&
- (RtsInfoPtr->RtsStatus == SC_Status_EXECUTING))
+ if ((SC_AppData.NextCmdTime[SC_Process_RTP] <= SC_AppData.CurrentWakeupCount)
+ && (RtsInfoPtr->RtsStatus == SC_Status_EXECUTING))
{
/*
** Count the command for the rate limiter
@@ -360,9 +365,11 @@ void SC_ProcessRtpCommand(void)
/*
** Send an event message to report the invalid command status
*/
- CFE_EVS_SendEvent(SC_RTS_DIST_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_RTS_DIST_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"RTS %03u Command Distribution Failed: RTS Stopped. SB returned 0x%08X",
- SC_IDNUM_AS_UINT(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum), (unsigned int)Result);
+ SC_IDNUM_AS_UINT(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum),
+ (unsigned int)Result);
SC_OperData.HkPacket.Payload.RtsCmdErrCtr++;
RtsInfoPtr->CmdErrCtr++;
@@ -382,7 +389,8 @@ void SC_ProcessRtpCommand(void)
/*
** Send an event message to report the invalid command status
*/
- CFE_EVS_SendEvent(SC_RTS_CHKSUM_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_RTS_CHKSUM_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"RTS %03u Command Failed Checksum: RTS Stopped",
SC_IDNUM_AS_UINT(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum));
/*
@@ -398,7 +406,7 @@ void SC_ProcessRtpCommand(void)
*/
SC_KillRts(RtsIndex);
} /* end if */
- } /* end if */
+ } /* end if */
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -449,15 +457,20 @@ void SC_SendHkPacket(void)
** Fill out the RTS status bit mask
** First clear out the status mask
*/
- memset(SC_OperData.HkPacket.Payload.RtsExecutingStatus, 0, sizeof(SC_OperData.HkPacket.Payload.RtsExecutingStatus));
- memset(SC_OperData.HkPacket.Payload.RtsDisabledStatus, 0, sizeof(SC_OperData.HkPacket.Payload.RtsDisabledStatus));
+ memset(SC_OperData.HkPacket.Payload.RtsExecutingStatusBits,
+ 0,
+ sizeof(SC_OperData.HkPacket.Payload.RtsExecutingStatusBits));
+ memset(SC_OperData.HkPacket.Payload.RtsDisabledStatusBits,
+ 0,
+ sizeof(SC_OperData.HkPacket.Payload.RtsDisabledStatusBits));
for (i = 0; i < SC_NUMBER_OF_RTS; i++)
{
RtsInfoPtr = SC_GetRtsInfoObject(SC_RTS_IDX_C(i));
- SC_SET_HKTLM_RTS_MASK(SC_OperData.HkPacket.Payload.RtsDisabledStatus, i, RtsInfoPtr->DisabledFlag);
- SC_SET_HKTLM_RTS_MASK(SC_OperData.HkPacket.Payload.RtsExecutingStatus, i,
+ SC_SET_HKTLM_RTS_MASK(SC_OperData.HkPacket.Payload.RtsDisabledStatusBits, i, RtsInfoPtr->DisabledFlag);
+ SC_SET_HKTLM_RTS_MASK(SC_OperData.HkPacket.Payload.RtsExecutingStatusBits,
+ i,
(RtsInfoPtr->RtsStatus == SC_Status_EXECUTING));
} /* end for */
@@ -577,8 +590,13 @@ CFE_Status_t SC_WakeupCmd(const SC_WakeupCmd_t *Cmd)
CFE_Status_t SC_NoopCmd(const SC_NoopCmd_t *Cmd)
{
SC_OperData.HkPacket.Payload.CmdCtr++;
- CFE_EVS_SendEvent(SC_NOOP_INF_EID, CFE_EVS_EventType_INFORMATION, "No-op command. Version %d.%d.%d.%d",
- SC_MAJOR_VERSION, SC_MINOR_VERSION, SC_REVISION, SC_MISSION_REV);
+ CFE_EVS_SendEvent(SC_NOOP_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "No-op command. Version %d.%d.%d.%d",
+ SC_MAJOR_VERSION,
+ SC_MINOR_VERSION,
+ SC_REVISION,
+ SC_MISSION_REV);
return CFE_SUCCESS;
}
@@ -638,8 +656,10 @@ CFE_Status_t SC_ManageTableCmd(const SC_ManageTableCmd_t *Cmd)
else
{
/* Invalid table ID */
- CFE_EVS_SendEvent(SC_TABLE_MANAGE_ID_ERR_EID, CFE_EVS_EventType_ERROR,
- "Table manage command packet error: table ID = %d", (int)TableID);
+ CFE_EVS_SendEvent(SC_TABLE_MANAGE_ID_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Table manage command packet error: table ID = %d",
+ (int)TableID);
}
// No success/informational event is sent for this command intentionally, to avoid the risk of flooding.
@@ -658,8 +678,10 @@ void SC_ManageRtsTable(int32 ArrayIndex)
/* validate array index */
if (ArrayIndex >= SC_NUMBER_OF_RTS)
{
- CFE_EVS_SendEvent(SC_TABLE_MANAGE_RTS_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS table manage error: invalid RTS index %d", (int)ArrayIndex);
+ CFE_EVS_SendEvent(SC_TABLE_MANAGE_RTS_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS table manage error: invalid RTS index %d",
+ (int)ArrayIndex);
return;
}
@@ -677,8 +699,10 @@ void SC_ManageAtsTable(int32 ArrayIndex)
/* validate array index */
if (ArrayIndex >= SC_NUMBER_OF_ATS)
{
- CFE_EVS_SendEvent(SC_TABLE_MANAGE_ATS_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS table manage error: invalid ATS index %d", (int)ArrayIndex);
+ CFE_EVS_SendEvent(SC_TABLE_MANAGE_ATS_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS table manage error: invalid ATS index %d",
+ (int)ArrayIndex);
return;
}
@@ -695,8 +719,8 @@ void SC_ManageTable(SC_TableType type, int32 ArrayIndex)
{
CFE_Status_t Result;
CFE_TBL_Handle_t TblHandle;
- uint32 ** TblAddr;
- void * TblPtrNew;
+ uint32 **TblAddr;
+ void *TblPtrNew;
switch (type)
{
@@ -745,20 +769,26 @@ void SC_ManageTable(SC_TableType type, int32 ArrayIndex)
/* Ignore successful dump or validate and cmds before first activate. */
if (type == ATS)
{
- CFE_EVS_SendEvent(SC_TABLE_MANAGE_ATS_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_TABLE_MANAGE_ATS_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"ATS table manage process error: ATS = %u, Result = 0x%X",
- SC_IDNUM_AS_UINT(SC_AtsIndexToNum(SC_ATS_IDX_C(ArrayIndex))), (unsigned int)Result);
+ SC_IDNUM_AS_UINT(SC_AtsIndexToNum(SC_ATS_IDX_C(ArrayIndex))),
+ (unsigned int)Result);
}
else if (type == RTS)
{
- CFE_EVS_SendEvent(SC_TABLE_MANAGE_RTS_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_TABLE_MANAGE_RTS_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"RTS table manage process error: RTS = %u, Result = 0x%X",
- SC_IDNUM_AS_UINT(SC_RtsIndexToNum(SC_RTS_IDX_C(ArrayIndex))), (unsigned int)Result);
+ SC_IDNUM_AS_UINT(SC_RtsIndexToNum(SC_RTS_IDX_C(ArrayIndex))),
+ (unsigned int)Result);
}
else
{
- CFE_EVS_SendEvent(SC_TABLE_MANAGE_APPEND_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS Append table manage process error: Result = 0x%X", (unsigned int)Result);
+ CFE_EVS_SendEvent(SC_TABLE_MANAGE_APPEND_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS Append table manage process error: Result = 0x%X",
+ (unsigned int)Result);
}
}
} /* End SC_ManageTable() */
diff --git a/fsw/src/sc_cmds.h b/fsw/src/sc_cmds.h
index d1f437f..b8f6c7c 100644
--- a/fsw/src/sc_cmds.h
+++ b/fsw/src/sc_cmds.h
@@ -35,22 +35,19 @@ typedef enum
APPEND
} SC_TableType;
-#define SC_HKTLM_MEMBER_SIZE(x) sizeof(((SC_HkTlm_Payload_t *)0)->x)
-
/* Macro to set/clear bits in the HK TLM bitmask for RTS status */
enum
{
- SC_BITS_PER_HKTLM_OCTET = SC_NUMBER_OF_RTS / SC_HKTLM_MEMBER_SIZE(RtsDisabledStatus),
- SC_BITS_PER_HKTLM_WORD = SC_HKTLM_MEMBER_SIZE(RtsDisabledStatus[0]) * SC_BITS_PER_HKTLM_OCTET,
+ SC_BITS_PER_HKTLM_ENTRY = 8 /* by definition, as this now uses uint8 only */
};
-#define SC_SET_HKTLM_RTS_MASK(f, s, v) \
- do \
- { \
- if (v) \
- f[s / SC_BITS_PER_HKTLM_WORD] |= (1 << (s % SC_BITS_PER_HKTLM_WORD)); \
- else \
- f[s / SC_BITS_PER_HKTLM_WORD] &= ~(1 << (s % SC_BITS_PER_HKTLM_WORD)); \
+#define SC_SET_HKTLM_RTS_MASK(f, s, v) \
+ do \
+ { \
+ if (v) \
+ f[s / SC_BITS_PER_HKTLM_ENTRY] |= (1 << (s % SC_BITS_PER_HKTLM_ENTRY)); \
+ else \
+ f[s / SC_BITS_PER_HKTLM_ENTRY] &= ~(1 << (s % SC_BITS_PER_HKTLM_ENTRY)); \
} while (0)
/**
diff --git a/fsw/src/sc_dispatch.c b/fsw/src/sc_dispatch.c
index 67c899b..a259fb9 100644
--- a/fsw/src/sc_dispatch.c
+++ b/fsw/src/sc_dispatch.c
@@ -64,9 +64,12 @@ bool SC_VerifyCmdLength(const CFE_MSG_Message_t *Msg, size_t ExpectedLength)
CFE_MSG_GetMsgId(Msg, &MessageID);
CFE_MSG_GetFcnCode(Msg, &CommandCode);
- CFE_EVS_SendEvent(SC_CMD_LEN_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_CMD_LEN_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Invalid msg length: ID = 0x%08lX, CC = %d, Len = %d, Expected = %d",
- (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode, (int)ActualLength,
+ (unsigned long)CFE_SB_MsgIdToValue(MessageID),
+ CommandCode,
+ (int)ActualLength,
(int)ExpectedLength);
Result = false;
if (CFE_SB_MsgIdToValue(MessageID) == SC_CMD_MID)
@@ -121,7 +124,9 @@ void SC_ProcessRequest(const CFE_SB_Buffer_t *BufPtr)
}
else
{
- CFE_EVS_SendEvent(SC_MID_ERR_EID, CFE_EVS_EventType_ERROR, "Invalid command pipe message ID: 0x%08lX",
+ CFE_EVS_SendEvent(SC_MID_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Invalid command pipe message ID: 0x%08lX",
(unsigned long)CFE_SB_MsgIdToValue(MessageID));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
@@ -267,8 +272,11 @@ void SC_ProcessCommand(const CFE_SB_Buffer_t *BufPtr)
break;
default:
- CFE_EVS_SendEvent(SC_CC_ERR_EID, CFE_EVS_EventType_ERROR, "Invalid Command Code: MID = 0x%08lX CC = %d",
- (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode);
+ CFE_EVS_SendEvent(SC_CC_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Invalid Command Code: MID = 0x%08lX CC = %d",
+ (unsigned long)CFE_SB_MsgIdToValue(MessageID),
+ CommandCode);
SC_OperData.HkPacket.Payload.CmdErrCtr++;
break;
} /* end switch */
diff --git a/fsw/src/sc_eds_dispatch.c b/fsw/src/sc_eds_dispatch.c
index 5ebf437..34ecdec 100644
--- a/fsw/src/sc_eds_dispatch.c
+++ b/fsw/src/sc_eds_dispatch.c
@@ -93,21 +93,29 @@ void SC_ProcessRequest(const CFE_SB_Buffer_t *BufPtr)
if (status == CFE_STATUS_VALIDATION_FAILURE || status == CFE_STATUS_UNKNOWN_MSG_ID)
{
- CFE_EVS_SendEvent(SC_MID_ERR_EID, CFE_EVS_EventType_ERROR, "Invalid command pipe message ID: 0x%08lX",
+ CFE_EVS_SendEvent(SC_MID_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Invalid command pipe message ID: 0x%08lX",
(unsigned long)CFE_SB_MsgIdToValue(MsgId));
}
else if (status == CFE_STATUS_WRONG_MSG_LENGTH)
{
CFE_MSG_GetSize(&BufPtr->Msg, &MsgSize);
- CFE_EVS_SendEvent(SC_CMD_LEN_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_CMD_LEN_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Invalid msg length: ID = 0x%08lX, CC = %d, Len = %lu",
- (unsigned long)CFE_SB_MsgIdToValue(MsgId), MsgFc, (unsigned long)MsgSize);
+ (unsigned long)CFE_SB_MsgIdToValue(MsgId),
+ MsgFc,
+ (unsigned long)MsgSize);
}
else
{
- CFE_EVS_SendEvent(SC_CC_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_CC_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Invalid message recvd: ID=0x%08lX, CC=%d, status=%d",
- (unsigned long)CFE_SB_MsgIdToValue(MsgId), MsgFc, (int)status);
+ (unsigned long)CFE_SB_MsgIdToValue(MsgId),
+ MsgFc,
+ (int)status);
}
}
}
diff --git a/fsw/src/sc_index_types.h b/fsw/src/sc_index_types.h
index 55968b1..8587fd2 100644
--- a/fsw/src/sc_index_types.h
+++ b/fsw/src/sc_index_types.h
@@ -371,8 +371,8 @@ static inline bool SC_RtsNumWithinRange(SC_RtsNum_t RtsNum, SC_RtsNum_t IdLimit)
*/
static inline bool SC_RtsNumValidateRange(SC_RtsNum_t FirstRtsNum, SC_RtsNum_t LastRtsNum)
{
- return SC_RtsNumIsValid(FirstRtsNum) && SC_RtsNumIsValid(LastRtsNum) &&
- SC_RtsNumWithinRange(FirstRtsNum, LastRtsNum);
+ return SC_RtsNumIsValid(FirstRtsNum) && SC_RtsNumIsValid(LastRtsNum)
+ && SC_RtsNumWithinRange(FirstRtsNum, LastRtsNum);
}
/**
@@ -388,7 +388,7 @@ static inline bool SC_RtsNumValidateRange(SC_RtsNum_t FirstRtsNum, SC_RtsNum_t L
*/
static inline SC_EntryOffset_t SC_EntryOffsetAdvance(SC_EntryOffset_t Pos, size_t Bytes)
{
- return (SC_EntryOffset_t) {SC_IDX_AS_UINT(Pos) + ((Bytes + sizeof(uint32) - 1) / sizeof(uint32))};
+ return (SC_EntryOffset_t) { SC_IDX_AS_UINT(Pos) + ((Bytes + sizeof(uint32) - 1) / sizeof(uint32)) };
}
#endif
diff --git a/fsw/src/sc_loads.c b/fsw/src/sc_loads.c
index eefcadf..4273a52 100644
--- a/fsw/src/sc_loads.c
+++ b/fsw/src/sc_loads.c
@@ -63,18 +63,20 @@ void SC_LoadAts(SC_AtsIndex_t AtsIndex)
SC_CommandNum_t AtsCmdNum; /* current ats entry command number */
SC_EntryOffset_t AtsEntryIndex; /* index into the load for current ats entry */
SC_EntryOffset_t PendingEntryIndex; /* index into the load for current ats entry */
- SC_AtsEntry_t * EntryPtr; /* a pointer to an ats entry */
+ SC_AtsEntry_t *EntryPtr; /* a pointer to an ats entry */
CFE_MSG_Size_t MessageSize = 0;
int32 Result = CFE_SUCCESS;
bool StillProcessing = true;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec; /* ATS entry location in table */
/* validate ATS array index */
if (!SC_AtsIndexIsValid(AtsIndex))
{
- CFE_EVS_SendEvent(SC_LOADATS_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR, "ATS load error: invalid ATS index %d",
+ CFE_EVS_SendEvent(SC_LOADATS_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS load error: invalid ATS index %d",
SC_IDX_AS_UINT(AtsIndex));
return;
}
@@ -187,7 +189,7 @@ void SC_LoadAts(SC_AtsIndex_t AtsIndex)
Result = CFE_SUCCESS;
StillProcessing = false;
} /*end else */
- } /* end while */
+ } /* end while */
/*
** Now the commands are parsed through, need to build the tables
@@ -223,8 +225,10 @@ void SC_BuildTimeIndexTable(SC_AtsIndex_t AtsIndex)
/* validate ATS array index */
if (!SC_AtsIndexIsValid(AtsIndex))
{
- CFE_EVS_SendEvent(SC_BUILD_TIME_IDXTBL_ERR_EID, CFE_EVS_EventType_ERROR,
- "Build time index table error: invalid ATS index %u", SC_IDX_AS_UINT(AtsIndex));
+ CFE_EVS_SendEvent(SC_BUILD_TIME_IDXTBL_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Build time index table error: invalid ATS index %u",
+ SC_IDX_AS_UINT(AtsIndex));
return;
}
@@ -254,20 +258,22 @@ void SC_BuildTimeIndexTable(SC_AtsIndex_t AtsIndex)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SC_Insert(SC_AtsIndex_t AtsIndex, SC_CommandIndex_t NewCmdIndex, uint32 ListLength)
{
- SC_AtsEntryHeader_t * EntryHeader; /* ATS table entry pointer */
+ SC_AtsEntryHeader_t *EntryHeader; /* ATS table entry pointer */
SC_AbsTimeTag_t NewCmdTime = 0; /* new command execution time */
SC_AbsTimeTag_t ListCmdTime; /* list entry execution time */
SC_CommandIndex_t CmdIndex; /* ATS command index (cmd num - 1) */
SC_SeqIndex_t TimeBufIndex;
SC_SeqIndex_t NextIndex;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec; /* ATS entry location in table */
- SC_AtsCmdNumRecord_t * AtsCmdNumRec;
+ SC_AtsCmdNumRecord_t *AtsCmdNumRec;
/* validate ATS array index */
if (!SC_AtsIndexIsValid(AtsIndex))
{
- CFE_EVS_SendEvent(SC_INSERTATS_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS insert error: invalid ATS index %u", SC_IDX_AS_UINT(AtsIndex));
+ CFE_EVS_SendEvent(SC_INSERTATS_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS insert error: invalid ATS index %u",
+ SC_IDX_AS_UINT(AtsIndex));
return;
}
@@ -277,9 +283,9 @@ void SC_Insert(SC_AtsIndex_t AtsIndex, SC_CommandIndex_t NewCmdIndex, uint32 Lis
/* first get the entry index in the selected ATS table for the new command */
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, NewCmdIndex);
/* then get a pointer to the ATS entry */
- EntryHeader = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
+ EntryHeader = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
/* then get the execution time from the ATS entry for the new command */
- NewCmdTime = SC_GetAtsEntryTime(EntryHeader);
+ NewCmdTime = SC_GetAtsEntryTime(EntryHeader);
}
/* start at last element in the sorted by time list */
@@ -288,13 +294,13 @@ void SC_Insert(SC_AtsIndex_t AtsIndex, SC_CommandIndex_t NewCmdIndex, uint32 Lis
while (SC_IDX_WITHIN_LIMIT(TimeBufIndex, ListLength))
{
/* first get the cmd index for this list entry */
- CmdIndex = SC_CommandNumToIndex(SC_GetAtsCommandNumAtSeq(AtsIndex, TimeBufIndex)->CmdNum);
+ CmdIndex = SC_CommandNumToIndex(SC_GetAtsCommandNumAtSeq(AtsIndex, TimeBufIndex)->CmdNum);
/* then get the entry index from the ATS table */
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, CmdIndex);
/* then get a pointer to the ATS entry data */
- EntryHeader = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
+ EntryHeader = &SC_GetAtsEntryAtOffset(AtsIndex, CmdOffsetRec->Offset)->Header;
/* then get cmd execution time from the ATS entry */
- ListCmdTime = SC_GetAtsEntryTime(EntryHeader);
+ ListCmdTime = SC_GetAtsEntryTime(EntryHeader);
/* compare time for this list entry to time for new cmd */
if (SC_CompareAbsTime(ListCmdTime, NewCmdTime))
@@ -339,16 +345,18 @@ void SC_Insert(SC_AtsIndex_t AtsIndex, SC_CommandIndex_t NewCmdIndex, uint32 Lis
void SC_InitAtsTables(SC_AtsIndex_t AtsIndex)
{
int32 i;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
- SC_AtsCmdNumRecord_t * AtsCmdNumRec;
+ SC_AtsCmdNumRecord_t *AtsCmdNumRec;
/* validate ATS array index */
if (!SC_AtsIndexIsValid(AtsIndex))
{
- CFE_EVS_SendEvent(SC_INIT_ATSTBL_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS table init error: invalid ATS index %u", SC_IDX_AS_UINT(AtsIndex));
+ CFE_EVS_SendEvent(SC_INIT_ATSTBL_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS table init error: invalid ATS index %u",
+ SC_IDX_AS_UINT(AtsIndex));
return;
}
@@ -397,8 +405,10 @@ void SC_LoadRts(SC_RtsIndex_t RtsIndex)
}
else
{
- CFE_EVS_SendEvent(SC_LOADRTS_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS table init error: invalid RTS index %u", SC_IDX_AS_UINT(RtsIndex));
+ CFE_EVS_SendEvent(SC_LOADRTS_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS table init error: invalid RTS index %u",
+ SC_IDX_AS_UINT(RtsIndex));
return;
}
} /* SC_LoadRts */
@@ -463,8 +473,10 @@ bool SC_ParseRts(uint32 Buffer32[])
}
else
{
- CFE_EVS_SendEvent(SC_RTS_INVLD_MID_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS cmd loaded with invalid MID at %d", i);
+ CFE_EVS_SendEvent(SC_RTS_INVLD_MID_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS cmd loaded with invalid MID at %d",
+ i);
Error = true; /* invalid message id */
}
}
@@ -473,16 +485,21 @@ bool SC_ParseRts(uint32 Buffer32[])
/* check to see if the length field in the RTS is valid */
if (CmdSize < SC_PACKET_MIN_SIZE || CmdSize > SC_PACKET_MAX_SIZE)
{
- CFE_EVS_SendEvent(SC_RTS_LEN_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS cmd loaded with invalid length at %d, len: %d", i, (int)CmdSize);
+ CFE_EVS_SendEvent(SC_RTS_LEN_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS cmd loaded with invalid length at %d, len: %d",
+ i,
+ (int)CmdSize);
Error = true; /* Length error */
}
else if ((i + IndexDelta) > SC_RTS_BUFF_SIZE32)
{
- CFE_EVS_SendEvent(SC_RTS_LEN_BUFFER_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS cmd at %d runs off end of buffer", i);
+ CFE_EVS_SendEvent(SC_RTS_LEN_BUFFER_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS cmd at %d runs off end of buffer",
+ i);
Error = true; /* command runs off of the end of the buffer */
}
@@ -512,8 +529,10 @@ bool SC_ParseRts(uint32 Buffer32[])
}
else
{
- CFE_EVS_SendEvent(SC_RTS_LEN_TOO_LONG_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS cmd loaded won't fit in buffer at %d", i);
+ CFE_EVS_SendEvent(SC_RTS_LEN_TOO_LONG_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS cmd loaded won't fit in buffer at %d",
+ i);
Error = true;
}
} /* endif */
@@ -630,9 +649,11 @@ void SC_UpdateAppend(void)
SC_OperData.HkPacket.Payload.AppendByteCount = EntryIndex * SC_BYTES_IN_ATS_APPEND_ENTRY;
SC_AppData.AppendWordCount = EntryIndex;
- CFE_EVS_SendEvent(SC_UPDATE_APPEND_EID, CFE_EVS_EventType_INFORMATION,
+ CFE_EVS_SendEvent(SC_UPDATE_APPEND_EID,
+ CFE_EVS_EventType_INFORMATION,
"Update Append ATS Table: load count = %d, command count = %d, byte count = %d",
- SC_OperData.HkPacket.Payload.AppendLoadCount, (int)EntryCount,
+ SC_OperData.HkPacket.Payload.AppendLoadCount,
+ (int)EntryCount,
(int)EntryIndex * SC_BYTES_IN_WORD);
}
@@ -643,20 +664,22 @@ void SC_UpdateAppend(void)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SC_ProcessAppend(SC_AtsIndex_t AtsIndex)
{
- SC_AtsEntry_t * EntryPtr;
+ SC_AtsEntry_t *EntryPtr;
CFE_MSG_Size_t CommandBytes = 0;
SC_EntryOffset_t EntryIndex;
int32 i;
SC_CommandIndex_t CmdIndex;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
/* validate ATS array index */
if (!SC_AtsIndexIsValid(AtsIndex))
{
- CFE_EVS_SendEvent(SC_PROCESS_APPEND_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR,
- "ATS process append error: invalid ATS index %u", SC_IDX_AS_UINT(AtsIndex));
+ CFE_EVS_SendEvent(SC_PROCESS_APPEND_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "ATS process append error: invalid ATS index %u",
+ SC_IDX_AS_UINT(AtsIndex));
return;
}
@@ -665,7 +688,8 @@ void SC_ProcessAppend(SC_AtsIndex_t AtsIndex)
EntryIndex = SC_ENTRY_OFFSET_C(AtsInfoPtr->AtsSize);
/* copy Append table data to end of ATS table data */
- memcpy(SC_GetAtsEntryAtOffset(AtsIndex, EntryIndex), SC_OperData.AppendTblAddr,
+ memcpy(SC_GetAtsEntryAtOffset(AtsIndex, EntryIndex),
+ SC_OperData.AppendTblAddr,
SC_AppData.AppendWordCount * SC_BYTES_IN_WORD);
/* update size of ATS table data */
@@ -702,8 +726,8 @@ void SC_ProcessAppend(SC_AtsIndex_t AtsIndex)
SC_BuildTimeIndexTable(AtsIndex);
/* did we just append to an ats that was executing? */
- if ((SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING) &&
- (SC_IDNUM_EQUAL(SC_OperData.AtsCtrlBlckAddr->CurrAtsNum, SC_AtsIndexToNum(AtsIndex))))
+ if ((SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING)
+ && (SC_IDNUM_EQUAL(SC_OperData.AtsCtrlBlckAddr->CurrAtsNum, SC_AtsIndexToNum(AtsIndex))))
{
/*
** re-start the ats -- this will go thru the process of skipping
@@ -770,13 +794,16 @@ int32 SC_VerifyAtsTable(uint32 *Buffer32, int32 BufferWords)
/* Table must contain at least one valid entry */
Result = SC_ERROR;
- CFE_EVS_SendEvent(SC_VERIFY_ATS_MPT_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_VERIFY_ATS_MPT_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Verify ATS Table error: table is empty");
}
else
{
- CFE_EVS_SendEvent(SC_VERIFY_ATS_EID, CFE_EVS_EventType_INFORMATION,
- "Verify ATS Table: command count = %d, byte count = %d", (int)CommandCount,
+ CFE_EVS_SendEvent(SC_VERIFY_ATS_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Verify ATS Table: command count = %d, byte count = %d",
+ (int)CommandCount,
(int)BufferIndex * SC_BYTES_IN_WORD);
}
}
@@ -830,18 +857,23 @@ int32 SC_VerifyAtsEntry(uint32 *Buffer32, int32 EntryIndex, int32 BufferWords)
/* Error -- invalid command number */
Result = SC_ERROR;
- CFE_EVS_SendEvent(SC_VERIFY_ATS_NUM_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_VERIFY_ATS_NUM_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Verify ATS Table error: invalid command number: buf index = %d, cmd num = %u",
- (int)EntryIndex, SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber));
+ (int)EntryIndex,
+ SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber));
}
else if ((EntryIndex + SC_ATS_HDR_WORDS) > BufferWords)
{
/* Error -- not enough room for smallest possible ATS entry */
Result = SC_ERROR;
- CFE_EVS_SendEvent(SC_VERIFY_ATS_END_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_VERIFY_ATS_END_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Verify ATS Table error: buffer full: buf index = %d, cmd num = %u, buf words = %d",
- (int)EntryIndex, SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber), (int)BufferWords);
+ (int)EntryIndex,
+ SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber),
+ (int)BufferWords);
}
else
{
@@ -856,27 +888,35 @@ int32 SC_VerifyAtsEntry(uint32 *Buffer32, int32 EntryIndex, int32 BufferWords)
/* Error -- invalid command packet byte length */
Result = SC_ERROR;
- CFE_EVS_SendEvent(SC_VERIFY_ATS_PKT_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_VERIFY_ATS_PKT_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Verify ATS Table error: invalid length: buf index = %d, cmd num = %u, pkt len = %d",
- (int)EntryIndex, SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber), (int)CommandBytes);
+ (int)EntryIndex,
+ SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber),
+ (int)CommandBytes);
}
else if ((EntryIndex + SC_ATS_HDR_NOPKT_WORDS + CommandWords) > BufferWords)
{
/* Error -- packet must fit within buffer */
Result = SC_ERROR;
- CFE_EVS_SendEvent(SC_VERIFY_ATS_BUF_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_VERIFY_ATS_BUF_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Verify ATS Table error: buffer overflow: buf index = %d, cmd num = %u, pkt len = %d",
- (int)EntryIndex, SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber), (int)CommandBytes);
+ (int)EntryIndex,
+ SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber),
+ (int)CommandBytes);
}
else if (SC_GetAtsDupTest(EntryPtr->Header.CmdNumber) != SC_DUP_TEST_UNUSED)
{
/* Entry with duplicate command number is invalid */
Result = SC_ERROR;
- CFE_EVS_SendEvent(SC_VERIFY_ATS_DUP_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_VERIFY_ATS_DUP_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Verify ATS Table error: dup cmd number: buf index = %d, cmd num = %u, dup index = %d",
- (int)EntryIndex, SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber),
+ (int)EntryIndex,
+ SC_IDNUM_AS_UINT(EntryPtr->Header.CmdNumber),
(int)SC_GetAtsDupTest(EntryPtr->Header.CmdNumber));
}
else
diff --git a/fsw/src/sc_rtsrq.c b/fsw/src/sc_rtsrq.c
index a337e66..6aede85 100644
--- a/fsw/src/sc_rtsrq.c
+++ b/fsw/src/sc_rtsrq.c
@@ -52,9 +52,9 @@ CFE_Status_t SC_StartRtsCmd(const SC_StartRtsCmd_t *Cmd)
SC_RtsNum_t RtsNum; /* rts number */
SC_RtsIndex_t RtsIndex; /* rts array index */
SC_RtsEntryHeader_t *RtsEntryPtr; /* pointer to an rts entry */
- CFE_MSG_Message_t * RtsEntryCmd; /* pointer to an rts command */
+ CFE_MSG_Message_t *RtsEntryCmd; /* pointer to an rts command */
CFE_MSG_Size_t CmdLength = 0; /* the length of the 1st cmd */
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
/*
** Check start RTS parameters
@@ -109,21 +109,27 @@ CFE_Status_t SC_StartRtsCmd(const SC_StartRtsCmd_t *Cmd)
if (SC_RtsNumHasEvent(Cmd->Payload.RtsNum))
{
- CFE_EVS_SendEvent(SC_RTS_START_INF_EID, CFE_EVS_EventType_INFORMATION,
- "RTS Number %03u Started", SC_IDNUM_AS_UINT(RtsNum));
+ CFE_EVS_SendEvent(SC_RTS_START_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "RTS Number %03u Started",
+ SC_IDNUM_AS_UINT(RtsNum));
}
else
{
- CFE_EVS_SendEvent(SC_STARTRTS_CMD_DBG_EID, CFE_EVS_EventType_DEBUG, "Start RTS #%u command",
+ CFE_EVS_SendEvent(SC_STARTRTS_CMD_DBG_EID,
+ CFE_EVS_EventType_DEBUG,
+ "Start RTS #%u command",
SC_IDNUM_AS_UINT(RtsNum));
}
}
else
{ /* the length field of the 1st cmd was bad */
CFE_EVS_SendEvent(
- SC_STARTRTS_CMD_INVLD_LEN_ERR_EID, CFE_EVS_EventType_ERROR,
+ SC_STARTRTS_CMD_INVLD_LEN_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Start RTS %03u Rejected: Invld Len Field for 1st Cmd in Sequence. Invld Cmd Length = %lu",
- SC_IDNUM_AS_UINT(RtsNum), (unsigned long)CmdLength);
+ SC_IDNUM_AS_UINT(RtsNum),
+ (unsigned long)CmdLength);
SC_OperData.HkPacket.Payload.CmdErrCtr++;
SC_OperData.HkPacket.Payload.RtsActiveErrCtr++;
@@ -133,9 +139,11 @@ CFE_Status_t SC_StartRtsCmd(const SC_StartRtsCmd_t *Cmd)
else
{ /* Cannot use the RTS now */
- CFE_EVS_SendEvent(SC_STARTRTS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_STARTRTS_CMD_NOT_LDED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Start RTS %03u Rejected: RTS Not Loaded or In Use, Status: %lu",
- SC_IDNUM_AS_UINT(Cmd->Payload.RtsNum), (unsigned long)RtsInfoPtr->RtsStatus);
+ SC_IDNUM_AS_UINT(Cmd->Payload.RtsNum),
+ (unsigned long)RtsInfoPtr->RtsStatus);
SC_OperData.HkPacket.Payload.CmdErrCtr++;
SC_OperData.HkPacket.Payload.RtsActiveErrCtr++;
@@ -144,8 +152,10 @@ CFE_Status_t SC_StartRtsCmd(const SC_StartRtsCmd_t *Cmd)
}
else
{ /* the RTS is disabled */
- CFE_EVS_SendEvent(SC_STARTRTS_CMD_DISABLED_ERR_EID, CFE_EVS_EventType_ERROR,
- "Start RTS %03u Rejected: RTS Disabled", SC_IDNUM_AS_UINT(RtsNum));
+ CFE_EVS_SendEvent(SC_STARTRTS_CMD_DISABLED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Start RTS %03u Rejected: RTS Disabled",
+ SC_IDNUM_AS_UINT(RtsNum));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
SC_OperData.HkPacket.Payload.RtsActiveErrCtr++;
@@ -153,8 +163,10 @@ CFE_Status_t SC_StartRtsCmd(const SC_StartRtsCmd_t *Cmd)
}
else
{ /* the rts id is invalid */
- CFE_EVS_SendEvent(SC_STARTRTS_CMD_INVALID_ERR_EID, CFE_EVS_EventType_ERROR,
- "Start RTS %03u Rejected: Invalid RTS ID", SC_IDNUM_AS_UINT(RtsNum));
+ CFE_EVS_SendEvent(SC_STARTRTS_CMD_INVALID_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Start RTS %03u Rejected: Invalid RTS ID",
+ SC_IDNUM_AS_UINT(RtsNum));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
SC_OperData.HkPacket.Payload.RtsActiveErrCtr++;
@@ -218,9 +230,11 @@ CFE_Status_t SC_StartRtsGrpCmd(const SC_StartRtsGrpCmd_t *Cmd)
else
{ /* Cannot use the RTS now */
CFE_EVS_SendEvent(
- SC_STARTRTSGRP_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR,
+ SC_STARTRTSGRP_CMD_NOT_LDED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Start RTS group error: rejected RTS ID %03u, RTS Not Loaded or In Use, Status: %lu",
- SC_IDNUM_AS_UINT(SC_RtsIndexToNum(RtsIndex)), (unsigned long)RtsInfoPtr->RtsStatus);
+ SC_IDNUM_AS_UINT(SC_RtsIndexToNum(RtsIndex)),
+ (unsigned long)RtsInfoPtr->RtsStatus);
SC_OperData.HkPacket.Payload.RtsActiveErrCtr++;
@@ -228,7 +242,8 @@ CFE_Status_t SC_StartRtsGrpCmd(const SC_StartRtsGrpCmd_t *Cmd)
}
else
{ /* the RTS is disabled */
- CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_DISABLED_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_DISABLED_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Start RTS group error: rejected RTS ID %03u, RTS Disabled",
SC_IDNUM_AS_UINT(SC_RtsIndexToNum(RtsIndex)));
@@ -238,15 +253,20 @@ CFE_Status_t SC_StartRtsGrpCmd(const SC_StartRtsGrpCmd_t *Cmd)
}
/* success */
- CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Start RTS group: FirstID=%u, LastID=%u, Modified=%d", SC_IDNUM_AS_UINT(FirstRtsNum),
- SC_IDNUM_AS_UINT(LastRtsNum), (int)StartCount);
+ CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Start RTS group: FirstID=%u, LastID=%u, Modified=%d",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
+ SC_IDNUM_AS_UINT(LastRtsNum),
+ (int)StartCount);
SC_OperData.HkPacket.Payload.CmdCtr++;
}
else
{ /* error */
- CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR,
- "Start RTS group error: FirstID=%u, LastID=%u", SC_IDNUM_AS_UINT(FirstRtsNum),
+ CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Start RTS group error: FirstID=%u, LastID=%u",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
SC_IDNUM_AS_UINT(LastRtsNum));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
}
@@ -277,14 +297,18 @@ CFE_Status_t SC_StopRtsCmd(const SC_StopRtsCmd_t *Cmd)
SC_OperData.HkPacket.Payload.CmdCtr++;
- CFE_EVS_SendEvent(SC_STOPRTS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, "RTS %03u Aborted",
+ CFE_EVS_SendEvent(SC_STOPRTS_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "RTS %03u Aborted",
SC_IDNUM_AS_UINT(RtsNum));
}
else
{ /* the specified RTS is invalid */
/* the rts id is invalid */
- CFE_EVS_SendEvent(SC_STOPRTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, "Stop RTS %03u rejected: Invalid RTS ID",
+ CFE_EVS_SendEvent(SC_STOPRTS_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Stop RTS %03u rejected: Invalid RTS ID",
SC_IDNUM_AS_UINT(RtsNum));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
@@ -332,15 +356,20 @@ CFE_Status_t SC_StopRtsGrpCmd(const SC_StopRtsGrpCmd_t *Cmd)
}
/* success */
- CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Stop RTS group: FirstID=%u, LastID=%u, Modified=%d", SC_IDNUM_AS_UINT(FirstRtsNum),
- SC_IDNUM_AS_UINT(LastRtsNum), (int)StopCount);
+ CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Stop RTS group: FirstID=%u, LastID=%u, Modified=%d",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
+ SC_IDNUM_AS_UINT(LastRtsNum),
+ (int)StopCount);
SC_OperData.HkPacket.Payload.CmdCtr++;
}
else
{ /* error */
- CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR,
- "Stop RTS group error: FirstID=%u, LastID=%u", SC_IDNUM_AS_UINT(FirstRtsNum),
+ CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Stop RTS group error: FirstID=%u, LastID=%u",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
SC_IDNUM_AS_UINT(LastRtsNum));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
}
@@ -374,12 +403,16 @@ CFE_Status_t SC_DisableRtsCmd(const SC_DisableRtsCmd_t *Cmd)
/* update the command status */
SC_OperData.HkPacket.Payload.CmdCtr++;
- CFE_EVS_SendEvent(SC_DISABLE_RTS_INF_EID, CFE_EVS_EventType_INFORMATION, "Disabled RTS %03u",
+ CFE_EVS_SendEvent(SC_DISABLE_RTS_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Disabled RTS %03u",
SC_IDNUM_AS_UINT(RtsNum));
}
else
{ /* it is not a valid RTS id */
- CFE_EVS_SendEvent(SC_DISRTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, "Disable RTS %03u Rejected: Invalid RTS ID",
+ CFE_EVS_SendEvent(SC_DISRTS_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Disable RTS %03u Rejected: Invalid RTS ID",
SC_IDNUM_AS_UINT(RtsNum));
/* update the command error status */
@@ -427,15 +460,20 @@ CFE_Status_t SC_DisableRtsGrpCmd(const SC_DisableRtsGrpCmd_t *Cmd)
}
/* success */
- CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Disable RTS group: FirstID=%u, LastID=%u, Modified=%d", SC_IDNUM_AS_UINT(FirstRtsNum),
- SC_IDNUM_AS_UINT(LastRtsNum), (int)DisableCount);
+ CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Disable RTS group: FirstID=%u, LastID=%u, Modified=%d",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
+ SC_IDNUM_AS_UINT(LastRtsNum),
+ (int)DisableCount);
SC_OperData.HkPacket.Payload.CmdCtr++;
}
else
{ /* error */
- CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR,
- "Disable RTS group error: FirstID=%u, LastID=%u", SC_IDNUM_AS_UINT(FirstRtsNum),
+ CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Disable RTS group error: FirstID=%u, LastID=%u",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
SC_IDNUM_AS_UINT(LastRtsNum));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
}
@@ -469,12 +507,16 @@ CFE_Status_t SC_EnableRtsCmd(const SC_EnableRtsCmd_t *Cmd)
/* update the command status */
SC_OperData.HkPacket.Payload.CmdCtr++;
- CFE_EVS_SendEvent(SC_ENABLE_RTS_INF_EID, CFE_EVS_EventType_INFORMATION, "Enabled RTS %03u",
+ CFE_EVS_SendEvent(SC_ENABLE_RTS_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Enabled RTS %03u",
SC_IDNUM_AS_UINT(RtsNum));
}
else
{ /* it is not a valid RTS id */
- CFE_EVS_SendEvent(SC_ENARTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, "Enable RTS %03u Rejected: Invalid RTS ID",
+ CFE_EVS_SendEvent(SC_ENARTS_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Enable RTS %03u Rejected: Invalid RTS ID",
SC_IDNUM_AS_UINT(RtsNum));
/* update the command error status */
@@ -523,15 +565,20 @@ CFE_Status_t SC_EnableRtsGrpCmd(const SC_EnableRtsGrpCmd_t *Cmd)
}
/* success */
- CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION,
- "Enable RTS group: FirstID=%u, LastID=%u, Modified=%d", SC_IDNUM_AS_UINT(FirstRtsNum),
- SC_IDNUM_AS_UINT(LastRtsNum), (int)EnableCount);
+ CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "Enable RTS group: FirstID=%u, LastID=%u, Modified=%d",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
+ SC_IDNUM_AS_UINT(LastRtsNum),
+ (int)EnableCount);
SC_OperData.HkPacket.Payload.CmdCtr++;
}
else
{ /* error */
- CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR,
- "Enable RTS group error: FirstID=%u, LastID=%u", SC_IDNUM_AS_UINT(FirstRtsNum),
+ CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "Enable RTS group error: FirstID=%u, LastID=%u",
+ SC_IDNUM_AS_UINT(FirstRtsNum),
SC_IDNUM_AS_UINT(LastRtsNum));
SC_OperData.HkPacket.Payload.CmdErrCtr++;
}
@@ -553,7 +600,9 @@ void SC_KillRts(SC_RtsIndex_t RtsIndex)
/* validate RTS array index */
if (!SC_RtsIndexIsValid(RtsIndex))
{
- CFE_EVS_SendEvent(SC_KILLRTS_INV_INDEX_ERR_EID, CFE_EVS_EventType_ERROR, "RTS kill error: invalid RTS index %u",
+ CFE_EVS_SendEvent(SC_KILLRTS_INV_INDEX_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS kill error: invalid RTS index %u",
SC_IDX_AS_UINT(RtsIndex));
}
else if (RtsInfoPtr->RtsStatus == SC_Status_EXECUTING)
@@ -612,7 +661,9 @@ void SC_AutoStartRts(SC_RtsNum_t RtsNum)
}
else
{
- CFE_EVS_SendEvent(SC_AUTOSTART_RTS_INV_ID_ERR_EID, CFE_EVS_EventType_ERROR,
- "RTS autostart error: invalid RTS ID %u", SC_IDNUM_AS_UINT(RtsNum));
+ CFE_EVS_SendEvent(SC_AUTOSTART_RTS_INV_ID_ERR_EID,
+ CFE_EVS_EventType_ERROR,
+ "RTS autostart error: invalid RTS ID %u",
+ SC_IDNUM_AS_UINT(RtsNum));
}
}
diff --git a/fsw/src/sc_state.c b/fsw/src/sc_state.c
index 3ddc3d6..2b42e19 100644
--- a/fsw/src/sc_state.c
+++ b/fsw/src/sc_state.c
@@ -47,7 +47,7 @@
**************************************************************************/
/* used for RTS table iteration */
-#define SC_INVALID_RTS_INDEX ((SC_RtsIndex_t) {-1})
+#define SC_INVALID_RTS_INDEX ((SC_RtsIndex_t) { -1 })
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
@@ -61,7 +61,7 @@ void SC_GetNextRtsTime(void)
uint32 NextWakeupCnt; /* the next wakeup count for the RTS */
SC_RtsInfoEntry_t *RtsInfoPtr;
- NextRts = SC_INVALID_RTS_INDEX;
+ NextRts = SC_INVALID_RTS_INDEX;
NextWakeupCnt = SC_MAX_WAKEUP_CNT;
/*
@@ -78,10 +78,10 @@ void SC_GetNextRtsTime(void)
if (RtsInfoPtr->NextCommandTgtWakeup <= NextWakeupCnt)
{
NextWakeupCnt = RtsInfoPtr->NextCommandTgtWakeup;
- NextRts = SC_RTS_IDX_C(i);
+ NextRts = SC_RTS_IDX_C(i);
} /* end if */
- } /* end if */
- } /* end for */
+ } /* end if */
+ } /* end for */
if (!SC_RtsIndexIsValid(NextRts))
{
@@ -105,7 +105,7 @@ void SC_GetNextRtsCommand(void)
SC_RtsIndex_t RtsIndex;
SC_EntryOffset_t CmdOffset;
SC_EntryOffset_t PendingOffset;
- SC_RtsEntry_t * EntryPtr;
+ SC_RtsEntry_t *EntryPtr;
CFE_MSG_Size_t CmdLength = 0;
SC_RtsInfoEntry_t *RtsInfoPtr;
@@ -207,7 +207,8 @@ void SC_GetNextRtsCommand(void)
** Stop the RTS from executing
*/
SC_KillRts(RtsIndex);
- CFE_EVS_SendEvent(SC_RTS_LNGTH_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_RTS_LNGTH_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Cmd Runs passed end of table, RTS %03u Aborted",
SC_IDNUM_AS_UINT(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum));
@@ -224,10 +225,12 @@ void SC_GetNextRtsCommand(void)
/* Stop the RTS from executing */
SC_KillRts(RtsIndex);
- CFE_EVS_SendEvent(SC_RTS_CMD_LNGTH_ERR_EID, CFE_EVS_EventType_ERROR,
+ CFE_EVS_SendEvent(SC_RTS_CMD_LNGTH_ERR_EID,
+ CFE_EVS_EventType_ERROR,
"Invalid Length Field in RTS Command, RTS %03u Aborted. Length: %u, Max: %d",
SC_IDNUM_AS_UINT(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum),
- (unsigned int)(CmdLength - (uint16)SC_RTS_HEADER_SIZE), SC_PACKET_MAX_SIZE);
+ (unsigned int)(CmdLength - (uint16)SC_RTS_HEADER_SIZE),
+ SC_PACKET_MAX_SIZE);
} /* end if the command length is invalid */
}
@@ -241,7 +244,8 @@ void SC_GetNextRtsCommand(void)
SC_KillRts(RtsIndex);
if (SC_RtsNumHasEvent(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum))
{
- CFE_EVS_SendEvent(SC_RTS_COMPL_INF_EID, CFE_EVS_EventType_INFORMATION,
+ CFE_EVS_SendEvent(SC_RTS_COMPL_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
"RTS %03u Execution Completed",
SC_IDNUM_AS_UINT(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum));
}
@@ -253,7 +257,8 @@ void SC_GetNextRtsCommand(void)
SC_KillRts(RtsIndex);
if (SC_RtsNumHasEvent(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum))
{
- CFE_EVS_SendEvent(SC_RTS_COMPL_INF_EID, CFE_EVS_EventType_INFORMATION,
+ CFE_EVS_SendEvent(SC_RTS_COMPL_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
"RTS %03u Execution Completed",
SC_IDNUM_AS_UINT(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum));
}
@@ -275,9 +280,9 @@ void SC_GetNextAtsCommand(void)
SC_AtsIndex_t AtsIndex; /* ats array index */
SC_SeqIndex_t TimeIndex; /* a time index pointer */
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
- SC_AtsEntry_t * EntryPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdNumRecord_t * AtsCmdNumRec;
+ SC_AtsEntry_t *EntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdNumRecord_t *AtsCmdNumRec;
SC_CommandIndex_t CurrCmdIndex;
if (SC_OperData.AtsCtrlBlckAddr->AtpState == SC_Status_EXECUTING)
@@ -314,7 +319,9 @@ void SC_GetNextAtsCommand(void)
/* stop the ATS */
SC_KillAts();
- CFE_EVS_SendEvent(SC_ATS_COMPL_INF_EID, CFE_EVS_EventType_INFORMATION, "ATS %c Execution Completed",
+ CFE_EVS_SendEvent(SC_ATS_COMPL_INF_EID,
+ CFE_EVS_EventType_INFORMATION,
+ "ATS %c Execution Completed",
SC_IDX_AS_CHAR(AtsIndex));
/* stop any switch that is pending */
diff --git a/fsw/src/sc_utils.c b/fsw/src/sc_utils.c
index a49aa4b..b8c3f64 100644
--- a/fsw/src/sc_utils.c
+++ b/fsw/src/sc_utils.c
@@ -46,11 +46,11 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SC_TimeAccessor_t SC_LookupTimeAccessor(SC_TimeRef_Enum_t TimeRef)
{
- static const SC_TimeAccessor_t TIMEREF_LOOKUP[] = {[SC_TimeRef_USE_CFE_TIME] = {CFE_TIME_GetTime},
- [SC_TimeRef_USE_TAI] = {CFE_TIME_GetTAI},
- [SC_TimeRef_USE_UTC] = {CFE_TIME_GetUTC}};
+ static const SC_TimeAccessor_t TIMEREF_LOOKUP[] = { [SC_TimeRef_USE_CFE_TIME] = { CFE_TIME_GetTime },
+ [SC_TimeRef_USE_TAI] = { CFE_TIME_GetTAI },
+ [SC_TimeRef_USE_UTC] = { CFE_TIME_GetUTC } };
- SC_TimeAccessor_t Result = {NULL};
+ SC_TimeAccessor_t Result = { NULL };
if (TimeRef < (sizeof(TIMEREF_LOOKUP) / sizeof(TIMEREF_LOOKUP[0])))
{
@@ -122,7 +122,7 @@ SC_AbsTimeTag_t SC_ComputeAbsTime(uint32 RelTime)
/*
** add the relative time the current time
*/
- ResultTimeWSubs = CFE_TIME_Add(AbsoluteTimeWSubs, RelTimeWSubs);
+ ResultTimeWSubs = CFE_TIME_Add(AbsoluteTimeWSubs, RelTimeWSubs);
/* We don't need subseconds */
return ResultTimeWSubs.Seconds;
diff --git a/fsw/src/sc_version.h b/fsw/src/sc_version.h
index f2b6f8f..9e42422 100644
--- a/fsw/src/sc_version.h
+++ b/fsw/src/sc_version.h
@@ -30,8 +30,8 @@
* \{
*/
-#define SC_MAJOR_VERSION 7 /**< \brief Major version number */
-#define SC_MINOR_VERSION 0 /**< \brief Minor version number */
+#define SC_MAJOR_VERSION 7 /**< \brief Major version number */
+#define SC_MINOR_VERSION 0 /**< \brief Minor version number */
#define SC_REVISION 0 /**< \brief Revision number */
/**\}*/
diff --git a/fsw/tables/sc_ats1.c b/fsw/tables/sc_ats1.c
index b6bfbea..9e796d0 100644
--- a/fsw/tables/sc_ats1.c
+++ b/fsw/tables/sc_ats1.c
@@ -68,17 +68,22 @@
#define SC_RESET_COUNTERS_CKSUM (0x8E)
#endif
+typedef union
+{
+ uint32 Align32;
+ SC_AtsEntryHeader_t Hdr;
+} SC_AlignedAtsEntryHeader_t;
/* Custom table structure, modify as needed to add desired commands */
typedef struct
{
- SC_AtsEntryHeader_t hdr1;
- SC_NoopCmd_t cmd1;
- SC_AtsEntryHeader_t hdr2;
- SC_EnableRtsCmd_t cmd2;
- SC_AtsEntryHeader_t hdr3;
- SC_StartRtsCmd_t cmd3;
- SC_AtsEntryHeader_t hdr4;
- SC_ResetCountersCmd_t cmd4;
+ SC_AlignedAtsEntryHeader_t hdr1;
+ SC_NoopCmd_t cmd1;
+ SC_AlignedAtsEntryHeader_t hdr2;
+ SC_EnableRtsCmd_t cmd2;
+ SC_AlignedAtsEntryHeader_t hdr3;
+ SC_StartRtsCmd_t cmd3;
+ SC_AlignedAtsEntryHeader_t hdr4;
+ SC_ResetCountersCmd_t cmd4;
} SC_AtsStruct1_t;
/* Define the union to size the table correctly */
@@ -94,13 +99,13 @@ typedef union
/* Used designated intializers to be verbose, modify as needed/desired */
SC_AtsTable1_t SC_Ats1 = {
.ats = {/* 1 */
- .hdr1 = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(1),
+ .hdr1.Hdr = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(1),
.TimeTag_MS = SC_CMD1_TIME >> 16,
.TimeTag_LS = SC_CMD1_TIME & 0xFFFF},
- .cmd1 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, 0, SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .cmd1 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM)},
/* 2 */
- .hdr2 = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(2),
+ .hdr2.Hdr = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(2),
.TimeTag_MS = SC_CMD2_TIME >> 16,
.TimeTag_LS = SC_CMD2_TIME & 0xFFFF},
.cmd2 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_ENABLE_RTS_CC, SC_ENABLE_RTS1_CKSUM)},
@@ -108,17 +113,17 @@ SC_AtsTable1_t SC_Ats1 = {
.cmd2.Payload = {.RtsNum = SC_RTS_NUM_INITIALIZER(1)},
/* 3 */
- .hdr3 = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(3),
+ .hdr3.Hdr = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(3),
.TimeTag_MS = SC_CMD3_TIME >> 16,
.TimeTag_LS = SC_CMD3_TIME & 0xFFFF},
.cmd3 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_START_RTS_CC, SC_START_RTS1_CKSUM)},
/* 4 */
- .hdr4 = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(4),
+ .hdr4.Hdr = {.CmdNumber = SC_COMMAND_NUM_INITIALIZER(4),
.TimeTag_MS = SC_CMD4_TIME >> 16,
.TimeTag_LS = SC_CMD4_TIME & 0xFFFF},
.cmd4 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd4), SC_RESET_COUNTERS_CC,
SC_RESET_COUNTERS_CKSUM)}}};
/* Macro for table structure */
-CFE_TBL_FILEDEF(SC_Ats1, SC.AtsTable1, SC Example ATS_TBL1, sc_ats1.tbl)
+CFE_TBL_FILEDEF(SC_Ats1, SC.ATS_TBL1, SC Example ATS_TBL1, sc_ats1.tbl)
diff --git a/fsw/tables/sc_rts001.c b/fsw/tables/sc_rts001.c
index c7eb5fa..3ef44c7 100644
--- a/fsw/tables/sc_rts001.c
+++ b/fsw/tables/sc_rts001.c
@@ -78,17 +78,18 @@ typedef union
SC_RtsTable001_t SC_Rts001 = {
/* 1 */
.rts.hdr1.WakeupCount = 0,
- .rts.cmd1 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .rts.cmd1 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM) },
/* 2 */
.rts.hdr2.WakeupCount = 5,
- .rts.cmd2 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_ENABLE_RTS_CC, SC_ENABLE_RTS2_CKSUM)},
+ .rts.cmd2 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_ENABLE_RTS_CC, SC_ENABLE_RTS2_CKSUM) },
.rts.cmd2.Payload.RtsNum = SC_RTS_NUM_INITIALIZER(2),
/* 3 */
.rts.hdr3.WakeupCount = 5,
- .rts.cmd3 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_START_RTS_CC, SC_START_RTS2_CKSUM)},
- .rts.cmd3.Payload.RtsNum = SC_RTS_NUM_INITIALIZER(2)};
+ .rts.cmd3 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_START_RTS_CC, SC_START_RTS2_CKSUM) },
+ .rts.cmd3.Payload.RtsNum = SC_RTS_NUM_INITIALIZER(2)
+};
/* Macro for table structure */
CFE_TBL_FILEDEF(SC_Rts001, SC.RTS_TBL001, SC Example RTS_TBL001, sc_rts001.tbl)
diff --git a/fsw/tables/sc_rts002.c b/fsw/tables/sc_rts002.c
index a54fa5f..7610d7d 100644
--- a/fsw/tables/sc_rts002.c
+++ b/fsw/tables/sc_rts002.c
@@ -72,15 +72,16 @@ typedef union
SC_RtsTable002_t SC_Rts002 = {
/* 1 */
.rts.hdr1.WakeupCount = 0,
- .rts.cmd1 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .rts.cmd1 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM) },
/* 2 */
.rts.hdr2.WakeupCount = 5,
- .rts.cmd2 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .rts.cmd2 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_NOOP_CC, SC_NOOP_CKSUM) },
/* 3 */
.rts.hdr3.WakeupCount = 5,
- .rts.cmd3 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_NOOP_CC, SC_NOOP_CKSUM)}};
+ .rts.cmd3 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_NOOP_CC, SC_NOOP_CKSUM) }
+};
/* Macro for table structure */
CFE_TBL_FILEDEF(SC_Rts002, SC.RTS_TBL002, SC Example RTS_TBL002, sc_rts002.tbl)
diff --git a/fsw/tables/sc_rts003.c b/fsw/tables/sc_rts003.c
index 0eb592e..5f59f3e 100644
--- a/fsw/tables/sc_rts003.c
+++ b/fsw/tables/sc_rts003.c
@@ -72,15 +72,16 @@ typedef union
SC_RtsTable003_t SC_Rts003 = {
/* 1 */
.rts.hdr1.WakeupCount = 0,
- .rts.cmd1 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .rts.cmd1 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM) },
/* 2 */
.rts.hdr2.WakeupCount = 5,
- .rts.cmd2 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .rts.cmd2 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_NOOP_CC, SC_NOOP_CKSUM) },
/* 3 */
.rts.hdr3.WakeupCount = 5,
- .rts.cmd3 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_NOOP_CC, SC_NOOP_CKSUM)}};
+ .rts.cmd3 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_NOOP_CC, SC_NOOP_CKSUM) }
+};
/* Macro for table structure */
CFE_TBL_FILEDEF(SC_Rts003, SC.RTS_TBL003, SC Example RTS_TBL003, sc_rts003.tbl)
diff --git a/fsw/tables/sc_rts004.c b/fsw/tables/sc_rts004.c
index b70b68a..de94223 100644
--- a/fsw/tables/sc_rts004.c
+++ b/fsw/tables/sc_rts004.c
@@ -72,15 +72,16 @@ typedef union
SC_RtsTable004_t SC_Rts004 = {
/* 1 */
.rts.hdr1.WakeupCount = 0,
- .rts.cmd1 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .rts.cmd1 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd1), SC_NOOP_CC, SC_NOOP_CKSUM) },
/* 2 */
.rts.hdr2.WakeupCount = 5,
- .rts.cmd2 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_NOOP_CC, SC_NOOP_CKSUM)},
+ .rts.cmd2 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd2), SC_NOOP_CC, SC_NOOP_CKSUM) },
/* 3 */
.rts.hdr3.WakeupCount = 5,
- .rts.cmd3 = {CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_NOOP_CC, SC_NOOP_CKSUM)}};
+ .rts.cmd3 = { CFE_MSG_CMD_HDR_INIT(SC_CMD_MID, SC_MEMBER_SIZE(cmd3), SC_NOOP_CC, SC_NOOP_CKSUM) }
+};
/* Macro for table structure */
CFE_TBL_FILEDEF(SC_Rts004, SC.RTS_TBL004, SC Example RTS_TBL004, sc_rts004.tbl)
diff --git a/unit-test/sc_app_tests.c b/unit-test/sc_app_tests.c
index 36095ea..35cb710 100644
--- a/unit-test/sc_app_tests.c
+++ b/unit-test/sc_app_tests.c
@@ -91,7 +91,6 @@ void SC_AppMain_Test_Nominal(void)
void SC_AppMain_Test_AppInitError(void)
{
-
/* Set CFE_EVS_Register to return -1 in order to make SC_AppInit return -1, in order to reach "RunStatus =
* CFE_ES_APP_ERROR" */
UT_SetDeferredRetcode(UT_KEY(CFE_EVS_Register), 1, -1);
@@ -169,19 +168,33 @@ void SC_AppInit_Test_NominalPowerOnReset(void)
Expected_SC_OperData.HkPacket.Payload.ContinueAtsOnFailureFlag = SC_AtsCont_TRUE;
UtAssert_MemCmp(&SC_OperData.CmdPipe, &Expected_SC_OperData.CmdPipe, sizeof(Expected_SC_OperData.CmdPipe), "2");
- UtAssert_MemCmp(&SC_OperData.AtsInfoHandle, &Expected_SC_OperData.AtsInfoHandle,
- sizeof(Expected_SC_OperData.AtsInfoHandle), "AtsInfoHandle");
- UtAssert_MemCmp(&SC_OperData.RtsInfoHandle, &Expected_SC_OperData.RtsInfoHandle,
- sizeof(Expected_SC_OperData.RtsInfoHandle), "13");
- UtAssert_MemCmp(&SC_OperData.RtsCtrlBlckHandle, &Expected_SC_OperData.RtsCtrlBlckHandle,
- sizeof(Expected_SC_OperData.RtsCtrlBlckHandle), "RtsCtrlBlckHandle");
- UtAssert_MemCmp(&SC_OperData.AtsCtrlBlckHandle, &Expected_SC_OperData.AtsCtrlBlckHandle,
- sizeof(Expected_SC_OperData.AtsCtrlBlckHandle), "AtsCtrlBlckHandle");
- UtAssert_MemCmp(&SC_OperData.AtsCmdStatusHandle, &Expected_SC_OperData.AtsCmdStatusHandle,
- sizeof(Expected_SC_OperData.AtsCmdStatusHandle), "AtsCmdStatusHandle");
- UtAssert_MemCmp(&SC_OperData.AtsDupTestArray, &Expected_SC_OperData.AtsDupTestArray,
- sizeof(Expected_SC_OperData.AtsDupTestArray), "21");
- UtAssert_MemCmp(&SC_OperData.NumCmdsWakeup, &Expected_SC_OperData.NumCmdsWakeup, sizeof(Expected_SC_OperData.NumCmdsWakeup),
+ UtAssert_MemCmp(&SC_OperData.AtsInfoHandle,
+ &Expected_SC_OperData.AtsInfoHandle,
+ sizeof(Expected_SC_OperData.AtsInfoHandle),
+ "AtsInfoHandle");
+ UtAssert_MemCmp(&SC_OperData.RtsInfoHandle,
+ &Expected_SC_OperData.RtsInfoHandle,
+ sizeof(Expected_SC_OperData.RtsInfoHandle),
+ "13");
+ UtAssert_MemCmp(&SC_OperData.RtsCtrlBlckHandle,
+ &Expected_SC_OperData.RtsCtrlBlckHandle,
+ sizeof(Expected_SC_OperData.RtsCtrlBlckHandle),
+ "RtsCtrlBlckHandle");
+ UtAssert_MemCmp(&SC_OperData.AtsCtrlBlckHandle,
+ &Expected_SC_OperData.AtsCtrlBlckHandle,
+ sizeof(Expected_SC_OperData.AtsCtrlBlckHandle),
+ "AtsCtrlBlckHandle");
+ UtAssert_MemCmp(&SC_OperData.AtsCmdStatusHandle,
+ &Expected_SC_OperData.AtsCmdStatusHandle,
+ sizeof(Expected_SC_OperData.AtsCmdStatusHandle),
+ "AtsCmdStatusHandle");
+ UtAssert_MemCmp(&SC_OperData.AtsDupTestArray,
+ &Expected_SC_OperData.AtsDupTestArray,
+ sizeof(Expected_SC_OperData.AtsDupTestArray),
+ "21");
+ UtAssert_MemCmp(&SC_OperData.NumCmdsWakeup,
+ &Expected_SC_OperData.NumCmdsWakeup,
+ sizeof(Expected_SC_OperData.NumCmdsWakeup),
"22");
UtAssert_MemCmp(&SC_OperData.HkPacket, &Expected_SC_OperData.HkPacket, sizeof(Expected_SC_OperData.HkPacket), "23");
@@ -232,19 +245,33 @@ void SC_AppInit_Test_Nominal(void)
memset(&Expected_SC_OperData.AtsCmdStatusHandle, 0, sizeof(Expected_SC_OperData.AtsCmdStatusHandle));
UtAssert_MemCmp(&SC_OperData.CmdPipe, &Expected_SC_OperData.CmdPipe, sizeof(Expected_SC_OperData.CmdPipe), "2");
- UtAssert_MemCmp(&SC_OperData.AtsInfoHandle, &Expected_SC_OperData.AtsInfoHandle,
- sizeof(Expected_SC_OperData.AtsInfoHandle), "AtsInfoHandle");
- UtAssert_MemCmp(&SC_OperData.RtsInfoHandle, &Expected_SC_OperData.RtsInfoHandle,
- sizeof(Expected_SC_OperData.RtsInfoHandle), "13");
- UtAssert_MemCmp(&SC_OperData.RtsCtrlBlckHandle, &Expected_SC_OperData.RtsCtrlBlckHandle,
- sizeof(Expected_SC_OperData.RtsCtrlBlckHandle), "RtsCtrlBlckHandle");
- UtAssert_MemCmp(&SC_OperData.AtsCtrlBlckHandle, &Expected_SC_OperData.AtsCtrlBlckHandle,
- sizeof(Expected_SC_OperData.AtsCtrlBlckHandle), "AtsCtrlBlckHandle");
- UtAssert_MemCmp(&SC_OperData.AtsCmdStatusHandle, &Expected_SC_OperData.AtsCmdStatusHandle,
- sizeof(Expected_SC_OperData.AtsCmdStatusHandle), "AtsCmdStatusHandle");
- UtAssert_MemCmp(&SC_OperData.AtsDupTestArray, &Expected_SC_OperData.AtsDupTestArray,
- sizeof(Expected_SC_OperData.AtsDupTestArray), "21");
- UtAssert_MemCmp(&SC_OperData.NumCmdsWakeup, &Expected_SC_OperData.NumCmdsWakeup, sizeof(Expected_SC_OperData.NumCmdsWakeup),
+ UtAssert_MemCmp(&SC_OperData.AtsInfoHandle,
+ &Expected_SC_OperData.AtsInfoHandle,
+ sizeof(Expected_SC_OperData.AtsInfoHandle),
+ "AtsInfoHandle");
+ UtAssert_MemCmp(&SC_OperData.RtsInfoHandle,
+ &Expected_SC_OperData.RtsInfoHandle,
+ sizeof(Expected_SC_OperData.RtsInfoHandle),
+ "13");
+ UtAssert_MemCmp(&SC_OperData.RtsCtrlBlckHandle,
+ &Expected_SC_OperData.RtsCtrlBlckHandle,
+ sizeof(Expected_SC_OperData.RtsCtrlBlckHandle),
+ "RtsCtrlBlckHandle");
+ UtAssert_MemCmp(&SC_OperData.AtsCtrlBlckHandle,
+ &Expected_SC_OperData.AtsCtrlBlckHandle,
+ sizeof(Expected_SC_OperData.AtsCtrlBlckHandle),
+ "AtsCtrlBlckHandle");
+ UtAssert_MemCmp(&SC_OperData.AtsCmdStatusHandle,
+ &Expected_SC_OperData.AtsCmdStatusHandle,
+ sizeof(Expected_SC_OperData.AtsCmdStatusHandle),
+ "AtsCmdStatusHandle");
+ UtAssert_MemCmp(&SC_OperData.AtsDupTestArray,
+ &Expected_SC_OperData.AtsDupTestArray,
+ sizeof(Expected_SC_OperData.AtsDupTestArray),
+ "21");
+ UtAssert_MemCmp(&SC_OperData.NumCmdsWakeup,
+ &Expected_SC_OperData.NumCmdsWakeup,
+ sizeof(Expected_SC_OperData.NumCmdsWakeup),
"22");
UtAssert_MemCmp(&SC_OperData.HkPacket, &Expected_SC_OperData.HkPacket, sizeof(Expected_SC_OperData.HkPacket), "23");
@@ -543,7 +570,6 @@ void SC_GetDumpTablePointers_Test_Nominal(void)
void SC_GetDumpTablePointers_Test_ErrorGetAddressRTSInformation(void)
{
-
/* Need to set CFE_TBL_GetAddress to return -1 on 1st call (to generate error message
* SC_GET_ADDRESS_RTS_INFO_ERR_EID) and CFE_SUCCESS on all other calls.
*/
@@ -691,65 +717,119 @@ void UtTest_Setup(void)
UtTest_Add(SC_AppMain_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_AppMain_Test_Nominal");
UtTest_Add(SC_AppMain_Test_AppInitError, SC_Test_Setup, SC_Test_TearDown, "SC_AppMain_Test_AppInitError");
UtTest_Add(SC_AppMain_Test_RcvMsgError, SC_Test_Setup, SC_Test_TearDown, "SC_AppMain_Test_RcvMsgError");
- UtTest_Add(SC_AppInit_Test_NominalPowerOnReset, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppInit_Test_NominalPowerOnReset,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppInit_Test_NominalPowerOnReset");
UtTest_Add(SC_AppInit_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_AppInit_Test_Nominal");
UtTest_Add(SC_AppInit_Test_EVSRegisterError, SC_Test_Setup, SC_Test_TearDown, "SC_AppInit_Test_EVSRegisterError");
UtTest_Add(SC_AppInit_Test_SBCreatePipeError, SC_Test_Setup, SC_Test_TearDown, "SC_AppInit_Test_SBCreatePipeError");
- UtTest_Add(SC_AppInit_Test_SBSubscribeHKError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppInit_Test_SBSubscribeHKError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppInit_Test_SBSubscribeHKError");
- UtTest_Add(SC_AppInit_Test_SBSubscribeToCmdError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppInit_Test_SBSubscribeToCmdError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppInit_Test_SBSubscribeToCmdError");
- UtTest_Add(SC_AppInit_Test_SubscribeToWakeupError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppInit_Test_SubscribeToWakeupError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppInit_Test_SubscribeToWakeupError");
UtTest_Add(SC_AppInit_Test_InitTablesError, SC_Test_Setup, SC_Test_TearDown, "SC_AppInit_Test_InitTablesError");
UtTest_Add(SC_InitTables_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_InitTables_Test_Nominal");
- UtTest_Add(SC_InitTables_Test_ErrorRegisterAllTables, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_InitTables_Test_ErrorRegisterAllTables,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_InitTables_Test_ErrorRegisterAllTables");
- UtTest_Add(SC_InitTables_Test_ErrorGetDumpTablePointers, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_InitTables_Test_ErrorGetDumpTablePointers,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_InitTables_Test_ErrorGetDumpTablePointers");
- UtTest_Add(SC_InitTables_Test_ErrorGetLoadTablePointers, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_InitTables_Test_ErrorGetLoadTablePointers,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_InitTables_Test_ErrorGetLoadTablePointers");
UtTest_Add(SC_RegisterAllTables_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_RegisterAllTables_Test_Nominal");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterRTSInformation, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterRTSInformation,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterRTSInformation");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterRTPControl, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterRTPControl,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterRTPControl");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterATSInformation, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterATSInformation,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterATSInformation");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterATPControl, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterATPControl,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterATPControl");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterATSCommandStatus, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterATSCommandStatus,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterATSCommandStatus");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterLoadableRTS, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterLoadableRTS,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterLoadableRTS");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterLoadableATS, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterLoadableATS,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterLoadableATS");
- UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterLoadableAppendATS, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterAllTables_Test_ErrorRegisterLoadableAppendATS,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterAllTables_Test_ErrorRegisterLoadableAppendATS");
- UtTest_Add(SC_RegisterDumpOnlyTables_Test_Nominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterDumpOnlyTables_Test_Nominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterDumpOnlyTables_Test_Nominal");
- UtTest_Add(SC_RegisterLoadableTables_Test_Nominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_RegisterLoadableTables_Test_Nominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_RegisterLoadableTables_Test_Nominal");
- UtTest_Add(SC_GetDumpTablePointers_Test_Nominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetDumpTablePointers_Test_Nominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetDumpTablePointers_Test_Nominal");
- UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressRTSInformation, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressRTSInformation,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetDumpTablePointers_Test_ErrorGetAddressRTSInformation");
- UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressRTPControl, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressRTPControl,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetDumpTablePointers_Test_ErrorGetAddressRTPControl");
- UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressATSInformation, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressATSInformation,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetDumpTablePointers_Test_ErrorGetAddressATSInformation");
- UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressATPControl, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressATPControl,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetDumpTablePointers_Test_ErrorGetAddressATPControl");
- UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressATSCommandStatus, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetDumpTablePointers_Test_ErrorGetAddressATSCommandStatus,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetDumpTablePointers_Test_ErrorGetAddressATSCommandStatus");
- UtTest_Add(SC_GetLoadTablePointers_Test_Nominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetLoadTablePointers_Test_Nominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetLoadTablePointers_Test_Nominal");
- UtTest_Add(SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableATS, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableATS,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableATS");
- UtTest_Add(SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableATSAppend, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableATSAppend,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableATSAppend");
- UtTest_Add(SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableRTS, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableRTS,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetLoadTablePointers_Test_ErrorGetAddressLoadableRTS");
UtTest_Add(SC_LoadDefaultTables_Test, SC_Test_Setup, SC_Test_TearDown, "SC_LoadDefaultTables_Test");
}
diff --git a/unit-test/sc_atsrq_tests.c b/unit-test/sc_atsrq_tests.c
index 2510a75..0b0caf6 100644
--- a/unit-test/sc_atsrq_tests.c
+++ b/unit-test/sc_atsrq_tests.c
@@ -42,7 +42,9 @@
* Function Definitions
*/
-int32 UT_SC_StartAtsRq_CompareHookAgreaterthanB(void *UserObj, int32 StubRetcode, uint32 CallCount,
+int32 UT_SC_StartAtsRq_CompareHookAgreaterthanB(void *UserObj,
+ int32 StubRetcode,
+ uint32 CallCount,
const UT_StubContext_t *Context)
{
return CFE_TIME_A_GT_B;
@@ -66,7 +68,7 @@ void SC_StartAtsCmd_Test_NominalA(void)
{
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
SC_AtsCmdNumRecord_t *AtsCmdNumRec;
AtsCmdNumRec = SC_GetAtsCommandNumAtSeq(AtsIndex, SC_SEQUENCE_IDX_FIRST);
@@ -95,7 +97,7 @@ void SC_StartAtsCmd_Test_NominalB(void)
{
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
SC_AtsCmdNumRecord_t *AtsCmdNumRec;
AtsCmdNumRec = SC_GetAtsCommandNumAtSeq(AtsIndex, SC_SEQUENCE_IDX_FIRST);
@@ -330,7 +332,7 @@ void SC_BeginAts_Test_Nominal(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
uint16 TimeOffset = 0;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
SC_AtsCmdNumRecord_t *AtsCmdNumRec;
AtsCmdNumRec = SC_GetAtsCommandNumAtSeq(AtsIndex, SC_SEQUENCE_IDX_FIRST);
@@ -356,9 +358,9 @@ void SC_BeginAts_Test_AllCommandsSkipped(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
uint16 TimeOffset = 0;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
SC_AtsCmdStatusEntry_t *StatusEntryPtr;
- SC_AtsCmdNumRecord_t * AtsCmdNumRec;
+ SC_AtsCmdNumRecord_t *AtsCmdNumRec;
AtsCmdNumRec = SC_GetAtsCommandNumAtSeq(AtsIndex, SC_SEQUENCE_IDX_FIRST);
StatusEntryPtr = SC_GetAtsStatusEntryForCommand(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -786,7 +788,7 @@ void SC_JumpAtsCmd_Test_SkipOneCmd(void)
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_JUMP_ATS_CC;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
SC_AtsCmdStatusEntry_t *StatusPtr0;
SC_AtsCmdStatusEntry_t *StatusPtr1;
@@ -836,7 +838,7 @@ void SC_JumpAtsCmd_Test_AllCommandsSkipped(void)
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_JUMP_ATS_CC;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
SC_AtsCmdStatusEntry_t *StatusEntryPtr;
AtsInfoPtr = SC_GetAtsInfoObject(AtsIndex);
@@ -891,7 +893,7 @@ void SC_JumpAtsCmd_Test_AtsNotLoaded(void)
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_JUMP_ATS_CC;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
SC_AtsCmdStatusEntry_t *StatusPtr0;
SC_AtsCmdStatusEntry_t *StatusPtr1;
@@ -951,8 +953,7 @@ void ContinueAtsOnFailureCmd_Test_Nominal(void)
UtAssert_BOOL_TRUE(SC_OperData.HkPacket.Payload.ContinueAtsOnFailureFlag);
UtAssert_True(SC_OperData.HkPacket.Payload.CmdCtr == 1, "SC_OperData.HkPacket.Payload.CmdCtr == 1");
- UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID,
- SC_CONT_CMD_INF_EID);
+ UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, SC_CONT_CMD_INF_EID);
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1);
}
@@ -974,8 +975,7 @@ void ContinueAtsOnFailureCmd_Test_FalseState(void)
"SC_OperData.HkPacket.Payload.ContinueAtsOnFailureFlag == false");
UtAssert_True(SC_OperData.HkPacket.Payload.CmdCtr == 1, "SC_OperData.HkPacket.Payload.CmdCtr == 1");
- UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID,
- SC_CONT_CMD_INF_EID);
+ UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, SC_CONT_CMD_INF_EID);
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1);
}
@@ -1005,7 +1005,7 @@ void SC_AppendAtsCmd_Test_Nominal(void)
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_APPEND_ATS_CC;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
AtsInfoPtr = SC_GetAtsInfoObject(AtsIndex);
@@ -1161,58 +1161,96 @@ void UtTest_Setup(void)
UtTest_Add(SC_StartAtsCmd_Test_NoCommandsB, SC_Test_Setup, SC_Test_TearDown, "SC_StartAtsCmd_Test_NoCommandsB");
UtTest_Add(SC_StartAtsCmd_Test_InUse, SC_Test_Setup, SC_Test_TearDown, "SC_StartAtsCmd_Test_InUse");
UtTest_Add(SC_StartAtsCmd_Test_InvalidAtsNum, SC_Test_Setup, SC_Test_TearDown, "SC_StartAtsCmd_Test_InvalidAtsNum");
- UtTest_Add(SC_StartAtsCmd_Test_InvalidAtsNumZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartAtsCmd_Test_InvalidAtsNumZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartAtsCmd_Test_InvalidAtsNumZero");
UtTest_Add(SC_StopAtsCmd_Test_NominalA, SC_Test_Setup, SC_Test_TearDown, "SC_StopAtsCmd_Test_NominalA");
UtTest_Add(SC_StopAtsCmd_Test_NominalB, SC_Test_Setup, SC_Test_TearDown, "SC_StopAtsCmd_Test_NominalB");
UtTest_Add(SC_StopAtsCmd_Test_NoRunningAts, SC_Test_Setup, SC_Test_TearDown, "SC_StopAtsCmd_Test_NoRunningAts");
UtTest_Add(SC_BeginAts_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_BeginAts_Test_Nominal");
- UtTest_Add(SC_BeginAts_Test_AllCommandsSkipped, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_BeginAts_Test_AllCommandsSkipped,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_BeginAts_Test_AllCommandsSkipped");
UtTest_Add(SC_BeginAts_Test_InvalidAtsIndex, SC_Test_Setup, SC_Test_TearDown, "SC_BeginAts_Test_InvalidAtsIndex");
UtTest_Add(SC_KillAts_Test, SC_Test_Setup, SC_Test_TearDown, "SC_KillAts_Test");
UtTest_Add(SC_SwitchAtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_SwitchAtsCmd_Test_Nominal");
UtTest_Add(SC_SwitchAtsCmd_Test_BadId, SC_Test_Setup, SC_Test_TearDown, "SC_SwitchAtsCmd_Test_BadId");
- UtTest_Add(SC_SwitchAtsCmd_Test_DestinationAtsNotLoaded, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_SwitchAtsCmd_Test_DestinationAtsNotLoaded,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_SwitchAtsCmd_Test_DestinationAtsNotLoaded");
UtTest_Add(SC_SwitchAtsCmd_Test_AtpIdle, SC_Test_Setup, SC_Test_TearDown, "SC_SwitchAtsCmd_Test_AtpIdle");
- UtTest_Add(SC_ServiceSwitchPend_Test_NominalA, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ServiceSwitchPend_Test_NominalA,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ServiceSwitchPend_Test_NominalA");
- UtTest_Add(SC_ServiceSwitchPend_Test_NominalB, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ServiceSwitchPend_Test_NominalB,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ServiceSwitchPend_Test_NominalB");
- UtTest_Add(SC_ServiceSwitchPend_Test_AtsEmpty, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ServiceSwitchPend_Test_AtsEmpty,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ServiceSwitchPend_Test_AtsEmpty");
UtTest_Add(SC_ServiceSwitchPend_Test_AtpIdle, SC_Test_Setup, SC_Test_TearDown, "SC_ServiceSwitchPend_Test_AtpIdle");
- UtTest_Add(SC_ServiceSwitchPend_Test_NoSwitch, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ServiceSwitchPend_Test_NoSwitch,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ServiceSwitchPend_Test_NoSwitch");
- UtTest_Add(SC_ServiceSwitchPend_Test_AtsNotStarted, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ServiceSwitchPend_Test_AtsNotStarted,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ServiceSwitchPend_Test_AtsNotStarted");
UtTest_Add(SC_InlineSwitch_Test_NominalA, SC_Test_Setup, SC_Test_TearDown, "SC_InlineSwitch_Test_NominalA");
UtTest_Add(SC_InlineSwitch_Test_NominalB, SC_Test_Setup, SC_Test_TearDown, "SC_InlineSwitch_Test_NominalB");
- UtTest_Add(SC_InlineSwitch_Test_AllCommandsSkipped, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_InlineSwitch_Test_AllCommandsSkipped,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_InlineSwitch_Test_AllCommandsSkipped");
- UtTest_Add(SC_InlineSwitch_Test_DestinationAtsNotLoaded, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_InlineSwitch_Test_DestinationAtsNotLoaded,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_InlineSwitch_Test_DestinationAtsNotLoaded");
UtTest_Add(SC_JumpAtsCmd_Test_SkipOneCmd, SC_Test_Setup, SC_Test_TearDown, "SC_JumpAtsCmd_Test_SkipOneCmd");
- UtTest_Add(SC_JumpAtsCmd_Test_AllCommandsSkipped, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_JumpAtsCmd_Test_AllCommandsSkipped,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_JumpAtsCmd_Test_AllCommandsSkipped");
UtTest_Add(SC_JumpAtsCmd_Test_NoRunningAts, SC_Test_Setup, SC_Test_TearDown, "SC_JumpAtsCmd_Test_NoRunningAts");
UtTest_Add(SC_JumpAtsCmd_Test_AtsNotLoaded, SC_Test_Setup, SC_Test_TearDown, "SC_JumpAtsCmd_Test_AtsNotLoaded");
- UtTest_Add(ContinueAtsOnFailureCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(ContinueAtsOnFailureCmd_Test_Nominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"ContinueAtsOnFailureCmd_Test_Nominal");
- UtTest_Add(ContinueAtsOnFailureCmd_Test_FalseState, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(ContinueAtsOnFailureCmd_Test_FalseState,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"ContinueAtsOnFailureCmd_Test_FalseState");
- UtTest_Add(ContinueAtsOnFailureCmd_Test_InvalidState, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(ContinueAtsOnFailureCmd_Test_InvalidState,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"ContinueAtsOnFailureCmd_Test_InvalidState");
UtTest_Add(SC_AppendAtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_AppendAtsCmd_Test_Nominal");
- UtTest_Add(SC_AppendAtsCmd_Test_InvalidAtsNum, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppendAtsCmd_Test_InvalidAtsNum,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppendAtsCmd_Test_InvalidAtsNum");
- UtTest_Add(SC_AppendAtsCmd_Test_InvalidAtsNumZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppendAtsCmd_Test_InvalidAtsNumZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppendAtsCmd_Test_InvalidAtsNumZero");
- UtTest_Add(SC_AppendAtsCmd_Test_AtsTableEmpty, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppendAtsCmd_Test_AtsTableEmpty,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppendAtsCmd_Test_AtsTableEmpty");
- UtTest_Add(SC_AppendAtsCmd_Test_AppendTableEmpty, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppendAtsCmd_Test_AppendTableEmpty,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppendAtsCmd_Test_AppendTableEmpty");
- UtTest_Add(SC_AppendAtsCmd_Test_NoRoomForAppendInAts, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AppendAtsCmd_Test_NoRoomForAppendInAts,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AppendAtsCmd_Test_NoRoomForAppendInAts");
}
diff --git a/unit-test/sc_cmds_tests.c b/unit-test/sc_cmds_tests.c
index 4dc0f21..6efeebf 100644
--- a/unit-test/sc_cmds_tests.c
+++ b/unit-test/sc_cmds_tests.c
@@ -43,7 +43,9 @@
* Function Definitions
*/
-int32 Ut_CFE_TIME_CompareHookAlessthanB(void *UserObj, int32 StubRetcode, uint32 CallCount,
+int32 Ut_CFE_TIME_CompareHookAlessthanB(void *UserObj,
+ int32 StubRetcode,
+ uint32 CallCount,
const UT_StubContext_t *Context)
{
return CFE_TIME_A_LT_B;
@@ -51,11 +53,11 @@ int32 Ut_CFE_TIME_CompareHookAlessthanB(void *UserObj, int32 StubRetcode, uint32
void SC_ProcessAtpCmd_Test_SwitchCmd(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_SWITCH_ATS_CC;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
StatusEntryPtr = SC_GetAtsStatusEntryForCommand(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -98,11 +100,11 @@ void SC_ProcessAtpCmd_Test_SwitchCmd(void)
void SC_ProcessAtpCmd_Test_NonSwitchCmd(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_NOOP_CC;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -145,11 +147,11 @@ void SC_ProcessAtpCmd_Test_NonSwitchCmd(void)
void SC_ProcessAtpCmd_Test_InlineSwitchError(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_SWITCH_ATS_CC;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -196,11 +198,11 @@ void SC_ProcessAtpCmd_Test_InlineSwitchError(void)
void SC_ProcessAtpCmd_Test_SBErrorAtsA(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_NOOP_CC;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -247,11 +249,11 @@ void SC_ProcessAtpCmd_Test_SBErrorAtsA(void)
void SC_ProcessAtpCmd_Test_SBErrorAtsB(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_NOOP_CC;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -298,12 +300,12 @@ void SC_ProcessAtpCmd_Test_SBErrorAtsB(void)
void SC_ProcessAtpCmd_Test_ChecksumFailedAtsA(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_SWITCH_ATS_CC;
bool ChecksumValid;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -353,12 +355,12 @@ void SC_ProcessAtpCmd_Test_ChecksumFailedAtsA(void)
void SC_ProcessAtpCmd_Test_ChecksumFailedAtsB(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_SWITCH_ATS_CC;
bool ChecksumValid;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -408,12 +410,12 @@ void SC_ProcessAtpCmd_Test_ChecksumFailedAtsB(void)
void SC_ProcessAtpCmd_Test_ChecksumFailedAtsAContinue(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_SWITCH_ATS_CC;
bool ChecksumValid;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -462,9 +464,9 @@ void SC_ProcessAtpCmd_Test_ChecksumFailedAtsAContinue(void)
void SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsA(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -499,9 +501,9 @@ void SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsA(void)
void SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsB(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -536,7 +538,7 @@ void SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsB(void)
void SC_ProcessAtpCmd_Test_CmdNotLoaded(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
@@ -567,7 +569,7 @@ void SC_ProcessAtpCmd_Test_CmdNotLoaded(void)
void SC_ProcessAtpCmd_Test_CompareAbsTime(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
@@ -598,7 +600,7 @@ void SC_ProcessAtpCmd_Test_CompareAbsTime(void)
void SC_ProcessAtpCmd_Test_AtpState(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
@@ -626,11 +628,11 @@ void SC_ProcessAtpCmd_Test_AtpState(void)
void SC_ProcessAtpCmd_Test_CmdMid(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_INVALID_MSG_ID;
CFE_MSG_FcnCode_t FcnCode = SC_SWITCH_ATS_CC;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -835,8 +837,8 @@ void SC_SendHkPacket_Test(void)
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(SC_NUMBER_OF_RTS - 1);
SC_RtsInfoEntry_t *RtsInfoPtr;
SC_AtsInfoTable_t *AtsInfoPtr;
- uint16 ExpectedRtsExecStatus[(SC_NUMBER_OF_RTS + 15) / 16];
- uint16 ExpectedRtsDisabledStatus[(SC_NUMBER_OF_RTS + 15) / 16];
+ uint8 ExpectedRtsExecStatus[(SC_NUMBER_OF_RTS + 7) / 8];
+ uint8 ExpectedRtsDisabledStatus[(SC_NUMBER_OF_RTS + 7) / 8];
memset(&ExpectedRtsExecStatus[0], 0u, sizeof(ExpectedRtsExecStatus));
memset(&ExpectedRtsDisabledStatus[0], 0u, sizeof(ExpectedRtsDisabledStatus));
@@ -1063,11 +1065,11 @@ void SC_ProcessRequest_Test_WakeupRtpExecutionTime(void)
void SC_ProcessRequest_Test_WakeupAtpExecutionTime(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID);
CFE_MSG_FcnCode_t FcnCode = SC_NOOP_CC;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
SC_AppData.NextCmdTime[SC_Process_ATP] = 0;
@@ -1626,64 +1628,114 @@ void SC_ProcessCommand_Test_EnableRtsGrp(void)
void UtTest_Setup(void)
{
UtTest_Add(SC_ProcessAtpCmd_Test_SwitchCmd, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessAtpCmd_Test_SwitchCmd");
- UtTest_Add(SC_ProcessAtpCmd_Test_NonSwitchCmd, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_NonSwitchCmd,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_NonSwitchCmd");
- UtTest_Add(SC_ProcessAtpCmd_Test_InlineSwitchError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_InlineSwitchError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_InlineSwitchError");
UtTest_Add(SC_ProcessAtpCmd_Test_SBErrorAtsA, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessAtpCmd_Test_SBErrorAtsA");
UtTest_Add(SC_ProcessAtpCmd_Test_SBErrorAtsB, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessAtpCmd_Test_SBErrorAtsB");
- UtTest_Add(SC_ProcessAtpCmd_Test_ChecksumFailedAtsA, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_ChecksumFailedAtsA,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_ChecksumFailedAtsA");
- UtTest_Add(SC_ProcessAtpCmd_Test_ChecksumFailedAtsB, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_ChecksumFailedAtsB,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_ChecksumFailedAtsB");
- UtTest_Add(SC_ProcessAtpCmd_Test_ChecksumFailedAtsAContinue, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_ChecksumFailedAtsAContinue,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_ChecksumFailedAtsAContinue");
- UtTest_Add(SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsA, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsA,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsA");
- UtTest_Add(SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsB, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsB,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_CmdNumberMismatchAtsB");
- UtTest_Add(SC_ProcessAtpCmd_Test_CmdNotLoaded, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_CmdNotLoaded,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_CmdNotLoaded");
- UtTest_Add(SC_ProcessAtpCmd_Test_CompareAbsTime, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAtpCmd_Test_CompareAbsTime,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAtpCmd_Test_CompareAbsTime");
UtTest_Add(SC_ProcessAtpCmd_Test_AtpState, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessAtpCmd_Test_AtpState");
UtTest_Add(SC_ProcessAtpCmd_Test_CmdMid, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessAtpCmd_Test_CmdMid");
UtTest_Add(SC_ProcessRtpCommand_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessRtpCommand_Test_Nominal");
- UtTest_Add(SC_ProcessRtpCommand_Test_BadSoftwareBusReturn, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRtpCommand_Test_BadSoftwareBusReturn,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRtpCommand_Test_BadSoftwareBusReturn");
- UtTest_Add(SC_ProcessRtpCommand_Test_BadChecksum, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRtpCommand_Test_BadChecksum,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRtpCommand_Test_BadChecksum");
- UtTest_Add(SC_ProcessRtpCommand_Test_NextCmdTime, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRtpCommand_Test_NextCmdTime,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRtpCommand_Test_NextCmdTime");
- UtTest_Add(SC_ProcessRtpCommand_Test_RtsNumZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRtpCommand_Test_RtsNumZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRtpCommand_Test_RtsNumZero");
- UtTest_Add(SC_ProcessRtpCommand_Test_RtsNumHigh, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRtpCommand_Test_RtsNumHigh,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRtpCommand_Test_RtsNumHigh");
- UtTest_Add(SC_ProcessRtpCommand_Test_RtsStatus, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRtpCommand_Test_RtsStatus,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRtpCommand_Test_RtsStatus");
UtTest_Add(SC_SendHkPacket_Test, SC_Test_Setup, SC_Test_TearDown, "SC_SendHkPacket_Test");
UtTest_Add(SC_ProcessRequest_Test_HkMID, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessRequest_Test_HkMID");
- UtTest_Add(SC_ProcessRequest_Test_HkMIDAutoStartRts, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_HkMIDAutoStartRts,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_HkMIDAutoStartRts");
- UtTest_Add(SC_ProcessRequest_Test_HkMIDAutoStartRtsLoaded, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_HkMIDAutoStartRtsLoaded,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_HkMIDAutoStartRtsLoaded");
UtTest_Add(SC_ProcessRequest_Test_WakeupNONE, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessRequest_Test_WakeupNONE");
- UtTest_Add(SC_ProcessRequest_Test_WakeupRtpNotExecutionTime, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupRtpNotExecutionTime,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupRtpNotExecutionTime");
- UtTest_Add(SC_ProcessRequest_Test_WakeupNoSwitchPending, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupNoSwitchPending,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupNoSwitchPending");
- UtTest_Add(SC_ProcessRequest_Test_WakeupAtpNotExecutionTime, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupAtpNotExecutionTime,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupAtpNotExecutionTime");
- UtTest_Add(SC_ProcessRequest_Test_WakeupRtpExecutionTime, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupRtpExecutionTime,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupRtpExecutionTime");
- UtTest_Add(SC_ProcessRequest_Test_WakeupAtpExecutionTime, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupAtpExecutionTime,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupAtpExecutionTime");
- UtTest_Add(SC_ProcessRequest_Test_WakeupRtpExecutionTimeTooManyCmds, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupRtpExecutionTimeTooManyCmds,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupRtpExecutionTimeTooManyCmds");
- UtTest_Add(SC_ProcessRequest_Test_WakeupAtpExecutionTimeTooManyCmds, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupAtpExecutionTimeTooManyCmds,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupAtpExecutionTimeTooManyCmds");
UtTest_Add(SC_ProcessCommand_Test_NoOp, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_NoOp");
- UtTest_Add(SC_ProcessCommand_Test_ResetCounters, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_ResetCounters,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_ResetCounters");
UtTest_Add(SC_ProcessCommand_Test_StartAts, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_StartAts");
UtTest_Add(SC_ProcessCommand_Test_StopAts, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_StopAts");
@@ -1693,58 +1745,110 @@ void UtTest_Setup(void)
UtTest_Add(SC_ProcessCommand_Test_EnableRts, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_EnableRts");
UtTest_Add(SC_ProcessCommand_Test_SwitchAts, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_SwitchAts");
UtTest_Add(SC_ProcessCommand_Test_JumpAts, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_JumpAts");
- UtTest_Add(SC_ProcessCommand_Test_ContinueAtsOnFailure, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_ContinueAtsOnFailure,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_ContinueAtsOnFailure");
UtTest_Add(SC_ProcessCommand_Test_AppendAts, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_AppendAts");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsTableNominal");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableGetAddressError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableGetAddressError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsTableGetAddressError");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableID, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableID,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsTableID");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTable_InvalidIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTable_InvalidIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsTable_InvalidIndex");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableGetAddressNeverLoaded, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableGetAddressNeverLoaded,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsTableGetAddressNeverLoaded");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableGetAddressSuccess, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsTableGetAddressSuccess,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsTableGetAddressSuccess");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAppendTableNominal");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableGetAddressError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableGetAddressError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAppendTableGetAddressError");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableGetAddressNeverLoaded, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableGetAddressNeverLoaded,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAppendTableGetAddressNeverLoaded");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableGetAddressSuccess, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAppendTableGetAddressSuccess,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAppendTableGetAddressSuccess");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtsTableNominal");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableGetAddressError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableGetAddressError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtsTableGetAddressError");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableID, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableID,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtsTableID");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTable_InvalidIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTable_InvalidIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtsTable_InvalidIndex");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableGetAddressNeverLoaded, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableGetAddressNeverLoaded,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtsTableGetAddressNeverLoaded");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableGetAddressSuccess, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtsTableGetAddressSuccess,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtsTableGetAddressSuccess");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtsInfo, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtsInfo,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtsInfo");
- UtTest_Add(SC_ProcessCommand_Test_TableManageRtpCtrl, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageRtpCtrl,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageRtpCtrl");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsInfo, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsInfo,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsInfo");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtpCtrl, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtpCtrl,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtpCtrl");
- UtTest_Add(SC_ProcessCommand_Test_TableManageAtsCmdStatus, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageAtsCmdStatus,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageAtsCmdStatus");
- UtTest_Add(SC_ProcessCommand_Test_TableManageInvalidTableID, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageInvalidTableID,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageInvalidTableID");
- UtTest_Add(SC_ProcessCommand_Test_StartRtsGrp, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StartRtsGrp,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StartRtsGrp");
UtTest_Add(SC_ProcessCommand_Test_StopRtsGrp, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_StopRtsGrp");
- UtTest_Add(SC_ProcessCommand_Test_DisableRtsGrp, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_DisableRtsGrp,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_DisableRtsGrp");
- UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrp, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrp,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_EnableRtsGrp");
}
diff --git a/unit-test/sc_dispatch_tests.c b/unit-test/sc_dispatch_tests.c
index 49049e7..dce7b81 100644
--- a/unit-test/sc_dispatch_tests.c
+++ b/unit-test/sc_dispatch_tests.c
@@ -923,89 +923,169 @@ void UtTest_Setup(void)
{
UtTest_Add(SC_VerifyCmdLength_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_VerifyCmdLength_Test_Nominal");
UtTest_Add(SC_VerifyCmdLength_Test_LenError, SC_Test_Setup, SC_Test_TearDown, "SC_VerifyCmdLength_Test_LenError");
- UtTest_Add(SC_VerifyCmdLength_Test_LenErrorNotMID, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyCmdLength_Test_LenErrorNotMID,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyCmdLength_Test_LenErrorNotMID");
UtTest_Add(SC_ProcessRequest_Test_CmdNominal, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessRequest_Test_CmdNominal");
- UtTest_Add(SC_ProcessRequest_Test_SendHkNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_SendHkNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_SendHkNominal");
- UtTest_Add(SC_ProcessRequest_Test_SendHkCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_SendHkCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_SendHkCmdInvalidLength");
- UtTest_Add(SC_ProcessRequest_Test_WakeupCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupCmdInvalidLength");
- UtTest_Add(SC_ProcessRequest_Test_WakeupNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessRequest_Test_WakeupNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessRequest_Test_WakeupNominal");
UtTest_Add(SC_ProcessRequest_Test_MIDError, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessRequest_Test_MIDError");
- UtTest_Add(SC_ProcessCommand_Test_NoopCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_NoopCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_NoopCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_ResetCounterCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_ResetCounterCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_ResetCounterCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_StartAtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StartAtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StartAtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_StopAtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StopAtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StopAtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_StartRtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StartRtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StartRtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_StopRtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StopRtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StopRtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_DisableRtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_DisableRtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_DisableRtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_EnableRtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_EnableRtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_EnableRtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_SwitchAtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_SwitchAtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_SwitchAtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_JumpAtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_JumpAtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_JumpAtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_ContinueAtsOnFailureCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_ContinueAtsOnFailureCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_ContinueAtsOnFailureCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_AppendAtsCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_AppendAtsCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_AppendAtsCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_TableManageCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_StartRtsGrpCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StartRtsGrpCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StartRtsGrpCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_StopRtsGrpCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StopRtsGrpCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StopRtsGrpCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_DisableRtsGrpCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_DisableRtsGrpCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_DisableRtsGrpCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrpCmdNominal, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrpCmdNominal,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_EnableRtsGrpCmdNominal");
- UtTest_Add(SC_ProcessCommand_Test_NoopCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_NoopCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_NoopCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_ResetCounterCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_ResetCounterCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_ResetCounterCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_StartAtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StartAtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StartAtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_StopAtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StopAtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StopAtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_StartRtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StartRtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StartRtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_StopRtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StopRtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StopRtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_DisableRtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_DisableRtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_DisableRtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_EnableRtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_EnableRtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_EnableRtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_SwitchAtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_SwitchAtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_SwitchAtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_JumpAtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_JumpAtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_JumpAtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_ContinueAtsOnFailureCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_ContinueAtsOnFailureCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_ContinueAtsOnFailureCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_AppendAtsCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_AppendAtsCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_AppendAtsCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_TableManageCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_TableManageCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_TableManageCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_StartRtsGrpCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StartRtsGrpCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StartRtsGrpCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_StopRtsGrpCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_StopRtsGrpCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_StopRtsGrpCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_DisableRtsGrpCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_DisableRtsGrpCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_DisableRtsGrpCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrpCmdInvalidLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrpCmdInvalidLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_EnableRtsGrpCmdInvalidLength");
- UtTest_Add(SC_ProcessCommand_Test_InvalidCmdError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessCommand_Test_InvalidCmdError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessCommand_Test_InvalidCmdError");
}
diff --git a/unit-test/sc_loads_tests.c b/unit-test/sc_loads_tests.c
index 7b593c8..9c72b84 100644
--- a/unit-test/sc_loads_tests.c
+++ b/unit-test/sc_loads_tests.c
@@ -52,8 +52,8 @@ static const SC_SeqIndex_t UT_SEQ_INDEX_1 = SC_IDX_FROM_UINT(1);
void UT_SC_CmdTableSizeHandler(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context)
{
const CFE_MSG_Message_t *MsgPtr = UT_Hook_GetArgValueByName(Context, "MsgPtr", const CFE_MSG_Message_t *);
- CFE_MSG_Size_t * Size = UT_Hook_GetArgValueByName(Context, "Size", CFE_MSG_Size_t *);
- uint32 * StoredSize = (uint32 *)(void *)MsgPtr;
+ CFE_MSG_Size_t *Size = UT_Hook_GetArgValueByName(Context, "Size", CFE_MSG_Size_t *);
+ uint32 *StoredSize = (uint32 *)(void *)MsgPtr;
*Size = *StoredSize;
}
@@ -151,8 +151,8 @@ SC_AtsEntryHeader_t *UT_SC_SetupSingleAtsEntry(SC_AtsIndex_t AtsIndex, uint16 Cm
return UT_SC_AppendSingleAtsEntry(&TailPtr, CmdNumber, MsgSize);
}
-SC_RtsEntryHeader_t *UT_SC_SetupSingleRtsEntry(SC_RtsIndex_t RtsIndex, CFE_SB_MsgId_t MsgId,
- SC_RelWakeupCount_t WakeupCount, size_t MsgSize)
+SC_RtsEntryHeader_t *
+UT_SC_SetupSingleRtsEntry(SC_RtsIndex_t RtsIndex, CFE_SB_MsgId_t MsgId, SC_RelWakeupCount_t WakeupCount, size_t MsgSize)
{
void *TailPtr;
@@ -167,11 +167,15 @@ uint32 UT_SC_GetEntryWordCount(size_t HdrSize, size_t MsgSize)
return (MsgSize + HdrSize + SC_ROUND_UP_BYTES) / SC_BYTES_IN_WORD;
}
-void *UT_SC_SetupFullTable(void **TailPtr, size_t HdrSize, size_t MsgSize, size_t MaxLimitWords,
- size_t TargetEndingWord, void (*EntryInit_Callback)(void *, size_t, size_t))
+void *UT_SC_SetupFullTable(void **TailPtr,
+ size_t HdrSize,
+ size_t MsgSize,
+ size_t MaxLimitWords,
+ size_t TargetEndingWord,
+ void (*EntryInit_Callback)(void *, size_t, size_t))
{
uint8 *HeadPtr;
- void * CurrPtr;
+ void *CurrPtr;
size_t BufEntryWords;
size_t LastUsableWord;
size_t Idx;
@@ -234,14 +238,18 @@ void UT_SC_AtsEntryInit(void *EntryPtr, size_t Idx, size_t MsgSize)
Entry->CmdNumber = SC_CommandIndexToNum(SC_COMMAND_IDX_C(Idx));
}
-SC_AtsEntryHeader_t *UT_SC_SetupAtsTable(SC_AtsIndex_t AtsIndex, size_t MsgSize, size_t TargetEndingWord,
- void **TailPtrOut)
+SC_AtsEntryHeader_t *
+UT_SC_SetupAtsTable(SC_AtsIndex_t AtsIndex, size_t MsgSize, size_t TargetEndingWord, void **TailPtrOut)
{
- void * TailPtr;
+ void *TailPtr;
SC_AtsEntryHeader_t *FinalEntry;
TailPtr = UT_SC_GetAtsTable(AtsIndex);
- FinalEntry = UT_SC_SetupFullTable(&TailPtr, SC_ATS_HEADER_SIZE, MsgSize, SC_ATS_BUFF_SIZE32, TargetEndingWord,
+ FinalEntry = UT_SC_SetupFullTable(&TailPtr,
+ SC_ATS_HEADER_SIZE,
+ MsgSize,
+ SC_ATS_BUFF_SIZE32,
+ TargetEndingWord,
UT_SC_AtsEntryInit);
/* Capture a pointer to the _end_ of the filled data -
@@ -263,15 +271,22 @@ void UT_SC_RtsEntryInit(void *EntryPtr, size_t Idx, size_t MsgSize)
Entry->WakeupCount = 1;
}
-SC_RtsEntryHeader_t *UT_SC_SetupRtsTable(SC_RtsIndex_t RtsIndex, CFE_SB_MsgId_t MsgId, size_t MsgSize,
- size_t TargetEndingWord, void **TailPtrOut)
+SC_RtsEntryHeader_t *UT_SC_SetupRtsTable(SC_RtsIndex_t RtsIndex,
+ CFE_SB_MsgId_t MsgId,
+ size_t MsgSize,
+ size_t TargetEndingWord,
+ void **TailPtrOut)
{
- void * TailPtr;
+ void *TailPtr;
SC_RtsEntryHeader_t *FinalEntry;
UT_SC_SetMsgId(MsgId);
TailPtr = UT_SC_GetRtsTable(RtsIndex);
- FinalEntry = UT_SC_SetupFullTable(&TailPtr, SC_RTS_HEADER_SIZE, MsgSize, SC_RTS_BUFF_SIZE32, TargetEndingWord,
+ FinalEntry = UT_SC_SetupFullTable(&TailPtr,
+ SC_RTS_HEADER_SIZE,
+ MsgSize,
+ SC_RTS_BUFF_SIZE32,
+ TargetEndingWord,
UT_SC_RtsEntryInit);
/* Capture a pointer to the _end_ of the filled data -
@@ -289,8 +304,8 @@ SC_RtsEntryHeader_t *UT_SC_SetupRtsTable(SC_RtsIndex_t RtsIndex, CFE_SB_MsgId_t
void SC_LoadAts_Test_Nominal(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -313,8 +328,8 @@ void SC_LoadAts_Test_Nominal(void)
void SC_LoadAts_Test_CmdRunOffEndOfBuffer(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -338,8 +353,8 @@ void SC_LoadAts_Test_CmdRunOffEndOfBuffer(void)
void SC_LoadAts_Test_CmdLengthInvalid(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -362,8 +377,8 @@ void SC_LoadAts_Test_CmdLengthInvalid(void)
void SC_LoadAts_Test_CmdLengthZero(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -386,8 +401,8 @@ void SC_LoadAts_Test_CmdLengthZero(void)
void SC_LoadAts_Test_CmdNumberInvalid(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -409,12 +424,12 @@ void SC_LoadAts_Test_CmdNumberInvalid(void)
void SC_LoadAts_Test_AtsBufferTooSmall(void)
{
- SC_AtsEntryHeader_t * LastValidEntry;
- void * TailPtr;
- SC_AtsEntryHeader_t * InvalidEntry;
+ SC_AtsEntryHeader_t *LastValidEntry;
+ void *TailPtr;
+ SC_AtsEntryHeader_t *InvalidEntry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -426,7 +441,7 @@ void SC_LoadAts_Test_AtsBufferTooSmall(void)
LastValidEntry =
UT_SC_SetupAtsTable(AtsIndex, UT_SC_NOMINAL_CMD_SIZE, SC_ATS_BUFF_SIZE32 - SC_ATS_HDR_NOPKT_WORDS, &TailPtr);
- InvalidEntry = TailPtr;
+ InvalidEntry = TailPtr;
/*
* Set up final (invalid) entry that will create error condition -
* This is an ATS header at the very end of the ATS buffer, where there is no room
@@ -448,8 +463,8 @@ void SC_LoadAts_Test_AtsBufferTooSmall(void)
void SC_LoadAts_Test_AtsEmpty(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -470,10 +485,10 @@ void SC_LoadAts_Test_AtsEmpty(void)
void SC_LoadAts_Test_LoadExactlyBufferLength(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -497,10 +512,10 @@ void SC_LoadAts_Test_LoadExactlyBufferLength(void)
void SC_LoadAts_Test_CmdNotEmpty(void)
{
- void * TailPtr;
+ void *TailPtr;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -659,7 +674,7 @@ void SC_InitAtsTables_Test_InvalidIndex(void)
void SC_ValidateAts_Test(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -675,7 +690,7 @@ void SC_ValidateAts_Test(void)
void SC_ValidateAppend_Test(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -691,7 +706,7 @@ void SC_ValidateAppend_Test(void)
void SC_ValidateRts_Test(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -709,7 +724,7 @@ void SC_ValidateRts_Test(void)
void SC_ValidateRts_Test_ParseRts(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -752,7 +767,7 @@ void SC_LoadRts_Test_InvalidIndex(void)
void SC_ParseRts_Test_EndOfFile(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -768,7 +783,7 @@ void SC_ParseRts_Test_EndOfFile(void)
void SC_ParseRts_Test_InvalidMsgId(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -786,7 +801,7 @@ void SC_ParseRts_Test_InvalidMsgId(void)
void SC_ParseRts_Test_LengthErrorTooShort(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -804,7 +819,7 @@ void SC_ParseRts_Test_LengthErrorTooShort(void)
void SC_ParseRts_Test_LengthErrorTooLong(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -822,7 +837,7 @@ void SC_ParseRts_Test_LengthErrorTooLong(void)
void SC_ParseRts_Test_CmdRunsOffEndOfBuffer(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -841,7 +856,7 @@ void SC_ParseRts_Test_CmdRunsOffEndOfBuffer(void)
void SC_ParseRts_Test_CmdLengthEqualsBufferLength(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -857,7 +872,7 @@ void SC_ParseRts_Test_CmdLengthEqualsBufferLength(void)
void SC_ParseRts_Test_CmdDoesNotFitBufferEmpty(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -872,8 +887,8 @@ void SC_ParseRts_Test_CmdDoesNotFitBufferEmpty(void)
void SC_ParseRts_Test_CmdDoesNotFitBufferNotEmpty(void)
{
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- void * TailPtr;
- void * TablePtr;
+ void *TailPtr;
+ void *TablePtr;
TablePtr = UT_SC_GetRtsTable(RtsIndex);
@@ -914,13 +929,17 @@ void SC_UpdateAppend_Test_CmdDoesNotFitBuffer(void)
{
uint32 *FirstPtr;
uint32 *LastPtr;
- void * TailPtr;
+ void *TailPtr;
uint32 ExpectedCount;
TailPtr = UT_SC_GetAppendTable();
FirstPtr = TailPtr;
- LastPtr = UT_SC_SetupFullTable(&TailPtr, SC_ATS_HEADER_SIZE, UT_SC_NOMINAL_CMD_SIZE, SC_APPEND_BUFF_SIZE32,
- SC_APPEND_BUFF_SIZE32 + 1, UT_SC_AtsEntryInit);
+ LastPtr = UT_SC_SetupFullTable(&TailPtr,
+ SC_ATS_HEADER_SIZE,
+ UT_SC_NOMINAL_CMD_SIZE,
+ SC_APPEND_BUFF_SIZE32,
+ SC_APPEND_BUFF_SIZE32 + 1,
+ UT_SC_AtsEntryInit);
ExpectedCount = (SC_APPEND_BUFF_SIZE32 / UT_SC_GetEntryWordCount(SC_ATS_HEADER_SIZE, UT_SC_NOMINAL_CMD_SIZE)) - 1;
/* Execute the function being tested */
@@ -978,12 +997,16 @@ void SC_UpdateAppend_Test_InvalidCmdLengthTooHigh(void)
void SC_UpdateAppend_Test_EndOfBuffer(void)
{
- void * TailPtr;
+ void *TailPtr;
uint32 ExpectedCount;
TailPtr = UT_SC_GetAppendTable();
- UT_SC_SetupFullTable(&TailPtr, SC_ATS_HEADER_SIZE, UT_SC_NOMINAL_CMD_SIZE, SC_APPEND_BUFF_SIZE32,
- SC_APPEND_BUFF_SIZE32, UT_SC_AtsEntryInit);
+ UT_SC_SetupFullTable(&TailPtr,
+ SC_ATS_HEADER_SIZE,
+ UT_SC_NOMINAL_CMD_SIZE,
+ SC_APPEND_BUFF_SIZE32,
+ SC_APPEND_BUFF_SIZE32,
+ UT_SC_AtsEntryInit);
ExpectedCount = SC_APPEND_BUFF_SIZE32 / UT_SC_GetEntryWordCount(SC_ATS_HEADER_SIZE, UT_SC_NOMINAL_CMD_SIZE);
/* Execute the function being tested */
@@ -1042,9 +1065,9 @@ void SC_UpdateAppend_Test_CmdNumberTooHigh(void)
void SC_ProcessAppend_Test(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TailPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ void *TailPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -1082,9 +1105,9 @@ void SC_ProcessAppend_Test(void)
void SC_ProcessAppend_Test_CmdLoaded(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TailPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ void *TailPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -1119,9 +1142,9 @@ void SC_ProcessAppend_Test_CmdLoaded(void)
void SC_ProcessAppend_Test_NotExecuting(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TailPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ void *TailPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -1156,9 +1179,9 @@ void SC_ProcessAppend_Test_NotExecuting(void)
void SC_ProcessAppend_Test_IdMismatch(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TailPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ void *TailPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -1193,9 +1216,9 @@ void SC_ProcessAppend_Test_IdMismatch(void)
void SC_ProcessAppend_Test_AtsNum(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TailPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ void *TailPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -1244,7 +1267,7 @@ void SC_ProcessAppend_Test_InvalidIndex(void)
void SC_VerifyAtsTable_Test_Nominal(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1272,7 +1295,7 @@ void SC_VerifyAtsTable_Test_Nominal(void)
void SC_VerifyAtsTable_Test_InvalidEntry(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1290,7 +1313,7 @@ void SC_VerifyAtsTable_Test_InvalidEntry(void)
void SC_VerifyAtsTable_Test_EmptyTable(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1306,7 +1329,7 @@ void SC_VerifyAtsTable_Test_EmptyTable(void)
void SC_VerifyAtsEntry_Test_Nominal(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1326,7 +1349,7 @@ void SC_VerifyAtsEntry_Test_Nominal(void)
void SC_VerifyAtsEntry_Test_EndOfBuffer(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1342,7 +1365,7 @@ void SC_VerifyAtsEntry_Test_EndOfBuffer(void)
void SC_VerifyAtsEntry_Test_InvalidCmdNumber(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1360,7 +1383,7 @@ void SC_VerifyAtsEntry_Test_InvalidCmdNumber(void)
void SC_VerifyAtsEntry_Test_BufferFull(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1378,7 +1401,7 @@ void SC_VerifyAtsEntry_Test_BufferFull(void)
void SC_VerifyAtsEntry_Test_InvalidCmdLengthTooLow(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1396,7 +1419,7 @@ void SC_VerifyAtsEntry_Test_InvalidCmdLengthTooLow(void)
void SC_VerifyAtsEntry_Test_InvalidCmdLengthTooHigh(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1414,7 +1437,7 @@ void SC_VerifyAtsEntry_Test_InvalidCmdLengthTooHigh(void)
void SC_VerifyAtsEntry_Test_BufferOverflow(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1432,7 +1455,7 @@ void SC_VerifyAtsEntry_Test_BufferOverflow(void)
void SC_VerifyAtsEntry_Test_DuplicateCmdNumber(void)
{
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- void * TablePtr;
+ void *TablePtr;
TablePtr = UT_SC_GetAtsTable(AtsIndex);
@@ -1453,30 +1476,48 @@ void SC_VerifyAtsEntry_Test_DuplicateCmdNumber(void)
void UtTest_Setup(void)
{
UtTest_Add(SC_LoadAts_Test_Nominal, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_LoadAts_Test_Nominal");
- UtTest_Add(SC_LoadAts_Test_CmdRunOffEndOfBuffer, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_LoadAts_Test_CmdRunOffEndOfBuffer,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_LoadAts_Test_CmdRunOffEndOfBuffer");
- UtTest_Add(SC_LoadAts_Test_CmdLengthInvalid, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_LoadAts_Test_CmdLengthInvalid,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_LoadAts_Test_CmdLengthInvalid");
- UtTest_Add(SC_LoadAts_Test_CmdLengthZero, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_LoadAts_Test_CmdLengthZero,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_LoadAts_Test_CmdLengthZero");
- UtTest_Add(SC_LoadAts_Test_CmdNumberInvalid, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_LoadAts_Test_CmdNumberInvalid,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_LoadAts_Test_CmdNumberInvalid");
- UtTest_Add(SC_LoadAts_Test_AtsBufferTooSmall, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_LoadAts_Test_AtsBufferTooSmall,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_LoadAts_Test_AtsBufferTooSmall");
UtTest_Add(SC_LoadAts_Test_AtsEmpty, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_LoadAts_Test_AtsEmpty");
- UtTest_Add(SC_LoadAts_Test_LoadExactlyBufferLength, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_LoadAts_Test_LoadExactlyBufferLength,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_LoadAts_Test_LoadExactlyBufferLength");
UtTest_Add(SC_LoadAts_Test_CmdNotEmpty, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_LoadAts_Test_CmdNotEmpty");
UtTest_Add(SC_LoadAts_Test_InvalidIndex, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_LoadAts_Test_InvalidIndex");
- UtTest_Add(SC_BuildTimeIndexTable_Test_InvalidIndex, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_BuildTimeIndexTable_Test_InvalidIndex,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_BuildTimeIndexTable_Test_InvalidIndex");
UtTest_Add(SC_Insert_Test, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_Insert_Test");
UtTest_Add(SC_Insert_Test_MiddleOfList, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_Insert_Test_MiddleOfList");
- UtTest_Add(SC_Insert_Test_MiddleOfListCompareAbsTimeTrue, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_Insert_Test_MiddleOfListCompareAbsTimeTrue,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_Insert_Test_MiddleOfListCompareAbsTimeTrue");
UtTest_Add(SC_Insert_Test_InvalidIndex, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_Insert_Test_InvalidIndex");
- UtTest_Add(SC_InitAtsTables_Test_InvalidIndex, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_InitAtsTables_Test_InvalidIndex,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_InitAtsTables_Test_InvalidIndex");
UtTest_Add(SC_ValidateAts_Test, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_ValidateAts_Test");
UtTest_Add(SC_ValidateAppend_Test, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_ValidateAppend_Test");
@@ -1485,63 +1526,119 @@ void UtTest_Setup(void)
UtTest_Add(SC_LoadRts_Test_Nominal, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_LoadRts_Test_Nominal");
UtTest_Add(SC_LoadRts_Test_InvalidIndex, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_LoadRts_Test_InvalidIndex");
UtTest_Add(SC_ParseRts_Test_EndOfFile, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_ParseRts_Test_EndOfFile");
- UtTest_Add(SC_ParseRts_Test_InvalidMsgId, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ParseRts_Test_InvalidMsgId,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ParseRts_Test_InvalidMsgId");
- UtTest_Add(SC_ParseRts_Test_LengthErrorTooShort, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ParseRts_Test_LengthErrorTooShort,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ParseRts_Test_LengthErrorTooShort");
- UtTest_Add(SC_ParseRts_Test_LengthErrorTooLong, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ParseRts_Test_LengthErrorTooLong,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ParseRts_Test_LengthErrorTooLong");
- UtTest_Add(SC_ParseRts_Test_CmdRunsOffEndOfBuffer, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ParseRts_Test_CmdRunsOffEndOfBuffer,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ParseRts_Test_CmdRunsOffEndOfBuffer");
- UtTest_Add(SC_ParseRts_Test_CmdLengthEqualsBufferLength, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ParseRts_Test_CmdLengthEqualsBufferLength,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ParseRts_Test_CmdLengthEqualsBufferLength");
- UtTest_Add(SC_ParseRts_Test_CmdDoesNotFitBufferEmpty, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ParseRts_Test_CmdDoesNotFitBufferEmpty,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ParseRts_Test_CmdDoesNotFitBufferEmpty");
- UtTest_Add(SC_ParseRts_Test_CmdDoesNotFitBufferNotEmpty, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ParseRts_Test_CmdDoesNotFitBufferNotEmpty,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ParseRts_Test_CmdDoesNotFitBufferNotEmpty");
UtTest_Add(SC_UpdateAppend_Test_Nominal, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_UpdateAppend_Test_Nominal");
- UtTest_Add(SC_UpdateAppend_Test_CmdDoesNotFitBuffer, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_UpdateAppend_Test_CmdDoesNotFitBuffer,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_UpdateAppend_Test_CmdDoesNotFitBuffer");
- UtTest_Add(SC_UpdateAppend_Test_InvalidCmdLengthTooLow, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_UpdateAppend_Test_InvalidCmdLengthTooLow,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_UpdateAppend_Test_InvalidCmdLengthTooLow");
- UtTest_Add(SC_UpdateAppend_Test_InvalidCmdLengthTooHigh, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_UpdateAppend_Test_InvalidCmdLengthTooHigh,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_UpdateAppend_Test_InvalidCmdLengthTooHigh");
- UtTest_Add(SC_UpdateAppend_Test_EndOfBuffer, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_UpdateAppend_Test_EndOfBuffer,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_UpdateAppend_Test_EndOfBuffer");
- UtTest_Add(SC_UpdateAppend_Test_CmdNumberZero, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_UpdateAppend_Test_CmdNumberZero,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_UpdateAppend_Test_CmdNumberZero");
- UtTest_Add(SC_UpdateAppend_Test_CmdNumberTooHigh, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_UpdateAppend_Test_CmdNumberTooHigh,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_UpdateAppend_Test_CmdNumberTooHigh");
UtTest_Add(SC_ProcessAppend_Test, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_ProcessAppend_Test");
- UtTest_Add(SC_ProcessAppend_Test_CmdLoaded, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAppend_Test_CmdLoaded,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAppend_Test_CmdLoaded");
- UtTest_Add(SC_ProcessAppend_Test_NotExecuting, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAppend_Test_NotExecuting,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAppend_Test_NotExecuting");
- UtTest_Add(SC_ProcessAppend_Test_IdMismatch, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAppend_Test_IdMismatch,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAppend_Test_IdMismatch");
UtTest_Add(SC_ProcessAppend_Test_AtsNum, UT_SC_Loads_Test_Setup, SC_Test_TearDown, "SC_ProcessAppend_Test_AtsNum");
- UtTest_Add(SC_ProcessAppend_Test_InvalidIndex, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_ProcessAppend_Test_InvalidIndex,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_ProcessAppend_Test_InvalidIndex");
- UtTest_Add(SC_VerifyAtsTable_Test_Nominal, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsTable_Test_Nominal,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsTable_Test_Nominal");
- UtTest_Add(SC_VerifyAtsTable_Test_InvalidEntry, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsTable_Test_InvalidEntry,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsTable_Test_InvalidEntry");
- UtTest_Add(SC_VerifyAtsTable_Test_EmptyTable, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsTable_Test_EmptyTable,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsTable_Test_EmptyTable");
- UtTest_Add(SC_VerifyAtsEntry_Test_Nominal, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_Nominal,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_Nominal");
- UtTest_Add(SC_VerifyAtsEntry_Test_EndOfBuffer, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_EndOfBuffer,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_EndOfBuffer");
- UtTest_Add(SC_VerifyAtsEntry_Test_InvalidCmdNumber, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_InvalidCmdNumber,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_InvalidCmdNumber");
- UtTest_Add(SC_VerifyAtsEntry_Test_BufferFull, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_BufferFull,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_BufferFull");
- UtTest_Add(SC_VerifyAtsEntry_Test_InvalidCmdLengthTooLow, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_InvalidCmdLengthTooLow,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_InvalidCmdLengthTooLow");
- UtTest_Add(SC_VerifyAtsEntry_Test_InvalidCmdLengthTooHigh, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_InvalidCmdLengthTooHigh,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_InvalidCmdLengthTooHigh");
- UtTest_Add(SC_VerifyAtsEntry_Test_BufferOverflow, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_BufferOverflow,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_BufferOverflow");
- UtTest_Add(SC_VerifyAtsEntry_Test_DuplicateCmdNumber, UT_SC_Loads_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_VerifyAtsEntry_Test_DuplicateCmdNumber,
+ UT_SC_Loads_Test_Setup,
+ SC_Test_TearDown,
"SC_VerifyAtsEntry_Test_DuplicateCmdNumber");
}
diff --git a/unit-test/sc_rtsrq_tests.c b/unit-test/sc_rtsrq_tests.c
index 916aa23..bd5f248 100644
--- a/unit-test/sc_rtsrq_tests.c
+++ b/unit-test/sc_rtsrq_tests.c
@@ -47,11 +47,11 @@ void SC_StartRtsCmd_Test_Nominal(void)
SC_RtsEntryHeader_t *Entry;
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
size_t MsgSize;
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
Entry->WakeupCount = 0;
UT_CmdBuf.StartRtsCmd.Payload.RtsNum = SC_RtsIndexToNum(RtsIndex);
@@ -88,14 +88,14 @@ void SC_StartRtsCmd_Test_StartRtsNoEvents(void)
SC_RtsEntryHeader_t *Entry;
SC_RtsIndex_t RtsIndex;
size_t MsgSize;
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
UT_CmdBuf.StartRtsCmd.Payload.RtsNum = SC_RTS_NUM_C(SC_NUMBER_OF_RTS);
RtsIndex = SC_RtsNumToIndex(UT_CmdBuf.StartRtsCmd.Payload.RtsNum);
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
Entry->WakeupCount = 0;
RtsInfoPtr->DisabledFlag = false;
@@ -140,11 +140,11 @@ void SC_StartRtsCmd_Test_InvalidCommandLength1(void)
SC_RtsEntryHeader_t *Entry;
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
size_t MsgSize;
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
Entry->WakeupCount = 0;
UT_CmdBuf.StartRtsCmd.Payload.RtsNum = SC_RtsIndexToNum(RtsIndex);
@@ -171,11 +171,11 @@ void SC_StartRtsCmd_Test_InvalidCommandLength2(void)
SC_RtsEntryHeader_t *Entry;
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
size_t MsgSize;
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
Entry->WakeupCount = 0;
UT_CmdBuf.StartRtsCmd.Payload.RtsNum = SC_RtsIndexToNum(RtsIndex);
@@ -201,11 +201,11 @@ void SC_StartRtsCmd_Test_RtsNotLoadedOrInUse(void)
{
SC_RtsEntryHeader_t *Entry;
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
Entry->WakeupCount = 0;
UT_CmdBuf.StartRtsCmd.Payload.RtsNum = SC_RtsIndexToNum(RtsIndex);
@@ -225,11 +225,11 @@ void SC_StartRtsCmd_Test_RtsDisabled(void)
{
SC_RtsEntryHeader_t *Entry;
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- SC_RtsInfoEntry_t * RtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
Entry->WakeupCount = 0;
UT_CmdBuf.StartRtsCmd.Payload.RtsNum = SC_RtsIndexToNum(RtsIndex);
@@ -633,8 +633,7 @@ void SC_DisableRtsCmd_Test_Nominal(void)
UtAssert_True(RtsInfoPtr->DisabledFlag == true, "RtsInfoPtr->DisabledFlag == true");
UtAssert_True(SC_OperData.HkPacket.Payload.CmdCtr == 1, "SC_OperData.HkPacket.Payload.CmdCtr == 1");
- UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID,
- SC_DISABLE_RTS_INF_EID);
+ UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, SC_DISABLE_RTS_INF_EID);
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1);
}
@@ -802,8 +801,7 @@ void SC_EnableRtsCmd_Test_Nominal(void)
UtAssert_True(RtsInfoPtr->DisabledFlag == false, "RtsInfoPtr->DisabledFlag == false");
UtAssert_True(SC_OperData.HkPacket.Payload.CmdCtr == 1, "SC_OperData.HkPacket.Payload.CmdCtr == 1");
- UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID,
- SC_ENABLE_RTS_INF_EID);
+ UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, SC_ENABLE_RTS_INF_EID);
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1);
}
@@ -987,7 +985,8 @@ void SC_KillRts_Test(void)
/* Verify results */
UtAssert_True(RtsInfoPtr->RtsStatus == SC_Status_LOADED, "RtsInfoPtr->RtsStatus == SC_Status_LOADED");
- UtAssert_True(RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT, "RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT");
+ UtAssert_True(RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT,
+ "RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT");
UtAssert_True(SC_OperData.RtsCtrlBlckAddr->NumRtsActive == 0, "SC_OperData.RtsCtrlBlckAddr->NumRtsActive == 0");
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0);
@@ -1008,7 +1007,8 @@ void SC_KillRts_Test_NoActiveRts(void)
/* Verify results */
UtAssert_True(RtsInfoPtr->RtsStatus == SC_Status_LOADED, "RtsInfoPtr->RtsStatus == SC_Status_LOADED");
- UtAssert_True(RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT, "RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT");
+ UtAssert_True(RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT,
+ "RtsInfoPtr->NextCommandTgtWakeup == SC_MAX_WAKEUP_CNT");
UtAssert_True(SC_OperData.RtsCtrlBlckAddr->NumRtsActive == 0, "SC_OperData.RtsCtrlBlckAddr->NumRtsActive == 0");
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0);
@@ -1064,91 +1064,157 @@ void SC_AutoStartRts_Test_InvalidIdZero(void)
void UtTest_Setup(void)
{
UtTest_Add(SC_StartRtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsCmd_Test_Nominal");
- UtTest_Add(SC_StartRtsCmd_Test_StartRtsNoEvents, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsCmd_Test_StartRtsNoEvents,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsCmd_Test_StartRtsNoEvents");
- UtTest_Add(SC_StartRtsCmd_Test_InvalidCommandLength1, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsCmd_Test_InvalidCommandLength1,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsCmd_Test_InvalidCommandLength1");
- UtTest_Add(SC_StartRtsCmd_Test_InvalidCommandLength2, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsCmd_Test_InvalidCommandLength2,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsCmd_Test_InvalidCommandLength2");
- UtTest_Add(SC_StartRtsCmd_Test_RtsNotLoadedOrInUse, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsCmd_Test_RtsNotLoadedOrInUse,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsCmd_Test_RtsNotLoadedOrInUse");
UtTest_Add(SC_StartRtsCmd_Test_RtsDisabled, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsCmd_Test_RtsDisabled");
UtTest_Add(SC_StartRtsCmd_Test_InvalidRtsNum, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsCmd_Test_InvalidRtsNum");
- UtTest_Add(SC_StartRtsCmd_Test_InvalidRtsNumZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsCmd_Test_InvalidRtsNumZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsCmd_Test_InvalidRtsNumZero");
UtTest_Add(SC_StartRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsGrpCmd_Test_Nominal");
- UtTest_Add(SC_StartRtsGrpCmd_Test_StartRtsGroupError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsGrpCmd_Test_StartRtsGroupError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsGrpCmd_Test_StartRtsGroupError");
- UtTest_Add(SC_StartRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsGrpCmd_Test_FirstRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsGrpCmd_Test_FirstRtsIndex");
- UtTest_Add(SC_StartRtsGrpCmd_Test_FirstRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsGrpCmd_Test_FirstRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsGrpCmd_Test_FirstRtsIndexZero");
- UtTest_Add(SC_StartRtsGrpCmd_Test_LastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsGrpCmd_Test_LastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsGrpCmd_Test_LastRtsIndex");
- UtTest_Add(SC_StartRtsGrpCmd_Test_LastRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsGrpCmd_Test_LastRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsGrpCmd_Test_LastRtsIndexZero");
- UtTest_Add(SC_StartRtsGrpCmd_Test_FirstLastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsGrpCmd_Test_FirstLastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsGrpCmd_Test_FirstLastRtsIndex");
- UtTest_Add(SC_StartRtsGrpCmd_Test_DisabledFlag, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StartRtsGrpCmd_Test_DisabledFlag,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StartRtsGrpCmd_Test_DisabledFlag");
UtTest_Add(SC_StartRtsGrpCmd_Test_RtsStatus, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsGrpCmd_Test_RtsStatus");
UtTest_Add(SC_StopRtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsCmd_Test_Nominal");
UtTest_Add(SC_StopRtsCmd_Test_InvalidRts, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsCmd_Test_InvalidRts");
UtTest_Add(SC_StopRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsGrpCmd_Test_Nominal");
UtTest_Add(SC_StopRtsGrpCmd_Test_Error, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsGrpCmd_Test_Error");
- UtTest_Add(SC_StopRtsGrpCmd_Test_NotExecuting, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StopRtsGrpCmd_Test_NotExecuting,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StopRtsGrpCmd_Test_NotExecuting");
- UtTest_Add(SC_StopRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StopRtsGrpCmd_Test_FirstRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StopRtsGrpCmd_Test_FirstRtsIndex");
- UtTest_Add(SC_StopRtsGrpCmd_Test_FirstRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StopRtsGrpCmd_Test_FirstRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StopRtsGrpCmd_Test_FirstRtsIndexZero");
- UtTest_Add(SC_StopRtsGrpCmd_Test_LastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StopRtsGrpCmd_Test_LastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StopRtsGrpCmd_Test_LastRtsIndex");
- UtTest_Add(SC_StopRtsGrpCmd_Test_LastRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StopRtsGrpCmd_Test_LastRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StopRtsGrpCmd_Test_LastRtsIndexZero");
- UtTest_Add(SC_StopRtsGrpCmd_Test_FirstLastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_StopRtsGrpCmd_Test_FirstLastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_StopRtsGrpCmd_Test_FirstLastRtsIndex");
UtTest_Add(SC_DisableRtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsCmd_Test_Nominal");
- UtTest_Add(SC_DisableRtsCmd_Test_InvalidRtsID, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_DisableRtsCmd_Test_InvalidRtsID,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_DisableRtsCmd_Test_InvalidRtsID");
UtTest_Add(SC_DisableRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsGrpCmd_Test_Nominal");
UtTest_Add(SC_DisableRtsGrpCmd_Test_Error, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsGrpCmd_Test_Error");
- UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_DisableRtsGrpCmd_Test_FirstRtsIndex");
- UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_DisableRtsGrpCmd_Test_FirstRtsIndexZero");
- UtTest_Add(SC_DisableRtsGrpCmd_Test_LastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_DisableRtsGrpCmd_Test_LastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_DisableRtsGrpCmd_Test_LastRtsIndex");
- UtTest_Add(SC_DisableRtsGrpCmd_Test_LastRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_DisableRtsGrpCmd_Test_LastRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_DisableRtsGrpCmd_Test_LastRtsIndexZero");
- UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstLastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstLastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_DisableRtsGrpCmd_Test_FirstLastRtsIndex");
- UtTest_Add(SC_DisableRtsGrpCmd_Test_DisabledFlag, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_DisableRtsGrpCmd_Test_DisabledFlag,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_DisableRtsGrpCmd_Test_DisabledFlag");
UtTest_Add(SC_EnableRtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsCmd_Test_Nominal");
UtTest_Add(SC_EnableRtsCmd_Test_InvalidRtsID, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsCmd_Test_InvalidRtsID");
- UtTest_Add(SC_EnableRtsCmd_Test_InvalidRtsIDZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_EnableRtsCmd_Test_InvalidRtsIDZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_EnableRtsCmd_Test_InvalidRtsIDZero");
UtTest_Add(SC_EnableRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsGrpCmd_Test_Nominal");
UtTest_Add(SC_EnableRtsGrpCmd_Test_Error, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsGrpCmd_Test_Error");
- UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_EnableRtsGrpCmd_Test_FirstRtsIndex");
- UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_EnableRtsGrpCmd_Test_FirstRtsIndexZero");
- UtTest_Add(SC_EnableRtsGrpCmd_Test_LastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_EnableRtsGrpCmd_Test_LastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_EnableRtsGrpCmd_Test_LastRtsIndex");
- UtTest_Add(SC_EnableRtsGrpCmd_Test_LastRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_EnableRtsGrpCmd_Test_LastRtsIndexZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_EnableRtsGrpCmd_Test_LastRtsIndexZero");
- UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstLastRtsIndex, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstLastRtsIndex,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_EnableRtsGrpCmd_Test_FirstLastRtsIndex");
- UtTest_Add(SC_EnableRtsGrpCmd_Test_DisabledFlag, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_EnableRtsGrpCmd_Test_DisabledFlag,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_EnableRtsGrpCmd_Test_DisabledFlag");
UtTest_Add(SC_KillRts_Test, SC_Test_Setup, SC_Test_TearDown, "SC_KillRts_Test");
UtTest_Add(SC_KillRts_Test_NoActiveRts, SC_Test_Setup, SC_Test_TearDown, "SC_KillRts_Test_NoActiveRts");
UtTest_Add(SC_KillRts_Test_InvalidIndex, SC_Test_Setup, SC_Test_TearDown, "SC_KillRts_Test_InvalidIndex");
UtTest_Add(SC_AutoStartRts_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_AutoStartRts_Test_Nominal");
UtTest_Add(SC_AutoStartRts_Test_InvalidId, SC_Test_Setup, SC_Test_TearDown, "SC_AutoStartRts_Test_InvalidId");
- UtTest_Add(SC_AutoStartRts_Test_InvalidIdZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_AutoStartRts_Test_InvalidIdZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_AutoStartRts_Test_InvalidIdZero");
}
diff --git a/unit-test/sc_state_tests.c b/unit-test/sc_state_tests.c
index 7c431ba..9a17dea 100644
--- a/unit-test/sc_state_tests.c
+++ b/unit-test/sc_state_tests.c
@@ -42,7 +42,9 @@
* Function Definitions
*/
uint8 SC_STATE_TEST_GetTotalMsgLengthHook_RunCount;
-int32 SC_STATE_TEST_CFE_SB_GetTotalMsgLengthHook(void *UserObj, int32 StubRetcode, uint32 CallCount,
+int32 SC_STATE_TEST_CFE_SB_GetTotalMsgLengthHook(void *UserObj,
+ int32 StubRetcode,
+ uint32 CallCount,
const UT_StubContext_t *Context)
{
SC_STATE_TEST_GetTotalMsgLengthHook_RunCount += 1;
@@ -60,7 +62,7 @@ void SC_GetNextRtsTime_Test_Nominal(void)
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
- RtsInfoPtr->RtsStatus = SC_Status_EXECUTING;
+ RtsInfoPtr->RtsStatus = SC_Status_EXECUTING;
RtsInfoPtr->NextCommandTgtWakeup = SC_MAX_WAKEUP_CNT;
/* Execute the function being tested */
@@ -68,7 +70,8 @@ void SC_GetNextRtsTime_Test_Nominal(void)
/* Verify results */
SC_Assert_ID_VALUE(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum, 1);
- UtAssert_True(SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT, "SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT");
+ UtAssert_True(SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT,
+ "SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT");
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0);
}
@@ -104,10 +107,10 @@ void SC_GetNextRtsTime_Test_RtsPriority(void)
RtsInfoPtr0 = SC_GetRtsInfoObject(SC_RTS_IDX_C(0));
RtsInfoPtr1 = SC_GetRtsInfoObject(SC_RTS_IDX_C(1));
- RtsInfoPtr0->RtsStatus = SC_Status_EXECUTING;
+ RtsInfoPtr0->RtsStatus = SC_Status_EXECUTING;
RtsInfoPtr0->NextCommandTgtWakeup = SC_MAX_WAKEUP_CNT;
- RtsInfoPtr1->RtsStatus = SC_Status_EXECUTING;
+ RtsInfoPtr1->RtsStatus = SC_Status_EXECUTING;
RtsInfoPtr1->NextCommandTgtWakeup = SC_MAX_WAKEUP_CNT - 1;
/* Execute the function being tested */
@@ -115,7 +118,8 @@ void SC_GetNextRtsTime_Test_RtsPriority(void)
/* Verify results */
SC_Assert_ID_VALUE(SC_OperData.RtsCtrlBlckAddr->CurrRtsNum, 2);
- UtAssert_True(SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT - 1, "SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT - 1");
+ UtAssert_True(SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT - 1,
+ "SC_AppData.NextCmdTime[SC_Process_RTP] == SC_MAX_WAKEUP_CNT - 1");
UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0);
}
@@ -267,8 +271,8 @@ void SC_GetNextRtsCommand_Test_RtsLengthError(void)
uint32 EntryOffsetVal;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- SC_RtsInfoEntry_t * RtsInfoPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
AtsInfoPtr = SC_GetAtsInfoObject(AtsIndex);
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
@@ -319,8 +323,8 @@ void SC_GetNextRtsCommand_Test_CommandLengthError(void)
uint32 EntryOffsetVal;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- SC_RtsInfoEntry_t * RtsInfoPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
AtsInfoPtr = SC_GetAtsInfoObject(AtsIndex);
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
@@ -371,8 +375,8 @@ void SC_GetNextRtsCommand_Test_ZeroCommandLength(void)
uint32 EntryOffsetVal;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(SC_LAST_RTS_WITH_EVENTS - 1);
- SC_RtsInfoEntry_t * RtsInfoPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
AtsInfoPtr = SC_GetAtsInfoObject(AtsIndex);
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
@@ -416,8 +420,8 @@ void SC_GetNextRtsCommand_Test_ZeroCommandLengthLastRts(void)
uint32 EntryOffsetVal;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(SC_LAST_RTS_WITH_EVENTS);
- SC_RtsInfoEntry_t * RtsInfoPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
/* This test intended to test the first event suppressed RTS, skip if none are suppressed */
if (SC_LAST_RTS_WITH_EVENTS != SC_NUMBER_OF_RTS)
@@ -430,9 +434,9 @@ void SC_GetNextRtsCommand_Test_ZeroCommandLengthLastRts(void)
SC_OperData.RtsCtrlBlckAddr->CurrRtsNum = SC_RtsIndexToNum(RtsIndex);
RtsInfoPtr->RtsStatus = SC_Status_EXECUTING;
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
- EntryOffsetVal =
- SC_RTS_BUFF_SIZE32 - SC_RTS_HDR_WORDS - ((SC_PACKET_MIN_SIZE + SC_RTS_HEADER_SIZE + 3) / SC_BYTES_IN_WORD) - 1;
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ EntryOffsetVal = SC_RTS_BUFF_SIZE32 - SC_RTS_HDR_WORDS
+ - ((SC_PACKET_MIN_SIZE + SC_RTS_HEADER_SIZE + 3) / SC_BYTES_IN_WORD) - 1;
/* Set to generate error message SC_RTS_LNGTH_ERR_EID */
CFE_MSG_Init((CFE_MSG_Message_t *)Entry, CFE_SB_ValueToMsgId(SC_CMD_MID), SC_PACKET_MIN_SIZE - 1);
@@ -463,8 +467,8 @@ void SC_GetNextRtsCommand_Test_EndOfBuffer(void)
uint32 EntryOffsetVal;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(0);
- SC_RtsInfoEntry_t * RtsInfoPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
AtsInfoPtr = SC_GetAtsInfoObject(AtsIndex);
RtsInfoPtr = SC_GetRtsInfoObject(RtsIndex);
@@ -505,8 +509,8 @@ void SC_GetNextRtsCommand_Test_EndOfBufferLastRts(void)
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
uint32 EntryOffsetVal;
SC_RtsIndex_t RtsIndex = SC_RTS_IDX_C(SC_LAST_RTS_WITH_EVENTS);
- SC_RtsInfoEntry_t * RtsInfoPtr;
- SC_AtsInfoTable_t * AtsInfoPtr;
+ SC_RtsInfoEntry_t *RtsInfoPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
/* This test intended to test the first event suppressed RTS, skip if none are suppressed */
if (SC_LAST_RTS_WITH_EVENTS != SC_NUMBER_OF_RTS)
@@ -519,9 +523,9 @@ void SC_GetNextRtsCommand_Test_EndOfBufferLastRts(void)
SC_OperData.RtsCtrlBlckAddr->CurrRtsNum = SC_RtsIndexToNum(RtsIndex);
RtsInfoPtr->RtsStatus = SC_Status_EXECUTING;
- Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
- EntryOffsetVal =
- SC_RTS_BUFF_SIZE32 - SC_RTS_HDR_WORDS - ((SC_PACKET_MIN_SIZE + SC_RTS_HEADER_SIZE + 3) / SC_BYTES_IN_WORD) - 1;
+ Entry = (SC_RtsEntryHeader_t *)SC_GetRtsEntryAtOffset(RtsIndex, SC_ENTRY_OFFSET_FIRST);
+ EntryOffsetVal = SC_RTS_BUFF_SIZE32 - SC_RTS_HDR_WORDS
+ - ((SC_PACKET_MIN_SIZE + SC_RTS_HEADER_SIZE + 3) / SC_BYTES_IN_WORD) - 1;
/* Set to generate error message SC_RTS_LNGTH_ERR_EID */
CFE_MSG_Init((CFE_MSG_Message_t *)Entry, CFE_SB_ValueToMsgId(SC_CMD_MID), 2 * SC_RTS_BUFF_SIZE);
@@ -577,10 +581,10 @@ void SC_GetNextAtsCommand_Test_Idle(void)
void SC_GetNextAtsCommand_Test_GetNextCommand(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsInfoTable_t * AtsInfoPtr;
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsInfoTable_t *AtsInfoPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -616,9 +620,9 @@ void SC_GetNextAtsCommand_Test_GetNextCommand(void)
void SC_GetNextAtsCommand_Test_ExecutionACompleted(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(0);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -647,9 +651,9 @@ void SC_GetNextAtsCommand_Test_ExecutionACompleted(void)
void SC_GetNextAtsCommand_Test_ExecutionBCompleted(void)
{
- SC_AtsEntryHeader_t * Entry;
+ SC_AtsEntryHeader_t *Entry;
SC_AtsIndex_t AtsIndex = SC_ATS_IDX_C(1);
- SC_AtsCmdStatusEntry_t * StatusEntryPtr;
+ SC_AtsCmdStatusEntry_t *StatusEntryPtr;
SC_AtsCmdEntryOffsetRecord_t *CmdOffsetRec;
CmdOffsetRec = SC_GetAtsEntryOffsetForCmd(AtsIndex, SC_COMMAND_IDX_C(0));
@@ -679,39 +683,73 @@ void SC_GetNextAtsCommand_Test_ExecutionBCompleted(void)
void UtTest_Setup(void)
{
UtTest_Add(SC_GetNextRtsTime_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_GetNextRtsTime_Test_Nominal");
- UtTest_Add(SC_GetNextRtsTime_Test_InvalidRtsNum, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsTime_Test_InvalidRtsNum,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsTime_Test_InvalidRtsNum");
- UtTest_Add(SC_GetNextRtsTime_Test_RtsPriority, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsTime_Test_RtsPriority,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsTime_Test_RtsPriority");
- UtTest_Add(SC_GetNextRtsCommand_Test_GetNextCommand, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_GetNextCommand,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_GetNextCommand");
- UtTest_Add(SC_GetNextRtsCommand_Test_RtsNumZero, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_RtsNumZero,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_RtsNumZero");
- UtTest_Add(SC_GetNextRtsCommand_Test_RtsNumMax, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_RtsNumMax,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_RtsNumMax");
- UtTest_Add(SC_GetNextRtsCommand_Test_RtsNumOverMax, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_RtsNumOverMax,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_RtsNumOverMax");
- UtTest_Add(SC_GetNextRtsCommand_Test_RtsNotExecuting, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_RtsNotExecuting,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_RtsNotExecuting");
- UtTest_Add(SC_GetNextRtsCommand_Test_RtsLengthError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_RtsLengthError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_RtsLengthError");
- UtTest_Add(SC_GetNextRtsCommand_Test_CommandLengthError, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_CommandLengthError,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_CommandLengthError");
- UtTest_Add(SC_GetNextRtsCommand_Test_ZeroCommandLength, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_ZeroCommandLength,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_ZeroCommandLength");
- UtTest_Add(SC_GetNextRtsCommand_Test_ZeroCommandLengthLastRts, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_ZeroCommandLengthLastRts,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_ZeroCommandLengthLastRts");
- UtTest_Add(SC_GetNextRtsCommand_Test_EndOfBufferLastRts, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_EndOfBufferLastRts,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_EndOfBufferLastRts");
- UtTest_Add(SC_GetNextRtsCommand_Test_EndOfBuffer, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextRtsCommand_Test_EndOfBuffer,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextRtsCommand_Test_EndOfBuffer");
- UtTest_Add(SC_GetNextAtsCommand_Test_Starting, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextAtsCommand_Test_Starting,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextAtsCommand_Test_Starting");
UtTest_Add(SC_GetNextAtsCommand_Test_Idle, SC_Test_Setup, SC_Test_TearDown, "SC_GetNextAtsCommand_Test_Idle");
- UtTest_Add(SC_GetNextAtsCommand_Test_GetNextCommand, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextAtsCommand_Test_GetNextCommand,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextAtsCommand_Test_GetNextCommand");
- UtTest_Add(SC_GetNextAtsCommand_Test_ExecutionACompleted, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextAtsCommand_Test_ExecutionACompleted,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextAtsCommand_Test_ExecutionACompleted");
- UtTest_Add(SC_GetNextAtsCommand_Test_ExecutionBCompleted, SC_Test_Setup, SC_Test_TearDown,
+ UtTest_Add(SC_GetNextAtsCommand_Test_ExecutionBCompleted,
+ SC_Test_Setup,
+ SC_Test_TearDown,
"SC_GetNextAtsCommand_Test_ExecutionBCompleted");
}
diff --git a/unit-test/sc_utils_tests.c b/unit-test/sc_utils_tests.c
index 620baee..d6b9c7d 100644
--- a/unit-test/sc_utils_tests.c
+++ b/unit-test/sc_utils_tests.c
@@ -31,7 +31,7 @@
static CFE_TIME_SysTime_t UT_TimeRefFunc(void)
{
- return (CFE_TIME_SysTime_t) {1234, 5678};
+ return (CFE_TIME_SysTime_t) { 1234, 5678 };
}
void SC_LookupTimeAccessor_Test(void)
@@ -39,7 +39,7 @@ void SC_LookupTimeAccessor_Test(void)
union
{
SC_TimeAccessor_t Obj;
- void * Addr;
+ void *Addr;
} Accessor;
Accessor.Addr = NULL;
@@ -53,7 +53,7 @@ void SC_LookupTimeAccessor_Test(void)
void SC_GetCurrentTime_Test(void)
{
- SC_AppData.TimeRef = (SC_TimeAccessor_t) {UT_TimeRefFunc};
+ SC_AppData.TimeRef = (SC_TimeAccessor_t) { UT_TimeRefFunc };
SC_AppData.CurrentTime = 0;
/* Execute the function being tested */
@@ -92,8 +92,8 @@ void SC_ComputeAbsWakeup_Test(void)
void SC_CompareAbsTime_Test_True(void)
{
- SC_AbsTimeTag_t AbsTimeTag1 = {0};
- SC_AbsTimeTag_t AbsTimeTag2 = {0};
+ SC_AbsTimeTag_t AbsTimeTag1 = { 0 };
+ SC_AbsTimeTag_t AbsTimeTag2 = { 0 };
UT_SetDeferredRetcode(UT_KEY(CFE_TIME_Compare), 1, CFE_TIME_A_GT_B);
@@ -103,8 +103,8 @@ void SC_CompareAbsTime_Test_True(void)
void SC_CompareAbsTime_Test_False(void)
{
- SC_AbsTimeTag_t AbsTimeTag1 = {0};
- SC_AbsTimeTag_t AbsTimeTag2 = {0};
+ SC_AbsTimeTag_t AbsTimeTag1 = { 0 };
+ SC_AbsTimeTag_t AbsTimeTag2 = { 0 };
UT_SetDeferredRetcode(UT_KEY(CFE_TIME_Compare), 1, -1);
diff --git a/unit-test/stubs/sc_app_stubs.c b/unit-test/stubs/sc_app_stubs.c
index 88a761c..f539d0b 100644
--- a/unit-test/stubs/sc_app_stubs.c
+++ b/unit-test/stubs/sc_app_stubs.c
@@ -46,7 +46,6 @@ CFE_Status_t SC_AppInit(void)
*/
void SC_AppMain(void)
{
-
UT_GenStub_Execute(SC_AppMain, Basic, NULL);
}
@@ -99,7 +98,6 @@ CFE_Status_t SC_InitTables(void)
*/
void SC_LoadDefaultTables(void)
{
-
UT_GenStub_Execute(SC_LoadDefaultTables, Basic, NULL);
}
@@ -152,6 +150,5 @@ CFE_Status_t SC_RegisterLoadableTables(void)
*/
void SC_RegisterManageCmds(void)
{
-
UT_GenStub_Execute(SC_RegisterManageCmds, Basic, NULL);
}
diff --git a/unit-test/stubs/sc_atsrq_stubs.c b/unit-test/stubs/sc_atsrq_stubs.c
index 7d49e7d..4091705 100644
--- a/unit-test/stubs/sc_atsrq_stubs.c
+++ b/unit-test/stubs/sc_atsrq_stubs.c
@@ -111,7 +111,6 @@ CFE_Status_t SC_JumpAtsCmd(const SC_JumpAtsCmd_t *Cmd)
*/
void SC_KillAts(void)
{
-
UT_GenStub_Execute(SC_KillAts, Basic, NULL);
}
@@ -122,7 +121,6 @@ void SC_KillAts(void)
*/
void SC_ServiceSwitchPend(void)
{
-
UT_GenStub_Execute(SC_ServiceSwitchPend, Basic, NULL);
}
diff --git a/unit-test/stubs/sc_cmds_stubs.c b/unit-test/stubs/sc_cmds_stubs.c
index eda8ff3..52ab8ad 100644
--- a/unit-test/stubs/sc_cmds_stubs.c
+++ b/unit-test/stubs/sc_cmds_stubs.c
@@ -101,7 +101,6 @@ CFE_Status_t SC_NoopCmd(const SC_NoopCmd_t *Cmd)
*/
void SC_ProcessAtpCmd(void)
{
-
UT_GenStub_Execute(SC_ProcessAtpCmd, Basic, NULL);
}
@@ -112,7 +111,6 @@ void SC_ProcessAtpCmd(void)
*/
void SC_ProcessRtpCommand(void)
{
-
UT_GenStub_Execute(SC_ProcessRtpCommand, Basic, NULL);
}
@@ -155,7 +153,6 @@ CFE_Status_t SC_SendHkCmd(const SC_SendHkCmd_t *Cmd)
*/
void SC_SendHkPacket(void)
{
-
UT_GenStub_Execute(SC_SendHkPacket, Basic, NULL);
}
diff --git a/unit-test/stubs/sc_loads_stubs.c b/unit-test/stubs/sc_loads_stubs.c
index 81a8b06..26e938f 100644
--- a/unit-test/stubs/sc_loads_stubs.c
+++ b/unit-test/stubs/sc_loads_stubs.c
@@ -120,7 +120,6 @@ void SC_ProcessAppend(SC_AtsIndex_t AtsIndex)
*/
void SC_UpdateAppend(void)
{
-
UT_GenStub_Execute(SC_UpdateAppend, Basic, NULL);
}
diff --git a/unit-test/stubs/sc_state_stubs.c b/unit-test/stubs/sc_state_stubs.c
index cc0380b..99bd3a2 100644
--- a/unit-test/stubs/sc_state_stubs.c
+++ b/unit-test/stubs/sc_state_stubs.c
@@ -32,7 +32,6 @@
*/
void SC_GetNextAtsCommand(void)
{
-
UT_GenStub_Execute(SC_GetNextAtsCommand, Basic, NULL);
}
@@ -43,7 +42,6 @@ void SC_GetNextAtsCommand(void)
*/
void SC_GetNextRtsCommand(void)
{
-
UT_GenStub_Execute(SC_GetNextRtsCommand, Basic, NULL);
}
@@ -54,6 +52,5 @@ void SC_GetNextRtsCommand(void)
*/
void SC_GetNextRtsTime(void)
{
-
UT_GenStub_Execute(SC_GetNextRtsTime, Basic, NULL);
}
diff --git a/unit-test/stubs/sc_utils_stubs.c b/unit-test/stubs/sc_utils_stubs.c
index 078b475..f925e48 100644
--- a/unit-test/stubs/sc_utils_stubs.c
+++ b/unit-test/stubs/sc_utils_stubs.c
@@ -97,7 +97,6 @@ SC_AbsTimeTag_t SC_GetAtsEntryTime(SC_AtsEntryHeader_t *Entry)
*/
void SC_GetCurrentTime(void)
{
-
UT_GenStub_Execute(SC_GetCurrentTime, Basic, NULL);
}
diff --git a/unit-test/utilities/sc_test_utils.c b/unit-test/utilities/sc_test_utils.c
index cef366f..dabb356 100644
--- a/unit-test/utilities/sc_test_utils.c
+++ b/unit-test/utilities/sc_test_utils.c
@@ -62,7 +62,8 @@ void UT_Handler_CFE_EVS_SendEvent(void *UserObj, UT_EntryKey_t FuncKey, const UT
if (CallCount > (sizeof(context_CFE_EVS_SendEvent) / sizeof(context_CFE_EVS_SendEvent[0])))
{
UtAssert_Failed("CFE_EVS_SendEvent UT depth %u exceeded: %u, increase UT_MAX_SENDEVENT_DEPTH",
- UT_MAX_SENDEVENT_DEPTH, CallCount);
+ UT_MAX_SENDEVENT_DEPTH,
+ CallCount);
}
else
{
@@ -70,7 +71,8 @@ void UT_Handler_CFE_EVS_SendEvent(void *UserObj, UT_EntryKey_t FuncKey, const UT
context_CFE_EVS_SendEvent[idx].EventID = UT_Hook_GetArgValueByName(Context, "EventID", uint16);
context_CFE_EVS_SendEvent[idx].EventType = UT_Hook_GetArgValueByName(Context, "EventType", uint16);
- strncpy(context_CFE_EVS_SendEvent[idx].Spec, UT_Hook_GetArgValueByName(Context, "Spec", const char *),
+ strncpy(context_CFE_EVS_SendEvent[idx].Spec,
+ UT_Hook_GetArgValueByName(Context, "Spec", const char *),
CFE_MISSION_EVS_MAX_MESSAGE_LENGTH);
context_CFE_EVS_SendEvent[idx].Spec[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1] = '\0';
}
@@ -78,7 +80,8 @@ void UT_Handler_CFE_EVS_SendEvent(void *UserObj, UT_EntryKey_t FuncKey, const UT
void UT_Handler_CFE_ES_WriteToSysLog(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context, va_list va)
{
- strncpy(context_CFE_ES_WriteToSysLog.Spec, UT_Hook_GetArgValueByName(Context, "SpecStringPtr", const char *),
+ strncpy(context_CFE_ES_WriteToSysLog.Spec,
+ UT_Hook_GetArgValueByName(Context, "SpecStringPtr", const char *),
CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1);
context_CFE_ES_WriteToSysLog.Spec[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1] = '\0';
}
@@ -106,7 +109,6 @@ void SC_Test_SetTableAddrs(void)
void SC_Test_Setup(void)
{
-
/* initialize test environment to default state for every test */
UT_ResetState(0);
diff --git a/unit-test/utilities/sc_test_utils.h b/unit-test/utilities/sc_test_utils.h
index edc2ffa..936ee28 100644
--- a/unit-test/utilities/sc_test_utils.h
+++ b/unit-test/utilities/sc_test_utils.h
@@ -85,25 +85,60 @@ extern UT_CmdBuf_t UT_CmdBuf;
#define SC_UT_MID_1 CFE_SB_ValueToMsgId(1)
/* SC-specific assert macros */
-#define SC_Assert_ID_EQ(actual, ref) \
- UtAssert_GenericUnsignedCompare(SC_IDNUM_AS_UINT(actual), UtAssert_Compare_EQ, SC_IDNUM_AS_UINT(ref), \
- UtAssert_Radix_DECIMAL, __FILE__, __LINE__, "ID", #actual, #ref)
-
-#define SC_Assert_ID_VALUE(actual, ref) \
- UtAssert_GenericUnsignedCompare(SC_IDNUM_AS_UINT(actual), UtAssert_Compare_EQ, (unsigned int)(ref), \
- UtAssert_Radix_DECIMAL, __FILE__, __LINE__, "IDV", #actual, #ref)
-
-#define SC_Assert_IDX_EQ(actual, ref) \
- UtAssert_GenericUnsignedCompare(SC_IDX_AS_UINT(actual), UtAssert_Compare_EQ, SC_IDX_AS_UINT(ref), \
- UtAssert_Radix_DECIMAL, __FILE__, __LINE__, "IDX", #actual, #ref)
-
-#define SC_Assert_IDX_VALUE(actual, ref) \
- UtAssert_GenericUnsignedCompare(SC_IDX_AS_UINT(actual), UtAssert_Compare_EQ, (unsigned int)(ref), \
- UtAssert_Radix_DECIMAL, __FILE__, __LINE__, "IDXV", #actual, #ref)
-
-#define SC_Assert_CmdStatus(actual, ref) \
- UtAssert_GenericUnsignedCompare((unsigned long)(actual), UtAssert_Compare_EQ, (unsigned long)(ref), \
- UtAssert_Radix_DECIMAL, __FILE__, __LINE__, "Status", #actual, #ref)
+#define SC_Assert_ID_EQ(actual, ref) \
+ UtAssert_GenericUnsignedCompare(SC_IDNUM_AS_UINT(actual), \
+ UtAssert_Compare_EQ, \
+ SC_IDNUM_AS_UINT(ref), \
+ UtAssert_Radix_DECIMAL, \
+ __FILE__, \
+ __LINE__, \
+ "ID", \
+ #actual, \
+ #ref)
+
+#define SC_Assert_ID_VALUE(actual, ref) \
+ UtAssert_GenericUnsignedCompare(SC_IDNUM_AS_UINT(actual), \
+ UtAssert_Compare_EQ, \
+ (unsigned int)(ref), \
+ UtAssert_Radix_DECIMAL, \
+ __FILE__, \
+ __LINE__, \
+ "IDV", \
+ #actual, \
+ #ref)
+
+#define SC_Assert_IDX_EQ(actual, ref) \
+ UtAssert_GenericUnsignedCompare(SC_IDX_AS_UINT(actual), \
+ UtAssert_Compare_EQ, \
+ SC_IDX_AS_UINT(ref), \
+ UtAssert_Radix_DECIMAL, \
+ __FILE__, \
+ __LINE__, \
+ "IDX", \
+ #actual, \
+ #ref)
+
+#define SC_Assert_IDX_VALUE(actual, ref) \
+ UtAssert_GenericUnsignedCompare(SC_IDX_AS_UINT(actual), \
+ UtAssert_Compare_EQ, \
+ (unsigned int)(ref), \
+ UtAssert_Radix_DECIMAL, \
+ __FILE__, \
+ __LINE__, \
+ "IDXV", \
+ #actual, \
+ #ref)
+
+#define SC_Assert_CmdStatus(actual, ref) \
+ UtAssert_GenericUnsignedCompare((unsigned long)(actual), \
+ UtAssert_Compare_EQ, \
+ (unsigned long)(ref), \
+ UtAssert_Radix_DECIMAL, \
+ __FILE__, \
+ __LINE__, \
+ "Status", \
+ #actual, \
+ #ref)
/*
* Function Definitions