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

Svc/ActiveLogger/test/ut/ActiveLoggerImplTester.cpp

@@ -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;

Svc/ActiveRateGroup/test/ut/ActiveRateGroupImplTester.cpp

@@ -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 <
+            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 == 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 <
+        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 == 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 <
+        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 == 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 <
+        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 == 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);
 
     }
 

Svc/ActiveRateGroup/test/ut/ActiveRateGroupTester.cpp

@@ -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));
     }
 

Svc/BufferManager/test/ut/Tester.cpp

@@ -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};
 

Svc/CmdDispatcher/test/ut/CommandDispatcherImplTester.cpp

@@ -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(static_cast<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<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(static_cast<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<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

Svc/CmdSequencer/FPrimeSequence.cpp

@@ -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

Svc/ComLogger/ComLogger.cpp

@@ -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),
+    FW_ASSERT(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
+      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",
+    bytesCopied = snprintf(this->fileName, sizeof(this->fileName), "%s_%d_%d_%06d.com",
-      this->filePrefix, (U32) timestamp.getTimeBase(), timestamp.getSeconds(), timestamp.getUSeconds());
+      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",
+    bytesCopied = snprintf(this->hashFileName, sizeof(this->hashFileName), "%s_%d_%d_%06d.com%s",
-      this->filePrefix, (U32) timestamp.getTimeBase(), timestamp.getSeconds(), timestamp.getUSeconds(), Utils::Hash::getFileExtensionString());
+      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 logStringArg1(this->fileName);
-      Fw::LogStringArg logStringArg2((char*) this->hashFileName);
+      Fw::LogStringArg logStringArg2(this->hashFileName);
       this->log_WARNING_LO_FileValidationError(logStringArg1, logStringArg2, validateStatus);
     }
   }

Svc/ComLogger/ComLogger.hpp

@@ -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];
+      CHAR fileName[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
-      U8 hashFileName[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
+      CHAR hashFileName[MAX_FILENAME_SIZE + MAX_PATH_SIZE];
       U32 byteCount;
       bool writeErrorOccurred;
       bool openErrorOccurred;

Svc/ComLogger/test/ut/Tester.cpp

@@ -68,10 +68,10 @@ namespace Svc {
   void Tester ::
     testLogging()
   {
-      U8 fileName[2048];
+      CHAR fileName[2048];
-      U8 prevFileName[2048];
+      CHAR prevFileName[2048];
-      U8 hashFileName[2048];
+      CHAR hashFileName[2048];
-      U8 prevHashFileName[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];
+      CHAR fileName[2048];
-      U8 prevFileName[2048];
+      CHAR prevFileName[2048];
-      U8 hashFileName[2048];
+      CHAR hashFileName[2048];
-      U8 prevHashFileName[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];
+      CHAR filePrefix[2048];
-      U8 fileName[2128];
+      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];
+    CHAR fileName[2048];
-    U8 hashFileName[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();
   }

Svc/ComLogger/test/ut/Tester.hpp

@@ -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)
 

Svc/FatalHandler/FatalHandlerComponentBaremetalImpl.cpp

@@ -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
     }
 

Svc/FatalHandler/FatalHandlerComponentLinuxImpl.cpp

@@ -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 );

Svc/FatalHandler/FatalHandlerComponentVxWorksImpl.cpp

@@ -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);
     }
 

Svc/FileDownlink/FileDownlink.cpp

@@ -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;

Svc/Framer/test/ut/Tester.cpp

@@ -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);

Svc/Health/test/ut/Tester.cpp

@@ -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);
                   }
               }
           }

Svc/PolyDb/test/ut/PolyDbComponentTestAc.cpp

@@ -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);

Svc/PolyDb/test/ut/PolyDbImplTester.cpp

@@ -32,18 +32,18 @@ namespace Svc {
         Fw::PolyType vals[NUM_TEST_VALS];
 
         // set test values
-        vals[0] = (U8)1;
+        vals[0] = static_cast<U8>(1);
-        vals[1] = (I8)2;
+        vals[1] = static_cast<I8>(2);
-        vals[2] = (U16)3;
+        vals[2] = static_cast<U16>(3);
-        vals[3] = (I16)4;
+        vals[3] = static_cast<I16>(4);
-        vals[4] = (U32)5;
+        vals[4] = static_cast<U32>(5);
-        vals[5] = (I32)6;
+        vals[5] = static_cast<I32>(6);
-        vals[6] = (U64)7;
+        vals[6] = static_cast<U64>(7);
-        vals[7] = (I64)8;
+        vals[7] = static_cast<I64>(8);
-        vals[8] = (F32)9.0;
+        vals[8] = static_cast<F32>(9.0);
-        vals[9] = (F64)10.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);
         }
 
     }

Svc/PrmDb/PrmDbImpl.cpp

@@ -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++;
 
         }

Svc/PrmDb/test/ut/PrmDbImplTester.cpp

@@ -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));
+            EXPECT_EQ(Fw::FW_SERIALIZE_OK,pBuff.serialize(static_cast<U32>(10)));
-            this->invoke_to_setPrm(0,(FwPrmIdType)entry,pBuff);
+            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();

Svc/TlmChan/test/ut/TlmChanImplTester.cpp

@@ -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());
 
     }
 

Svc/UdpReceiver/UdpReceiverComponentImpl.cpp

@@ -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));

Svc/UdpReceiver/test/ut/Tester.cpp

@@ -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);

Svc/UdpSender/UdpSenderComponentImpl.cpp

@@ -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));

Svc/UdpSender/test/ut/Tester.cpp

@@ -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));