Repository: nasa/fprime (language: python)

Issue:
Remove Ground Interface
| | |
|:---|:---|
|**_F´ Version_**| |
|**_Affected Component_**|  |
---
## Feature Description

The GroundInterface component has been entirely surpassed by Framer and Deframe. It needs to be removed.


Discussion / hints:

Fix patch:
diff --git a/STest/README.md b/STest/README.md
index 4d2a03fc0c..ac0a41107a 100644
--- a/STest/README.md
+++ b/STest/README.md
@@ -55,7 +55,7 @@ The iterated and random scenarios allow you to construct complex tests that expl
 
 ### Use in F Prime
 
-At present, F Prime uses STest for unit testing of components. Examples include [Svc/GroundInterface](https://github.com/nasa/fprime/blob/master/Svc/GroundInterface/test/ut/GroundInterfaceRules.cpp) and [Fw/Logger](https://github.com/nasa/fprime/blob/master/Fw/Logger/test/ut/LoggerRules.cpp). The main scenarios used here are
+At present, F Prime uses STest for unit testing of components. An example is [Fw/Logger](https://github.com/nasa/fprime/blob/master/Fw/Logger/test/ut/LoggerRules.cpp). The main scenarios used here are
 as follows:
 
 * Short sequences of rules that set up the system state and then test a particular rule.
diff --git a/Svc/CMakeLists.txt b/Svc/CMakeLists.txt
index 175654cccc..b71f3667b4 100644
--- a/Svc/CMakeLists.txt
+++ b/Svc/CMakeLists.txt
@@ -32,7 +32,6 @@ add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/FileDownlink/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/FileManager/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/FileUplink/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/GenericHub/")
-add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/GroundInterface/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Framer/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/FramingProtocol/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Health/")
diff --git a/Svc/GroundInterface/CMakeLists.txt b/Svc/GroundInterface/CMakeLists.txt
deleted file mode 100644
index 94e8bf8bed..0000000000
--- a/Svc/GroundInterface/CMakeLists.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-####
-# F prime CMakeLists.txt:
-#
-# SOURCE_FILES: combined list of source and autocoding files
-# MOD_DEPS: (optional) module dependencies
-#
-# Note: using PROJECT_NAME as EXECUTABLE_NAME
-####
-set(SOURCE_FILES
-  "${CMAKE_CURRENT_LIST_DIR}/GroundInterface.fpp"
-  "${CMAKE_CURRENT_LIST_DIR}/GroundInterface.cpp"
-)
-set(MOD_DEPS "Utils/Types")
-register_fprime_module()
-
-# Rules based unit testing
-set(UT_MOD_DEPS
-        STest
-        Fw/Types)
-
-set(UT_SOURCE_FILES
-        "${CMAKE_CURRENT_LIST_DIR}/GroundInterface.fpp"
-        "${CMAKE_CURRENT_LIST_DIR}/test/ut/GroundInterfaceTester.cpp"
-        "${CMAKE_CURRENT_LIST_DIR}/test/ut/GroundInterfaceTestMain.cpp"
-        "${CMAKE_CURRENT_LIST_DIR}/test/ut/GroundInterfaceRules.cpp"
-        )
-# STest Includes for this UT
-register_fprime_ut()
diff --git a/Svc/GroundInterface/Events.fppi b/Svc/GroundInterface/Events.fppi
deleted file mode 100644
index 9fd78dcaf8..0000000000
--- a/Svc/GroundInterface/Events.fppi
+++ /dev/null
@@ -1,5 +0,0 @@
-@ An error in the ground interface, here to make the UTs happy.
-event GroundInterfaceError \
-  severity warning high \
-  id 0 \
-  format "Ground interface encountered an error"
diff --git a/Svc/GroundInterface/GroundInterface.cpp b/Svc/GroundInterface/GroundInterface.cpp
deleted file mode 100644
index 0e4638eb94..0000000000
--- a/Svc/GroundInterface/GroundInterface.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-// ======================================================================
-// \title  GroundInterface.cpp
-// \author lestarch
-// \brief  cpp file for GroundInterface component implementation class
-// ======================================================================
-
-#include <Fw/Com/ComPacket.hpp>
-#include <Svc/GroundInterface/GroundInterface.hpp>
-#include <FpConfig.hpp>
-#include <cstring>
-
-namespace Svc {
-
-  const U32 GroundInterfaceComponentImpl::MAX_DATA_SIZE = 2048;
-  const TOKEN_TYPE GroundInterfaceComponentImpl::START_WORD = static_cast<TOKEN_TYPE>(0xdeadbeef);
-  const U32 GroundInterfaceComponentImpl::END_WORD = static_cast<U32>(0xcafecafe);
-
-  // ----------------------------------------------------------------------
-  // Construction, initialization, and destruction
-  // ----------------------------------------------------------------------
-
-  GroundInterfaceComponentImpl ::
-    GroundInterfaceComponentImpl(
-        const char *const compName
-    ) : GroundInterfaceComponentBase(compName),
-        m_ext_buffer(m_buffer, GND_BUFFER_SIZE),
-        m_data_size(0),
-        m_in_ring(m_in_buffer, GND_BUFFER_SIZE)
-  {
-
-  }
-
-  void GroundInterfaceComponentImpl ::
-    init(
-        const NATIVE_INT_TYPE instance
-    )
-  {
-    GroundInterfaceComponentBase::init(instance);
-  }
-
-  GroundInterfaceComponentImpl ::
-    ~GroundInterfaceComponentImpl()
-  {
-
-  }
-
-  // ----------------------------------------------------------------------
-  // Handler implementations for user-defined typed input ports
-  // ----------------------------------------------------------------------
-
-  void GroundInterfaceComponentImpl ::
-    downlinkPort_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::ComBuffer &data,
-        U32 context
-    )
-  {
-      FW_ASSERT(data.getBuffLength() <= MAX_DATA_SIZE);
-      frame_send(data.getBuffAddr(), data.getBuffLength());
-  }
-
-  void GroundInterfaceComponentImpl ::
-    fileDownlinkBufferSendIn_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::Buffer &fwBuffer
-    )
-  {
-      FW_ASSERT(fwBuffer.getSize() <= MAX_DATA_SIZE);
-      frame_send(fwBuffer.getData(), fwBuffer.getSize(), Fw::ComPacket::FW_PACKET_FILE);
-      fileDownlinkBufferSendOut_out(0, fwBuffer);
-  }
-
-  void GroundInterfaceComponentImpl ::
-    readCallback_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::Buffer &buffer
-    )
-  {
-      processBuffer(buffer);
-  }
-
-  void GroundInterfaceComponentImpl ::
-    schedIn_handler(
-        const NATIVE_INT_TYPE portNum, /*!< The port number*/
-        U32 context /*!< The call order*/
-    )
-  {
-      // TODO: replace with a call to a buffer manager
-      Fw::Buffer buffer = m_ext_buffer;
-      // Call read poll if it is hooked up
-      if (isConnected_readPoll_OutputPort(0)) {
-          readPoll_out(0, buffer);
-          processBuffer(buffer);
-      }
-  }
-
-  void GroundInterfaceComponentImpl::frame_send(U8 *data, TOKEN_TYPE size, TOKEN_TYPE packet_type) {
-      // TODO: replace with a call to a buffer manager
-      Fw::Buffer buffer = m_ext_buffer;
-      Fw::SerializeBufferBase& buffer_wrapper = buffer.getSerializeRepr();
-      buffer_wrapper.resetSer();
-      // True size is supplied size plus sizeof(TOKEN_TYPE) if a packet_type other than "UNKNOWN" was supplied.
-      // This is because if not UNKNOWN, the packet_type is serialized too.  Otherwise it is assumed the PACKET_TYPE is
-      // already the first token in the UNKNOWN typed buffer.
-      U32 true_size = (packet_type != Fw::ComPacket::FW_PACKET_UNKNOWN) ? size + sizeof(TOKEN_TYPE) : size;
-      U32 total_size = sizeof(TOKEN_TYPE) + sizeof(TOKEN_TYPE) + true_size + sizeof(U32);
-      // Serialize data
-      FW_ASSERT(GND_BUFFER_SIZE >= total_size, GND_BUFFER_SIZE, total_size);
-      buffer_wrapper.serialize(START_WORD);
-      buffer_wrapper.serialize(static_cast<TOKEN_TYPE>(true_size));
-      // Explicitly set the packet type, if it didn't come with the data already
-      if (packet_type != Fw::ComPacket::FW_PACKET_UNKNOWN) {
-          buffer_wrapper.serialize(packet_type);
-      }
-      buffer_wrapper.serialize(data, size, true);
-      buffer_wrapper.serialize(static_cast<TOKEN_TYPE>(END_WORD));
-
-      // Setup for sending by truncating unused data
-      buffer.setSize(buffer_wrapper.getBuffLength());
-      FW_ASSERT(buffer.getSize() == total_size, buffer.getSize(), total_size);
-      write_out(0, buffer);
-  }
-
-  void GroundInterfaceComponentImpl ::
-    routeComData()
-  {
-      // Read the packet type from the data buffer
-      FwPacketDescriptorType packet_type = Fw::ComPacket::FW_PACKET_UNKNOWN;
-
-      //read packet descriptor in size agnostic way
-      U8 packet_descriptor_size = sizeof(FwPacketDescriptorType);
-      U8 packet_type_bytes[sizeof(FwPacketDescriptorType)];
-      Fw::SerializeStatus stat = m_in_ring.peek(packet_type_bytes, packet_descriptor_size, HEADER_SIZE);
-      //m_in_ring.peek(packet_type, HEADER_SIZE); // this way is only valid for 4byte packet descriptors
-      if(stat == Fw::FW_SERIALIZE_OK)
-      {
-        // unpack Big Endian encoded bytes
-        packet_type = 0;
-        for(int i = 0; i < packet_descriptor_size; i++)
-        {
-          packet_type <<= 8;
-          packet_type |= packet_type_bytes[i];
-        }
-      }
-
-      // Process variable type
-      switch (packet_type) {
-          case Fw::ComPacket::FW_PACKET_COMMAND: {
-              Fw::ComBuffer com;
-              m_in_ring.peek(com.getBuffAddr(), m_data_size, HEADER_SIZE);
-              // Reset com buffer for sending out data
-              com.setBuffLen(m_data_size);
-              uplinkPort_out(0, com, 0);
-              break;
-          }
-          case Fw::ComPacket::FW_PACKET_FILE: {
-              // If file uplink is possible, handle files.  Otherwise ignore.
-              if (isConnected_fileUplinkBufferGet_OutputPort(0) &&
-                  isConnected_fileDownlinkBufferSendOut_OutputPort(0)) {
-                  Fw::Buffer buffer = fileUplinkBufferGet_out(0, m_data_size);
-                  m_in_ring.peek(buffer.getData(), m_data_size - sizeof(packet_type), HEADER_SIZE + sizeof(packet_type));
-                  buffer.setSize(m_data_size - sizeof(packet_type));
-                  fileUplinkBufferSendOut_out(0, buffer);
-              }
-              break;
-          }
-          default:
-              return;
-      }
-  }
-
-  void GroundInterfaceComponentImpl ::
-    processRing()
-  {
-      // Header items for the packet
-      TOKEN_TYPE start;
-      U32 checksum; //TODO: make this run a CRC32
-      // Inner-loop, process ring buffer looking for at least the header
-      while (m_in_ring.get_allocated_size() >= HEADER_SIZE) {
-          m_data_size = 0;
-          // Peek into the header and read out values
-          Fw::SerializeStatus status = m_in_ring.peek(start, 0);
-          FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-          status = m_in_ring.peek(m_data_size, sizeof(TOKEN_TYPE));
-          FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-          // Check the header for correctness
-          if (start != START_WORD || m_data_size >= MAX_DATA_SIZE) {
-              m_in_ring.rotate(1);
-              continue;
-          }
-          // Check for enough data to deserialize everything otherwise break and wait for more.
-          else if (m_in_ring.get_allocated_size() < (HEADER_SIZE + m_data_size + sizeof(END_WORD))) {
-              break;
-          }
-          // Continue with the data portion and checksum
-          m_in_ring.peek(checksum, HEADER_SIZE + m_data_size);
-          // Check checksum
-          if (checksum == END_WORD) {
-              routeComData();
-              m_in_ring.rotate(HEADER_SIZE + m_data_size + sizeof(U32));
-          }
-          // Failed checksum, keep looking for valid message
-          else {
-              m_in_ring.rotate(1);
-          }
-      }
-  }
-
-  void GroundInterfaceComponentImpl ::
-    processBuffer(Fw::Buffer& buffer)
-  {
-      NATIVE_UINT_TYPE buffer_offset = 0;
-      while (buffer_offset < buffer.getSize()) {
-          NATIVE_UINT_TYPE ser_size = (buffer.getSize() >= m_in_ring.get_free_size()) ?
-              m_in_ring.get_free_size() : static_cast<NATIVE_UINT_TYPE>(buffer.getSize());
-          m_in_ring.serialize(buffer.getData() + buffer_offset, ser_size);
-          buffer_offset = buffer_offset + ser_size;
-          processRing();
-      }
-  }
-} // end namespace Svc
diff --git a/Svc/GroundInterface/GroundInterface.fpp b/Svc/GroundInterface/GroundInterface.fpp
deleted file mode 100644
index fed5c04ac7..0000000000
--- a/Svc/GroundInterface/GroundInterface.fpp
+++ /dev/null
@@ -1,61 +0,0 @@
-module Svc {
-
-  @ A component representing the FSW ground interface
-  passive component GroundInterface {
-
-    # ----------------------------------------------------------------------
-    # General Ports
-    # ----------------------------------------------------------------------
-
-    @ Mutexed Downlink input port
-    guarded input port downlinkPort: Fw.Com
-
-    @ Mutexed File downlink buffer send input port
-    guarded input port fileDownlinkBufferSendIn: Fw.BufferSend
-
-    @ Mutexed Read cal back input port
-    guarded input port readCallback: Fw.BufferSend
-
-    @ Mutexed Schedule input port
-    guarded input port schedIn: Svc.Sched
-
-    @ File Uplink buffer send output port
-    output port fileUplinkBufferSendOut: Fw.BufferSend
-
-    @ Uplink port
-    output port uplinkPort: Fw.Com
-
-    @ File Downlink buffer send output port
-    output port fileDownlinkBufferSendOut: Fw.BufferSend
-
-    @ File Uplink buffer get output port
-    output port fileUplinkBufferGet: Fw.BufferGet
-
-    @ Write output port
-    output port write: Fw.BufferSend
-
-    @ Read poll output port
-    output port readPoll: Fw.BufferSend
-
-    # ----------------------------------------------------------------------
-    # Special Ports
-    # ----------------------------------------------------------------------
-
-    @ Event port
-    event port Log
-
-    @ Text event port
-    text event port LogText
-
-    @ Time get port
-    time get port Time
-
-    # ----------------------------------------------------------------------
-    # Events
-    # ----------------------------------------------------------------------
-
-    include "Events.fppi"
-
-  }
-
-}
diff --git a/Svc/GroundInterface/GroundInterface.hpp b/Svc/GroundInterface/GroundInterface.hpp
deleted file mode 100644
index b227cd1133..0000000000
--- a/Svc/GroundInterface/GroundInterface.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-// ======================================================================
-// \title  GroundInterfaceImpl.hpp
-// \author lestarch
-// \brief  hpp file for GroundInterface component implementation class
-// ======================================================================
-#include <Fw/Types/Serializable.hpp>
-#include "Svc/GroundInterface/GroundInterfaceComponentAc.hpp"
-#include "Utils/Types/CircularBuffer.hpp"
-#ifndef GroundInterface_HPP
-#define GroundInterface_HPP
-
-#define GND_BUFFER_SIZE 1024
-#define TOKEN_TYPE U32
-#define HEADER_SIZE (2 * sizeof(TOKEN_TYPE))
-
-namespace Svc {
-
-  class GroundInterfaceComponentImpl :
-    public GroundInterfaceComponentBase
-  {
-    public:
-      static const U32 MAX_DATA_SIZE;
-      static const TOKEN_TYPE START_WORD;
-      static const U32 END_WORD;
-      // ----------------------------------------------------------------------
-      // Construction, initialization, and destruction
-      // ----------------------------------------------------------------------
-
-      //! Construct object GroundInterface
-      //!
-      GroundInterfaceComponentImpl(
-          const char *const compName /*!< The component name*/
-      );
-
-      //! Initialize object GroundInterface
-      //!
-      void init(
-          const NATIVE_INT_TYPE instance = 0 /*!< The instance number*/
-      );
-
-      //! Destroy object GroundInterface
-      //!
-      ~GroundInterfaceComponentImpl();
-
-    PRIVATE:
-
-      // ----------------------------------------------------------------------
-      // Handler implementations for user-defined typed input ports
-      // ----------------------------------------------------------------------
-
-      //! Handler implementation for downlinkPort
-      //!
-      void downlinkPort_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::ComBuffer &data, /*!< Buffer containing packet data*/
-          U32 context /*!< Call context value; meaning chosen by user*/
-      );
-
-      //! Handler implementation for fileDownlinkBufferSendIn
-      //!
-      void fileDownlinkBufferSendIn_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::Buffer &fwBuffer
-      );
-
-      //! Handler implementation for readCallback
-      //!
-      void readCallback_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::Buffer &fwBuffer
-      );
-
-      //! Handler implementation for schedIn
-      //!
-      void schedIn_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          U32 context /*!< The call order*/
-      );
-      //! Frame and send some data
-      //!
-      void frame_send(
-          U8* data, /*!< Data to be framed and sent out */
-          TOKEN_TYPE size, /*!< Size of data in typed format */
-          TOKEN_TYPE packet_type = Fw::ComPacket::FW_PACKET_UNKNOWN /*!< Packet type override for anonymous data i.e. file downlink */
-      );
-
-      //! Processes the out-going data into coms order
-      void routeComData();
-
-      //! Process all the data in the ring
-      void processRing();
-
-      //! Process a data buffer containing a read from the serial port
-      void processBuffer(Fw::Buffer& data /*!< Data to process */);
-
-      // Basic data movement variables
-      Fw::Buffer m_ext_buffer;
-      U8 m_buffer[GND_BUFFER_SIZE];
-      // Input variables
-      TOKEN_TYPE m_data_size; //!< Data size expected in incoming data
-      U8 m_in_buffer[GND_BUFFER_SIZE];
-      Types::CircularBuffer m_in_ring;
-    };
-
-} // end namespace Svc
-
-#endif
diff --git a/Svc/GroundInterface/README b/Svc/GroundInterface/README
deleted file mode 100644
index ecbc8d597f..0000000000
--- a/Svc/GroundInterface/README
+++ /dev/null
@@ -1,7 +0,0 @@
-A generic interface to ground that interacts with 3 data passing ports:
-
- 1. Read Callback: (input) called when data is available, if connected
- 2. Read Poll: (output) poll-able port for retrieving data, if connected
- 3. Write: (output) used to send out data
-
- Note: it is expected that only one of the read ports is hooked up.
\ No newline at end of file


Test patch:
diff --git a/Svc/GroundInterface/test/ut/DeframerRules.hpp b/Svc/GroundInterface/test/ut/DeframerRules.hpp
deleted file mode 100644
index 3a398d9a49..0000000000
--- a/Svc/GroundInterface/test/ut/DeframerRules.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * GroundInterfaceRules.hpp:
- *
- * This file specifies Rule classes for testing of the Svc::GroundInterface. These rules can then be used by the main
- * testing program to test the code. These rules support rule-based random testing.
- *
- * GroundInterface rules:
- *
- * 1. On read-callback of sufficient parts, an uplink-out is produced
- * 2. On schedIn a sufficient number of times, an uplink-out is produced
- * 3. On a call to Log, TextLog, downlink, a framed call to write is produced.
- *
- * @author mstarch
- */
-#ifndef FPRIME_SVC_GROUND_INTERFACE_HPP
-#define FPRIME_SVC_GROUND_INTERFACE_HPP
-
-#include <FpConfig.hpp>
-#include <Fw/Types/EightyCharString.hpp>
-#include "GroundInterfaceTester.hpp"
-#include <STest/STest/Rule/Rule.hpp>
-#include <STest/STest/Pick/Pick.hpp>
-
-
-namespace Svc {
-
-    /**
-     * RandomizeRule:
-     *
-     * This rule sets up random state
-     */
-    struct RandomizeRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        RandomizeRule(const Fw::EightyCharString& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-    struct DownlinkRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        DownlinkRule(const Fw::EightyCharString& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-    struct FileDownlinkRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        FileDownlinkRule(const Fw::EightyCharString& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-    struct SendAvailableRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        SendAvailableRule(const Fw::EightyCharString& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-};
-#endif //FPRIME_SVC_GROUND_INTERFACE_HPP
diff --git a/Svc/GroundInterface/test/ut/GroundInterfaceRules.cpp b/Svc/GroundInterface/test/ut/GroundInterfaceRules.cpp
deleted file mode 100644
index 8060867d3b..0000000000
--- a/Svc/GroundInterface/test/ut/GroundInterfaceRules.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- * GroundInterfaceRules.cpp:
- *
- * This file specifies Rule classes for testing of the Svc::GroundInterface. These rules can then be used by the main
- * testing program to test the code.
- *
- *
- * @author mstarch
- */
-#include "GroundInterfaceRules.hpp"
-#include <STest/Pick/Pick.hpp>
-
-namespace Svc {
-    // Constructor
-    RandomizeRule :: RandomizeRule(const Fw::String& name) : STest::Rule<GroundInterfaceTester>(name.toChar()) {}
-
-    // Can always randomize
-    bool RandomizeRule :: precondition(const Svc::GroundInterfaceTester &state) {
-        return true;
-    }
-    // Randomize
-    void RandomizeRule :: action(Svc::GroundInterfaceTester &state) {
-        state.m_uplink_type = STest::Pick::lowerUpper(0, 1);
-        state.m_uplink_size = STest::Pick::lowerUpper(0, sizeof(state.m_uplink_data) - 1);
-        // Reset or not sent allows randomization
-        if (state.m_uplink_type == 2 || state.m_uplink_point == 0) {
-            state.m_uplink_type = STest::Pick::lowerUpper(0, 1);
-            state.m_uplink_used = STest::Pick::lowerUpper(4, FW_COM_BUFFER_MAX_SIZE);
-            state.m_uplink_com_type = static_cast<Fw::ComPacket::ComPacketType>(
-                    STest::Pick::lowerUpper(Fw::ComPacket::FW_PACKET_COMMAND,Fw::ComPacket::FW_PACKET_FILE));
-            for (U32 i = 0; i < state.m_uplink_used; i++) {
-                state.m_uplink_data[(sizeof(TOKEN_TYPE) * 2) + i] =
-                        static_cast<U8>(STest::Pick::lowerUpper(0, 255));
-            }
-        }
-        // Correct header info for items
-        state.update_header_info();
-    }
-
-
-    // Constructor
-    DownlinkRule :: DownlinkRule(const Fw::String& name) : STest::Rule<GroundInterfaceTester>(name.toChar()) {}
-
-    // Can always downlink
-    bool DownlinkRule :: precondition(const Svc::GroundInterfaceTester &state) {
-        return true;
-    }
-    // Pick a rule and downlink
-    void DownlinkRule :: action(Svc::GroundInterfaceTester &state) {
-        Fw::ComBuffer buffer;
-        // Force a U32 to know the size
-        buffer.serialize(static_cast<U32>(0xdeadbeef));
-        state.setInputParams(sizeof(U32), buffer.getBuffAddr());
-        state.invoke_to_downlinkPort(0, buffer, 0);
-        state.assert_from_write_size(__FILE__, __LINE__, 1);
-        state.clearFromPortHistory();
-    }
-
-    // Constructor
-    FileDownlinkRule :: FileDownlinkRule(const Fw::String& name) : STest::Rule<GroundInterfaceTester>(name.toChar()) {}
-
-    // Can always downlink
-    bool FileDownlinkRule :: precondition(const Svc::GroundInterfaceTester &state) {
-        return true;
-    }
-    // Pick a rule and downlink
-    void FileDownlinkRule :: action(Svc::GroundInterfaceTester &state) {
-        U8 data_holder[2048];
-        Fw::Buffer buffer(data_holder, sizeof(data_holder));
-        Fw::ExternalSerializeBuffer buffer_wrapper(buffer.getData(), buffer.getSize());
-        // Force a U32 to know the size
-        buffer_wrapper.serialize(static_cast<U32>(0xdeadbeef));
-        buffer.setSize(buffer_wrapper.getBuffLength());
-        state.setInputParams(sizeof(U32) + sizeof(TOKEN_TYPE), buffer.getData(),
-                             Fw::ComPacket::FW_PACKET_FILE);
-        state.invoke_to_fileDownlinkBufferSendIn(0, buffer);
-        state.assert_from_write_size(__FILE__, __LINE__, 1);
-        state.assert_from_fileDownlinkBufferSendOut_size(__FILE__, __LINE__, 1);
-        state.clearFromPortHistory();
-    }
-
-    // Constructor
-    SendAvailableRule :: SendAvailableRule(const Fw::String& name) : STest::Rule<GroundInterfaceTester>(name.toChar()) {}
-
-    // Can always downlink
-    bool SendAvailableRule :: precondition(const Svc::GroundInterfaceTester &state) {
-        return true;
-    }
-
-    // Pick a rule and downlink
-    void SendAvailableRule :: action(Svc::GroundInterfaceTester &state) {
-        U32 total_used = state.m_uplink_used + HEADER_SIZE + sizeof(U32);
-        U8* up_ptr = state.m_uplink_data + state.m_uplink_point;
-        U32 size = ((state.m_uplink_point + state.m_uplink_size) >= total_used) ?
-                    (total_used - state.m_uplink_point) : state.m_uplink_size;
-        state.m_uplink_point = (state.m_uplink_point + size >= total_used) ? 0 : (state.m_uplink_point + size);
-        Fw::Buffer buffer(up_ptr, size);
-        // Uplink based on uplink type
-        if (state.m_uplink_type) {
-            state.invoke_to_readCallback(0,buffer);
-        } else {
-            state.m_incoming_buffer = buffer;
-            state.invoke_to_schedIn(0, 0);
-        }
-        // Finished current uplink, check that the uplink was handled
-        if (state.m_uplink_point == 0 && size > 0) {
-            // Check uplink type
-            if (state.m_uplink_com_type == Fw::ComPacket::FW_PACKET_COMMAND) {
-                state.assert_from_uplinkPort_size(__FILE__, __LINE__, 1);
-            } else if (state.m_uplink_com_type == Fw::ComPacket::FW_PACKET_FILE) {
-                state.assert_from_fileUplinkBufferSendOut_size(__FILE__, __LINE__, 1);
-            }
-            state.clearFromPortHistory();
-        } else {
-            state.assert_from_uplinkPort_size(__FILE__, __LINE__, 0);
-        }
-    }
-};
diff --git a/Svc/GroundInterface/test/ut/GroundInterfaceRules.hpp b/Svc/GroundInterface/test/ut/GroundInterfaceRules.hpp
deleted file mode 100644
index 9e980a1745..0000000000
--- a/Svc/GroundInterface/test/ut/GroundInterfaceRules.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * GroundInterfaceRules.hpp:
- *
- * This file specifies Rule classes for testing of the Svc::GroundInterface. These rules can then be used by the main
- * testing program to test the code. These rules support rule-based random testing.
- *
- * GroundInterface rules:
- *
- * 1. On read-callback of sufficient parts, an uplink-out is produced
- * 2. On schedIn a sufficient number of times, an uplink-out is produced
- * 3. On a call to Log, TextLog, downlink, a framed call to write is produced.
- *
- * @author mstarch
- */
-#ifndef FPRIME_SVC_GROUND_INTERFACE_HPP
-#define FPRIME_SVC_GROUND_INTERFACE_HPP
-
-#include <FpConfig.hpp>
-#include <Fw/Types/String.hpp>
-#include "GroundInterfaceTester.hpp"
-#include <STest/STest/Rule/Rule.hpp>
-#include <STest/STest/Pick/Pick.hpp>
-
-
-namespace Svc {
-
-    /**
-     * RandomizeRule:
-     *
-     * This rule sets up random state
-     */
-    struct RandomizeRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        RandomizeRule(const Fw::String& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-    struct DownlinkRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        DownlinkRule(const Fw::String& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-    struct FileDownlinkRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        FileDownlinkRule(const Fw::String& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-    struct SendAvailableRule : public STest::Rule<GroundInterfaceTester> {
-        // Constructor
-        SendAvailableRule(const Fw::String& name);
-
-        // Always valid
-        bool precondition(const GroundInterfaceTester& state);
-
-        // Will randomize the test state
-        void action(GroundInterfaceTester& truth);
-    };
-
-};
-#endif //FPRIME_SVC_GROUND_INTERFACE_HPP
diff --git a/Svc/GroundInterface/test/ut/GroundInterfaceTestMain.cpp b/Svc/GroundInterface/test/ut/GroundInterfaceTestMain.cpp
deleted file mode 100644
index 7290ddb68d..0000000000
--- a/Svc/GroundInterface/test/ut/GroundInterfaceTestMain.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-// ----------------------------------------------------------------------
-// TestMain.cpp
-// ----------------------------------------------------------------------
-
-#include "GroundInterfaceTester.hpp"
-#include <gtest/gtest.h>
-#include <Svc/GroundInterface/test/ut/GroundInterfaceRules.hpp>
-#include <STest/Scenario/Scenario.hpp>
-#include <STest/Scenario/RandomScenario.hpp>
-#include <STest/Scenario/BoundedScenario.hpp>
-
-#define STEP_COUNT 10000
-
-/**
- * A random hopper for rules. Apply STEP_COUNT times.
- */
-TEST(Nominal, RandomizedGroundIf) {
-    Svc::GroundInterfaceTester tester;
-
-    // Create rules, and assign them into the array
-    Svc::RandomizeRule randomize("Randomize");
-    Svc::DownlinkRule downlink("Downlink");
-    Svc::FileDownlinkRule filedown("File Down");
-    Svc::SendAvailableRule sendup("");
-
-    // Setup a list of rules to choose from
-    STest::Rule<Svc::GroundInterfaceTester>* rules[] = {
-            &randomize,
-            &downlink,
-            &filedown,
-            &sendup
-    };
-    // Construct the random scenario and run it with the defined bounds
-    STest::RandomScenario<Svc::GroundInterfaceTester> random("Random Rules", rules, FW_NUM_ARRAY_ELEMENTS(rules));
-
-    // Setup a bounded scenario to run rules a set number of times
-    STest::BoundedScenario<Svc::GroundInterfaceTester> bounded("Bounded Random Rules Scenario", random, STEP_COUNT);
-    // Run!
-    const U32 numSteps = bounded.run(tester);
-    printf("Ran %u steps.\n", numSteps);
-}
-
-
-TEST(Nominal, BasicUplink) {
-    Svc::GroundInterfaceTester tester;
-    Svc::SendAvailableRule rule("Uplink Rule");
-    rule.apply(tester);
-}
-
-TEST(Nominal, BasicDownlink) {
-    Svc::GroundInterfaceTester tester;
-    Svc::DownlinkRule rule("Downlink Rule");
-    rule.apply(tester);
-}
-
-TEST(Nominal, FileDownlink) {
-    Svc::GroundInterfaceTester tester;
-    Svc::FileDownlinkRule rule("File Down Rule");
-    rule.apply(tester);
-}
-
-int main(int argc, char **argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}
diff --git a/Svc/GroundInterface/test/ut/GroundInterfaceTester.cpp b/Svc/GroundInterface/test/ut/GroundInterfaceTester.cpp
deleted file mode 100644
index e4c4de0644..0000000000
--- a/Svc/GroundInterface/test/ut/GroundInterfaceTester.cpp
+++ /dev/null
@@ -1,278 +0,0 @@
-// ======================================================================
-// \title  GroundInterface.hpp
-// \author mstarch
-// \brief  cpp file for GroundInterface test harness implementation class
-//
-// \copyright
-// Copyright 2009-2015, by the California Institute of Technology.
-// ALL RIGHTS RESERVED.  United States Government Sponsorship
-// acknowledged.
-//
-// ======================================================================
-
-#include "GroundInterfaceTester.hpp"
-
-#define INSTANCE 0
-#define MAX_HISTORY_SIZE 10
-
-U8 file_back_buffer[10240];
-
-namespace Svc {
-  // ----------------------------------------------------------------------
-  // Construction and destruction
-  // ----------------------------------------------------------------------
-
-  GroundInterfaceTester ::
-    GroundInterfaceTester() :
-      GroundInterfaceGTestBase("Tester", MAX_HISTORY_SIZE),
-      component("GroundInterface")
-      ,
-      m_buffer(nullptr),
-      m_uplink_type(1),
-      m_uplink_used(30),
-      m_uplink_size(sizeof(TOKEN_TYPE) * 3 + m_uplink_used),
-      m_uplink_point(0),
-      m_uplink_com_type(Fw::ComPacket::FW_PACKET_COMMAND)
-  {
-    this->initComponents();
-    this->connectPorts();
-    update_header_info();
-  }
-
-  GroundInterfaceTester ::
-    ~GroundInterfaceTester()
-  {
-
-  }
-
-
-
-  // ----------------------------------------------------------------------
-  // Tests State Adjustments
-  // ----------------------------------------------------------------------
-
-  void GroundInterfaceTester :: update_header_info() {
-      // Write token types
-      for (U32 i = 0; i < sizeof(TOKEN_TYPE); i++) {
-          m_uplink_data[i] = (GroundInterfaceComponentImpl::START_WORD >> ((sizeof(TOKEN_TYPE) - 1 - i) * 8)) & 0xFF;
-          m_uplink_data[i + sizeof(TOKEN_TYPE)] =
-                  (m_uplink_used >> ((sizeof(TOKEN_TYPE) - 1 - i) * 8)) & 0xFF;
-          m_uplink_data[i + 2 * sizeof(TOKEN_TYPE) + m_uplink_used] =
-                  (GroundInterfaceComponentImpl::END_WORD >> ((sizeof(TOKEN_TYPE) - 1 - i) * 8)) & 0xFF;
-      }
-      // Packet type
-      m_uplink_data[2 * sizeof(TOKEN_TYPE) + 0] = (static_cast<U32>(m_uplink_com_type) >> 24) & 0xFF;
-      m_uplink_data[2 * sizeof(TOKEN_TYPE) + 1] = (static_cast<U32>(m_uplink_com_type) >> 16) & 0xFF;
-      m_uplink_data[2 * sizeof(TOKEN_TYPE) + 2] = (static_cast<U32>(m_uplink_com_type) >>  8) & 0xFF;
-      m_uplink_data[2 * sizeof(TOKEN_TYPE) + 3] = (static_cast<U32>(m_uplink_com_type) >>  0) & 0xFF;
-  }
-
-  void GroundInterfaceTester :: setInputParams(TOKEN_TYPE size, U8* buffer, TOKEN_TYPE packet_type) {
-      m_size = size;
-      m_buffer = buffer;
-      m_packet = packet_type;
-  }
-
-  // ----------------------------------------------------------------------
-  // Handlers for typed from ports
-  // ----------------------------------------------------------------------
-
-  void GroundInterfaceTester ::
-    from_fileUplinkBufferSendOut_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::Buffer &fwBuffer
-    )
-  {
-    this->pushFromPortEntry_fileUplinkBufferSendOut(fwBuffer);
-    for (U32 i = 0; i < fwBuffer.getSize(); i++) {
-        // File uplink strips type before outputting to FileUplink
-        ASSERT_EQ(fwBuffer.getData()[i], m_uplink_data[i + HEADER_SIZE + sizeof(TOKEN_TYPE)]);
-    }
-  }
-
-  void GroundInterfaceTester ::
-    from_uplinkPort_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::ComBuffer &data,
-        U32 context
-    )
-  {
-    this->pushFromPortEntry_uplinkPort(data, context);
-    for (U32 i = 0; i < data.getBuffLength(); i++) {
-        ASSERT_EQ(data.getBuffAddr()[i], m_uplink_data[i + HEADER_SIZE]);
-    }
-  }
-
-  void GroundInterfaceTester ::
-    from_fileDownlinkBufferSendOut_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::Buffer &fwBuffer
-    )
-  {
-    this->pushFromPortEntry_fileDownlinkBufferSendOut(fwBuffer);
-
-  }
-
-  Fw::Buffer GroundInterfaceTester ::
-    from_fileUplinkBufferGet_handler(
-        const NATIVE_INT_TYPE portNum,
-        U32 size
-    )
-  {
-    this->pushFromPortEntry_fileUplinkBufferGet(size);
-    m_incoming_file_buffer.setData(file_back_buffer);
-    m_incoming_file_buffer.setSize(size);
-    return m_incoming_file_buffer;
-  }
-
-  void GroundInterfaceTester ::
-    from_write_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::Buffer &fwBuffer
-    )
-  {
-    this->pushFromPortEntry_write(fwBuffer);
-    // All writes can be processed here
-    TOKEN_TYPE start = 0;
-    TOKEN_TYPE size = 0;
-    TOKEN_TYPE packet = 0;
-    U32 end = 0;
-    Fw::ExternalSerializeBuffer buffer_wrapper(fwBuffer.getData(), fwBuffer.getSize());
-    buffer_wrapper.setBuffLen(fwBuffer.getSize());
-    // Check basic deserialization
-    ASSERT_EQ(buffer_wrapper.deserialize(start), Fw::FW_SERIALIZE_OK);
-    ASSERT_EQ(buffer_wrapper.deserialize(size), Fw::FW_SERIALIZE_OK);
-    ASSERT_EQ(start, GroundInterfaceComponentImpl::START_WORD);
-    ASSERT_EQ(size, m_size);
-    // Deserialize the packet type, if know. This handles the different paths for FilePackets and homogenized packets
-    if (m_packet != Fw::ComPacket::FW_PACKET_UNKNOWN) {
-        ASSERT_EQ(buffer_wrapper.deserialize(packet), Fw::FW_SERIALIZE_OK);
-        // For now, only FilePackets take this path
-        ASSERT_EQ(packet, Fw::ComPacket::FW_PACKET_FILE);
-        m_size -= sizeof(packet);
-    }
-    // Note: no checking for symmetric errors, as we are depending on ExternalSerializeBuffer's correctness here
-    for (U32 i = 0; i < m_size; i++) {
-        U8 byte_data;
-        ASSERT_EQ(buffer_wrapper.deserialize(byte_data), Fw::FW_SERIALIZE_OK);
-        ASSERT_EQ(byte_data, m_buffer[i]);
-    }
-    // Look at end work
-    ASSERT_EQ(buffer_wrapper.deserialize(end), Fw::FW_SERIALIZE_OK);
-    ASSERT_EQ(end, GroundInterfaceComponentImpl::END_WORD);
-    ASSERT_from_write_SIZE(1);
-  }
-
-  void GroundInterfaceTester ::
-    from_readPoll_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::Buffer &fwBuffer
-    )
-  {
-    this->pushFromPortEntry_readPoll(fwBuffer);
-    U8* incoming = m_incoming_buffer.getData();
-    U8* outgoing = fwBuffer.getData();
-    for (U32 i = 0; i < m_incoming_buffer.getSize(); i++) {
-        outgoing[i] = incoming[i];
-    }
-    fwBuffer.setSize(m_incoming_buffer.getSize());
-  }
-
-  // ----------------------------------------------------------------------
-  // Helper methods
-  // ----------------------------------------------------------------------
-
-  void GroundInterfaceTester ::
-    connectPorts()
-  {
-
-    // downlinkPort
-    this->connect_to_downlinkPort(
-        0,
-        this->component.get_downlinkPort_InputPort(0)
-    );
-
-    // fileDownlinkBufferSendIn
-    this->connect_to_fileDownlinkBufferSendIn(
-        0,
-        this->component.get_fileDownlinkBufferSendIn_InputPort(0)
-    );
-
-    // readCallback
-    this->connect_to_readCallback(
-        0,
-        this->component.get_readCallback_InputPort(0)
-    );
-
-    // schedIn
-    this->connect_to_schedIn(
-        0,
-        this->component.get_schedIn_InputPort(0)
-    );
-
-    // fileUplinkBufferSendOut
-    this->component.set_fileUplinkBufferSendOut_OutputPort(
-        0,
-        this->get_from_fileUplinkBufferSendOut(0)
-    );
-
-    // Log
-    this->component.set_Log_OutputPort(
-        0,
-        this->get_from_Log(0)
-    );
-
-    // LogText
-    this->component.set_LogText_OutputPort(
-        0,
-        this->get_from_LogText(0)
-    );
-
-    // Time
-    this->component.set_Time_OutputPort(
-        0,
-        this->get_from_Time(0)
-    );
-
-    // uplinkPort
-    this->component.set_uplinkPort_OutputPort(
-        0,
-        this->get_from_uplinkPort(0)
-    );
-
-    // fileDownlinkBufferSendOut
-    this->component.set_fileDownlinkBufferSendOut_OutputPort(
-        0,
-        this->get_from_fileDownlinkBufferSendOut(0)
-    );
-
-    // fileUplinkBufferGet
-    this->component.set_fileUplinkBufferGet_OutputPort(
-        0,
-        this->get_from_fileUplinkBufferGet(0)
-    );
-
-    // write
-    this->component.set_write_OutputPort(
-        0,
-        this->get_from_write(0)
-    );
-
-    // readPoll
-    this->component.set_readPoll_OutputPort(
-        0,
-        this->get_from_readPoll(0)
-    );
-
-  }
-
-  void GroundInterfaceTester ::
-    initComponents()
-  {
-    this->init();
-    this->component.init(
-        INSTANCE
-    );
-  }
-
-} // end namespace Svc
diff --git a/Svc/GroundInterface/test/ut/GroundInterfaceTester.hpp b/Svc/GroundInterface/test/ut/GroundInterfaceTester.hpp
deleted file mode 100644
index 8e6aec7f9e..0000000000
--- a/Svc/GroundInterface/test/ut/GroundInterfaceTester.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-// ======================================================================
-// \title  GroundInterface/test/ut/Tester.hpp
-// \author mstarch
-// \brief  hpp file for GroundInterface test harness implementation class
-//
-// \copyright
-// Copyright 2009-2015, by the California Institute of Technology.
-// ALL RIGHTS RESERVED.  United States Government Sponsorship
-// acknowledged.
-//
-// ======================================================================
-
-#ifndef TESTER_HPP
-#define TESTER_HPP
-
-#include <Fw/Com/ComPacket.hpp>
-#include "GroundInterfaceGTestBase.hpp"
-#include "Svc/GroundInterface/GroundInterface.hpp"
-
-namespace Svc {
-
-  class GroundInterfaceTester :
-    public GroundInterfaceGTestBase
-  {
-    private:
-      friend struct RandomizeRule;
-      friend struct DownlinkRule;
-      friend struct FileDownlinkRule;
-      friend struct SendAvailableRule;
-      // ----------------------------------------------------------------------
-      // Construction and destruction
-      // ----------------------------------------------------------------------
-
-    public:
-      //! Construct object GroundInterfaceTester
-      //!
-      GroundInterfaceTester();
-
-      //! Destroy object GroundInterfaceTester
-      //!
-      ~GroundInterfaceTester();
-
-    public:
-
-      // ----------------------------------------------------------------------
-      // Tests
-      // ----------------------------------------------------------------------
-
-      void update_header_info();
-
-      void setInputParams(TOKEN_TYPE size, U8* buffer, TOKEN_TYPE packet_type = Fw::ComPacket::FW_PACKET_UNKNOWN);
-
-    private:
-
-      // ----------------------------------------------------------------------
-      // Handlers for typed from ports
-      // ----------------------------------------------------------------------
-
-      //! Handler for from_fileUplinkBufferSendOut
-      //!
-      void from_fileUplinkBufferSendOut_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::Buffer &fwBuffer
-      );
-
-      //! Handler for from_uplinkPort
-      //!
-      void from_uplinkPort_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::ComBuffer &data, /*!< Buffer containing packet data*/
-          U32 context /*!< Call context value; meaning chosen by user*/
-      );
-
-      //! Handler for from_fileDownlinkBufferSendOut
-      //!
-      void from_fileDownlinkBufferSendOut_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::Buffer &fwBuffer
-      );
-
-      //! Handler for from_fileUplinkBufferGet
-      //!
-      Fw::Buffer from_fileUplinkBufferGet_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          U32 size
-      );
-
-      //! Handler for from_write
-      //!
-      void from_write_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::Buffer &fwBuffer
-      );
-
-      //! Handler for from_readPoll
-      //!
-      void from_readPoll_handler(
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          Fw::Buffer &fwBuffer
-      );
-
-    private:
-
-      // ----------------------------------------------------------------------
-      // Helper methods
-      // ----------------------------------------------------------------------
-
-      //! Connect ports
-      //!
-      void connectPorts();
-
-      //! Initialize components
-      //!
-      void initComponents();
-
-    private:
-
-      // ----------------------------------------------------------------------
-      // Variables
-      // ----------------------------------------------------------------------
-
-      //! The component under test
-      //!
-      GroundInterfaceComponentImpl component;
-
-      //! Expected buffer, for checking of the interface
-      TOKEN_TYPE m_size;
-      TOKEN_TYPE m_packet;
-      Fw::Buffer m_incoming_buffer;
-      Fw::Buffer m_incoming_file_buffer;
-      U8* m_buffer;
-      U32 m_uplink_type;
-      U32 m_uplink_used;
-      U32 m_uplink_size;
-      U32 m_uplink_point;
-      Fw::ComPacket::ComPacketType m_uplink_com_type;
-      // Initialize to empty list to appease valgrind
-      U8 m_uplink_data[(sizeof(TOKEN_TYPE) * 3) + FW_COM_BUFFER_MAX_SIZE] = {};
-
-  };
-
-} // end namespace Svc
-
-#endif
diff --git a/cmake/test/src/test_unittests.py b/cmake/test/src/test_unittests.py
index fb4f464b9d..7a07c3471d 100644
--- a/cmake/test/src/test_unittests.py
+++ b/cmake/test/src/test_unittests.py
@@ -50,7 +50,6 @@
     "Svc_FileUplink_ut_exe",
     "Svc_Framer_ut_exe",
     "Svc_GenericHub_ut_exe",
-    "Svc_GroundInterface_ut_exe",
     "Svc_Health_ut_exe",
     "Svc_PosixTime_ut_exe",
     "Svc_LinuxTimer_ut_exe",