nasa/fprime
1
0
Fork 0
mirror of https://github.com/nasa/fprime.git synced 2025-12-10 00:44:37 -06:00
Code Issues Packages Projects Releases 34 Wiki Activity

Svc: Convert C style casts to C++ style casts

Browse Source
This commit is contained in:
Joshua Anderson 2021-08-31 10:05:51 -07:00
parent f4b601c186
commit 05f4557ca8
No known key found for this signature in database
GPG Key ID: 041556EA8799A403
25 changed files with 217 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Svc/ActiveLogger/test/ut/ActiveLoggerImplTester.cpp
View File

@ -123,7 +123,7 @@ namespace Svc {
FwPacketDescriptorType desc;
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,(FwPacketDescriptorType)Fw::ComPacket::FW_PACKET_LOG);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
FwEventIdType sentId;
stat = this->m_sentPacket.deserialize(sentId);
@ -140,7 +140,7 @@ namespace Svc {
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, val);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),(NATIVE_UINT_TYPE)0);
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
// Disable severity filter
this->clearHistory();
@ -216,7 +216,7 @@ namespace Svc {
void ActiveLoggerImplTester::runFilterEventNominal() {
for (Fw::LogSeverity::t sev = Fw::LogSeverity::WARNING_HI; sev <= Fw::LogSeverity::DIAGNOSTIC; sev = (Fw::LogSeverity::t)((NATIVE_INT_TYPE)sev + 1)) {
for (Fw::LogSeverity::t sev = Fw::LogSeverity::WARNING_HI; sev <= Fw::LogSeverity::DIAGNOSTIC; sev = static_cast<Fw::LogSeverity::t>(sev + 1)) {
this->runWithFilters(sev);
}
@ -456,7 +456,7 @@ namespace Svc {
FwPacketDescriptorType desc;
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,(FwPacketDescriptorType)Fw::ComPacket::FW_PACKET_LOG);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
FwEventIdType sentId;
stat = this->m_sentPacket.deserialize(sentId);
@ -473,7 +473,7 @@ namespace Svc {
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, val);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),(NATIVE_UINT_TYPE)0);
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
// Turn on all filters and make sure FATAL still gets through
this->clearHistory();
@ -508,7 +508,7 @@ namespace Svc {
// first piece should be log packet descriptor
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,(FwPacketDescriptorType)Fw::ComPacket::FW_PACKET_LOG);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
stat = this->m_sentPacket.deserialize(sentId);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
@ -522,7 +522,7 @@ namespace Svc {
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, val);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),(NATIVE_UINT_TYPE)0);
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
// turn off filters
@ -557,7 +557,7 @@ namespace Svc {
FwPacketDescriptorType desc;
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,(FwPacketDescriptorType)Fw::ComPacket::FW_PACKET_LOG);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
FwEventIdType sentId;
stat = this->m_sentPacket.deserialize(sentId);
@ -574,7 +574,7 @@ namespace Svc {
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, value);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),(NATIVE_UINT_TYPE)0);
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
}
@ -585,7 +585,7 @@ namespace Svc {
BYTE de;
NATIVE_INT_TYPE readSize = sizeof(de);
ASSERT_EQ(file.read((void*)&de,readSize,true),Os::File::OP_OK);
ASSERT_EQ(file.read(&de,readSize,true),Os::File::OP_OK);
ASSERT_EQ(delimiter,de);
// next is LogPacket
Fw::ComBuffer comBuff;

38
Svc/ActiveRateGroup/test/ut/ActiveRateGroupImplTester.cpp
View File

@ -43,7 +43,7 @@ namespace Svc {
}
void ActiveRateGroupImplTester::from_RateGroupMemberOut_handler(NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context) {
ASSERT_TRUE(portNum < (NATIVE_INT_TYPE)FW_NUM_ARRAY_ELEMENTS(m_impl.m_RateGroupMemberOut_OutputPort));
ASSERT_TRUE(portNum < static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(m_impl.m_RateGroupMemberOut_OutputPort)));
this->m_callLog[portNum].portCalled = true;
this->m_callLog[portNum].contextVal = context;
this->m_callLog[portNum].order = this->m_callOrder++;
@ -97,7 +97,7 @@ namespace Svc {
// check calls
REQUIREMENT("ARG-002");
for (NATIVE_UINT_TYPE portNum = 0; portNum <
(NATIVE_INT_TYPE)FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort); portNum++) {
static_cast<NATIVE_UINT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort)); portNum++) {
ASSERT_TRUE(this->m_callLog[portNum].portCalled);
ASSERT_EQ(this->m_callLog[portNum].contextVal,contexts[portNum]);
ASSERT_EQ(this->m_callLog[portNum].order,portNum);
@ -150,17 +150,17 @@ namespace Svc {
// verify cycle started flag is still set
ASSERT_TRUE(this->m_impl.m_cycleStarted);
// verify cycle count
ASSERT_EQ(this->m_impl.m_cycles,(U32)cycle+1);
ASSERT_EQ(this->m_impl.m_cycles,static_cast<U32>(cycle)+1);
// check calls
for (NATIVE_INT_TYPE portNum = 0; portNum <
(NATIVE_INT_TYPE)FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort); portNum++) {
for (NATIVE_UINT_TYPE portNum = 0; portNum <
static_cast<NATIVE_UINT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort)); portNum++) {
ASSERT_TRUE(this->m_callLog[portNum].portCalled == true);
}
REQUIREMENT("ARG-004");
// verify overrun event
ASSERT_EVENTS_RateGroupCycleSlip_SIZE(1);
ASSERT_EVENTS_RateGroupCycleSlip(0,(U32)cycle);
ASSERT_EVENTS_RateGroupCycleSlip(0,static_cast<U32>(cycle));
// verify cycle slip counter is counting up
ASSERT_EQ(this->m_impl.m_overrunThrottle,cycle+1);
@ -172,7 +172,7 @@ namespace Svc {
ASSERT_TLM_SIZE(1);
}
ASSERT_TLM_RgCycleSlips_SIZE(1);
ASSERT_TLM_RgCycleSlips(0,(U32)(cycle+1));
ASSERT_TLM_RgCycleSlips(0,static_cast<U32>(cycle)+1);
}
@ -197,10 +197,10 @@ namespace Svc {
// verify cycle started flag is still set
ASSERT_TRUE(this->m_impl.m_cycleStarted);
// verify cycle count
ASSERT_EQ(this->m_impl.m_cycles,(U32)ACTIVE_RATE_GROUP_OVERRUN_THROTTLE+1);
ASSERT_EQ(this->m_impl.m_cycles, static_cast<U32>(ACTIVE_RATE_GROUP_OVERRUN_THROTTLE)+1);
// check calls
for (NATIVE_INT_TYPE portNum = 0; portNum <
(NATIVE_INT_TYPE)FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort); portNum++) {
for (NATIVE_UINT_TYPE portNum = 0; portNum <
static_cast<NATIVE_UINT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort)); portNum++) {
ASSERT_TRUE(this->m_callLog[portNum].portCalled == true);
}
// verify overrun event is NOT sent since throttled
@ -218,7 +218,7 @@ namespace Svc {
ASSERT_TLM_SIZE(1);
}
ASSERT_TLM_RgCycleSlips_SIZE(1);
ASSERT_TLM_RgCycleSlips(0,(U32)(ACTIVE_RATE_GROUP_OVERRUN_THROTTLE+1));
ASSERT_TLM_RgCycleSlips(0, static_cast<U32>(ACTIVE_RATE_GROUP_OVERRUN_THROTTLE)+1);
// A good cycle should count down the throttle value
@ -241,10 +241,10 @@ namespace Svc {
// verify cycle started flag is not set
ASSERT_FALSE(this->m_impl.m_cycleStarted);
// verify cycle count
ASSERT_EQ(this->m_impl.m_cycles,(U32)ACTIVE_RATE_GROUP_OVERRUN_THROTTLE+2);
ASSERT_EQ(this->m_impl.m_cycles,static_cast<U32>(ACTIVE_RATE_GROUP_OVERRUN_THROTTLE)+2);
// check calls
for (NATIVE_INT_TYPE portNum = 0; portNum <
(NATIVE_INT_TYPE)FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort); portNum++) {
for (NATIVE_UINT_TYPE portNum = 0; portNum <
static_cast<NATIVE_UINT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort)); portNum++) {
ASSERT_TRUE(this->m_callLog[portNum].portCalled == true);
}
@ -279,10 +279,10 @@ namespace Svc {
// verify cycle started flag is still set
ASSERT_TRUE(this->m_impl.m_cycleStarted);
// verify cycle count
ASSERT_EQ(this->m_impl.m_cycles,(U32)ACTIVE_RATE_GROUP_OVERRUN_THROTTLE+3);
ASSERT_EQ(this->m_impl.m_cycles,static_cast<U32>(ACTIVE_RATE_GROUP_OVERRUN_THROTTLE)+3);
// check calls
for (NATIVE_INT_TYPE portNum = 0; portNum <
(NATIVE_INT_TYPE)FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort); portNum++) {
for (NATIVE_UINT_TYPE portNum = 0; portNum <
static_cast<NATIVE_UINT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_impl.m_RateGroupMemberOut_OutputPort)); portNum++) {
ASSERT_TRUE(this->m_callLog[portNum].portCalled == true);
}
// verify overrun event is sent
@ -299,7 +299,7 @@ namespace Svc {
ASSERT_TLM_SIZE(1);
}
ASSERT_TLM_RgCycleSlips_SIZE(1);
ASSERT_TLM_RgCycleSlips(0,(U32)(ACTIVE_RATE_GROUP_OVERRUN_THROTTLE+2));
ASSERT_TLM_RgCycleSlips(0, static_cast<U32>(ACTIVE_RATE_GROUP_OVERRUN_THROTTLE)+2);
}
@ -311,7 +311,7 @@ namespace Svc {
// look for return port call
ASSERT_FROM_PORT_HISTORY_SIZE(1);
// look for key
ASSERT_from_PingOut(0,(U32)0x123);
ASSERT_from_PingOut(0, 0x123);
}

2
Svc/ActiveRateGroup/test/ut/ActiveRateGroupTester.cpp
View File

@ -27,7 +27,7 @@ void connectPorts(Svc::ActiveRateGroupImpl& impl, Svc::ActiveRateGroupImplTester
tester.connect_to_CycleIn(0,impl.get_CycleIn_InputPort(0));
for (NATIVE_INT_TYPE portNum = 0; portNum < (NATIVE_INT_TYPE)FW_NUM_ARRAY_ELEMENTS(impl.m_RateGroupMemberOut_OutputPort); portNum++) {
for (NATIVE_UINT_TYPE portNum = 0; portNum < static_cast<NATIVE_UINT_TYPE>(FW_NUM_ARRAY_ELEMENTS(impl.m_RateGroupMemberOut_OutputPort)); portNum++) {
impl.set_RateGroupMemberOut_OutputPort(portNum,tester.get_from_RateGroupMemberOut(portNum));
}

2
Svc/BufferManager/test/ut/Tester.cpp
View File

@ -241,7 +241,7 @@ namespace Svc {
// randomly return buffers
time_t t;
srand((unsigned) time(&t));
srand(static_cast<unsigned>(time(&t)));
bool returned[BIN1_NUM_BUFFERS] = {false};

94
Svc/CmdDispatcher/test/ut/CommandDispatcherImplTester.cpp
View File

@ -121,18 +121,18 @@ namespace Svc {
// verify dispatch event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched(0,(U32)testOpCode,0);
ASSERT_EVENTS_OpCodeDispatched(0,testOpCode,0);
// verify sequence table entry
ASSERT_TRUE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].seq,(U32)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].seq, 0u);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort, 0);
// verify command received
ASSERT_TRUE(this->m_cmdSendRcvd);
ASSERT_EQ(this->m_cmdSendOpCode,testOpCode);
ASSERT_EQ(this->m_cmdSendCmdSeq,(U32)0);
ASSERT_EQ(this->m_cmdSendCmdSeq,0);
// check argument
U32 checkVal;
ASSERT_EQ(this->m_cmdSendArgs.deserialize(checkVal),Fw::FW_SERIALIZE_OK);
@ -146,21 +146,21 @@ namespace Svc {
// Check dispatch table
ASSERT_FALSE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].seq,(U32)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].seq,0u);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].context,testContext);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
// Verify completed event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeCompleted_SIZE(1);
ASSERT_EVENTS_OpCodeCompleted(0,(U32)testOpCode);
ASSERT_EVENTS_OpCodeCompleted(0u,testOpCode);
REQUIREMENT("CD-004");
// Verify status passed back to port
ASSERT_TRUE(this->m_seqStatusRcvd);
ASSERT_EQ(this->m_seqStatusOpCode,(U32)testOpCode);
ASSERT_EQ(this->m_seqStatusOpCode,testOpCode);
ASSERT_EQ(this->m_seqStatusCmdSeq,testContext);
ASSERT_EQ(this->m_seqStatusCmdResponse,Fw::CmdResponse::OK);
}
@ -211,8 +211,8 @@ namespace Svc {
// send NO_OP command
this->m_seqStatusRcvd = false;
Fw::ComBuffer buff;
ASSERT_EQ(buff.serialize(FwPacketDescriptorType(Fw::ComPacket::FW_PACKET_COMMAND)),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize((FwOpcodeType)CommandDispatcherImpl::OPCODE_CMD_NO_OP),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_COMMAND)),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<FwOpcodeType>(CommandDispatcherImpl::OPCODE_CMD_NO_OP)),Fw::FW_SERIALIZE_OK);
this->clearEvents();
this->invoke_to_seqCmdBuff(0,buff,12);
@ -231,7 +231,7 @@ namespace Svc {
ASSERT_TRUE(this->m_seqStatusRcvd);
ASSERT_EQ(CommandDispatcherImpl::OPCODE_CMD_NO_OP,this->m_seqStatusOpCode);
// Verify correct context value is passed back.
ASSERT_EQ((U32)12,this->m_seqStatusCmdSeq);
ASSERT_EQ(12u,this->m_seqStatusCmdSeq);
ASSERT_EQ(this->m_seqStatusCmdResponse,Fw::CmdResponse::OK);
// send NO_OP_STRING command
@ -239,7 +239,7 @@ namespace Svc {
this->m_seqStatusRcvd = false;
buff.resetSer();
ASSERT_EQ(buff.serialize(FwPacketDescriptorType(Fw::ComPacket::FW_PACKET_COMMAND)),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize((FwOpcodeType)CommandDispatcherImpl::OPCODE_CMD_NO_OP_STRING),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(FwOpcodeType(CommandDispatcherImpl::OPCODE_CMD_NO_OP_STRING)),Fw::FW_SERIALIZE_OK);
// serialize arg1
Fw::CmdStringArg argString("BOO!");
ASSERT_EQ(buff.serialize(argString),Fw::FW_SERIALIZE_OK);
@ -259,20 +259,20 @@ namespace Svc {
// Verify status passed back to port
ASSERT_TRUE(this->m_seqStatusRcvd);
ASSERT_EQ(CommandDispatcherImpl::OPCODE_CMD_NO_OP_STRING,this->m_seqStatusOpCode);
ASSERT_EQ((U32)13,this->m_seqStatusCmdSeq);
ASSERT_EQ(13u,this->m_seqStatusCmdSeq);
ASSERT_EQ(this->m_seqStatusCmdResponse,Fw::CmdResponse::OK);
// send TEST_CMD_1 command
this->m_seqStatusRcvd = false;
buff.resetSer();
ASSERT_EQ(buff.serialize(FwPacketDescriptorType(Fw::ComPacket::FW_PACKET_COMMAND)),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize((FwOpcodeType)CommandDispatcherImpl::OPCODE_CMD_TEST_CMD_1),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_COMMAND)),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<FwOpcodeType>(CommandDispatcherImpl::OPCODE_CMD_TEST_CMD_1)),Fw::FW_SERIALIZE_OK);
// serialize arg1
ASSERT_EQ(buff.serialize((I32)1),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<I32>(1)),Fw::FW_SERIALIZE_OK);
// serialize arg2
ASSERT_EQ(buff.serialize((F32)2.3),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<F32>(2.3)),Fw::FW_SERIALIZE_OK);
// serialize arg3
ASSERT_EQ(buff.serialize((U8)4),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<U8>(4)),Fw::FW_SERIALIZE_OK);
this->clearEvents();
this->invoke_to_seqCmdBuff(0,buff,14);
@ -290,7 +290,7 @@ namespace Svc {
// Verify status passed back to port
ASSERT_TRUE(this->m_seqStatusRcvd);
ASSERT_EQ(CommandDispatcherImpl::OPCODE_CMD_TEST_CMD_1,this->m_seqStatusOpCode);
ASSERT_EQ((U32)14,this->m_seqStatusCmdSeq);
ASSERT_EQ(14u,this->m_seqStatusCmdSeq);
ASSERT_EQ(this->m_seqStatusCmdResponse,Fw::CmdResponse::OK);
}
@ -380,7 +380,7 @@ namespace Svc {
// verify registration event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered(0,(U32)testOpCode,0,4);
ASSERT_EVENTS_OpCodeRegistered(0,testOpCode,0,4);
// dispatch a test command with a bad opcode
U32 testCmdArg = 100;
@ -399,12 +399,12 @@ namespace Svc {
// verify dispatch event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_InvalidCommand_SIZE(1);
ASSERT_EVENTS_InvalidCommand(0,(U32)testOpCode+1);
ASSERT_EVENTS_InvalidCommand(0u,testOpCode+1);
// Verify status passed back to port
ASSERT_TRUE(this->m_seqStatusRcvd);
ASSERT_EQ(this->m_seqStatusOpCode,(U32)testOpCode+1);
ASSERT_EQ(this->m_seqStatusOpCode,testOpCode+1);
ASSERT_EQ(this->m_seqStatusCmdSeq,testContext);
ASSERT_EQ(this->m_seqStatusCmdResponse,Fw::CmdResponse::INVALID_OPCODE);
}
@ -461,7 +461,7 @@ namespace Svc {
// verify registration event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered(0,(U32)testOpCode,0,4);
ASSERT_EVENTS_OpCodeRegistered(0,testOpCode,0,4);
U32 currSeq = 0;
@ -480,14 +480,14 @@ namespace Svc {
// verify dispatch event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched(0,(U32)testOpCode,0);
ASSERT_EVENTS_OpCodeDispatched(0,testOpCode,0);
// verify sequence table entry
ASSERT_TRUE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(currSeq,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].context,testContext);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
// verify command received
ASSERT_TRUE(this->m_cmdSendRcvd);
@ -508,12 +508,12 @@ namespace Svc {
ASSERT_FALSE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(currSeq,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
// Verify completed event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeError_SIZE(1);
ASSERT_EVENTS_OpCodeError(0,(U32)testOpCode, Fw::CmdResponse::EXECUTION_ERROR);
ASSERT_EVENTS_OpCodeError(0,testOpCode, Fw::CmdResponse::EXECUTION_ERROR);
// Verify status passed back to port
ASSERT_TRUE(this->m_seqStatusRcvd);
@ -534,14 +534,14 @@ namespace Svc {
// verify dispatch event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched(0,(U32)testOpCode,0);
ASSERT_EVENTS_OpCodeDispatched(0,testOpCode,0);
// verify sequence table entry
ASSERT_TRUE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(currSeq,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].context,testContext);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
// verify command received
ASSERT_TRUE(this->m_cmdSendRcvd);
@ -561,16 +561,16 @@ namespace Svc {
ASSERT_FALSE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(currSeq,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
// Verify completed event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeError_SIZE(1);
ASSERT_EVENTS_OpCodeError(0,(U32)testOpCode,Fw::CmdResponse::INVALID_OPCODE);
ASSERT_EVENTS_OpCodeError(0,testOpCode,Fw::CmdResponse::INVALID_OPCODE);
// Verify status passed back to port
ASSERT_TRUE(this->m_seqStatusRcvd);
ASSERT_EQ(this->m_seqStatusOpCode,(U32)testOpCode);
ASSERT_EQ(this->m_seqStatusOpCode,testOpCode);
ASSERT_EQ(testContext,this->m_seqStatusCmdSeq);
ASSERT_EQ(this->m_seqStatusCmdResponse,Fw::CmdResponse::INVALID_OPCODE);
@ -588,13 +588,13 @@ namespace Svc {
// verify dispatch event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched(0,(U32)testOpCode,0);
ASSERT_EVENTS_OpCodeDispatched(0,testOpCode,0);
// verify sequence table entry
ASSERT_TRUE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(currSeq,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].context,testContext);
// verify command received
@ -615,16 +615,16 @@ namespace Svc {
ASSERT_FALSE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ(currSeq,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
// Verify completed event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeError_SIZE(1);
ASSERT_EVENTS_OpCodeError(0,(U32)testOpCode,Fw::CmdResponse::VALIDATION_ERROR);
ASSERT_EVENTS_OpCodeError(0,testOpCode,Fw::CmdResponse::VALIDATION_ERROR);
// Verify status passed back to port
ASSERT_TRUE(this->m_seqStatusRcvd);
ASSERT_EQ(this->m_seqStatusOpCode,(U32)testOpCode);
ASSERT_EQ(this->m_seqStatusOpCode,testOpCode);
ASSERT_EQ(testContext,this->m_seqStatusCmdSeq);
ASSERT_EQ(this->m_seqStatusCmdResponse,Fw::CmdResponse::VALIDATION_ERROR);
}
@ -649,7 +649,7 @@ namespace Svc {
FwOpcodeType testOpCode = 0x50;
this->clearEvents();
Fw::ComBuffer buff;
ASSERT_EQ(buff.serialize((U32)100),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(U32(100)),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(testOpCode),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(testCmdArg),Fw::FW_SERIALIZE_OK);
@ -716,7 +716,7 @@ namespace Svc {
// verify registration event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered(0,(U32)testOpCode,0,4);
ASSERT_EVENTS_OpCodeRegistered(0,testOpCode,0,4);
for (NATIVE_UINT_TYPE disp = 0; disp < CMD_DISPATCHER_SEQUENCER_TABLE_SIZE + 1; disp++) {
// dispatch a test command
@ -735,14 +735,14 @@ namespace Svc {
// verify dispatch event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched(0,(U32)testOpCode,0);
ASSERT_EVENTS_OpCodeDispatched(0,testOpCode,0);
// verify sequence table entry
ASSERT_TRUE(this->m_impl.m_sequenceTracker[disp].used);
ASSERT_EQ(disp,this->m_impl.m_sequenceTracker[disp].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[disp].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[disp].context,testContext);
ASSERT_EQ(this->m_impl.m_sequenceTracker[disp].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[disp].callerPort,0);
// verify command received
ASSERT_TRUE(this->m_cmdSendRcvd);
@ -814,7 +814,7 @@ namespace Svc {
// verify registration event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered_SIZE(1);
ASSERT_EVENTS_OpCodeRegistered(0,(U32)testOpCode,0,4);
ASSERT_EVENTS_OpCodeRegistered(0,testOpCode,0,4);
// dispatch a test command
U32 testCmdArg = 100;
@ -830,19 +830,19 @@ namespace Svc {
// verify dispatch event
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched_SIZE(1);
ASSERT_EVENTS_OpCodeDispatched(0,(U32)testOpCode,0);
ASSERT_EVENTS_OpCodeDispatched(0,testOpCode,0);
// verify sequence table entry
ASSERT_TRUE(this->m_impl.m_sequenceTracker[0].used);
ASSERT_EQ((U32)0,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(0u,this->m_impl.m_sequenceTracker[0].seq);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].opCode,testOpCode);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].context,testContext);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,(NATIVE_INT_TYPE)0);
ASSERT_EQ(this->m_impl.m_sequenceTracker[0].callerPort,0);
// verify command received
ASSERT_TRUE(this->m_cmdSendRcvd);
ASSERT_EQ(this->m_cmdSendOpCode,testOpCode);
ASSERT_EQ((U32)0,this->m_cmdSendCmdSeq);
ASSERT_EQ(0u,this->m_cmdSendCmdSeq);
// check argument
U32 checkVal;
ASSERT_EQ(this->m_cmdSendArgs.deserialize(checkVal),Fw::FW_SERIALIZE_OK);
@ -853,7 +853,7 @@ namespace Svc {
buff.resetSer();
ASSERT_EQ(buff.serialize(FwPacketDescriptorType(Fw::ComPacket::FW_PACKET_COMMAND)),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize((FwOpcodeType)CommandDispatcherImpl::OPCODE_CMD_CLEAR_TRACKING),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(buff.serialize(static_cast<FwOpcodeType>(CommandDispatcherImpl::OPCODE_CMD_CLEAR_TRACKING)),Fw::FW_SERIALIZE_OK);
this->invoke_to_seqCmdBuff(0,buff,testContext);
// send buffer to command dispatcher

2
Svc/CmdSequencer/FPrimeSequence.cpp
View File

@ -279,7 +279,7 @@ namespace Svc {
return false;
}
// check read size
if ((NATIVE_INT_TYPE) size != readLen) {
if (static_cast<NATIVE_INT_TYPE>(size) != readLen) {
this->m_events.fileInvalid(
CmdSequencer_FileReadStage::READ_SEQ_DATA_SIZE,
readLen

30
Svc/ComLogger/ComLogger.cpp
View File

@ -33,11 +33,11 @@ namespace Svc {
else {
FW_ASSERT(maxFileSize > sizeof(0), maxFileSize); // must be a positive integer
}
FW_ASSERT((NATIVE_UINT_TYPE)strnlen(incomingFilePrefix, sizeof(this->filePrefix)) < sizeof(this->filePrefix),
(NATIVE_UINT_TYPE) strnlen(incomingFilePrefix, sizeof(this->filePrefix)), (NATIVE_UINT_TYPE) sizeof(this->filePrefix)); // ensure that file prefix is not too big
FW_ASSERT(strnlen(incomingFilePrefix, sizeof(this->filePrefix)) < sizeof(this->filePrefix),
strnlen(incomingFilePrefix, sizeof(this->filePrefix)), sizeof(this->filePrefix)); // ensure that file prefix is not too big
// Set the file prefix:
Fw::StringUtils::string_copy((char*) this->filePrefix, incomingFilePrefix, sizeof(this->filePrefix));
Fw::StringUtils::string_copy(this->filePrefix, incomingFilePrefix, sizeof(this->filePrefix));
}
void ComLogger ::
@ -147,23 +147,23 @@ namespace Svc {
// Create filename:
Fw::Time timestamp = getTime();
memset(this->fileName, 0, sizeof(this->fileName));
bytesCopied = snprintf((char*) this->fileName, sizeof(this->fileName), "%s_%d_%d_%06d.com",
this->filePrefix, (U32) timestamp.getTimeBase(), timestamp.getSeconds(), timestamp.getUSeconds());
bytesCopied = snprintf(this->fileName, sizeof(this->fileName), "%s_%d_%d_%06d.com",
this->filePrefix, static_cast<U32>(timestamp.getTimeBase()), timestamp.getSeconds(), timestamp.getUSeconds());
// "A return value of size or more means that the output was truncated"
// See here: http://linux.die.net/man/3/snprintf
FW_ASSERT( bytesCopied < sizeof(this->fileName) );
// Create sha filename:
bytesCopied = snprintf((char*) this->hashFileName, sizeof(this->hashFileName), "%s_%d_%d_%06d.com%s",
this->filePrefix, (U32) timestamp.getTimeBase(), timestamp.getSeconds(), timestamp.getUSeconds(), Utils::Hash::getFileExtensionString());
bytesCopied = snprintf(this->hashFileName, sizeof(this->hashFileName), "%s_%d_%d_%06d.com%s",
this->filePrefix, static_cast<U32>(timestamp.getTimeBase()), timestamp.getSeconds(), timestamp.getUSeconds(), Utils::Hash::getFileExtensionString());
FW_ASSERT( bytesCopied < sizeof(this->hashFileName) );
Os::File::Status ret = file.open((char*) this->fileName, Os::File::OPEN_WRITE);
Os::File::Status ret = file.open(this->fileName, Os::File::OPEN_WRITE);
if( Os::File::OP_OK != ret ) {
if( !this->openErrorOccurred ) { // throttle this event, otherwise a positive
// feedback event loop can occur!
Fw::LogStringArg logStringArg((char*) this->fileName);
Fw::LogStringArg logStringArg(this->fileName);
this->log_WARNING_HI_FileOpenError(ret, logStringArg);
}
this->openErrorOccurred = true;
@ -194,7 +194,7 @@ namespace Svc {
this->fileMode = CLOSED;
// Send event:
Fw::LogStringArg logStringArg((char*) this->fileName);
Fw::LogStringArg logStringArg(this->fileName);
this->log_DIAGNOSTIC_FileClosed(logStringArg);
}
}
@ -232,10 +232,10 @@ namespace Svc {
{
NATIVE_INT_TYPE size = length;
Os::File::Status ret = file.write(data, size);
if( Os::File::OP_OK != ret || size != (NATIVE_INT_TYPE) length ) {
if( Os::File::OP_OK != ret || size != static_cast<NATIVE_INT_TYPE>(length) ) {
if( !this->writeErrorOccurred ) { // throttle this event, otherwise a positive
// feedback event loop can occur!
Fw::LogStringArg logStringArg((char*) this->fileName);
Fw::LogStringArg logStringArg(this->fileName);
this->log_WARNING_HI_FileWriteError(ret, size, length, logStringArg);
}
this->writeErrorOccurred = true;
@ -251,10 +251,10 @@ namespace Svc {
)
{
Os::ValidateFile::Status validateStatus;
validateStatus = Os::ValidateFile::createValidation((char*) this->fileName, (char*)this->hashFileName);
validateStatus = Os::ValidateFile::createValidation(this->fileName, this->hashFileName);
if( Os::ValidateFile::VALIDATION_OK != validateStatus ) {
Fw::LogStringArg logStringArg1((char*) this->fileName);
Fw::LogStringArg logStringArg2((char*) this->hashFileName);
Fw::LogStringArg logStringArg1(this->fileName);
Fw::LogStringArg logStringArg2(this->hashFileName);
this->log_WARNING_LO_FileValidationError(logStringArg1, logStringArg2, validateStatus);
}
}

6
Svc/ComLogger/ComLogger.hpp
View File

@ -86,7 +86,7 @@ namespace Svc {
};
// The filename data:
U8 filePrefix[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
CHAR filePrefix[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
U32 maxFileSize;
// ----------------------------------------------------------------------
@ -99,8 +99,8 @@ namespace Svc {
FileMode fileMode;
Os::File file;
U8 fileName[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
U8 hashFileName[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
CHAR fileName[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
CHAR hashFileName[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
U32 byteCount;
bool writeErrorOccurred;
bool openErrorOccurred;

106
Svc/ComLogger/test/ut/Tester.cpp
View File

@ -68,10 +68,10 @@ namespace Svc {
void Tester ::
testLogging()
{
U8 fileName[2048];
U8 prevFileName[2048];
U8 hashFileName[2048];
U8 prevHashFileName[2048];
CHAR fileName[2048];
CHAR prevFileName[2048];
CHAR hashFileName[2048];
CHAR prevHashFileName[2048];
U8 buf[1024];
NATIVE_INT_TYPE length;
U16 bufferSize = 0;
@ -95,13 +95,13 @@ namespace Svc {
// File names for the different iterations:
memset(fileName, 0, sizeof(fileName));
snprintf((char*) fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
snprintf(fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
memset(hashFileName, 0, sizeof(hashFileName));
snprintf((char*) hashFileName, sizeof(hashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds(), Utils::Hash::getFileExtensionString());
snprintf(hashFileName, sizeof(hashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds(), Utils::Hash::getFileExtensionString());
memset(prevFileName, 0, sizeof(prevFileName));
snprintf((char*) prevFileName, sizeof(prevFileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds());
snprintf(prevFileName, sizeof(prevFileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds());
memset(prevHashFileName, 0, sizeof(prevHashFileName));
snprintf((char*) prevHashFileName, sizeof(prevHashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds(), Utils::Hash::getFileExtensionString());
snprintf(prevHashFileName, sizeof(prevHashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds(), Utils::Hash::getFileExtensionString());
// Set the test time to the current time:
setTestTime(testTime);
@ -124,25 +124,25 @@ namespace Svc {
// A new file should have been opened from the previous loop iteration:
if( j > 0 ) {
ASSERT_TRUE(comLogger.fileMode == ComLogger::OPEN);
ASSERT_TRUE(strcmp((char*) comLogger.fileName, (char*) fileName) == 0 );
ASSERT_TRUE(strcmp(static_cast<char*>(comLogger.fileName), fileName) == 0 );
}
// Make sure we got a closed file event:
ASSERT_EVENTS_SIZE(j);
ASSERT_EVENTS_FileClosed_SIZE(j);
if( j > 0 ) {
ASSERT_EVENTS_FileClosed(j-1, (char*) prevFileName);
ASSERT_EVENTS_FileClosed(j-1, prevFileName);
}
// Make sure the file size is smaller or equal to the limit:
Os::FileSystem::Status fsStat;
U64 fileSize = 0;
fsStat = Os::FileSystem::getFileSize((char*) fileName, fileSize); //!< gets the size of the file (in bytes) at location path
fsStat = Os::FileSystem::getFileSize(fileName, fileSize); //!< gets the size of the file (in bytes) at location path
ASSERT_EQ(fsStat, Os::FileSystem::OP_OK);
ASSERT_LE(fileSize, MAX_BYTES_PER_FILE);
// Open file:
ret = file.open((char*) fileName, Os::File::OPEN_READ);
ret = file.open(fileName, Os::File::OPEN_READ);
ASSERT_EQ(Os::File::OP_OK,ret);
// Check data:
@ -152,18 +152,18 @@ namespace Svc {
NATIVE_INT_TYPE length = sizeof(U16);
ret = file.read(&buf, length);
ASSERT_EQ(Os::File::OP_OK, ret);
ASSERT_EQ(length, (NATIVE_INT_TYPE) sizeof(U16));
ASSERT_EQ(length, static_cast<NATIVE_INT_TYPE>(sizeof(U16)));
Fw::SerialBuffer comBuffLength(buf, length);
comBuffLength.fill();
stat = comBuffLength.deserialize(bufferSize);
ASSERT_EQ(stat, Fw::FW_SERIALIZE_OK);
ASSERT_EQ((U16) COM_BUFFER_LENGTH, bufferSize);
ASSERT_EQ(COM_BUFFER_LENGTH, bufferSize);
// Read and check buffer:
length = bufferSize;
ret = file.read(&buf, length);
ASSERT_EQ(Os::File::OP_OK,ret);
ASSERT_EQ(length, (NATIVE_INT_TYPE) bufferSize);
ASSERT_EQ(length, static_cast<NATIVE_INT_TYPE>(bufferSize));
ASSERT_EQ(memcmp(buf, data, COM_BUFFER_LENGTH), 0);
//for(int k=0; k < 4; k++)
@ -181,7 +181,7 @@ namespace Svc {
// Assert that the hashes match:
if( j > 0 ) {
Os::ValidateFile::Status status;
status = Os::ValidateFile::validate((char*) prevFileName, (char*) prevHashFileName);
status = Os::ValidateFile::validate(prevFileName, prevHashFileName);
ASSERT_EQ(Os::ValidateFile::VALIDATION_OK, status);
}
}
@ -190,10 +190,10 @@ namespace Svc {
void Tester ::
testLoggingNoLength()
{
U8 fileName[2048];
U8 prevFileName[2048];
U8 hashFileName[2048];
U8 prevHashFileName[2048];
CHAR fileName[2048];
CHAR prevFileName[2048];
CHAR hashFileName[2048];
CHAR prevHashFileName[2048];
U8 buf[1024];
NATIVE_INT_TYPE length;
Os::File::Status ret;
@ -218,13 +218,13 @@ namespace Svc {
// File names for the different iterations:
memset(fileName, 0, sizeof(fileName));
snprintf((char*) fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
snprintf(fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
memset(hashFileName, 0, sizeof(hashFileName));
snprintf((char*) hashFileName, sizeof(hashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds(), Utils::Hash::getFileExtensionString());
snprintf(hashFileName, sizeof(hashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds(), Utils::Hash::getFileExtensionString());
memset(prevFileName, 0, sizeof(prevFileName));
snprintf((char*) prevFileName, sizeof(prevFileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds());
snprintf(prevFileName, sizeof(prevFileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds());
memset(prevHashFileName, 0, sizeof(prevHashFileName));
snprintf((char*) prevHashFileName, sizeof(prevHashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds(), Utils::Hash::getFileExtensionString());
snprintf(prevHashFileName, sizeof(prevHashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTimePrev.getSeconds(), testTimePrev.getUSeconds(), Utils::Hash::getFileExtensionString());
// Set the test time to the current time:
setTestTime(testTime);
@ -247,25 +247,25 @@ namespace Svc {
// A new file should have been opened from the previous loop iteration:
if( j > 0 ) {
ASSERT_TRUE(comLogger.fileMode == ComLogger::OPEN);
ASSERT_TRUE(strcmp((char*) comLogger.fileName, (char*) fileName) == 0 );
ASSERT_TRUE(strcmp(static_cast<char*>(comLogger.fileName), fileName) == 0 );
}
// Make sure we got a closed file event:
ASSERT_EVENTS_SIZE(j);
ASSERT_EVENTS_FileClosed_SIZE(j);
if( j > 0 ) {
ASSERT_EVENTS_FileClosed(j-1, (char*) prevFileName);
ASSERT_EVENTS_FileClosed(j-1, prevFileName);
}
// Make sure the file size is smaller or equal to the limit:
Os::FileSystem::Status fsStat;
U64 fileSize = 0;
fsStat = Os::FileSystem::getFileSize((char*) fileName, fileSize); //!< gets the size of the file (in bytes) at location path
fsStat = Os::FileSystem::getFileSize(fileName, fileSize); //!< gets the size of the file (in bytes) at location path
ASSERT_EQ(fsStat, Os::FileSystem::OP_OK);
ASSERT_LE(fileSize, MAX_BYTES_PER_FILE);
// Open file:
ret = file.open((char*) fileName, Os::File::OPEN_READ);
ret = file.open(fileName, Os::File::OPEN_READ);
ASSERT_EQ(Os::File::OP_OK,ret);
// Check data:
@ -275,7 +275,7 @@ namespace Svc {
NATIVE_INT_TYPE length = COM_BUFFER_LENGTH;
ret = file.read(&buf, length);
ASSERT_EQ(Os::File::OP_OK,ret);
ASSERT_EQ(length, (NATIVE_INT_TYPE) COM_BUFFER_LENGTH);
ASSERT_EQ(length, COM_BUFFER_LENGTH);
ASSERT_EQ(memcmp(buf, data, COM_BUFFER_LENGTH), 0);
//for(int k=0; k < 4; k++)
@ -293,7 +293,7 @@ namespace Svc {
// Assert that the hashes match:
if( j > 0 ) {
Os::ValidateFile::Status status;
status = Os::ValidateFile::validate((char*) prevFileName, (char*) prevHashFileName);
status = Os::ValidateFile::validate(prevFileName, prevHashFileName);
ASSERT_EQ(Os::ValidateFile::VALIDATION_OK, status);
}
}
@ -303,13 +303,13 @@ namespace Svc {
openError()
{
// Construct illegal filePrefix, and set it via the friend:
U8 filePrefix[2048];
U8 fileName[2128];
CHAR filePrefix[2048];
CHAR fileName[2128];
memset(fileName, 0, sizeof(fileName));
memset(filePrefix, 0, sizeof(filePrefix));
snprintf((char*) filePrefix, sizeof(filePrefix), "illegal/fname?;\\*");
snprintf(filePrefix, sizeof(filePrefix), "illegal/fname?;\\*");
strncpy((char*) comLogger.filePrefix, (char*) filePrefix, sizeof(comLogger.filePrefix));
strncpy(static_cast<char*>(comLogger.filePrefix), filePrefix, sizeof(comLogger.filePrefix));
ASSERT_TRUE(comLogger.fileMode == ComLogger::CLOSED);
ASSERT_EVENTS_SIZE(0);
@ -320,7 +320,7 @@ namespace Svc {
Fw::Time testTime(TB_NONE, 4, 9876543);
setTestTime(testTime);
snprintf((char*) fileName, sizeof(fileName), "%s_%d_%d_%06d.com", filePrefix, (U32) testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
snprintf(fileName, sizeof(fileName), "%s_%d_%d_%06d.com", filePrefix, static_cast<U32>(testTime.getTimeBase()), testTime.getSeconds(), testTime.getUSeconds());
for(int i = 0; i < 3; i++)
{
@ -336,19 +336,19 @@ namespace Svc {
ASSERT_EVENTS_FileOpenError(
0,
Os::File::DOESNT_EXIST,
(char*) fileName
fileName
);
// Try again with valid file name:
memset(fileName, 0, sizeof(fileName));
memset(filePrefix, 0, sizeof(filePrefix));
snprintf((char*) filePrefix, sizeof(filePrefix), "good_");
snprintf(filePrefix, sizeof(filePrefix), "good_");
strncpy((char*) comLogger.filePrefix, (char*) filePrefix, sizeof(comLogger.filePrefix));
strncpy(comLogger.filePrefix, filePrefix, sizeof(comLogger.filePrefix));
ASSERT_TRUE(comLogger.fileMode == ComLogger::CLOSED);
snprintf((char*) fileName, sizeof(fileName), "%s_%d_%d_%06d.com", filePrefix, (U32) testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
snprintf(fileName, sizeof(fileName), "%s_%d_%d_%06d.com", filePrefix, static_cast<U32>(testTime.getTimeBase()), testTime.getSeconds(), testTime.getUSeconds());
for(int i = 0; i < 3; i++)
{
@ -366,13 +366,13 @@ namespace Svc {
// Try again with invalid file name:
memset(fileName, 0, sizeof(fileName));
memset(filePrefix, 0, sizeof(filePrefix));
snprintf((char*) filePrefix, sizeof(filePrefix), "illegal/fname?;\\*");
snprintf(filePrefix, sizeof(filePrefix), "illegal/fname?;\\*");
strncpy((char*) comLogger.filePrefix, (char*) filePrefix, sizeof(comLogger.filePrefix));
strncpy(static_cast<char*>(comLogger.filePrefix), filePrefix, sizeof(comLogger.filePrefix));
ASSERT_TRUE(comLogger.fileMode == ComLogger::CLOSED);
snprintf((char*) fileName, sizeof(fileName), "%s_%d_%d_%06d.com", filePrefix, (U32) testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
snprintf(fileName, sizeof(fileName), "%s_%d_%d_%06d.com", filePrefix, static_cast<U32>(testTime.getTimeBase()), testTime.getSeconds(), testTime.getUSeconds());
for(int i = 0; i < 3; i++)
{
@ -417,9 +417,9 @@ namespace Svc {
}
// Construct filename:
U8 fileName[2048];
CHAR fileName[2048];
memset(fileName, 0, sizeof(fileName));
snprintf((char*) fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, (U32) testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
snprintf(fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, static_cast<U32>(testTime.getTimeBase()), testTime.getSeconds(), testTime.getUSeconds());
// Check generated events:
// We should only see a single event because write
@ -431,7 +431,7 @@ namespace Svc {
Os::File::NOT_OPENED,
0,
2,
(char*) fileName
fileName
);
// Make comlogger open a new file:
@ -470,7 +470,7 @@ namespace Svc {
Os::File::NOT_OPENED,
0,
2,
(char*) fileName
fileName
);
}
@ -478,17 +478,17 @@ namespace Svc {
closeFileCommand()
{
Os::File file;
U8 fileName[2048];
U8 hashFileName[2048];
CHAR fileName[2048];
CHAR hashFileName[2048];
Os::File::Status ret;
// Form filenames:
Fw::Time testTime(TB_NONE, 6, 9876543);
setTestTime(testTime);
memset(fileName, 0, sizeof(fileName));
snprintf((char*) fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
snprintf(fileName, sizeof(fileName), "%s_%d_%d_%06d.com", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds());
memset(hashFileName, 0, sizeof(hashFileName));
snprintf((char*) hashFileName, sizeof(hashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds(), Utils::Hash::getFileExtensionString());
snprintf(hashFileName, sizeof(hashFileName), "%s_%d_%d_%06d.com%s", FILE_STR, testTime.getTimeBase(), testTime.getSeconds(), testTime.getUSeconds(), Utils::Hash::getFileExtensionString());
ASSERT_TRUE(comLogger.fileMode == ComLogger::CLOSED);
ASSERT_EVENTS_SIZE(0);
@ -542,13 +542,13 @@ namespace Svc {
// Make sure we got a closed file event:
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_FileClosed_SIZE(1);
ASSERT_EVENTS_FileClosed(0, (char*) fileName);
ASSERT_EVENTS_FileClosed(0, fileName);
// Open files to make sure they exist:
ret = file.open((char*) fileName, Os::File::OPEN_READ);
ret = file.open(fileName, Os::File::OPEN_READ);
ASSERT_EQ(Os::File::OP_OK,ret);
file.close();
ret = file.open((char*) hashFileName, Os::File::OPEN_READ);
ret = file.open(hashFileName, Os::File::OPEN_READ);
ASSERT_EQ(Os::File::OP_OK,ret);
file.close();
}

2
Svc/ComLogger/test/ut/Tester.hpp
View File

@ -13,7 +13,7 @@
#define QUEUE_DEPTH 10
#define FILE_STR "test"
#define MAX_ENTRIES_PER_FILE 5
#define COM_BUFFER_LENGTH 4
#define COM_BUFFER_LENGTH 4u
#define MAX_BYTES_PER_FILE (MAX_ENTRIES_PER_FILE*COM_BUFFER_LENGTH + MAX_ENTRIES_PER_FILE*sizeof(U16))
#define MAX_BYTES_PER_FILE_NO_LENGTH (MAX_ENTRIES_PER_FILE*COM_BUFFER_LENGTH)

6
Svc/FatalHandler/FatalHandlerComponentBaremetalImpl.cpp
View File

@ -1,8 +1,8 @@
// ======================================================================
// ======================================================================
// \title FatalHandlerImpl.cpp
// \author lestarch
// \brief cpp file for FatalHandler component implementation class
// ======================================================================
// ======================================================================
#include <stdlib.h>
#include <Os/Log.hpp>
@ -19,7 +19,7 @@ namespace Svc {
const NATIVE_INT_TYPE portNum,
FwEventIdType Id) {
// for **nix, delay then exit with error code
Os::Log::logMsg("FATAL %d handled.\n",(U32)Id,0,0,0,0,0);
Os::Log::logMsg("FATAL %d handled.\n",Id,0,0,0,0,0);
while (1) {} // Returning might be bad
}

8
Svc/FatalHandler/FatalHandlerComponentLinuxImpl.cpp
View File

@ -1,4 +1,4 @@
// ======================================================================
// ======================================================================
// \title FatalHandlerImpl.cpp
// \author tcanham
// \brief cpp file for FatalHandler component implementation class
@ -7,8 +7,8 @@
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
//
// ======================================================================
#include <stdlib.h>
#include <signal.h>
@ -26,7 +26,7 @@ namespace Svc {
const NATIVE_INT_TYPE portNum,
FwEventIdType Id) {
// for **nix, delay then exit with error code
Fw::Logger::logMsg("FATAL %d handled.\n",(U32)Id,0,0,0,0,0);
Fw::Logger::logMsg("FATAL %d handled.\n",Id,0,0,0,0,0);
(void)Os::Task::delay(1000);
Fw::Logger::logMsg("Exiting with segfault and core dump file.\n",0,0,0,0,0,0);
(void)raise( SIGSEGV );

8
Svc/FatalHandler/FatalHandlerComponentVxWorksImpl.cpp
View File

@ -1,4 +1,4 @@
// ======================================================================
// ======================================================================
// \title FatalHandlerImpl.cpp
// \author tcanham
// \brief cpp file for FatalHandler component implementation class
@ -7,8 +7,8 @@
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged.
//
// ======================================================================
//
// ======================================================================
#include <Svc/FatalHandler/FatalHandlerComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp"
@ -20,7 +20,7 @@ namespace Svc {
void FatalHandlerComponentImpl::FatalReceive_handler(
const NATIVE_INT_TYPE portNum,
FwEventIdType Id) {
Fw::Logger::logMsg("FATAL %d handled.\n",(U32)Id,0,0,0,0,0);
Fw::Logger::logMsg("FATAL %d handled.\n",Id,0,0,0,0,0);
taskSuspend(0);
}

10
Svc/FileDownlink/FileDownlink.cpp
View File

@ -106,7 +106,7 @@ namespace Svc {
NATIVE_INT_TYPE real_size = 0;
NATIVE_INT_TYPE prio = 0;
Os::Queue::QueueStatus stat = fileQueue.receive(
(U8 *) &this->curEntry,
reinterpret_cast<U8*>(&this->curEntry),
sizeof(this->curEntry),
real_size,
prio,
@ -176,7 +176,7 @@ namespace Svc {
Fw::StringUtils::string_copy(entry.srcFilename, sourceFilename.toChar(), sizeof(entry.srcFilename));
Fw::StringUtils::string_copy(entry.destFilename, destFilename.toChar(), sizeof(entry.destFilename));
Os::Queue::QueueStatus status = fileQueue.send((U8 *) &entry, sizeof(entry), 0, Os::Queue::QUEUE_NONBLOCKING);
Os::Queue::QueueStatus status = fileQueue.send(reinterpret_cast<U8*>(&entry), sizeof(entry), 0, Os::Queue::QUEUE_NONBLOCKING);
if(status != Os::Queue::QUEUE_OK) {
return SendFileResponse(SendFileStatus::ERROR, U32_MAX);
@ -249,7 +249,7 @@ namespace Svc {
Fw::StringUtils::string_copy(entry.srcFilename, sourceFilename.toChar(), sizeof(entry.srcFilename));
Fw::StringUtils::string_copy(entry.destFilename, destFilename.toChar(), sizeof(entry.destFilename));
Os::Queue::QueueStatus status = fileQueue.send((U8 *) &entry, sizeof(entry), 0, Os::Queue::QUEUE_NONBLOCKING);
Os::Queue::QueueStatus status = fileQueue.send(reinterpret_cast<U8*>(&entry), sizeof(entry), 0, Os::Queue::QUEUE_NONBLOCKING);
if(status != Os::Queue::QUEUE_OK) {
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
@ -282,7 +282,7 @@ namespace Svc {
Fw::StringUtils::string_copy(entry.srcFilename, sourceFilename.toChar(), sizeof(entry.srcFilename));
Fw::StringUtils::string_copy(entry.destFilename, destFilename.toChar(), sizeof(entry.destFilename));
Os::Queue::QueueStatus status = fileQueue.send((U8 *) &entry, sizeof(entry), 0, Os::Queue::QUEUE_NONBLOCKING);
Os::Queue::QueueStatus status = fileQueue.send(reinterpret_cast<U8*>(&entry), sizeof(entry), 0, Os::Queue::QUEUE_NONBLOCKING);
if(status != Os::Queue::QUEUE_OK) {
this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
@ -418,7 +418,7 @@ namespace Svc {
const Fw::FilePacket::DataPacket dataPacket = {
{ Fw::FilePacket::T_DATA, this->sequenceIndex },
byteOffset,
(U16)dataSize,
static_cast<U16>(dataSize),
buffer
};
++this->sequenceIndex;

2
Svc/Framer/test/ut/Tester.cpp
View File

@ -20,7 +20,7 @@ namespace Svc {
Tester::MockFramer::MockFramer(Tester& parent) : m_parent(parent) {}
void Tester::MockFramer::frame(const U8* const data, const U32 size, Fw::ComPacket::ComPacketType packet_type) {
Fw::Buffer buffer((U8*)data, size);
Fw::Buffer buffer(const_cast<U8*>(data), size);
m_parent.check_last_buffer(buffer);
Fw::Buffer allocated = m_interface->allocate(size);
m_interface->send(allocated);

6
Svc/Health/test/ut/Tester.cpp
View File

@ -370,7 +370,7 @@ namespace Svc {
this->invoke_to_Run(0,0);
// cycle count should stay the same
ASSERT_EQ((U32)Svc::HealthComponentBase::NUM_PINGSEND_OUTPUT_PORTS*2,
ASSERT_EQ(static_cast<U32>(Svc::HealthComponentBase::NUM_PINGSEND_OUTPUT_PORTS)*2,
this->component.m_pingTrackerEntries[0].cycleCount);
}
@ -455,10 +455,10 @@ namespace Svc {
for (NATIVE_INT_TYPE e3 = 0; e3 < Svc::HealthComponentBase::NUM_PINGSEND_OUTPUT_PORTS; e3++) {
if (e3 == entry) {
// shouldn't be counting up
ASSERT_EQ((U32)0,this->component.m_pingTrackerEntries[e3].cycleCount);
ASSERT_EQ(0u,this->component.m_pingTrackerEntries[e3].cycleCount);
} else {
// others should be counting up
ASSERT_EQ((U32)cycle+1,this->component.m_pingTrackerEntries[e3].cycleCount);
ASSERT_EQ(static_cast<U32>(cycle+1),this->component.m_pingTrackerEntries[e3].cycleCount);
}
}
}

20
Svc/PolyDb/test/ut/PolyDbComponentTestAc.cpp
View File

@ -9,12 +9,12 @@
namespace Svc {
// public methods
void PolyDbTesterComponentBase::set_getValue_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputPolyPort* port) {
FW_ASSERT(portNum < this->getNum_getValue_OutputPorts());
FW_ASSERT(portNum < this->getNum_getValue_OutputPorts());
this->m_getValue_OutputPort[portNum].addCallPort(port);
}
void PolyDbTesterComponentBase::set_setValue_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputPolyPort* port) {
FW_ASSERT(portNum < this->getNum_setValue_OutputPorts());
FW_ASSERT(portNum < this->getNum_setValue_OutputPorts());
this->m_setValue_OutputPort[portNum].addCallPort(port);
}
@ -40,22 +40,22 @@ namespace Svc {
// Set output ports
for (NATIVE_INT_TYPE port = 0; port < this->getNum_getValue_OutputPorts(); port++) {
this->m_getValue_OutputPort[port].init();
#if FW_OBJECT_NAMES == 1
#if FW_OBJECT_NAMES == 1
char portName[120];
snprintf(portName, sizeof(portName), "%s_getValue_OutputPort[%d]", this->m_objName, port);
this->m_getValue_OutputPort[port].setObjName(portName);
#endif
#endif
}
for (NATIVE_INT_TYPE port = 0; port < this->getNum_setValue_OutputPorts(); port++) {
this->m_setValue_OutputPort[port].init();
#if FW_OBJECT_NAMES == 1
#if FW_OBJECT_NAMES == 1
char portName[120];
snprintf(portName, sizeof(portName), "%s_setValue_OutputPort[%d]", this->m_objName, port);
this->m_setValue_OutputPort[port].setObjName(portName);
#endif
#endif
}
}
@ -72,10 +72,10 @@ namespace Svc {
}
NATIVE_INT_TYPE PolyDbTesterComponentBase::getNum_getValue_OutputPorts(void) {
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_getValue_OutputPort);
return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_getValue_OutputPort));
}
NATIVE_INT_TYPE PolyDbTesterComponentBase::getNum_setValue_OutputPorts(void) {
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_setValue_OutputPort);
return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_setValue_OutputPort));
}
bool PolyDbTesterComponentBase::isConnected_getValue_OutputPort(NATIVE_INT_TYPE portNum) {
FW_ASSERT(portNum < this->getNum_getValue_OutputPorts(),portNum);

24
Svc/PolyDb/test/ut/PolyDbImplTester.cpp
View File

@ -32,18 +32,18 @@ namespace Svc {
Fw::PolyType vals[NUM_TEST_VALS];
// set test values
vals[0] = (U8)1;
vals[1] = (I8)2;
vals[2] = (U16)3;
vals[3] = (I16)4;
vals[4] = (U32)5;
vals[5] = (I32)6;
vals[6] = (U64)7;
vals[7] = (I64)8;
vals[8] = (F32)9.0;
vals[9] = (F64)10.0;
vals[0] = static_cast<U8>(1);
vals[1] = static_cast<I8>(2);
vals[2] = static_cast<U16>(3);
vals[3] = static_cast<I16>(4);
vals[4] = static_cast<U32>(5);
vals[5] = static_cast<I32>(6);
vals[6] = static_cast<U64>(7);
vals[7] = static_cast<I64>(8);
vals[8] = static_cast<F32>(9.0);
vals[9] = static_cast<F64>(10.0);
vals[10] = true;
vals[11] = (void*)0x100;
vals[11] = reinterpret_cast<void*>(0x100);
Fw::Time ts(TB_NONE,6,7);
@ -85,7 +85,7 @@ namespace Svc {
}
ASSERT_EQ(mstatValue,checkStat.e);
}
mstatValue = (MeasurementStatus::t)((NATIVE_INT_TYPE)mstatValue + 1);
mstatValue = static_cast<MeasurementStatus::t>(mstatValue + 1);
}
}

14
Svc/PrmDb/PrmDbImpl.cpp
View File

@ -167,7 +167,7 @@ namespace Svc {
buff.resetSer();
Fw::SerializeStatus serStat = buff.serialize(recordSize);
// should always work
FW_ASSERT(Fw::FW_SERIALIZE_OK == serStat,(NATIVE_INT_TYPE)serStat);
FW_ASSERT(Fw::FW_SERIALIZE_OK == serStat,static_cast<NATIVE_INT_TYPE>(serStat));
// write record size
writeSize = buff.getBuffLength();
@ -192,7 +192,7 @@ namespace Svc {
serStat = buff.serialize(this->m_db[entry].id);
// should always work
FW_ASSERT(Fw::FW_SERIALIZE_OK == serStat,(NATIVE_INT_TYPE)serStat);
FW_ASSERT(Fw::FW_SERIALIZE_OK == serStat,static_cast<NATIVE_INT_TYPE>(serStat));
// write parameter ID
writeSize = buff.getBuffLength();
@ -203,7 +203,7 @@ namespace Svc {
this->cmdResponse_out(opCode,cmdSeq,Fw::CmdResponse::EXECUTION_ERROR);
return;
}
if (writeSize != (NATIVE_INT_TYPE)buff.getBuffLength()) {
if (writeSize != static_cast<NATIVE_INT_TYPE>(buff.getBuffLength())) {
this->unLock();
this->log_WARNING_HI_PrmFileWriteError(PrmWriteError::PARAMETER_ID_SIZE,numRecords,writeSize);
this->cmdResponse_out(opCode,cmdSeq,Fw::CmdResponse::EXECUTION_ERROR);
@ -220,7 +220,7 @@ namespace Svc {
this->cmdResponse_out(opCode,cmdSeq,Fw::CmdResponse::EXECUTION_ERROR);
return;
}
if (writeSize != (NATIVE_INT_TYPE)this->m_db[entry].val.getBuffLength()) {
if (writeSize != static_cast<NATIVE_INT_TYPE>(this->m_db[entry].val.getBuffLength())) {
this->unLock();
this->log_WARNING_HI_PrmFileWriteError(PrmWriteError::PARAMETER_VALUE_SIZE,numRecords,writeSize);
this->cmdResponse_out(opCode,cmdSeq,Fw::CmdResponse::EXECUTION_ERROR);
@ -299,7 +299,7 @@ namespace Svc {
// set serialized size to read size
Fw::SerializeStatus desStat = buff.setBuffLen(readSize);
// should never fail
FW_ASSERT(Fw::FW_SERIALIZE_OK == desStat,(NATIVE_INT_TYPE)desStat);
FW_ASSERT(Fw::FW_SERIALIZE_OK == desStat,static_cast<NATIVE_INT_TYPE>(desStat));
// reset deserialization
buff.resetDeser();
// deserialize, since record size is serialized in file
@ -329,7 +329,7 @@ namespace Svc {
// set serialized size to read parameter ID
desStat = buff.setBuffLen(readSize);
// should never fail
FW_ASSERT(Fw::FW_SERIALIZE_OK == desStat,(NATIVE_INT_TYPE)desStat);
FW_ASSERT(Fw::FW_SERIALIZE_OK == desStat,static_cast<NATIVE_INT_TYPE>(desStat));
// reset deserialization
buff.resetDeser();
// deserialize, since parameter ID is serialized in file
@ -354,7 +354,7 @@ namespace Svc {
// set serialized size to read size
desStat = this->m_db[entry].val.setBuffLen(readSize);
// should never fail
FW_ASSERT(Fw::FW_SERIALIZE_OK == desStat,(NATIVE_INT_TYPE)desStat);
FW_ASSERT(Fw::FW_SERIALIZE_OK == desStat,static_cast<NATIVE_INT_TYPE>(desStat));
recordNum++;
}

12
Svc/PrmDb/test/ut/PrmDbImplTester.cpp
View File

@ -162,7 +162,7 @@ namespace Svc {
// deserialize it
Fw::SerializeStatus stat = pBuff.deserialize(testVal);
EXPECT_EQ(Fw::FW_SERIALIZE_OK,stat);
EXPECT_EQ(testVal,(U32)0x15);
EXPECT_EQ(testVal,0x15u);
// second
pBuff.resetSer();
@ -170,7 +170,7 @@ namespace Svc {
// deserialize it
stat = pBuff.deserialize(testVal);
EXPECT_EQ(Fw::FW_SERIALIZE_OK,stat);
EXPECT_EQ(testVal,(U32)0x30);
EXPECT_EQ(testVal,0x30u);
}
@ -191,10 +191,10 @@ namespace Svc {
this->clearEvents();
// write too many entries
for (NATIVE_INT_TYPE entry = 0; entry <= PRMDB_NUM_DB_ENTRIES; entry++) {
for (FwPrmIdType entry = 0; entry <= PRMDB_NUM_DB_ENTRIES; entry++) {
Fw::ParamBuffer pBuff;
EXPECT_EQ(Fw::FW_SERIALIZE_OK,pBuff.serialize((U32)10));
this->invoke_to_setPrm(0,(FwPrmIdType)entry,pBuff);
EXPECT_EQ(Fw::FW_SERIALIZE_OK,pBuff.serialize(static_cast<U32>(10)));
this->invoke_to_setPrm(0,entry,pBuff);
// dispatch message
this->m_impl.doDispatch();
}
@ -473,7 +473,7 @@ void PrmDbImplTester::runFileReadError() {
// set test type to read error
this->m_readTestType = FILE_READ_DATA_ERROR;
Fw::ParamBuffer pBuff;
pBuff.serialize((U32) (FW_PARAM_BUFFER_MAX_SIZE + sizeof(U32) + 1));
pBuff.serialize(static_cast<U32>(FW_PARAM_BUFFER_MAX_SIZE + sizeof(U32) + 1));
memcpy(this->m_readData,pBuff.getBuffAddr(),pBuff.getBuffLength());
// call function to read file
this->m_impl.readParamFile();

6
Svc/TlmChan/test/ut/TlmChanImplTester.cpp
View File

@ -70,7 +70,7 @@ namespace Svc {
FwPacketDescriptorType desc;
stat = this->m_rcvdBuffer[packet].deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,(FwPacketDescriptorType)Fw::ComPacket::FW_PACKET_TELEM);
ASSERT_EQ(desc, static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_TELEM));
// next piece should be event ID
FwEventIdType sentId;
stat = this->m_rcvdBuffer[packet].deserialize(sentId);
@ -93,7 +93,7 @@ namespace Svc {
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, val);
// packet should be empty
ASSERT_EQ(this->m_rcvdBuffer[packet].getBuffLeft(),(NATIVE_UINT_TYPE)0);
ASSERT_EQ(this->m_rcvdBuffer[packet].getBuffLeft(),0u);
}
ASSERT_TRUE(packetFound);
@ -226,7 +226,7 @@ namespace Svc {
// Read back value
this->invoke_to_TlmGet(0,10,timeTag,buff);
ASSERT_EQ((NATIVE_UINT_TYPE)0,buff.getBuffLength());
ASSERT_EQ(0u,buff.getBuffLength());
}

2
Svc/UdpReceiver/UdpReceiverComponentImpl.cpp
View File

@ -75,7 +75,7 @@ namespace Svc {
sockaddr_in saddr;
// zero out the structure
memset((char *) &saddr, 0, sizeof(saddr));
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(atoi(port));

6
Svc/UdpReceiver/test/ut/Tester.cpp
View File

@ -74,7 +74,7 @@ namespace Svc {
// verify the port call
EXPECT_EQ((U32)20,this->m_sentVal);
EXPECT_EQ(20u,this->m_sentVal);
EXPECT_EQ(3,this->m_sentPort);
}
@ -169,7 +169,7 @@ namespace Svc {
/* fill in the server's address and data */
struct sockaddr_in sockAddr;
memset((char*)&sockAddr, 0, sizeof(sockAddr));
memset(&sockAddr, 0, sizeof(sockAddr));
sockAddr.sin_family = AF_INET;
sockAddr.sin_port = htons(atoi(port));
inet_aton(addr , &sockAddr.sin_addr);
@ -191,7 +191,7 @@ namespace Svc {
buff.getBuffAddr(),
buff.getBuffLength(),
0,
(struct sockaddr *) &sockAddr,
reinterpret_cast<struct sockaddr *>(&sockAddr),
sizeof(sockAddr));
EXPECT_NE(-1,sendStat);
EXPECT_EQ(buff.getBuffLength(),sendStat);

4
Svc/UdpSender/UdpSenderComponentImpl.cpp
View File

@ -74,7 +74,7 @@ namespace Svc {
}
/* fill in the server's address and data */
memset((char*)&m_servAddr, 0, sizeof(m_servAddr));
memset(&m_servAddr, 0, sizeof(m_servAddr));
m_servAddr.sin_family = AF_INET;
m_servAddr.sin_port = htons(atoi(port));
inet_aton(addr , &m_servAddr.sin_addr);
@ -134,7 +134,7 @@ namespace Svc {
m_sendBuff.getBuffAddr(),
m_sendBuff.getBuffLength(),
0,
(struct sockaddr *) &m_servAddr,
reinterpret_cast<struct sockaddr *>(&m_servAddr),
sizeof(m_servAddr));
if (-1 == sendStat) {
Fw::LogStringArg arg(strerror(errno));

4
Svc/UdpSender/test/ut/Tester.cpp
View File

@ -72,7 +72,7 @@ namespace Svc {
this->clearEvents();
// send a buffer
Svc::UdpSenderComponentImpl::UdpSerialBuffer buff;
ASSERT_EQ(Fw::FW_SERIALIZE_OK,buff.serialize((U32)(10)));
ASSERT_EQ(Fw::FW_SERIALIZE_OK,buff.serialize(static_cast<U32>(10)));
this->invoke_to_PortsIn(1,buff);
this->component.doDispatch();
@ -188,7 +188,7 @@ namespace Svc {
EXPECT_NE(-1,this->m_recvFd);
// zero out the structure
memset((char *) &saddr, 0, sizeof(saddr));
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(atoi(port));