Remove proto-RFNoC files

This commit removes all files and parts of files that are used by
proto-RFNoC only.

uhd: Fix include CMakeLists.txt, add missing files

18 files changed, 6 insertions, 1982 deletions

diff --git a/host/tests/CMakeLists.txt b/host/tests/CMakeLists.txt
index d790b214e..8a477b181 100644
--- a/host/tests/CMakeLists.txt
+++ b/host/tests/CMakeLists.txt
@@ -42,7 +42,6 @@ set(test_sources
     property_test.cpp
     ranges_test.cpp
     scope_exit_test.cpp
-    sid_t_test.cpp
     sensors_test.cpp
     soft_reg_test.cpp
     sph_recv_test.cpp
@@ -53,29 +52,16 @@ set(test_sources
     vrt_test.cpp
     expert_test.cpp
     fe_conn_test.cpp
-    rfnoc_node_test.cpp
     link_test.cpp
     rx_streamer_test.cpp
     tx_streamer_test.cpp
+    block_id_test.cpp
+    rfnoc_property_test.cpp
 )
 
 #turn each test cpp file into an executable with an int main() function
 add_definitions(-DBOOST_TEST_DYN_LINK -DBOOST_TEST_MAIN)
 
-if(ENABLE_RFNOC)
-    list(APPEND test_sources
-        block_id_test.cpp
-        blockdef_test.cpp
-        device3_test.cpp
-        graph_search_test.cpp
-        node_connect_test.cpp
-        rate_node_test.cpp
-        stream_sig_test.cpp
-        tick_node_test.cpp
-        rfnoc_property_test.cpp
-    )
-endif(ENABLE_RFNOC)
-
 if(ENABLE_C_API)
     list(APPEND test_sources
         eeprom_c_test.c
@@ -149,15 +135,6 @@ if(ENABLE_DPDK)
 ENDIF(ENABLE_DPDK)
 
 UHD_ADD_NONAPI_TEST(
-    TARGET "nocscript_expr_test.cpp"
-    EXTRA_SOURCES
-    "${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/expression.cpp"
-    INCLUDE_DIRS
-    ${CMAKE_BINARY_DIR}/lib/rfnoc/nocscript/
-    ${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/
-)
-
-UHD_ADD_NONAPI_TEST(
     TARGET "system_time_test.cpp"
     EXTRA_SOURCES
     "${CMAKE_SOURCE_DIR}/lib/utils/system_time.cpp"
@@ -175,36 +152,6 @@ UHD_ADD_NONAPI_TEST(
     NOAUTORUN # Don't register for auto-run
 )
 
-#UHD_ADD_NONAPI_TEST(
-    #TARGET "nocscript_expr_test.cpp"
-    #EXTRA_SOURCES
-    #"${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/expression.cpp"
-    #INCLUDE_DIRS
-    #${CMAKE_BINARY_DIR}/lib/rfnoc/nocscript/
-    #${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/
-#)
-
-#UHD_ADD_NONAPI_TEST(
-    #TARGET "nocscript_ftable_test.cpp"
-    #EXTRA_SOURCES
-    #${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/function_table.cpp
-    #${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/expression.cpp
-    #INCLUDE_DIRS
-    #${CMAKE_BINARY_DIR}/lib/rfnoc/nocscript/
-    #${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/
-#)
-
-UHD_ADD_NONAPI_TEST(
-    TARGET "nocscript_parser_test.cpp"
-    EXTRA_SOURCES
-    ${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/parser.cpp
-    ${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/function_table.cpp
-    ${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/expression.cpp
-    INCLUDE_DIRS
-    ${CMAKE_BINARY_DIR}/lib/rfnoc/nocscript/
-    ${CMAKE_SOURCE_DIR}/lib/rfnoc/nocscript/
-)
-
 UHD_ADD_NONAPI_TEST(
     TARGET "packet_handler_benchmark.cpp"
     NOAUTORUN
diff --git a/host/tests/common/CMakeLists.txt b/host/tests/common/CMakeLists.txt
index 58299c688..7f31f3463 100644
--- a/host/tests/common/CMakeLists.txt
+++ b/host/tests/common/CMakeLists.txt
@@ -8,8 +8,6 @@
 # Build uhd_test static lib
 ########################################################################
 include_directories("${CMAKE_SOURCE_DIR}/lib/include")
-add_library(uhd_test ${CMAKE_CURRENT_SOURCE_DIR}/mock_ctrl_iface_impl.cpp
-                     ${CMAKE_CURRENT_SOURCE_DIR}/mock_zero_copy.cpp
-                     ${CMAKE_SOURCE_DIR}/lib/rfnoc/graph_impl.cpp
-                     ${CMAKE_SOURCE_DIR}/lib/rfnoc/async_msg_handler.cpp
+add_library(uhd_test
+    ${CMAKE_CURRENT_SOURCE_DIR}/mock_zero_copy.cpp
 )
diff --git a/host/tests/common/mock_ctrl_iface_impl.cpp b/host/tests/common/mock_ctrl_iface_impl.cpp
deleted file mode 100644
index af32637df..000000000
--- a/host/tests/common/mock_ctrl_iface_impl.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "mock_ctrl_iface_impl.hpp"
-static const uint64_t TEST_NOC_ID = 0xAAAABBBBCCCCDDDD;
-
-uint64_t mock_ctrl_iface_impl::send_cmd_pkt(const size_t addr,
-    const size_t data,
-    const bool readback,
-    const uint64_t /* timestamp */
-)
-{
-    if (not readback) {
-        std::cout << str(boost::format("[MOCK] poke to addr: %016X, data == %016X") % addr
-                         % data)
-                  << std::endl;
-    } else {
-        std::cout << str(boost::format("[MOCK] peek64 to addr: %016X") % data)
-                  << std::endl;
-        switch (data) {
-            case uhd::rfnoc::SR_READBACK_REG_ID:
-                return TEST_NOC_ID;
-            case uhd::rfnoc::SR_READBACK_REG_FIFOSIZE:
-                return 0x0000000000010000;
-            case uhd::rfnoc::SR_READBACK_REG_USER:
-                return 0x0123456789ABCDEF;
-            case uhd::rfnoc::SR_READBACK_COMPAT:
-                return uint64_t(uhd::rfnoc::NOC_SHELL_COMPAT_MAJOR) << 32
-                       | uint64_t(uhd::rfnoc::NOC_SHELL_COMPAT_MINOR);
-            default:
-                return 0;
-        }
-    }
-    return 0;
-}
diff --git a/host/tests/common/mock_ctrl_iface_impl.hpp b/host/tests/common/mock_ctrl_iface_impl.hpp
deleted file mode 100644
index f20858b63..000000000
--- a/host/tests/common/mock_ctrl_iface_impl.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-
-#ifndef INCLUDED_MOCK_CTRL_IFACE_IMPL_HPP
-#define INCLUDED_MOCK_CTRL_IFACE_IMPL_HPP
-
-#include <uhd/rfnoc/constants.hpp>
-#include <uhdlib/rfnoc/ctrl_iface.hpp>
-#include <boost/bind.hpp>
-#include <boost/format.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <queue>
-
-class mock_ctrl_iface_impl : public uhd::rfnoc::ctrl_iface
-{
-    uint64_t send_cmd_pkt(const size_t addr,
-        const size_t data,
-        const bool readback      = false,
-        const uint64_t timestamp = 0);
-
-    void set_cmd_fifo_size(const size_t) {}
-};
-#endif /* INCLUDED_MOCK_CTRL_IFACE_IMPL_HPP */
diff --git a/host/tests/common/mock_zero_copy.hpp b/host/tests/common/mock_zero_copy.hpp
index 60e5f4659..515fde498 100644
--- a/host/tests/common/mock_zero_copy.hpp
+++ b/host/tests/common/mock_zero_copy.hpp
@@ -12,9 +12,7 @@
 #include <uhd/transport/vrt_if_packet.hpp>
 #include <uhd/transport/zero_copy.hpp>
 #include <uhd/types/endianness.hpp>
-#include <uhd/types/sid.hpp>
 #include <uhd/utils/byteswap.hpp>
-#include <uhdlib/rfnoc/xports.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/shared_array.hpp>
 #include <boost/shared_ptr.hpp>
diff --git a/host/tests/device3_test.cpp b/host/tests/device3_test.cpp
deleted file mode 100644
index b737e7012..000000000
--- a/host/tests/device3_test.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-//
-// Copyright 2014 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-
-#include "mock_ctrl_iface_impl.hpp"
-#include "mock_zero_copy.hpp"
-#include <uhd/device3.hpp>
-#include <uhd/property_tree.hpp>
-#include <uhd/rfnoc/block_ctrl.hpp>
-#include <uhd/rfnoc/graph.hpp>
-#include <uhdlib/rfnoc/graph_impl.hpp>
-#include <boost/enable_shared_from_this.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/test/unit_test.hpp>
-#include <exception>
-#include <iostream>
-
-
-using namespace uhd;
-using namespace uhd::rfnoc;
-using namespace uhd::transport::vrt;
-using uhd::transport::managed_recv_buffer;
-using uhd::transport::managed_send_buffer;
-
-static const sid_t TEST_SID0 = 0x00000200; // 0.0.2.0
-static const sid_t TEST_SID1 = 0x00000210; // 0.0.2.F
-
-uhd::both_xports_t make_mock_transport(const uhd::sid_t& tx_sid)
-{
-    uhd::both_xports_t xports;
-    xports.send_sid = tx_sid;
-    xports.recv_sid = tx_sid.reversed();
-    xports.send = boost::make_shared<mock_zero_copy>(if_packet_info_t::LINK_TYPE_CHDR);
-    xports.recv = xports.send;
-    xports.send_buff_size = xports.send->get_send_frame_size();
-    xports.recv_buff_size = xports.recv->get_recv_frame_size();
-    return xports;
-}
-
-// Mock-device
-class mock_device3_impl : public uhd::device3,
-                          public boost::enable_shared_from_this<mock_device3_impl>
-{
-public:
-    mock_device3_impl()
-    {
-        _tree = uhd::property_tree::make();
-        _tree->create<std::string>("/name").set("Test Mock-Device3");
-        // We can re-use this:
-        std::map<size_t, ctrl_iface::sptr> ctrl_ifaces{
-            {0, ctrl_iface::sptr(new mock_ctrl_iface_impl())}};
-
-        // Add two block controls:
-        uhd::rfnoc::make_args_t make_args;
-        make_args.ctrl_ifaces  = ctrl_ifaces;
-        make_args.base_address = TEST_SID0.get_dst();
-        make_args.device_index = 0;
-        make_args.tree         = _tree;
-        std::cout << "[MOCK] Generating block controls 1/2:" << std::endl;
-        _rfnoc_block_ctrl.push_back(block_ctrl_base::make(make_args));
-        std::cout << "[MOCK] Generating block controls 2/2:" << std::endl;
-        make_args.base_address = TEST_SID1.get_dst();
-        _rfnoc_block_ctrl.push_back(block_ctrl::make(make_args));
-    }
-
-    rx_streamer::sptr get_rx_stream(const stream_args_t& args)
-    {
-        throw uhd::not_implemented_error(args.args.to_string());
-    }
-
-    tx_streamer::sptr get_tx_stream(const stream_args_t& args)
-    {
-        throw uhd::not_implemented_error(args.args.to_string());
-    }
-
-    bool recv_async_msg(async_metadata_t& async_metadata, double timeout)
-    {
-        throw uhd::not_implemented_error(
-            str(boost::format("%d %f") % async_metadata.channel % timeout));
-    }
-
-    rfnoc::graph::sptr create_graph(const std::string& name)
-    {
-        sid_t async_sid(0);
-        async_sid.set_dst_addr(2);
-        auto async_xports = make_mock_transport(async_sid);
-
-        auto async_msg_handler = uhd::rfnoc::async_msg_handler::make(async_xports.recv,
-            async_xports.send,
-            async_xports.send_sid,
-            async_xports.endianness);
-        auto graph             = boost::make_shared<uhd::rfnoc::graph_impl>(
-            name, shared_from_this(), async_msg_handler);
-        return graph;
-    }
-};
-
-device3::sptr make_mock_device()
-{
-    return device3::sptr(new mock_device3_impl());
-}
-
-class mock_block_ctrl : public block_ctrl
-{
-    int foo;
-};
-
-BOOST_AUTO_TEST_CASE(test_device3)
-{
-    device3::sptr my_device = make_mock_device();
-
-    std::cout << "Checking block 0..." << std::endl;
-    BOOST_REQUIRE(my_device->find_blocks("Block").size());
-
-    std::cout << "Getting block 0..." << std::endl;
-    block_ctrl_base::sptr block0 =
-        my_device->get_block_ctrl(my_device->find_blocks("Block")[0]);
-    BOOST_REQUIRE(block0);
-    BOOST_CHECK_EQUAL(block0->get_block_id(), "0/Block#0");
-
-    std::cout << "Checking block 1..." << std::endl;
-    BOOST_REQUIRE(my_device->has_block(block_id_t("0/Block#1")));
-
-    std::cout << "Getting block 1..." << std::endl;
-    block_ctrl_base::sptr block1 = my_device->get_block_ctrl(block_id_t("0/Block#1"));
-    BOOST_REQUIRE(block1);
-    BOOST_CHECK_EQUAL(block1->get_block_id(), "0/Block#1");
-}
-
-
-BOOST_AUTO_TEST_CASE(test_device3_graph)
-{
-    auto my_device = make_mock_device();
-    std::cout << "Start device3 test graph.." << std::endl;
-    std::cout << "Checking block 0..." << std::endl;
-    BOOST_REQUIRE(my_device->find_blocks("Block").size());
-    std::cout << "Getting block 0..." << std::endl;
-    auto block0 = my_device->get_block_ctrl(my_device->find_blocks("Block")[0]);
-    BOOST_REQUIRE(block0);
-    BOOST_CHECK_EQUAL(block0->get_block_id(), "0/Block#0");
-
-    std::cout << "Checking block 1..." << std::endl;
-    BOOST_REQUIRE(my_device->has_block(block_id_t("0/Block#1")));
-
-    std::cout << "Getting block 1..." << std::endl;
-    auto block1 = my_device->get_block_ctrl(block_id_t("0/Block#1"));
-    BOOST_REQUIRE(block1);
-    BOOST_CHECK_EQUAL(block1->get_block_id(), "0/Block#1");
-    std::cout << "Creating graph..." << std::endl;
-    auto graph = my_device->create_graph("test_graph");
-    BOOST_CHECK(graph);
-    std::cout << "Connecting block_0 to block_1 ..." << std::endl;
-    graph->connect(block_id_t("0/Block#0"), 0, block_id_t("0/Block#1"), 0);
-
-    BOOST_CHECK_EQUAL(block0->list_upstream_nodes().size(), 0);
-    BOOST_CHECK_EQUAL(block0->list_downstream_nodes().size(), 1);
-    BOOST_CHECK_EQUAL(
-        block0->list_downstream_nodes()[0].lock()->unique_id(), "0/Block#1");
-    BOOST_CHECK_EQUAL(block1->list_upstream_nodes().size(), 1);
-    BOOST_CHECK_EQUAL(block1->list_downstream_nodes().size(), 0);
-    BOOST_CHECK_EQUAL(block1->list_upstream_nodes()[0].lock()->unique_id(), "0/Block#0");
-}
-
-BOOST_AUTO_TEST_CASE(test_device3_cast)
-{
-    device3::sptr my_device = make_mock_device();
-
-    std::cout << "Getting block 0..." << std::endl;
-    block_ctrl::sptr block0 =
-        my_device->get_block_ctrl<block_ctrl>(block_id_t("0/Block#0"));
-    BOOST_REQUIRE(block0);
-    BOOST_CHECK_EQUAL(block0->get_block_id(), "0/Block#0");
-
-    std::cout << "Getting block 1..." << std::endl;
-    block_ctrl_base::sptr block1 =
-        my_device->get_block_ctrl<block_ctrl>(block_id_t("0/Block#1"));
-    BOOST_CHECK_EQUAL(block1->get_block_id(), "0/Block#1");
-}
-
-BOOST_AUTO_TEST_CASE(test_device3_fail)
-{
-    device3::sptr my_device = make_mock_device();
-
-    BOOST_CHECK(not my_device->has_block(block_id_t("0/FooBarBlock#0")));
-    BOOST_CHECK(not my_device->has_block<mock_block_ctrl>(block_id_t("0/Block#1")));
-
-    BOOST_CHECK(my_device->find_blocks("FooBarBlock").size() == 0);
-    BOOST_CHECK(my_device->find_blocks<block_ctrl>("FooBarBlock").size() == 0);
-
-    BOOST_REQUIRE_THROW(
-        my_device->get_block_ctrl(block_id_t("0/FooBarBlock#17")), uhd::lookup_error);
-    BOOST_REQUIRE_THROW(
-        my_device->get_block_ctrl<mock_block_ctrl>(block_id_t("0/Block#1")),
-        uhd::lookup_error);
-}
-
-// vim: sw=4 et:
diff --git a/host/tests/graph.hpp b/host/tests/graph.hpp
deleted file mode 100644
index fb36ae510..000000000
--- a/host/tests/graph.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Copyright 2014 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#ifndef INCLUDED_TEST_GRAPH_HPP
-#define INCLUDED_TEST_GRAPH_HPP
-
-#include <uhd/rfnoc/node_ctrl_base.hpp>
-#include <uhd/rfnoc/sink_node_ctrl.hpp>
-#include <uhd/rfnoc/source_node_ctrl.hpp>
-
-#define MAKE_NODE(name) test_node::sptr name(new test_node(#name));
-
-// Smallest possible test class
-class test_node : virtual public uhd::rfnoc::sink_node_ctrl,
-                  virtual public uhd::rfnoc::source_node_ctrl
-{
-public:
-    typedef boost::shared_ptr<test_node> sptr;
-
-    test_node(const std::string& test_id) : _test_id(test_id){};
-
-    void issue_stream_cmd(const uhd::stream_cmd_t&, const size_t){/* nop */};
-
-    std::string get_test_id() const
-    {
-        return _test_id;
-    };
-
-private:
-    const std::string _test_id;
-
-}; /* class test_node */
-
-void connect_nodes(
-    uhd::rfnoc::source_node_ctrl::sptr A, uhd::rfnoc::sink_node_ctrl::sptr B)
-{
-    const size_t actual_src_port = A->connect_downstream(B);
-    const size_t actual_dst_port = B->connect_upstream(A);
-    A->set_downstream_port(actual_src_port, actual_dst_port);
-    B->set_upstream_port(actual_dst_port, actual_src_port);
-}
-
-#endif /* INCLUDED_TEST_GRAPH_HPP */
diff --git a/host/tests/graph_search_test.cpp b/host/tests/graph_search_test.cpp
deleted file mode 100644
index 932647d98..000000000
--- a/host/tests/graph_search_test.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-//
-// Copyright 2014-2016 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "graph.hpp"
-#include <boost/test/unit_test.hpp>
-#include <iostream>
-
-using namespace uhd::rfnoc;
-
-// test class derived, this is what we search for
-class result_node : public test_node
-{
-public:
-    typedef boost::shared_ptr<result_node> sptr;
-
-    result_node(const std::string& test_id) : test_node(test_id){};
-
-}; /* class result_node */
-
-#define MAKE_RESULT_NODE(name) result_node::sptr name(new result_node(#name));
-
-BOOST_AUTO_TEST_CASE(test_simplest_downstream_search)
-{
-    MAKE_NODE(node_A);
-    MAKE_NODE(node_B);
-
-    // Simplest possible scenario: Connect B downstream of A and let
-    // A find B
-    connect_nodes(node_A, node_B);
-
-    test_node::sptr result = node_A->find_downstream_node<test_node>()[0];
-    BOOST_REQUIRE(result);
-    BOOST_CHECK_EQUAL(result->get_test_id(), "node_B");
-}
-
-BOOST_AUTO_TEST_CASE(test_simple_downstream_search)
-{
-    MAKE_NODE(node_A);
-    MAKE_NODE(node_B0);
-    MAKE_NODE(node_B1);
-
-    // Simple scenario: Connect both B{1,2} downstream of A and let
-    // it find them
-    connect_nodes(node_A, node_B0);
-    connect_nodes(node_A, node_B1);
-
-    // We're still searching for test_node, so any downstream block will match
-    std::vector<test_node::sptr> result = node_A->find_downstream_node<test_node>();
-    BOOST_REQUIRE(result.size() == 2);
-    BOOST_CHECK(
-        (result[0]->get_test_id() == "node_B0" and result[1]->get_test_id() == "node_B1")
-        or (result[1]->get_test_id() == "node_B0"
-               and result[0]->get_test_id() == "node_B1"));
-    BOOST_CHECK(result[0] == node_B0 or result[0] == node_B1);
-}
-
-BOOST_AUTO_TEST_CASE(test_linear_downstream_search)
-{
-    MAKE_NODE(node_A);
-    MAKE_RESULT_NODE(node_B);
-    MAKE_RESULT_NODE(node_C);
-
-    // Slightly more complex graph:
-    connect_nodes(node_A, node_B);
-    connect_nodes(node_B, node_C);
-
-    // This time, we search for result_node
-    std::vector<result_node::sptr> result = node_A->find_downstream_node<result_node>();
-    std::cout << "size: " << result.size() << std::endl;
-    BOOST_CHECK_EQUAL(result.size(), 1);
-    BOOST_CHECK_EQUAL(result[0]->get_test_id(), "node_B");
-    for (const result_node::sptr& node : result) {
-        std::cout << node->get_test_id() << std::endl;
-    }
-}
-
-BOOST_AUTO_TEST_CASE(test_multi_iter_downstream_search)
-{
-    MAKE_NODE(node_A);
-    MAKE_NODE(node_B0);
-    MAKE_NODE(node_B1);
-    MAKE_NODE(node_C0);
-    MAKE_RESULT_NODE(node_C1);
-    MAKE_RESULT_NODE(node_C2);
-    MAKE_RESULT_NODE(node_C3);
-    MAKE_RESULT_NODE(node_D0);
-
-    // Slightly more complex graph:
-    connect_nodes(node_A, node_B0);
-    connect_nodes(node_A, node_B1);
-    connect_nodes(node_B0, node_C0);
-    connect_nodes(node_B0, node_C1);
-    connect_nodes(node_B1, node_C2);
-    connect_nodes(node_B1, node_C3);
-    connect_nodes(node_C0, node_D0);
-
-    // This time, we search for result_node
-    std::vector<result_node::sptr> result = node_A->find_downstream_node<result_node>();
-    BOOST_REQUIRE(result.size() == 4);
-    for (const result_node::sptr& node : result) {
-        std::cout << node->get_test_id() << std::endl;
-    }
-}
-
-BOOST_AUTO_TEST_CASE(test_multi_iter_cycle_downstream_search)
-{
-    MAKE_NODE(node_A);
-    MAKE_NODE(node_B0);
-    MAKE_NODE(node_B1);
-    MAKE_NODE(node_C0);
-    MAKE_RESULT_NODE(node_C1);
-    MAKE_RESULT_NODE(node_C2);
-    MAKE_RESULT_NODE(node_C3);
-    MAKE_RESULT_NODE(node_D0);
-
-    // Slightly more complex graph:
-    connect_nodes(node_A, node_B0);
-    // This connection goes both ways, causing a cycle
-    connect_nodes(node_A, node_B1);
-    connect_nodes(node_B1, node_A);
-    connect_nodes(node_B0, node_C0);
-    connect_nodes(node_B0, node_C1);
-    connect_nodes(node_B1, node_C2);
-    connect_nodes(node_B1, node_C3);
-    connect_nodes(node_C0, node_D0);
-
-    // This time, we search for result_node
-    std::vector<result_node::sptr> result = node_A->find_downstream_node<result_node>();
-    BOOST_REQUIRE(result.size() == 4);
-    for (const result_node::sptr& node : result) {
-        std::cout << node->get_test_id() << std::endl;
-    }
-}
-
-BOOST_AUTO_TEST_CASE(test_mini_cycle_downstream_and_upstream)
-{
-    MAKE_NODE(node_A);
-    MAKE_NODE(node_B);
-
-    // Connect them in a loop
-    connect_nodes(node_A, node_B);
-    connect_nodes(node_B, node_A);
-
-    std::vector<test_node::sptr> result;
-    result = node_A->find_downstream_node<test_node>();
-    BOOST_REQUIRE_EQUAL(result.size(), 1);
-    BOOST_REQUIRE(result[0] == node_B);
-    result = node_B->find_downstream_node<test_node>();
-    BOOST_REQUIRE_EQUAL(result.size(), 1);
-    BOOST_REQUIRE(result[0] == node_A);
-    result = node_A->find_upstream_node<test_node>();
-    BOOST_REQUIRE_EQUAL(result.size(), 1);
-    BOOST_REQUIRE(result[0] == node_B);
-    result = node_B->find_upstream_node<test_node>();
-    BOOST_REQUIRE_EQUAL(result.size(), 1);
-    BOOST_REQUIRE(result[0] == node_A);
-}
diff --git a/host/tests/nocscript_common.hpp b/host/tests/nocscript_common.hpp
deleted file mode 100644
index ad254fa0e..000000000
--- a/host/tests/nocscript_common.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// Copyright 2015 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "../lib/rfnoc/nocscript/expression.hpp"
-#include <boost/assign/list_of.hpp>
-
-using namespace uhd::rfnoc::nocscript;
-
-// Some global defs to make tests easier to write
-expression_function::argtype_list_type one_int_arg =
-    boost::assign::list_of(expression::TYPE_INT);
-expression_function::argtype_list_type two_int_args =
-    boost::assign::list_of(expression::TYPE_INT)(expression::TYPE_INT);
-expression_function::argtype_list_type one_double_arg =
-    boost::assign::list_of(expression::TYPE_DOUBLE);
-expression_function::argtype_list_type two_double_args =
-    boost::assign::list_of(expression::TYPE_DOUBLE)(expression::TYPE_DOUBLE);
-expression_function::argtype_list_type one_bool_arg =
-    boost::assign::list_of(expression::TYPE_BOOL);
-expression_function::argtype_list_type two_bool_args =
-    boost::assign::list_of(expression::TYPE_BOOL)(expression::TYPE_BOOL);
-expression_function::argtype_list_type no_args;
-
-expression_container::expr_list_type empty_arg_list;
-
-#define E(x) expression_literal::make(x)
diff --git a/host/tests/nocscript_expr_test.cpp b/host/tests/nocscript_expr_test.cpp
deleted file mode 100644
index ed5f6598d..000000000
--- a/host/tests/nocscript_expr_test.cpp
+++ /dev/null
@@ -1,405 +0,0 @@
-//
-// Copyright 2015 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "../lib/rfnoc/nocscript/function_table.hpp"
-#include "nocscript_common.hpp"
-#include <boost/bind.hpp>
-#include <boost/format.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-#include <boost/test/unit_test.hpp>
-#include <algorithm>
-#include <iostream>
-
-// We need this global variable for one of the later tests
-int and_counter = 0;
-
-BOOST_AUTO_TEST_CASE(test_literals)
-{
-    expression_literal literal_int("5", expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(literal_int.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(literal_int.get_int(), 5);
-    BOOST_CHECK_EQUAL(literal_int.to_bool(), true);
-    BOOST_REQUIRE_THROW(literal_int.get_string(), uhd::type_error);
-    BOOST_REQUIRE_THROW(literal_int.get_bool(), uhd::type_error);
-
-    expression_literal literal_int0("0", expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(literal_int0.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(literal_int0.to_bool(), false);
-
-    expression_literal literal_double("2.3", expression::TYPE_DOUBLE);
-    BOOST_CHECK_EQUAL(literal_double.infer_type(), expression::TYPE_DOUBLE);
-    BOOST_CHECK_CLOSE(literal_double.get_double(), 2.3, 0.01);
-    BOOST_CHECK_EQUAL(literal_double.to_bool(), true);
-    BOOST_REQUIRE_THROW(literal_double.get_string(), uhd::type_error);
-    BOOST_REQUIRE_THROW(literal_double.get_bool(), uhd::type_error);
-
-    expression_literal literal_bool(true);
-    BOOST_CHECK_EQUAL(literal_bool.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(literal_bool.get_bool(), true);
-    BOOST_CHECK_EQUAL(literal_bool.to_bool(), true);
-    BOOST_CHECK_EQUAL(literal_bool.eval().get_bool(), true);
-    BOOST_REQUIRE_THROW(literal_bool.get_string(), uhd::type_error);
-    BOOST_REQUIRE_THROW(literal_bool.get_int(), uhd::type_error);
-
-    expression_literal literal_bool_false(false);
-    BOOST_CHECK_EQUAL(literal_bool_false.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(literal_bool_false.get_bool(), false);
-    BOOST_CHECK_EQUAL(literal_bool_false.to_bool(), false);
-    BOOST_REQUIRE_EQUAL(literal_bool_false.eval().get_bool(), false);
-    BOOST_REQUIRE_THROW(literal_bool_false.get_string(), uhd::type_error);
-    BOOST_REQUIRE_THROW(literal_bool_false.get_int(), uhd::type_error);
-
-    expression_literal literal_string("'foo bar'", expression::TYPE_STRING);
-    BOOST_CHECK_EQUAL(literal_string.infer_type(), expression::TYPE_STRING);
-    BOOST_CHECK_EQUAL(literal_string.get_string(), "foo bar");
-    BOOST_REQUIRE_THROW(literal_string.get_bool(), uhd::type_error);
-    BOOST_REQUIRE_THROW(literal_string.get_int(), uhd::type_error);
-
-    expression_literal literal_int_vec("[1, 2, 3]", expression::TYPE_INT_VECTOR);
-    BOOST_CHECK_EQUAL(literal_int_vec.infer_type(), expression::TYPE_INT_VECTOR);
-    std::vector<int> test_data{1, 2, 3};
-    std::vector<int> result = literal_int_vec.get_int_vector();
-    BOOST_CHECK_EQUAL_COLLECTIONS(
-        test_data.begin(), test_data.end(), result.begin(), result.end());
-    BOOST_REQUIRE_THROW(literal_int_vec.get_bool(), uhd::type_error);
-    BOOST_REQUIRE_THROW(literal_int_vec.get_int(), uhd::type_error);
-}
-
-
-// Need those for the variable testing:
-expression::type_t variable_get_type(const std::string& var_name)
-{
-    if (var_name == "spp") {
-        std::cout << "Returning type for $spp..." << std::endl;
-        return expression::TYPE_INT;
-    }
-    if (var_name == "is_true") {
-        std::cout << "Returning type for $is_true..." << std::endl;
-        return expression::TYPE_BOOL;
-    }
-
-    throw uhd::syntax_error("Cannot infer type (unknown variable)");
-}
-
-expression_literal variable_get_value(const std::string& var_name)
-{
-    if (var_name == "spp") {
-        std::cout << "Returning value for $spp..." << std::endl;
-        return expression_literal(5);
-    }
-    if (var_name == "is_true") {
-        std::cout << "Returning value for $is_true..." << std::endl;
-        return expression_literal(true);
-    }
-
-    throw uhd::syntax_error("Cannot read value (unknown variable)");
-}
-
-BOOST_AUTO_TEST_CASE(test_variables)
-{
-    BOOST_REQUIRE_THROW(expression_variable v_fail("foo", // Invalid token
-                            boost::bind(&variable_get_type, _1),
-                            boost::bind(&variable_get_value, _1)),
-        uhd::assertion_error);
-
-    expression_variable v("$spp", // The token
-        boost::bind(&variable_get_type, _1), // type-getter
-        boost::bind(&variable_get_value, _1) // value-getter
-    );
-    BOOST_CHECK_EQUAL(v.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(v.eval().get_int(), 5);
-}
-
-BOOST_AUTO_TEST_CASE(test_container)
-{
-    // Create some sub-expressions:
-    expression_literal::sptr l_true  = E(true);
-    expression_literal::sptr l_false = E(false);
-    expression_literal::sptr l_int   = E(5);
-    BOOST_REQUIRE_EQUAL(l_false->get_bool(), false);
-    BOOST_REQUIRE_EQUAL(l_false->to_bool(), false);
-    expression_variable::sptr l_boolvar =
-        boost::make_shared<expression_variable>("$is_true",
-            boost::bind(&variable_get_type, _1),
-            boost::bind(&variable_get_value, _1));
-
-    // This will throw anytime it's evaluated:
-    expression_variable::sptr l_failvar =
-        boost::make_shared<expression_variable>("$does_not_exist",
-            boost::bind(&variable_get_type, _1),
-            boost::bind(&variable_get_value, _1));
-
-    expression_container c;
-    std::cout << "One true, OR: " << std::endl;
-    c.add(l_true);
-    c.set_combiner_safe(expression_container::COMBINE_OR);
-    expression_literal ret_val_1 = c.eval();
-    BOOST_CHECK_EQUAL(ret_val_1.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(ret_val_1.eval().get_bool(), true);
-
-    std::cout << std::endl << std::endl << "Two true, one false, OR: " << std::endl;
-    c.add(l_true);
-    c.add(l_false);
-    expression_literal ret_val_2 = c.eval();
-    BOOST_CHECK_EQUAL(ret_val_2.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(ret_val_2.eval().get_bool(), true);
-
-    expression_container c2;
-    c2.add(l_false);
-    c2.add(l_false);
-    c2.set_combiner(expression_container::COMBINE_AND);
-    std::cout << std::endl << std::endl << "Two false, AND: " << std::endl;
-    expression_literal ret_val_3 = c2.eval();
-    BOOST_CHECK_EQUAL(ret_val_3.infer_type(), expression::TYPE_BOOL);
-    BOOST_REQUIRE_EQUAL(ret_val_3.eval().get_bool(), false);
-
-    c2.add(l_failvar);
-    // Will not fail, because l_failvar never gets eval'd:
-    expression_literal ret_val_4 = c2.eval();
-    BOOST_CHECK_EQUAL(ret_val_4.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(ret_val_4.eval().get_bool(), false);
-
-    // Same here:
-    c.add(l_failvar);
-    expression_literal ret_val_5 = c.eval();
-    BOOST_CHECK_EQUAL(ret_val_5.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(ret_val_5.eval().get_bool(), true);
-
-    // Now it'll throw:
-    c.set_combiner(expression_container::COMBINE_ALL);
-    BOOST_REQUIRE_THROW(c.eval(), uhd::syntax_error);
-
-    std::cout << "Checking type inference on ',' sequences: " << std::endl;
-    // Check types match
-    BOOST_CHECK_EQUAL(c2.infer_type(), expression::TYPE_BOOL);
-    expression_container c3;
-    c3.set_combiner(expression_container::COMBINE_ALL);
-    c3.add(l_false);
-    c3.add(l_int);
-    BOOST_CHECK_EQUAL(c3.infer_type(), expression::TYPE_INT);
-}
-
-
-// We'll define two functions here: ADD and XOR. The former shall
-// be defined for INT and DOUBLE
-class functable_mockup_impl : public function_table
-{
-public:
-    functable_mockup_impl(void){};
-
-    bool function_exists(const std::string& name) const
-    {
-        return name == "ADD" or name == "XOR" or name == "AND";
-    }
-
-    bool function_exists(const std::string& name,
-        const expression_function::argtype_list_type& arg_types) const
-    {
-        if (name == "ADD") {
-            if (arg_types.size() == 2 and arg_types[0] == expression::TYPE_DOUBLE
-                and arg_types[1] == expression::TYPE_DOUBLE) {
-                return true;
-            }
-            if (arg_types.size() == 2 and arg_types[0] == expression::TYPE_INT
-                and arg_types[1] == expression::TYPE_INT) {
-                return true;
-            }
-            return false;
-        }
-
-        if (name == "XOR" or name == "AND") {
-            if (arg_types.size() == 2 and arg_types[0] == expression::TYPE_BOOL
-                and arg_types[1] == expression::TYPE_BOOL) {
-                return true;
-            }
-            return false;
-        }
-
-        return false;
-    }
-
-    expression::type_t get_type(const std::string& name,
-        const expression_function::argtype_list_type& arg_types) const
-    {
-        if (not function_exists(name, arg_types)) {
-            throw uhd::syntax_error(
-                str(boost::format(
-                        "[EXPR_TEXT] get_type(): Unknown function: %s, %d arguments")
-                    % name % arg_types.size()));
-        }
-
-        if (name == "XOR" or name == "AND") {
-            return expression::TYPE_BOOL;
-        }
-        if (name == "ADD") {
-            return arg_types[0];
-        }
-        UHD_THROW_INVALID_CODE_PATH();
-    }
-
-    expression_literal eval(const std::string& name,
-        const expression_function::argtype_list_type& arg_types,
-        expression_container::expr_list_type& args)
-    {
-        if (name == "XOR") {
-            if (arg_types.size() != 2 or args.size() != 2
-                or arg_types[0] != expression::TYPE_BOOL
-                or arg_types[1] != expression::TYPE_BOOL
-                or args[0]->infer_type() != expression::TYPE_BOOL
-                or args[1]->infer_type() != expression::TYPE_BOOL) {
-                throw uhd::syntax_error("eval(): XOR type mismatch");
-            }
-            return expression_literal(
-                bool(args[0]->eval().get_bool() xor args[1]->eval().get_bool()));
-        }
-
-        if (name == "AND") {
-            if (arg_types.size() != 2 or args.size() != 2
-                or arg_types[0] != expression::TYPE_BOOL
-                or arg_types[1] != expression::TYPE_BOOL
-                or args[0]->infer_type() != expression::TYPE_BOOL
-                or args[1]->infer_type() != expression::TYPE_BOOL) {
-                throw uhd::syntax_error("eval(): AND type mismatch");
-            }
-            std::cout << "Calling AND" << std::endl;
-            and_counter++;
-            return expression_literal(
-                bool(args[0]->eval().get_bool() and args[1]->eval().get_bool()));
-        }
-
-        if (name == "ADD") {
-            if (args.size() != 2) {
-                throw uhd::syntax_error("eval(): ADD type mismatch");
-            }
-            if ((args[0]->infer_type() == expression::TYPE_INT)
-                and (args[1]->infer_type() == expression::TYPE_INT)) {
-                return expression_literal(
-                    int(args[0]->eval().get_int() + args[1]->eval().get_int()));
-            } else if ((args[0]->infer_type() == expression::TYPE_DOUBLE)
-                       and (args[1]->infer_type() == expression::TYPE_DOUBLE)) {
-                return expression_literal(
-                    double(args[0]->eval().get_double() + args[1]->eval().get_double()));
-            }
-            throw uhd::syntax_error("eval(): ADD type mismatch");
-        }
-        throw uhd::syntax_error("eval(): unknown function");
-    }
-
-    // We don't actually need this
-    void register_function(const std::string&,
-        const function_table::function_ptr&,
-        const expression::type_t,
-        const expression_function::argtype_list_type&){};
-};
-
-
-// The annoying part: Testing the test fixtures
-BOOST_AUTO_TEST_CASE(test_functable_mockup)
-{
-    functable_mockup_impl functable;
-
-    BOOST_CHECK(functable.function_exists("ADD"));
-    BOOST_CHECK(functable.function_exists("XOR"));
-    BOOST_CHECK(not functable.function_exists("FOOBAR"));
-
-    BOOST_CHECK(functable.function_exists("ADD", two_int_args));
-    BOOST_CHECK(functable.function_exists("ADD", two_double_args));
-    BOOST_CHECK(functable.function_exists("XOR", two_bool_args));
-    BOOST_CHECK(not functable.function_exists("ADD", two_bool_args));
-    BOOST_CHECK(not functable.function_exists("ADD", no_args));
-    BOOST_CHECK(not functable.function_exists("XOR", no_args));
-
-    BOOST_CHECK_EQUAL(functable.get_type("ADD", two_int_args), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(
-        functable.get_type("ADD", two_double_args), expression::TYPE_DOUBLE);
-    BOOST_CHECK_EQUAL(functable.get_type("XOR", two_bool_args), expression::TYPE_BOOL);
-
-    expression_container::expr_list_type add_args_int{E(2), E(3)};
-    expression_container::expr_list_type add_args_dbl{E(2.25), E(5.0)};
-    expression_container::expr_list_type xor_args_bool{E(true), E(false)};
-
-    BOOST_CHECK_EQUAL(
-        functable.eval("ADD", two_int_args, add_args_int), expression_literal(5));
-    BOOST_CHECK_EQUAL(
-        functable.eval("ADD", two_double_args, add_args_dbl), expression_literal(7.25));
-    BOOST_CHECK_EQUAL(
-        functable.eval("XOR", two_bool_args, xor_args_bool), expression_literal(true));
-}
-
-BOOST_AUTO_TEST_CASE(test_function_expression)
-{
-    function_table::sptr ft = boost::make_shared<functable_mockup_impl>();
-
-    // Very simple function: ADD(2, 3)
-    expression_function func1("ADD", ft);
-    func1.add(E(2));
-    func1.add(E(3));
-
-    BOOST_CHECK_EQUAL(func1.eval(), expression_literal(5));
-
-    // More elaborate: ADD(ADD(2, 3), ADD(ADD(4, 5), 6)) ?= 20
-    //                 f4  f1         f3  f2
-    expression_function f1("ADD", ft);
-    f1.add(E(2));
-    f1.add(E(3));
-    expression_function f2("ADD", ft);
-    f2.add(E(4));
-    f2.add(E(5));
-    expression_function f3("ADD", ft);
-    f3.add(boost::make_shared<expression_function>(f2));
-    f3.add(E(6));
-    expression_function f4("ADD", ft);
-    f4.add(boost::make_shared<expression_function>(f1));
-    f4.add(boost::make_shared<expression_function>(f3));
-
-    BOOST_CHECK_EQUAL(f4.eval().get_int(), 20);
-}
-
-BOOST_AUTO_TEST_CASE(test_function_expression_laziness)
-{
-    function_table::sptr ft = boost::make_shared<functable_mockup_impl>();
-
-    // We run AND(AND(false, false), AND(false, false)).
-    //        f1  f2                 f3
-    // That makes three ANDs
-    // in total. However, we will only see AND being evaluated twice, because
-    // the outcome is clear after running the first AND in the argument list.
-    expression_function::sptr f2 = boost::make_shared<expression_function>("AND", ft);
-    f2->add(E(false));
-    f2->add(E(false));
-    BOOST_CHECK(not f2->eval().get_bool());
-
-    expression_function::sptr f3 = boost::make_shared<expression_function>("AND", ft);
-    f3->add(E(false));
-    f3->add(E(false));
-    BOOST_CHECK(not f3->eval().get_bool());
-
-    and_counter                  = 0;
-    expression_function::sptr f1 = boost::make_shared<expression_function>("AND", ft);
-    f1->add(f2);
-    f1->add(f3);
-
-    BOOST_CHECK(not f1->eval().get_bool());
-    BOOST_CHECK_EQUAL(and_counter, 2);
-}
-
-BOOST_AUTO_TEST_CASE(test_sptrs)
-{
-    expression_container::sptr c = expression_container::make();
-    BOOST_CHECK_EQUAL(c->infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK(c->eval().get_bool());
-
-    expression_variable::sptr v = expression_variable::make("$spp",
-        boost::bind(&variable_get_type, _1), // type-getter
-        boost::bind(&variable_get_value, _1) // value-getter
-    );
-
-    c->add(v);
-    BOOST_REQUIRE_EQUAL(c->infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(c->eval().get_int(), 5);
-}
diff --git a/host/tests/nocscript_ftable_test.cpp b/host/tests/nocscript_ftable_test.cpp
deleted file mode 100644
index 36aa314f2..000000000
--- a/host/tests/nocscript_ftable_test.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-//
-// Copyright 2015 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "../lib/rfnoc/nocscript/function_table.hpp"
-#include "nocscript_common.hpp"
-#include <boost/bind.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-#include <boost/test/unit_test.hpp>
-#include <algorithm>
-#include <iostream>
-
-BOOST_AUTO_TEST_CASE(test_basic_funcs)
-{
-    function_table::sptr ft = function_table::make();
-    BOOST_CHECK(ft->function_exists("ADD"));
-    BOOST_CHECK(ft->function_exists("ADD", two_int_args));
-    BOOST_CHECK(ft->function_exists("LE", two_int_args));
-    BOOST_CHECK(ft->function_exists("GE"));
-    BOOST_CHECK(ft->function_exists("GE", two_int_args));
-    BOOST_CHECK(ft->function_exists("TRUE"));
-    BOOST_CHECK(ft->function_exists("FALSE"));
-
-    // Math
-    expression_container::expr_list_type two_int_values{E(2), E(3)};
-    expression_container::expr_list_type two_int_values2{E(3), E(2)};
-    expression_container::expr_list_type two_double_values{E(2.0), E(3.0)};
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("ADD", two_int_args), expression::TYPE_INT);
-    expression_literal e_add = ft->eval("ADD", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_add.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_add.get_int(), 5);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("MULT", two_int_args), expression::TYPE_INT);
-    expression_literal e_mult_i = ft->eval("MULT", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_mult_i.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_mult_i.get_int(), 6);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("MULT", two_double_args), expression::TYPE_DOUBLE);
-    expression_literal e_mult_d = ft->eval("MULT", two_double_args, two_double_values);
-    BOOST_REQUIRE_EQUAL(e_mult_d.infer_type(), expression::TYPE_DOUBLE);
-    BOOST_CHECK_CLOSE(e_mult_d.get_double(), 6.0, 0.01);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("DIV", two_double_args), expression::TYPE_DOUBLE);
-    expression_literal e_div_d = ft->eval("DIV", two_double_args, two_double_values);
-    BOOST_REQUIRE_EQUAL(e_div_d.infer_type(), expression::TYPE_DOUBLE);
-    BOOST_CHECK_CLOSE(e_div_d.get_double(), 2.0 / 3.0, 0.01);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("MODULO", two_int_args), expression::TYPE_INT);
-    expression_literal e_modulo_i = ft->eval("MODULO", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_modulo_i.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_modulo_i.get_int(), 2 % 3);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("LE", two_int_args), expression::TYPE_BOOL);
-    expression_literal e_le = ft->eval("LE", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_le.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(e_le.get_bool(), true);
-    BOOST_CHECK_EQUAL(ft->eval("LE", two_int_args, two_int_values2).get_bool(), false);
-    expression_literal e_ge = ft->eval("GE", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(ft->get_type("GE", two_int_args), expression::TYPE_BOOL);
-    BOOST_REQUIRE_EQUAL(e_ge.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(e_ge.get_bool(), false);
-
-    expression_container::expr_list_type sixty_four{E(64)};
-    expression_literal e_pwr2 = ft->eval("IS_PWR_OF_2", one_int_arg, sixty_four);
-    BOOST_REQUIRE_EQUAL(e_pwr2.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK_EQUAL(e_pwr2.get_bool(), true);
-    expression_literal e_log2 = ft->eval("LOG2", one_int_arg, sixty_four);
-    BOOST_REQUIRE_EQUAL(e_log2.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_log2.get_int(), 6);
-
-    // Boolean Logic
-    expression_container::expr_list_type e_true{E(true)};
-    expression_container::expr_list_type e_false{E(false)};
-    BOOST_CHECK(ft->eval("TRUE", no_args, empty_arg_list).to_bool());
-    BOOST_CHECK(ft->eval("TRUE", no_args, empty_arg_list).get_bool());
-    BOOST_CHECK_EQUAL(ft->eval("FALSE", no_args, empty_arg_list).to_bool(), false);
-    BOOST_CHECK_EQUAL(ft->eval("FALSE", no_args, empty_arg_list).get_bool(), false);
-    BOOST_CHECK(ft->eval("NOT", one_bool_arg, e_false).to_bool());
-
-    // Control
-    std::cout << "Checking ~1s sleep until... ";
-    expression_container::expr_list_type e_sleeptime{E(.999)};
-    BOOST_CHECK(ft->eval("SLEEP", one_double_arg, e_sleeptime).get_bool());
-    std::cout << "Now." << std::endl;
-}
-
-// Some bogus function to test the registry
-expression_literal add_plus2_int(expression_container::expr_list_type args)
-{
-    return expression_literal(args[0]->eval().get_int() + args[1]->eval().get_int() + 2);
-}
-
-BOOST_AUTO_TEST_CASE(test_add_funcs)
-{
-    function_table::sptr ft = function_table::make();
-
-    BOOST_CHECK(not ft->function_exists("ADD_PLUS_2"));
-
-    expression_function::argtype_list_type add_int_args{
-        expression::TYPE_INT, expression::TYPE_INT};
-    ft->register_function("ADD_PLUS_2",
-        boost::bind(&add_plus2_int, _1),
-        expression::TYPE_INT,
-        add_int_args);
-
-    BOOST_CHECK(ft->function_exists("ADD_PLUS_2"));
-    BOOST_CHECK(ft->function_exists("ADD_PLUS_2", add_int_args));
-
-    expression_container::expr_list_type add_int_values{E(2), E(3)};
-    expression_literal e = ft->eval("ADD_PLUS_2", two_int_args, add_int_values);
-    BOOST_REQUIRE_EQUAL(e.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e.get_int(), 7);
-}
-
-int dummy_true_counter = 0;
-// Some bogus function to test the registry
-expression_literal dummy_true(expression_container::expr_list_type)
-{
-    dummy_true_counter++;
-    std::cout << "Running dummy/true statement." << std::endl;
-    return expression_literal(true);
-}
-
-int dummy_false_counter = 0;
-// Some bogus function to test the registry
-expression_literal dummy_false(expression_container::expr_list_type)
-{
-    dummy_false_counter++;
-    std::cout << "Running dummy/false statement." << std::endl;
-    return expression_literal(false);
-}
-
-BOOST_AUTO_TEST_CASE(test_conditionals)
-{
-    function_table::sptr ft = function_table::make();
-    ft->register_function(
-        "DUMMY", boost::bind(&dummy_true, _1), expression::TYPE_BOOL, no_args);
-    ft->register_function(
-        "DUMMY_F", boost::bind(&dummy_false, _1), expression::TYPE_BOOL, no_args);
-    BOOST_REQUIRE(ft->function_exists("DUMMY", no_args));
-    BOOST_REQUIRE(ft->function_exists("DUMMY_F", no_args));
-
-    expression_function::sptr dummy_statement =
-        boost::make_shared<expression_function>("DUMMY", ft);
-    expression_function::sptr if_statement =
-        boost::make_shared<expression_function>("IF", ft);
-    if_statement->add(E(true));
-    if_statement->add(dummy_statement);
-
-    std::cout << "Dummy statement should run once until END:" << std::endl;
-    dummy_true_counter = 0;
-    BOOST_CHECK(if_statement->eval().get_bool());
-    BOOST_CHECK_EQUAL(dummy_true_counter, 1);
-    std::cout << "END." << std::endl;
-
-    std::cout << "Dummy statement should not run until END:" << std::endl;
-    expression_function::sptr if_statement2 =
-        boost::make_shared<expression_function>("IF", ft);
-    if_statement2->add(E(false));
-    if_statement2->add(dummy_statement);
-    dummy_true_counter = 0;
-    BOOST_CHECK(not if_statement2->eval().get_bool());
-    BOOST_CHECK_EQUAL(dummy_true_counter, 0);
-    std::cout << "END." << std::endl;
-
-    expression_function::sptr if_else_statement =
-        boost::make_shared<expression_function>("IF_ELSE", ft);
-    expression_function::sptr dummy_statement_f =
-        boost::make_shared<expression_function>("DUMMY_F", ft);
-    if_else_statement->add(E(true));
-    if_else_statement->add(dummy_statement);
-    if_else_statement->add(dummy_statement_f);
-    dummy_true_counter  = 0;
-    dummy_false_counter = 0;
-    std::cout << "Should execute dummy/true statement before END:" << std::endl;
-    BOOST_CHECK(if_else_statement->eval().get_bool());
-    BOOST_CHECK_EQUAL(dummy_true_counter, 1);
-    BOOST_CHECK_EQUAL(dummy_false_counter, 0);
-    std::cout << "END." << std::endl;
-
-    expression_function::sptr if_else_statement2 =
-        boost::make_shared<expression_function>("IF_ELSE", ft);
-    if_else_statement2->add(E(false));
-    if_else_statement2->add(dummy_statement);
-    if_else_statement2->add(dummy_statement_f);
-    dummy_true_counter  = 0;
-    dummy_false_counter = 0;
-    std::cout << "Should execute dummy/false statement before END:" << std::endl;
-    BOOST_CHECK(not if_else_statement2->eval().get_bool());
-    BOOST_CHECK_EQUAL(dummy_true_counter, 0);
-    BOOST_CHECK_EQUAL(dummy_false_counter, 1);
-    std::cout << "END." << std::endl;
-}
-
-BOOST_AUTO_TEST_CASE(test_bitwise_funcs)
-{
-    function_table::sptr ft = function_table::make();
-    BOOST_CHECK(ft->function_exists("SHIFT_RIGHT"));
-    BOOST_CHECK(ft->function_exists("SHIFT_RIGHT", two_int_args));
-    BOOST_CHECK(ft->function_exists("SHIFT_LEFT"));
-    BOOST_CHECK(ft->function_exists("SHIFT_LEFT", two_int_args));
-    BOOST_CHECK(ft->function_exists("BITWISE_AND"));
-    BOOST_CHECK(ft->function_exists("BITWISE_AND", two_int_args));
-    BOOST_CHECK(ft->function_exists("BITWISE_OR"));
-    BOOST_CHECK(ft->function_exists("BITWISE_OR", two_int_args));
-    BOOST_CHECK(ft->function_exists("BITWISE_XOR"));
-    BOOST_CHECK(ft->function_exists("BITWISE_XOR", two_int_args));
-
-    // Bitwise Math
-    int int_value1 = 0x2;
-    int int_value2 = 0x3;
-    expression_container::expr_list_type two_int_values{E(int_value1), E(int_value2)};
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("SHIFT_RIGHT", two_int_args), expression::TYPE_INT);
-    expression_literal e_shift_right =
-        ft->eval("SHIFT_RIGHT", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_shift_right.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_shift_right.get_int(), int_value1 >> int_value2);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("SHIFT_LEFT", two_int_args), expression::TYPE_INT);
-    expression_literal e_shift_left =
-        ft->eval("SHIFT_LEFT", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_shift_left.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_shift_left.get_int(), int_value1 << int_value2);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("BITWISE_AND", two_int_args), expression::TYPE_INT);
-    expression_literal e_bitwise_and =
-        ft->eval("BITWISE_AND", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_bitwise_and.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_bitwise_and.get_int(), int_value1 & int_value2);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("BITWISE_OR", two_int_args), expression::TYPE_INT);
-    expression_literal e_bitwise_or =
-        ft->eval("BITWISE_OR", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_bitwise_or.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_bitwise_or.get_int(), int_value1 | int_value2);
-
-    BOOST_REQUIRE_EQUAL(ft->get_type("BITWISE_XOR", two_int_args), expression::TYPE_INT);
-    expression_literal e_bitwise_xor =
-        ft->eval("BITWISE_XOR", two_int_args, two_int_values);
-    BOOST_REQUIRE_EQUAL(e_bitwise_xor.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(e_bitwise_xor.get_int(), int_value1 ^ int_value2);
-}
diff --git a/host/tests/nocscript_parser_test.cpp b/host/tests/nocscript_parser_test.cpp
deleted file mode 100644
index eb9352995..000000000
--- a/host/tests/nocscript_parser_test.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// Copyright 2015 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "../lib/rfnoc/nocscript/function_table.hpp"
-#include "../lib/rfnoc/nocscript/parser.hpp"
-#include "nocscript_common.hpp"
-#include <uhd/exception.hpp>
-#include <boost/assign/list_of.hpp>
-#include <boost/bind.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-#include <boost/test/unit_test.hpp>
-#include <algorithm>
-#include <iostream>
-
-const int SPP_VALUE = 64;
-
-// Need those for the variable testing:
-expression::type_t variable_get_type(const std::string& var_name)
-{
-    if (var_name == "spp") {
-        std::cout << "Returning type for $spp..." << std::endl;
-        return expression::TYPE_INT;
-    }
-    if (var_name == "is_true") {
-        std::cout << "Returning type for $is_true..." << std::endl;
-        return expression::TYPE_BOOL;
-    }
-
-    throw uhd::syntax_error("Cannot infer type (unknown variable)");
-}
-
-expression_literal variable_get_value(const std::string& var_name)
-{
-    if (var_name == "spp") {
-        std::cout << "Returning value for $spp..." << std::endl;
-        return expression_literal(SPP_VALUE);
-    }
-    if (var_name == "is_true") {
-        std::cout << "Returning value for $is_true..." << std::endl;
-        return expression_literal(true);
-    }
-
-    throw uhd::syntax_error("Cannot read value (unknown variable)");
-}
-
-#define SETUP_FT_AND_PARSER()                         \
-    function_table::sptr ft = function_table::make(); \
-    parser::sptr p          = parser::make(           \
-        ft, boost::bind(&variable_get_type, _1), boost::bind(&variable_get_value, _1));
-
-BOOST_AUTO_TEST_CASE(test_fail)
-{
-    SETUP_FT_AND_PARSER();
-
-    // Missing closing parens:
-    BOOST_REQUIRE_THROW(p->create_expr_tree("ADD1(1, "), uhd::syntax_error);
-    // Double comma:
-    BOOST_REQUIRE_THROW(p->create_expr_tree("ADD(1,, 2)"), uhd::syntax_error);
-    // No comma:
-    BOOST_REQUIRE_THROW(p->create_expr_tree("ADD(1 2)"), uhd::syntax_error);
-    // Double closing parens:
-    BOOST_REQUIRE_THROW(p->create_expr_tree("ADD(1, 2))"), uhd::syntax_error);
-    // Unknown function:
-    BOOST_REQUIRE_THROW(p->create_expr_tree("GLORPGORP(1, 2)"), uhd::syntax_error);
-}
-
-BOOST_AUTO_TEST_CASE(test_adds_no_vars)
-{
-    SETUP_FT_AND_PARSER();
-    BOOST_REQUIRE(ft->function_exists("ADD"));
-
-    const std::string line("ADD(1, ADD(2, ADD(3, 4)))");
-    expression::sptr e        = p->create_expr_tree(line);
-    expression_literal result = e->eval();
-
-    BOOST_REQUIRE_EQUAL(result.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(result.get_int(), 1 + 2 + 3 + 4);
-}
-
-BOOST_AUTO_TEST_CASE(test_adds_with_vars)
-{
-    SETUP_FT_AND_PARSER();
-
-    const std::string line("ADD(1, ADD(2, $spp))");
-    expression::sptr e        = p->create_expr_tree(line);
-    expression_literal result = e->eval();
-
-    BOOST_REQUIRE_EQUAL(result.infer_type(), expression::TYPE_INT);
-    BOOST_CHECK_EQUAL(result.get_int(), 1 + 2 + SPP_VALUE);
-}
-
-BOOST_AUTO_TEST_CASE(test_fft_check)
-{
-    SETUP_FT_AND_PARSER();
-
-    const std::string line("GE($spp, 16) AND LE($spp, 4096) AND IS_PWR_OF_2($spp)");
-    expression::sptr e        = p->create_expr_tree(line);
-    expression_literal result = e->eval();
-
-    BOOST_REQUIRE_EQUAL(result.infer_type(), expression::TYPE_BOOL);
-    BOOST_CHECK(result.get_bool());
-}
-
-BOOST_AUTO_TEST_CASE(test_pure_string)
-{
-    SETUP_FT_AND_PARSER();
-
-    // Eval all, return last expression
-    const std::string line("'foo foo', \"bar\"");
-    expression_literal result = p->create_expr_tree(line)->eval();
-
-    BOOST_REQUIRE_EQUAL(result.infer_type(), expression::TYPE_STRING);
-    BOOST_CHECK_EQUAL(result.get_string(), "bar");
-}
-
-int dummy_false_counter = 0;
-expression_literal dummy_false(expression_container::expr_list_type)
-{
-    dummy_false_counter++;
-    std::cout << "Running dummy/false statement." << std::endl;
-    return expression_literal(false);
-}
-
-BOOST_AUTO_TEST_CASE(test_multi_commmand)
-{
-    SETUP_FT_AND_PARSER();
-
-    ft->register_function(
-        "DUMMY", boost::bind(&dummy_false, _1), expression::TYPE_BOOL, no_args);
-
-    dummy_false_counter = 0;
-    p->create_expr_tree("DUMMY(), DUMMY(), DUMMY()")->eval();
-    BOOST_CHECK_EQUAL(dummy_false_counter, 3);
-
-    dummy_false_counter = 0;
-    p->create_expr_tree("DUMMY() AND DUMMY() AND DUMMY()")->eval();
-    BOOST_CHECK_EQUAL(dummy_false_counter, 1);
-
-    dummy_false_counter = 0;
-    p->create_expr_tree("DUMMY() OR DUMMY() OR DUMMY()")->eval();
-    BOOST_CHECK_EQUAL(dummy_false_counter, 3);
-}
diff --git a/host/tests/node_connect_test.cpp b/host/tests/node_connect_test.cpp
deleted file mode 100644
index 97d052a06..000000000
--- a/host/tests/node_connect_test.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//
-// Copyright 2014 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "graph.hpp"
-#include <boost/test/unit_test.hpp>
-#include <iostream>
-
-using namespace uhd::rfnoc;
-
-class source_node : public test_node
-{
-public:
-    typedef boost::shared_ptr<source_node> sptr;
-
-    source_node(const std::string& test_id, size_t output_port)
-        : test_node(test_id), active_rx_streamer_on_port(0), _output_port(output_port){};
-
-    void set_rx_streamer(bool active, const size_t port)
-    {
-        if (active) {
-            std::cout << "[source_node] Someone is registering a rx streamer on port "
-                      << port << std::endl;
-            active_rx_streamer_on_port = port;
-        }
-    }
-    size_t active_rx_streamer_on_port;
-
-protected:
-    size_t _request_output_port(const size_t, const uhd::device_addr_t&) const
-    {
-        return _output_port;
-    }
-
-    const size_t _output_port;
-
-}; /* class result_node */
-
-class sink_node : public test_node
-{
-public:
-    typedef boost::shared_ptr<sink_node> sptr;
-
-    sink_node(const std::string& test_id, size_t input_port)
-        : test_node(test_id), active_tx_streamer_on_port(0), _input_port(input_port){};
-
-    void set_tx_streamer(bool active, const size_t port)
-    {
-        if (active) {
-            std::cout << "[sink_node] Someone is registering a tx streamer on port "
-                      << port << std::endl;
-            active_tx_streamer_on_port = port;
-        }
-    }
-    size_t active_tx_streamer_on_port;
-
-protected:
-    size_t _request_input_port(const size_t, const uhd::device_addr_t&) const
-    {
-        return _input_port;
-    }
-
-    const size_t _input_port;
-
-}; /* class result_node */
-
-#define MAKE_SOURCE_NODE(name, port) source_node::sptr name(new source_node(#name, port));
-#define MAKE_SINK_NODE(name, port) sink_node::sptr name(new sink_node(#name, port));
-
-BOOST_AUTO_TEST_CASE(test_simple_connect)
-{
-    MAKE_SOURCE_NODE(node_A, 42);
-    MAKE_SINK_NODE(node_B, 23);
-
-    size_t src_port = node_A->connect_downstream(node_B, 1);
-    size_t dst_port = node_B->connect_upstream(node_A, 2);
-
-    BOOST_CHECK_EQUAL(src_port, 42);
-    BOOST_CHECK_EQUAL(dst_port, 23);
-
-    node_A->set_downstream_port(src_port, dst_port);
-    node_B->set_upstream_port(dst_port, src_port);
-    BOOST_CHECK_EQUAL(node_A->get_downstream_port(src_port), dst_port);
-    BOOST_CHECK_EQUAL(node_B->get_upstream_port(dst_port), src_port);
-
-    BOOST_REQUIRE_THROW(node_A->get_downstream_port(999), uhd::value_error);
-}
-
-BOOST_AUTO_TEST_CASE(test_fail)
-{
-    MAKE_SOURCE_NODE(node_A, 42);
-    MAKE_SINK_NODE(node_B, ANY_PORT);
-
-    node_A->connect_downstream(node_B, 1);
-    BOOST_REQUIRE_THROW(node_B->connect_upstream(node_A, 2), uhd::type_error);
-}
-
-BOOST_AUTO_TEST_CASE(test_set_streamers)
-{
-    MAKE_SOURCE_NODE(node_A, 0);
-    MAKE_NODE(node_B);
-    MAKE_SINK_NODE(node_C, 0);
-
-    size_t src_port_A = node_A->connect_downstream(node_B, 0);
-    size_t src_port_B = node_B->connect_downstream(node_C, 0);
-    size_t dst_port_B = node_B->connect_upstream(node_A, 0);
-    size_t dst_port_C = node_C->connect_upstream(node_B, 0);
-
-    std::cout << "src_port_A: " << src_port_A << std::endl;
-    std::cout << "src_port_B: " << src_port_B << std::endl;
-    std::cout << "dst_port_B: " << dst_port_B << std::endl;
-    std::cout << "dst_port_C: " << dst_port_C << std::endl;
-
-    node_A->set_downstream_port(src_port_A, dst_port_B);
-    node_B->set_upstream_port(dst_port_B, src_port_A);
-    node_B->set_downstream_port(src_port_B, dst_port_C);
-    node_C->set_upstream_port(dst_port_C, src_port_B);
-
-    node_A->set_tx_streamer(true, 0);
-    node_C->set_rx_streamer(true, 0);
-
-    BOOST_CHECK_EQUAL(node_A->active_rx_streamer_on_port, src_port_A);
-    BOOST_CHECK_EQUAL(node_C->active_tx_streamer_on_port, dst_port_C);
-}
diff --git a/host/tests/packet_handler_benchmark.cpp b/host/tests/packet_handler_benchmark.cpp
index 6d4849831..d0a28bdc2 100644
--- a/host/tests/packet_handler_benchmark.cpp
+++ b/host/tests/packet_handler_benchmark.cpp
@@ -13,13 +13,11 @@
 
 #include "../lib/transport/super_recv_packet_handler.hpp"
 #include "../lib/transport/super_send_packet_handler.hpp"
-#include "../lib/usrp/device3/device3_flow_ctrl.hpp"
 #include "common/mock_zero_copy.hpp"
 #include <uhd/convert.hpp>
 #include <uhd/transport/chdr.hpp>
 #include <uhd/transport/zero_copy.hpp>
 #include <uhd/transport/zero_copy_flow_ctrl.hpp>
-#include <uhd/types/sid.hpp>
 #include <uhd/utils/safe_main.hpp>
 #include <uhd/utils/thread.hpp>
 #include <boost/program_options.hpp>
@@ -47,7 +45,6 @@ struct rx_fc_cache_t
     uint32_t total_packets_consumed = 0;
     //! Sequence number of next flow control packet
     uint64_t seq_num = 0;
-    uhd::sid_t sid;
     uhd::transport::zero_copy_if::sptr xport;
     std::function<uint32_t(uint32_t)> to_host;
     std::function<uint32_t(uint32_t)> from_host;
@@ -155,8 +152,7 @@ inline bool tx_flow_ctrl(boost::shared_ptr<tx_fc_cache_t> fc_cache,
 }
 
 inline void tx_flow_ctrl_ack(boost::shared_ptr<tx_fc_cache_t> fc_cache,
-    uhd::transport::zero_copy_if::sptr /*send_xport*/,
-    uhd::sid_t /*send_sid*/)
+    uhd::transport::zero_copy_if::sptr /*send_xport*/)
 {
     if (not fc_cache->fc_received) {
         return;
@@ -296,7 +292,7 @@ void benchmark_send_packet_handler(
 
     // Configure flow control ack
     streamer->set_xport_chan_post_send_cb(0, [fc_cache, zero_copy_xport]() {
-        tx_flow_ctrl_ack(fc_cache, zero_copy_xport, 0);
+        tx_flow_ctrl_ack(fc_cache, zero_copy_xport);
     });
 
     // Allocate buffer
diff --git a/host/tests/rate_node_test.cpp b/host/tests/rate_node_test.cpp
deleted file mode 100644
index 85502c325..000000000
--- a/host/tests/rate_node_test.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-//
-// Copyright 2014 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "graph.hpp"
-#include <uhd/rfnoc/rate_node_ctrl.hpp>
-#include <boost/test/unit_test.hpp>
-#include <iostream>
-
-using namespace uhd::rfnoc;
-
-// test class derived, knows about rates
-class rate_aware_node : public test_node, public rate_node_ctrl
-{
-public:
-    typedef boost::shared_ptr<rate_aware_node> sptr;
-
-    rate_aware_node(const std::string& test_id) : test_node(test_id){};
-
-}; /* class rate_aware_node */
-
-// test class derived, sets rates
-class rate_setting_node : public test_node, public rate_node_ctrl
-{
-public:
-    typedef boost::shared_ptr<rate_setting_node> sptr;
-
-    rate_setting_node(const std::string& test_id, double samp_rate)
-        : test_node(test_id), _samp_rate(samp_rate){};
-
-    double get_input_samp_rate(size_t)
-    {
-        return _samp_rate;
-    };
-    double get_output_samp_rate(size_t)
-    {
-        return _samp_rate;
-    };
-
-private:
-    double _samp_rate;
-
-}; /* class rate_setting_node */
-
-#define MAKE_RATE_NODE(name) rate_aware_node::sptr name(new rate_aware_node(#name));
-#define MAKE_RATE_SETTING_NODE(name, rate) \
-    rate_setting_node::sptr name(new rate_setting_node(#name, rate));
-
-BOOST_AUTO_TEST_CASE(test_simplest_downstream_search)
-{
-    const double test_rate = 0.25;
-    MAKE_RATE_NODE(node_A);
-    MAKE_RATE_SETTING_NODE(node_B, test_rate);
-
-    // Simplest possible scenario: Connect B downstream of A and let
-    // it find B
-    connect_nodes(node_A, node_B);
-
-    double result_rate = node_A->get_input_samp_rate();
-    BOOST_CHECK_EQUAL(result_rate, test_rate);
-}
-
-BOOST_AUTO_TEST_CASE(test_skip_downstream_search)
-{
-    const double test_rate = 0.25;
-    MAKE_RATE_NODE(node_A);
-    MAKE_NODE(node_B);
-    MAKE_RATE_SETTING_NODE(node_C, test_rate);
-
-    // Slightly more elaborate: Add another block in between that has no
-    // clue about rates
-    connect_nodes(node_A, node_B);
-    connect_nodes(node_B, node_C);
-
-    double result_rate = node_A->get_input_samp_rate();
-    BOOST_CHECK_EQUAL(result_rate, test_rate);
-}
-
-BOOST_AUTO_TEST_CASE(test_tree_downstream_search)
-{
-    const double test_rate = 0.25;
-    MAKE_RATE_NODE(node_A);
-    MAKE_NODE(node_B0);
-    MAKE_RATE_SETTING_NODE(node_B1, test_rate);
-    MAKE_RATE_SETTING_NODE(node_C0, test_rate);
-    MAKE_RATE_SETTING_NODE(node_C1, rate_node_ctrl::RATE_UNDEFINED);
-
-    // Tree: Downstream of our first node are 3 rate setting blocks.
-    // Two set the same rate, the third does not care.
-    connect_nodes(node_A, node_B0);
-    connect_nodes(node_A, node_B1);
-    connect_nodes(node_B0, node_C0);
-    connect_nodes(node_B0, node_C1);
-
-    double result_rate = node_A->get_input_samp_rate();
-    BOOST_CHECK_EQUAL(result_rate, test_rate);
-}
-
-BOOST_AUTO_TEST_CASE(test_tree_downstream_search_throw)
-{
-    const double test_rate = 0.25;
-    MAKE_RATE_NODE(node_A);
-    MAKE_NODE(node_B0);
-    MAKE_RATE_SETTING_NODE(node_B1, test_rate);
-    MAKE_RATE_SETTING_NODE(node_C0, test_rate);
-    MAKE_RATE_SETTING_NODE(node_C1, test_rate * 2);
-
-    // Tree: Downstream of our first node are 3 rate setting blocks.
-    // Two set the same rate, the third has a different rate.
-    // This will cause a throw.
-    connect_nodes(node_A, node_B0);
-    connect_nodes(node_A, node_B1);
-    connect_nodes(node_B0, node_C0);
-    connect_nodes(node_B0, node_C1);
-
-    BOOST_CHECK_THROW(node_A->get_input_samp_rate(), uhd::runtime_error);
-}
-
-BOOST_AUTO_TEST_CASE(test_skip_upstream_search)
-{
-    const double test_rate = 0.25;
-    MAKE_RATE_SETTING_NODE(node_A, test_rate);
-    MAKE_NODE(node_B);
-    MAKE_RATE_NODE(node_C);
-
-    // Slightly more elaborate: Add another block in between that has no
-    // clue about rates
-    connect_nodes(node_A, node_B);
-    connect_nodes(node_B, node_C);
-
-    double result_rate = node_C->get_output_samp_rate();
-    BOOST_CHECK_EQUAL(result_rate, test_rate);
-}
diff --git a/host/tests/sid_t_test.cpp b/host/tests/sid_t_test.cpp
deleted file mode 100644
index 2a13995df..000000000
--- a/host/tests/sid_t_test.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-// Copyright 2014 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include <uhd/exception.hpp>
-#include <uhd/types/sid.hpp>
-#include <boost/test/unit_test.hpp>
-#include <iostream>
-#include <sstream>
-
-using uhd::sid_t;
-
-BOOST_AUTO_TEST_CASE(test_sid_t)
-{
-    uint32_t sid_value = 0x01020310;
-    sid_t sid(sid_value);
-
-    BOOST_CHECK_EQUAL(sid.is_set(), true);
-    BOOST_CHECK_EQUAL(sid.to_pp_string(), "1.2>3.16");
-    BOOST_CHECK_EQUAL(sid.to_pp_string_hex(), "01:02>03:10");
-    BOOST_CHECK_EQUAL(sid.get_src(), (uint32_t)0x0102);
-    BOOST_CHECK_EQUAL(sid.get_dst(), (uint32_t)0x0310);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x01);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x02);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x03);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0x10);
-    BOOST_CHECK_EQUAL(sid == sid, true);
-    BOOST_CHECK_EQUAL(sid == sid_value, true);
-
-    uint32_t check_sid_val = (uint32_t)sid;
-    BOOST_CHECK_EQUAL(check_sid_val, sid_value);
-
-    std::stringstream ss_dec;
-    ss_dec << sid;
-    BOOST_CHECK_EQUAL(ss_dec.str(), "1.2>3.16");
-
-    std::stringstream ss_hex;
-    ss_hex << std::hex << sid;
-    BOOST_CHECK_EQUAL(ss_hex.str(), "01:02>03:10");
-
-    sid_t empty_sid;
-    BOOST_CHECK_EQUAL(empty_sid.is_set(), false);
-    BOOST_CHECK_EQUAL(empty_sid.to_pp_string(), "x.x>x.x");
-    BOOST_CHECK_EQUAL(empty_sid.to_pp_string_hex(), "xx:xx>xx:xx");
-    BOOST_CHECK_EQUAL(empty_sid == sid, false);
-    BOOST_CHECK_EQUAL(empty_sid == sid_value, false);
-    BOOST_CHECK_EQUAL((bool)empty_sid, false);
-
-    empty_sid = sid_value; // No longer empty
-    BOOST_CHECK_EQUAL(empty_sid.is_set(), true);
-    BOOST_CHECK_EQUAL(empty_sid == sid, true);
-}
-
-BOOST_AUTO_TEST_CASE(test_sid_t_set)
-{
-    uint32_t sid_value = 0x0;
-    sid_t sid(sid_value);
-
-    sid.set(0x01020304);
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x01020304);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x01);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x02);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x03);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0x04);
-    BOOST_CHECK_EQUAL(sid.get_dst_xbarport(), (uint32_t)0x0);
-    BOOST_CHECK_EQUAL(sid.get_dst_blockport(), (uint32_t)0x4);
-
-    sid.set_src_addr(0x0a);
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0a020304);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x0a);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x02);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x03);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0x04);
-
-    sid.set_src_endpoint(0x0b);
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0a0b0304);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x0a);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x0b);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x03);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0x04);
-
-    sid.set_dst_addr(0x0c);
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0a0b0c04);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x0a);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x0b);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x0c);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0x04);
-
-    sid.set_dst_endpoint(0x0d);
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0a0b0c0d);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x0a);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x0b);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x0c);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0x0d);
-
-    sid.set_dst_xbarport(0xb);
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0a0b0cbd);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x0a);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x0b);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x0c);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0xbd);
-
-    sid.set_dst_blockport(0xc);
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0a0b0cbc);
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)0x0a);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)0x0b);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)0x0c);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)0xbc);
-
-    const sid_t flipped_sid = sid.reversed();
-    BOOST_CHECK_EQUAL(flipped_sid.get(), (uint32_t)0x0cbc0a0b);
-    BOOST_CHECK_EQUAL(flipped_sid.reversed(), sid);
-
-    const sid_t sid2 = sid_t(sid.get_sid());
-    BOOST_CHECK_EQUAL(sid2, sid);
-
-    // In-place
-    sid.reverse();
-    BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0cbc0a0b);
-}
-
-BOOST_AUTO_TEST_CASE(test_sid_t_from_str)
-{
-    sid_t sid("1.2>3.4");
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)1);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)2);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)3);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)4);
-
-    sid = "01:02>03:10";
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)1);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)2);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)3);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)16);
-
-    sid = "01:06/03:10";
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)1);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)6);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)3);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)16);
-
-    sid = "01:02:04:10";
-    BOOST_CHECK_EQUAL(sid.get_src_addr(), (uint32_t)1);
-    BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (uint32_t)2);
-    BOOST_CHECK_EQUAL(sid.get_dst_addr(), (uint32_t)4);
-    BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (uint32_t)16);
-
-    BOOST_REQUIRE_THROW(sid_t fail_sid("foobar"), uhd::value_error);
-    BOOST_REQUIRE_THROW(sid_t fail_sid("01:02:03:4"), uhd::value_error);
-    BOOST_REQUIRE_THROW(sid_t fail_sid("01:02:03:004"), uhd::value_error);
-    BOOST_REQUIRE_THROW(sid_t fail_sid("1.2.3.0004"), uhd::value_error);
-}
diff --git a/host/tests/stream_sig_test.cpp b/host/tests/stream_sig_test.cpp
deleted file mode 100644
index 41c07c14f..000000000
--- a/host/tests/stream_sig_test.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// Copyright 2014-2015 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include <uhd/exception.hpp>
-#include <uhd/rfnoc/stream_sig.hpp>
-#include <boost/test/unit_test.hpp>
-#include <iostream>
-
-using namespace uhd::rfnoc;
-
-BOOST_AUTO_TEST_CASE(test_stream_sig)
-{
-    stream_sig_t stream_sig;
-
-    BOOST_CHECK_EQUAL(stream_sig.item_type, "");
-    BOOST_CHECK_EQUAL(stream_sig.vlen, 0);
-    BOOST_CHECK_EQUAL(stream_sig.packet_size, 0);
-    BOOST_CHECK_EQUAL(stream_sig.is_bursty, false);
-
-    std::stringstream ss;
-    ss << stream_sig;
-    // Eventually actually test the contents
-    std::cout << ss.str() << std::endl;
-}
-
-BOOST_AUTO_TEST_CASE(test_stream_sig_compat)
-{
-    stream_sig_t upstream_sig;
-    stream_sig_t downstream_sig;
-
-    BOOST_CHECK(stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    upstream_sig.vlen = 32;
-    BOOST_CHECK(stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    downstream_sig.vlen = 32;
-    BOOST_CHECK(stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    upstream_sig.vlen = 16;
-    BOOST_CHECK(not stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    upstream_sig.vlen = 32;
-    BOOST_CHECK(stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    upstream_sig.packet_size = 8;
-    BOOST_CHECK(stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    downstream_sig.packet_size = 12;
-    BOOST_CHECK(not stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    upstream_sig.packet_size = 0;
-    BOOST_CHECK(stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    downstream_sig.item_type = "";
-    BOOST_CHECK(stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-    upstream_sig.item_type   = "sc16";
-    downstream_sig.item_type = "s8";
-    BOOST_CHECK(not stream_sig_t::is_compatible(upstream_sig, downstream_sig));
-}
-
-BOOST_AUTO_TEST_CASE(test_stream_sig_types)
-{
-    stream_sig_t stream_sig;
-    BOOST_CHECK_EQUAL(stream_sig.get_bytes_per_item(), 0);
-    stream_sig.item_type = "sc16";
-    BOOST_CHECK_EQUAL(stream_sig.get_bytes_per_item(), 4);
-    stream_sig.item_type = "sc12";
-    BOOST_CHECK_EQUAL(stream_sig.get_bytes_per_item(), 3);
-    stream_sig.item_type = "sc8";
-    BOOST_CHECK_EQUAL(stream_sig.get_bytes_per_item(), 2);
-    stream_sig.item_type = "s16";
-    BOOST_CHECK_EQUAL(stream_sig.get_bytes_per_item(), 2);
-    stream_sig.item_type = "s8";
-    BOOST_CHECK_EQUAL(stream_sig.get_bytes_per_item(), 1);
-    stream_sig.item_type = "fc32";
-    BOOST_CHECK_EQUAL(stream_sig.get_bytes_per_item(), 8);
-    stream_sig.item_type = "not_a_type";
-    BOOST_REQUIRE_THROW(stream_sig.get_bytes_per_item(), uhd::key_error);
-}
diff --git a/host/tests/tick_node_test.cpp b/host/tests/tick_node_test.cpp
deleted file mode 100644
index ccec67c43..000000000
--- a/host/tests/tick_node_test.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// Copyright 2014 Ettus Research LLC
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#include "graph.hpp"
-#include <uhd/rfnoc/tick_node_ctrl.hpp>
-#include <boost/test/unit_test.hpp>
-#include <iostream>
-
-using namespace uhd::rfnoc;
-
-// test class derived, knows about rates
-class tick_aware_node : public test_node, public tick_node_ctrl
-{
-public:
-    typedef boost::shared_ptr<tick_aware_node> sptr;
-
-    tick_aware_node(const std::string& test_id) : test_node(test_id){};
-
-}; /* class tick_aware_node */
-
-// test class derived, sets rates
-class tick_setting_node : public test_node, public tick_node_ctrl
-{
-public:
-    typedef boost::shared_ptr<tick_setting_node> sptr;
-
-    tick_setting_node(const std::string& test_id, double tick_rate)
-        : test_node(test_id), _tick_rate(tick_rate){};
-
-protected:
-    double _get_tick_rate()
-    {
-        return _tick_rate;
-    };
-
-private:
-    const double _tick_rate;
-
-}; /* class tick_setting_node */
-
-#define MAKE_TICK_NODE(name) tick_aware_node::sptr name(new tick_aware_node(#name));
-#define MAKE_TICK_SETTING_NODE(name, rate) \
-    tick_setting_node::sptr name(new tick_setting_node(#name, rate));
-
-BOOST_AUTO_TEST_CASE(test_simplest_downstream_search)
-{
-    const double test_rate = 0.25;
-    MAKE_TICK_NODE(node_A);
-    MAKE_TICK_SETTING_NODE(node_B, test_rate);
-
-    // Simplest possible scenario: Connect B downstream of A and let
-    // it find B
-    connect_nodes(node_A, node_B);
-    node_A->set_tx_streamer(true, 0);
-    node_B->set_rx_streamer(true, 0);
-
-    double result_rate = node_A->get_tick_rate();
-    BOOST_CHECK_EQUAL(result_rate, test_rate);
-}
-
-BOOST_AUTO_TEST_CASE(test_both_ways_search)
-{
-    const double test_rate = 0.25;
-    MAKE_TICK_SETTING_NODE(node_A, tick_node_ctrl::RATE_UNDEFINED);
-    MAKE_TICK_NODE(node_B);
-    MAKE_TICK_SETTING_NODE(node_C, test_rate);
-
-    connect_nodes(node_A, node_B);
-    connect_nodes(node_B, node_C);
-    node_A->set_tx_streamer(true, 0);
-    node_B->set_tx_streamer(true, 0);
-    node_B->set_rx_streamer(true, 0);
-    node_C->set_rx_streamer(true, 0);
-
-    double result_rate = node_B->get_tick_rate();
-    BOOST_CHECK_EQUAL(result_rate, test_rate);
-}
-
-BOOST_AUTO_TEST_CASE(test_both_ways_search_reversed)
-{
-    const double test_rate = 0.25;
-    MAKE_TICK_SETTING_NODE(node_A, test_rate);
-    MAKE_TICK_NODE(node_B);
-    MAKE_TICK_SETTING_NODE(node_C, tick_node_ctrl::RATE_UNDEFINED);
-
-    connect_nodes(node_A, node_B);
-    connect_nodes(node_B, node_C);
-    node_A->set_tx_streamer(true, 0);
-    node_B->set_tx_streamer(true, 0);
-    node_B->set_rx_streamer(true, 0);
-    node_C->set_rx_streamer(true, 0);
-
-    double result_rate = node_B->get_tick_rate();
-    BOOST_CHECK_EQUAL(result_rate, test_rate);
-}
-
-BOOST_AUTO_TEST_CASE(test_both_ways_search_fail)
-{
-    const double test_rate = 0.25;
-    MAKE_TICK_SETTING_NODE(node_A, test_rate);
-    MAKE_TICK_NODE(node_B);
-    MAKE_TICK_SETTING_NODE(node_C, 2 * test_rate);
-
-    connect_nodes(node_A, node_B);
-    connect_nodes(node_B, node_C);
-    node_A->set_tx_streamer(true, 0);
-    node_B->set_tx_streamer(true, 0);
-    node_B->set_rx_streamer(true, 0);
-    node_C->set_rx_streamer(true, 0);
-
-    BOOST_CHECK_THROW(node_B->get_tick_rate(), uhd::runtime_error);
-}