diff options
Diffstat (limited to 'host/tests')
54 files changed, 2313 insertions, 2319 deletions
diff --git a/host/tests/addr_test.cpp b/host/tests/addr_test.cpp index 9819df1a5..03608d723 100644 --- a/host/tests/addr_test.cpp +++ b/host/tests/addr_test.cpp @@ -5,15 +5,16 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> -#include <uhd/types/mac_addr.hpp> #include <uhd/types/device_addr.hpp> +#include <uhd/types/mac_addr.hpp> #include <uhd/usrp/dboard_id.hpp> #include <boost/assign/list_of.hpp> +#include <boost/test/unit_test.hpp> #include <algorithm> #include <iostream> -BOOST_AUTO_TEST_CASE(test_mac_addr){ +BOOST_AUTO_TEST_CASE(test_mac_addr) +{ std::cout << "Testing mac addr..." << std::endl; const std::string mac_addr_str("00:01:23:45:67:89"); uhd::mac_addr_t mac_addr = uhd::mac_addr_t::from_string(mac_addr_str); @@ -22,39 +23,40 @@ BOOST_AUTO_TEST_CASE(test_mac_addr){ BOOST_CHECK_EQUAL(mac_addr_str, mac_addr.to_string()); } -BOOST_AUTO_TEST_CASE(test_device_addr){ +BOOST_AUTO_TEST_CASE(test_device_addr) +{ std::cout << "Testing device addr..." << std::endl; - //load the device address with something + // load the device address with something uhd::device_addr_t dev_addr; dev_addr["key1"] = "val1"; dev_addr["key1"] = "val1"; dev_addr["key3"] = ""; - //convert to and from args string + // convert to and from args string std::cout << "Pretty Print: " << std::endl << dev_addr.to_pp_string(); std::string args_str = dev_addr.to_string(); std::cout << "Args String: " << args_str << std::endl; uhd::device_addr_t new_dev_addr(args_str); - //they should be the same size + // they should be the same size BOOST_REQUIRE_EQUAL(dev_addr.size(), new_dev_addr.size()); - //the keys should match + // the keys should match std::vector<std::string> old_dev_addr_keys = dev_addr.keys(); std::vector<std::string> new_dev_addr_keys = new_dev_addr.keys(); - BOOST_CHECK_EQUAL_COLLECTIONS( - old_dev_addr_keys.begin(), old_dev_addr_keys.end(), - new_dev_addr_keys.begin(), new_dev_addr_keys.end() - ); + BOOST_CHECK_EQUAL_COLLECTIONS(old_dev_addr_keys.begin(), + old_dev_addr_keys.end(), + new_dev_addr_keys.begin(), + new_dev_addr_keys.end()); - //the vals should match + // the vals should match std::vector<std::string> old_dev_addr_vals = dev_addr.vals(); std::vector<std::string> new_dev_addr_vals = new_dev_addr.vals(); - BOOST_CHECK_EQUAL_COLLECTIONS( - old_dev_addr_vals.begin(), old_dev_addr_vals.end(), - new_dev_addr_vals.begin(), new_dev_addr_vals.end() - ); + BOOST_CHECK_EQUAL_COLLECTIONS(old_dev_addr_vals.begin(), + old_dev_addr_vals.end(), + new_dev_addr_vals.begin(), + new_dev_addr_vals.end()); uhd::device_addr_t dev_addr_lhs1("key1=val1,key2=val2"); dev_addr_lhs1.update(uhd::device_addr_t("key2=val2x,key3=val3"), false); @@ -64,7 +66,8 @@ BOOST_AUTO_TEST_CASE(test_device_addr){ std::cout << "Merged: " << dev_addr_lhs1.to_string() << std::endl; } -BOOST_AUTO_TEST_CASE(test_dboard_id){ +BOOST_AUTO_TEST_CASE(test_dboard_id) +{ std::cout << "Testing dboard id..." << std::endl; using namespace uhd::usrp; @@ -76,7 +79,8 @@ BOOST_AUTO_TEST_CASE(test_dboard_id){ std::cout << "Pretty Print: " << std::endl << dboard_id_t::none().to_pp_string(); } -BOOST_AUTO_TEST_CASE(test_map_device_addr){ +BOOST_AUTO_TEST_CASE(test_map_device_addr) +{ std::map<std::string, std::string> dev_addr_map; dev_addr_map["key1"] = "val1"; dev_addr_map["key2"] = "val2"; diff --git a/host/tests/block_id_test.cpp b/host/tests/block_id_test.cpp index 51be3a2a2..7c068e4d2 100644 --- a/host/tests/block_id_test.cpp +++ b/host/tests/block_id_test.cpp @@ -5,14 +5,15 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <iostream> -#include <boost/test/unit_test.hpp> #include <uhd/exception.hpp> #include <uhd/rfnoc/block_id.hpp> +#include <boost/test/unit_test.hpp> +#include <iostream> using namespace uhd::rfnoc; -BOOST_AUTO_TEST_CASE(test_block_id) { +BOOST_AUTO_TEST_CASE(test_block_id) +{ BOOST_CHECK(block_id_t::is_valid_block_id("00/Filter_1")); BOOST_CHECK(not block_id_t::is_valid_block_id("0/MAG_SQUARE")); BOOST_CHECK(block_id_t::is_valid_blockname("FilterFoo")); @@ -45,7 +46,8 @@ BOOST_AUTO_TEST_CASE(test_block_id) { BOOST_CHECK(not block_id.set_block_name("Foo_Bar")); BOOST_CHECK_EQUAL(block_id.get_device_no(), 17); - BOOST_CHECK_EQUAL(block_id.get_block_name(), "FooBar"); // Is unchanged because invalid + BOOST_CHECK_EQUAL( + block_id.get_block_name(), "FooBar"); // Is unchanged because invalid BOOST_CHECK_EQUAL(block_id.get_block_count(), 11); block_id++; @@ -82,7 +84,8 @@ BOOST_AUTO_TEST_CASE(test_block_id) { BOOST_CHECK(not other_block_id.match("2093ksdjfflsdkjf")); } -BOOST_AUTO_TEST_CASE(test_block_id_set) { +BOOST_AUTO_TEST_CASE(test_block_id_set) +{ // test set() block_id_t block_id_for_set(5, "Blockname", 9); block_id_for_set.set("FirFilter"); @@ -99,9 +102,10 @@ BOOST_AUTO_TEST_CASE(test_block_id_set) { BOOST_CHECK_EQUAL(block_id_for_set.get_block_count(), 3); } -BOOST_AUTO_TEST_CASE(test_block_id_cmp) { +BOOST_AUTO_TEST_CASE(test_block_id_cmp) +{ BOOST_CHECK(block_id_t("0/FFT_1") == block_id_t("0/FFT_1")); BOOST_CHECK(block_id_t("0/FFT_1") != block_id_t("1/FFT_1")); BOOST_CHECK(block_id_t("0/FFT_1") < block_id_t("1/aaaaaaaaa_0")); - BOOST_CHECK(not (block_id_t("0/FFT_1") > block_id_t("1/aaaaaaaaa_0"))); + BOOST_CHECK(not(block_id_t("0/FFT_1") > block_id_t("1/aaaaaaaaa_0"))); } diff --git a/host/tests/blockdef_test.cpp b/host/tests/blockdef_test.cpp index bc513bebd..7a663f514 100644 --- a/host/tests/blockdef_test.cpp +++ b/host/tests/blockdef_test.cpp @@ -5,30 +5,28 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <iostream> -#include <map> +#include <uhd/rfnoc/blockdef.hpp> #include <stdint.h> -#include <boost/test/unit_test.hpp> #include <boost/format.hpp> -#include <uhd/rfnoc/blockdef.hpp> +#include <boost/test/unit_test.hpp> +#include <iostream> +#include <map> using namespace uhd::rfnoc; -BOOST_AUTO_TEST_CASE(test_lookup) { - const std::map<uint64_t, std::string> blocknames{ - {0, "NullSrcSink"}, +BOOST_AUTO_TEST_CASE(test_lookup) +{ + const std::map<uint64_t, std::string> blocknames{{0, "NullSrcSink"}, {0xFF70000000000000, "FFT"}, {0xF112000000000001, "FIR"}, {0xF1F0000000000000, "FIFO"}, {0xD053000000000000, "Window"}, - {0x5CC0000000000000, "SchmidlCox"} - }; + {0x5CC0000000000000, "SchmidlCox"}}; std::cout << blocknames.size() << std::endl; for (const auto block : blocknames) { - std::cout << "Testing " << block.second - << " => " << str(boost::format("%016X") % block.first) - << std::endl; + std::cout << "Testing " << block.second << " => " + << str(boost::format("%016X") % block.first) << std::endl; auto block_definition = blockdef::make_from_noc_id(block.first); // If the previous function fails, it'll return a NULL pointer BOOST_REQUIRE(block_definition); @@ -37,10 +35,11 @@ BOOST_AUTO_TEST_CASE(test_lookup) { } } -BOOST_AUTO_TEST_CASE(test_ports) { +BOOST_AUTO_TEST_CASE(test_ports) +{ // Create an FFT: blockdef::sptr block_definition = blockdef::make_from_noc_id(0xFF70000000000000); - blockdef::ports_t in_ports = block_definition->get_input_ports(); + blockdef::ports_t in_ports = block_definition->get_input_ports(); BOOST_REQUIRE_EQUAL(in_ports.size(), 1); BOOST_CHECK_EQUAL(in_ports[0]["name"], "in"); BOOST_CHECK_EQUAL(in_ports[0]["type"], "sc16"); @@ -57,20 +56,22 @@ BOOST_AUTO_TEST_CASE(test_ports) { BOOST_CHECK_EQUAL(block_definition->get_all_port_numbers()[0], 0); } -BOOST_AUTO_TEST_CASE(test_args) { +BOOST_AUTO_TEST_CASE(test_args) +{ // Create an FFT: blockdef::sptr block_definition = blockdef::make_from_noc_id(0xFF70000000000000); - blockdef::args_t args = block_definition->get_args(); + blockdef::args_t args = block_definition->get_args(); BOOST_REQUIRE_EQUAL(args.size(), 7); BOOST_CHECK_EQUAL(args[0]["name"], "spp"); BOOST_CHECK_EQUAL(args[0]["type"], "int"); BOOST_CHECK_EQUAL(args[0]["value"], "256"); } -BOOST_AUTO_TEST_CASE(test_regs) { +BOOST_AUTO_TEST_CASE(test_regs) +{ // Create an FFT: blockdef::sptr block_definition = blockdef::make_from_noc_id(0xFF70000000000000); - blockdef::registers_t sregs = block_definition->get_settings_registers(); + blockdef::registers_t sregs = block_definition->get_settings_registers(); BOOST_REQUIRE_EQUAL(sregs.size(), 6); BOOST_CHECK_EQUAL(sregs["FFT_RESET"], 131); BOOST_CHECK_EQUAL(sregs["FFT_SIZE_LOG2"], 132); @@ -80,4 +81,3 @@ BOOST_AUTO_TEST_CASE(test_regs) { BOOST_CHECK_EQUAL(user_regs["RB_FFT_RESET"], 0); BOOST_CHECK_EQUAL(user_regs["RB_MAGNITUDE_OUT"], 1); } - diff --git a/host/tests/buffer_test.cpp b/host/tests/buffer_test.cpp index b2659a86b..ef4c68ff2 100644 --- a/host/tests/buffer_test.cpp +++ b/host/tests/buffer_test.cpp @@ -5,26 +5,27 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/transport/bounded_buffer.hpp> #include <boost/assign/list_of.hpp> +#include <boost/test/unit_test.hpp> using namespace boost::assign; using namespace uhd::transport; -static const double timeout = 0.01/*secs*/; +static const double timeout = 0.01 /*secs*/; -BOOST_AUTO_TEST_CASE(test_bounded_buffer_with_timed_wait){ +BOOST_AUTO_TEST_CASE(test_bounded_buffer_with_timed_wait) +{ bounded_buffer<int> bb(3); - //push elements, check for timeout + // push elements, check for timeout BOOST_CHECK(bb.push_with_timed_wait(0, timeout)); BOOST_CHECK(bb.push_with_timed_wait(1, timeout)); BOOST_CHECK(bb.push_with_timed_wait(2, timeout)); BOOST_CHECK(not bb.push_with_timed_wait(3, timeout)); int val; - //pop elements, check for timeout and check values + // pop elements, check for timeout and check values BOOST_CHECK(bb.pop_with_timed_wait(val, timeout)); BOOST_CHECK_EQUAL(val, 0); BOOST_CHECK(bb.pop_with_timed_wait(val, timeout)); @@ -34,17 +35,18 @@ BOOST_AUTO_TEST_CASE(test_bounded_buffer_with_timed_wait){ BOOST_CHECK(not bb.pop_with_timed_wait(val, timeout)); } -BOOST_AUTO_TEST_CASE(test_bounded_buffer_with_pop_on_full){ +BOOST_AUTO_TEST_CASE(test_bounded_buffer_with_pop_on_full) +{ bounded_buffer<int> bb(3); - //push elements, check for timeout + // push elements, check for timeout BOOST_CHECK(bb.push_with_pop_on_full(0)); BOOST_CHECK(bb.push_with_pop_on_full(1)); BOOST_CHECK(bb.push_with_pop_on_full(2)); BOOST_CHECK(not bb.push_with_pop_on_full(3)); int val; - //pop elements, check for timeout and check values + // pop elements, check for timeout and check values BOOST_CHECK(bb.pop_with_timed_wait(val, timeout)); BOOST_CHECK_EQUAL(val, 1); BOOST_CHECK(bb.pop_with_timed_wait(val, timeout)); diff --git a/host/tests/byteswap_test.cpp b/host/tests/byteswap_test.cpp index c006de169..4cc04f484 100644 --- a/host/tests/byteswap_test.cpp +++ b/host/tests/byteswap_test.cpp @@ -5,25 +5,27 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/utils/byteswap.hpp> +#include <boost/test/unit_test.hpp> -BOOST_AUTO_TEST_CASE(test_byteswap16){ +BOOST_AUTO_TEST_CASE(test_byteswap16) +{ uint16_t x = 0x0123; uint16_t y = 0x2301; BOOST_CHECK_EQUAL(uhd::byteswap(x), y); } -BOOST_AUTO_TEST_CASE(test_byteswap32){ +BOOST_AUTO_TEST_CASE(test_byteswap32) +{ uint32_t x = 0x01234567; uint32_t y = 0x67452301; BOOST_CHECK_EQUAL(uhd::byteswap(x), y); } -BOOST_AUTO_TEST_CASE(test_byteswap64){ - //split up 64 bit constants to avoid long-long compiler warnings +BOOST_AUTO_TEST_CASE(test_byteswap64) +{ + // split up 64 bit constants to avoid long-long compiler warnings uint64_t x = 0x01234567 | (uint64_t(0x89abcdef) << 32); uint64_t y = 0xefcdab89 | (uint64_t(0x67452301) << 32); BOOST_CHECK_EQUAL(uhd::byteswap(x), y); } - diff --git a/host/tests/cal_container_test.cpp b/host/tests/cal_container_test.cpp index 559a674c1..4957b0b0d 100644 --- a/host/tests/cal_container_test.cpp +++ b/host/tests/cal_container_test.cpp @@ -7,10 +7,10 @@ #include <uhd/cal/power_container.hpp> #include <uhd/exception.hpp> -#include <boost/test/unit_test.hpp> #include <boost/shared_ptr.hpp> -#include <vector> +#include <boost/test/unit_test.hpp> #include <fstream> +#include <vector> using namespace uhd; using namespace uhd::cal; @@ -18,8 +18,9 @@ using namespace uhd::cal; static const double eps = 1e-8; //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_power_container_bilinear){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_power_container_bilinear) +{ + //////////////////////////////////////////////////////////////////////// // Create the data container power_container::sptr container = power_container::make(); @@ -51,8 +52,9 @@ BOOST_AUTO_TEST_CASE(test_power_container_bilinear){ //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_power_temp_container){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_power_temp_container) +{ + //////////////////////////////////////////////////////////////////////// // Create the data container power_container::sptr container = power_container::make(); @@ -80,8 +82,9 @@ BOOST_AUTO_TEST_CASE(test_power_temp_container){ } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_power_container_metadata){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_power_container_metadata) +{ + //////////////////////////////////////////////////////////////////////// // Create the data container power_container::sptr container = power_container::make(); @@ -90,7 +93,7 @@ BOOST_AUTO_TEST_CASE(test_power_container_metadata){ base_container::metadata_t data; std::string fake_serial = "F2A432"; - data["x300"] = fake_serial; + data["x300"] = fake_serial; // Add some metadata container->add_metadata(data); @@ -102,8 +105,9 @@ BOOST_AUTO_TEST_CASE(test_power_container_metadata){ } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_power_serialization){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_power_serialization) +{ + //////////////////////////////////////////////////////////////////////// // Create the data container power_container::sptr container = power_container::make(); @@ -112,7 +116,7 @@ BOOST_AUTO_TEST_CASE(test_power_serialization){ base_container::metadata_t data; std::string fake_serial = "F2A432"; - data["x300"] = fake_serial; + data["x300"] = fake_serial; // Add some metadata container->add_metadata(data); @@ -167,8 +171,9 @@ BOOST_AUTO_TEST_CASE(test_power_serialization){ } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_interp_singular){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_interp_singular) +{ + //////////////////////////////////////////////////////////////////////// // Create the data container power_container::sptr container = power_container::make(); diff --git a/host/tests/cast_test.cpp b/host/tests/cast_test.cpp index d1357459e..296574b48 100644 --- a/host/tests/cast_test.cpp +++ b/host/tests/cast_test.cpp @@ -5,19 +5,18 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <iostream> -#include <boost/test/unit_test.hpp> -#include <stdint.h> #include <uhd/utils/cast.hpp> +#include <stdint.h> +#include <boost/test/unit_test.hpp> +#include <iostream> -BOOST_AUTO_TEST_CASE(test_mac_addr){ - std::string in = "0x0100"; +BOOST_AUTO_TEST_CASE(test_mac_addr) +{ + std::string in = "0x0100"; uint16_t correct_result = 256; - uint16_t x = uhd::cast::hexstr_cast<uint16_t>(in); - //uint16_t x = uhd::cast::hexstr_cast(in); - std::cout - << "Testing hex -> uint16_t conversion. " - << in << " == " << std::hex << x << "?" << std::endl; + uint16_t x = uhd::cast::hexstr_cast<uint16_t>(in); + // uint16_t x = uhd::cast::hexstr_cast(in); + std::cout << "Testing hex -> uint16_t conversion. " << in << " == " << std::hex << x + << "?" << std::endl; BOOST_CHECK_EQUAL(x, correct_result); } - diff --git a/host/tests/chdr_test.cpp b/host/tests/chdr_test.cpp index 11daca521..595d7011a 100644 --- a/host/tests/chdr_test.cpp +++ b/host/tests/chdr_test.cpp @@ -7,128 +7,131 @@ #include <uhd/transport/chdr.hpp> #include <uhd/utils/byteswap.hpp> -#include <boost/test/unit_test.hpp> #include <boost/format.hpp> +#include <boost/test/unit_test.hpp> #include <cstdlib> #include <iostream> using namespace uhd::transport::vrt; -static void pack_and_unpack( - if_packet_info_t &if_packet_info_in -){ +static void pack_and_unpack(if_packet_info_t& if_packet_info_in) +{ // Temp buffer for packed packet uint32_t packet_buff[2048] = {0}; // Check input (must not be lazy) - BOOST_REQUIRE( - (if_packet_info_in.num_payload_words32 == 0 and if_packet_info_in.num_payload_bytes == 0) - or - (if_packet_info_in.num_payload_words32 != 0 and if_packet_info_in.num_payload_bytes != 0) - ); + BOOST_REQUIRE((if_packet_info_in.num_payload_words32 == 0 + and if_packet_info_in.num_payload_bytes == 0) + or (if_packet_info_in.num_payload_words32 != 0 + and if_packet_info_in.num_payload_bytes != 0)); if (if_packet_info_in.num_payload_words32) { - BOOST_REQUIRE(if_packet_info_in.num_payload_bytes <= 4 * if_packet_info_in.num_payload_words32); - BOOST_REQUIRE(if_packet_info_in.num_payload_bytes > 4*(if_packet_info_in.num_payload_words32-1)); + BOOST_REQUIRE(if_packet_info_in.num_payload_bytes + <= 4 * if_packet_info_in.num_payload_words32); + BOOST_REQUIRE(if_packet_info_in.num_payload_bytes + > 4 * (if_packet_info_in.num_payload_words32 - 1)); } - //pack metadata into a vrt header - chdr::if_hdr_pack_be( - packet_buff, if_packet_info_in - ); + // pack metadata into a vrt header + chdr::if_hdr_pack_be(packet_buff, if_packet_info_in); std::cout << std::endl; uint32_t header_bits = (uhd::ntohx(packet_buff[0]) >> 28); std::cout << boost::format("header bits = 0b%d%d%d%d") % ((header_bits & 8) > 0) - % ((header_bits & 4) > 0) - % ((header_bits & 2) > 0) - % ((header_bits & 1) > 0) << std::endl; - for (size_t i = 0; i < 5; i++) - { - std::cout << boost::format("packet_buff[%u] = 0x%08x") % i % uhd::ntohx(packet_buff[i]) << std::endl; + % ((header_bits & 4) > 0) % ((header_bits & 2) > 0) + % ((header_bits & 1) > 0) + << std::endl; + for (size_t i = 0; i < 5; i++) { + std::cout << boost::format("packet_buff[%u] = 0x%08x") % i + % uhd::ntohx(packet_buff[i]) + << std::endl; } if_packet_info_t if_packet_info_out; // Must be set a-priori as per contract if_packet_info_out.num_packet_words32 = if_packet_info_in.num_packet_words32; - //unpack the vrt header back into metadata - chdr::if_hdr_unpack_be( - packet_buff, if_packet_info_out - ); + // unpack the vrt header back into metadata + chdr::if_hdr_unpack_be(packet_buff, if_packet_info_out); - //check the the unpacked metadata is the same + // check the the unpacked metadata is the same BOOST_CHECK_EQUAL(if_packet_info_in.packet_count, if_packet_info_out.packet_count); - BOOST_CHECK_EQUAL(if_packet_info_in.num_header_words32, if_packet_info_out.num_header_words32); - BOOST_CHECK_EQUAL(if_packet_info_in.num_payload_words32, if_packet_info_out.num_payload_words32); + BOOST_CHECK_EQUAL( + if_packet_info_in.num_header_words32, if_packet_info_out.num_header_words32); + BOOST_CHECK_EQUAL( + if_packet_info_in.num_payload_words32, if_packet_info_out.num_payload_words32); BOOST_CHECK(if_packet_info_out.has_sid); BOOST_CHECK_EQUAL(if_packet_info_in.sid, if_packet_info_out.sid); BOOST_CHECK(if_packet_info_out.has_sid); BOOST_CHECK_EQUAL(if_packet_info_in.has_tsf, if_packet_info_out.has_tsf); - if (if_packet_info_in.has_tsf and if_packet_info_out.has_tsf){ + if (if_packet_info_in.has_tsf and if_packet_info_out.has_tsf) { BOOST_CHECK_EQUAL(if_packet_info_in.tsf, if_packet_info_out.tsf); } } -BOOST_AUTO_TEST_CASE(test_with_chdr){ +BOOST_AUTO_TEST_CASE(test_with_chdr) +{ if_packet_info_t if_packet_info; - if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_DATA; - if_packet_info.eob = false; - if_packet_info.packet_count = 7; - if_packet_info.has_tsf = true; - if_packet_info.tsf = 0x1234567890ABCDEFull; - if_packet_info.sid = 0xAABBCCDD; + if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_DATA; + if_packet_info.eob = false; + if_packet_info.packet_count = 7; + if_packet_info.has_tsf = true; + if_packet_info.tsf = 0x1234567890ABCDEFull; + if_packet_info.sid = 0xAABBCCDD; if_packet_info.num_payload_words32 = 24; - if_packet_info.num_payload_bytes = 95; + if_packet_info.num_payload_bytes = 95; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_chdr_fc){ +BOOST_AUTO_TEST_CASE(test_with_chdr_fc) +{ if_packet_info_t if_packet_info; - if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_FC; - if_packet_info.eob = false; - if_packet_info.packet_count = 19; - if_packet_info.has_tsf = false; - if_packet_info.tsf = 0x1234567890ABCDEFull; - if_packet_info.sid = 0xAABBCCDD; + if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_FC; + if_packet_info.eob = false; + if_packet_info.packet_count = 19; + if_packet_info.has_tsf = false; + if_packet_info.tsf = 0x1234567890ABCDEFull; + if_packet_info.sid = 0xAABBCCDD; if_packet_info.num_payload_words32 = 4; - if_packet_info.num_payload_bytes = 16; + if_packet_info.num_payload_bytes = 16; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_chdr_cmd){ +BOOST_AUTO_TEST_CASE(test_with_chdr_cmd) +{ if_packet_info_t if_packet_info; - if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_CMD; - if_packet_info.packet_count = 19; - if_packet_info.has_tsf = true; - if_packet_info.tsf = 0x1234567890ABCDEFull; - if_packet_info.sid = 0xAABBCCDD; + if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_CMD; + if_packet_info.packet_count = 19; + if_packet_info.has_tsf = true; + if_packet_info.tsf = 0x1234567890ABCDEFull; + if_packet_info.sid = 0xAABBCCDD; if_packet_info.num_payload_words32 = 4; - if_packet_info.num_payload_bytes = 16; + if_packet_info.num_payload_bytes = 16; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_chdr_resp){ +BOOST_AUTO_TEST_CASE(test_with_chdr_resp) +{ if_packet_info_t if_packet_info; - if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_RESP; - if_packet_info.packet_count = 123; - if_packet_info.has_tsf = false; - if_packet_info.tsf = 0x1234567890ABCDEFull; - if_packet_info.sid = 0xAABBCCDD; + if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_RESP; + if_packet_info.packet_count = 123; + if_packet_info.has_tsf = false; + if_packet_info.tsf = 0x1234567890ABCDEFull; + if_packet_info.sid = 0xAABBCCDD; if_packet_info.num_payload_words32 = 4; - if_packet_info.num_payload_bytes = 16; + if_packet_info.num_payload_bytes = 16; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_chdr_err){ +BOOST_AUTO_TEST_CASE(test_with_chdr_err) +{ if_packet_info_t if_packet_info; - if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_ERROR; - if_packet_info.packet_count = 1928; - if_packet_info.eob = false; - if_packet_info.error = false; // Needs to be set explicitly - if_packet_info.has_tsf = false; - if_packet_info.tsf = 0x1234567890ABCDEFull; - if_packet_info.sid = 0xAABBCCDD; + if_packet_info.packet_type = if_packet_info_t::PACKET_TYPE_ERROR; + if_packet_info.packet_count = 1928; + if_packet_info.eob = false; + if_packet_info.error = false; // Needs to be set explicitly + if_packet_info.has_tsf = false; + if_packet_info.tsf = 0x1234567890ABCDEFull; + if_packet_info.sid = 0xAABBCCDD; if_packet_info.num_payload_words32 = 4; - if_packet_info.num_payload_bytes = 16; + if_packet_info.num_payload_bytes = 16; pack_and_unpack(if_packet_info); } - diff --git a/host/tests/common/mock_ctrl_iface_impl.cpp b/host/tests/common/mock_ctrl_iface_impl.cpp index 0e80ef9a0..e8560ad9e 100644 --- a/host/tests/common/mock_ctrl_iface_impl.cpp +++ b/host/tests/common/mock_ctrl_iface_impl.cpp @@ -7,16 +7,19 @@ #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 */ -) { +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; + 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; + 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; @@ -25,8 +28,8 @@ uint64_t mock_ctrl_iface_impl::send_cmd_pkt( case uhd::rfnoc::SR_READBACK_REG_USER: return 0x0123456789ABCDEF; case uhd::rfnoc::SR_READBACK_COMPAT: - return uhd::rfnoc::NOC_SHELL_COMPAT_MAJOR << 32 | - uhd::rfnoc::NOC_SHELL_COMPAT_MINOR; + return uhd::rfnoc::NOC_SHELL_COMPAT_MAJOR << 32 + | uhd::rfnoc::NOC_SHELL_COMPAT_MINOR; default: return 0; } diff --git a/host/tests/common/mock_ctrl_iface_impl.hpp b/host/tests/common/mock_ctrl_iface_impl.hpp index 8d2aafed6..ad60d32ef 100644 --- a/host/tests/common/mock_ctrl_iface_impl.hpp +++ b/host/tests/common/mock_ctrl_iface_impl.hpp @@ -10,21 +10,18 @@ #include <uhd/rfnoc/constants.hpp> #include <uhdlib/rfnoc/ctrl_iface.hpp> -#include <boost/thread/mutex.hpp> -#include <boost/thread/thread.hpp> -#include <boost/format.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 - ); + uint64_t send_cmd_pkt(const size_t addr, + const size_t data, + const bool readback = false, + const uint64_t timestamp = 0); }; #endif /* INCLUDED_MOCK_CTRL_IFACE_IMPL_HPP */
\ No newline at end of file diff --git a/host/tests/common/mock_zero_copy.cpp b/host/tests/common/mock_zero_copy.cpp index bc49c3f10..0843a0274 100644 --- a/host/tests/common/mock_zero_copy.cpp +++ b/host/tests/common/mock_zero_copy.cpp @@ -10,18 +10,19 @@ using namespace uhd::transport; -mock_zero_copy::mock_zero_copy( - vrt::if_packet_info_t::link_type_t link_type, +mock_zero_copy::mock_zero_copy(vrt::if_packet_info_t::link_type_t link_type, size_t recv_frame_size, - size_t send_frame_size -) : _link_type(link_type) - , _recv_frame_size(recv_frame_size) - , _send_frame_size(send_frame_size) { + size_t send_frame_size) + : _link_type(link_type) + , _recv_frame_size(recv_frame_size) + , _send_frame_size(send_frame_size) +{ } -uhd::transport::managed_recv_buffer::sptr mock_zero_copy::get_recv_buff(double) { +uhd::transport::managed_recv_buffer::sptr mock_zero_copy::get_recv_buff(double) +{ if (_simulate_io_error) { - throw uhd::io_error("IO error exception"); //simulate an IO error + throw uhd::io_error("IO error exception"); // simulate an IO error } if (_rx_mems.empty()) { return uhd::transport::managed_recv_buffer::sptr(); // timeout @@ -38,20 +39,22 @@ uhd::transport::managed_recv_buffer::sptr mock_zero_copy::get_recv_buff(double) return mrb; } -uhd::transport::managed_send_buffer::sptr mock_zero_copy::get_send_buff(double) { +uhd::transport::managed_send_buffer::sptr mock_zero_copy::get_send_buff(double) +{ if (not _reuse_send_memory or _tx_mems.size() == 0) { - _tx_mems.push_back( - boost::shared_array<uint8_t>(new uint8_t[_send_frame_size])); + _tx_mems.push_back(boost::shared_array<uint8_t>(new uint8_t[_send_frame_size])); _tx_lens.push_back(_send_frame_size); } return _msb.get_new(_tx_mems.back(), &_tx_lens.back()); } -void mock_zero_copy::set_reuse_recv_memory(bool reuse_recv) { +void mock_zero_copy::set_reuse_recv_memory(bool reuse_recv) +{ _reuse_recv_memory = reuse_recv; } -void mock_zero_copy::set_reuse_send_memory(bool reuse_send) { +void mock_zero_copy::set_reuse_send_memory(bool reuse_send) +{ _reuse_send_memory = reuse_send; } diff --git a/host/tests/common/mock_zero_copy.hpp b/host/tests/common/mock_zero_copy.hpp index 8d27c9b46..60e5f4659 100644 --- a/host/tests/common/mock_zero_copy.hpp +++ b/host/tests/common/mock_zero_copy.hpp @@ -7,18 +7,17 @@ #ifndef INCLUDED_MOCK_XPORT_HPP #define INCLUDED_MOCK_XPORT_HPP -#include <uhdlib/rfnoc/xports.hpp> +#include <uhd/exception.hpp> #include <uhd/transport/chdr.hpp> #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/exception.hpp> #include <uhd/utils/byteswap.hpp> -#include <uhd/exception.hpp> +#include <uhdlib/rfnoc/xports.hpp> #include <boost/make_shared.hpp> -#include <boost/shared_ptr.hpp> #include <boost/shared_array.hpp> +#include <boost/shared_ptr.hpp> #include <list> #include <vector> @@ -36,89 +35,101 @@ static constexpr size_t DEFAULT_RECV_FRAME_SIZE = 1024; /*********************************************************************** * Dummy managed buffers for testing **********************************************************************/ -class mock_msb : public uhd::transport::managed_send_buffer { - public: - void release(void) { /* nop */ +class mock_msb : public uhd::transport::managed_send_buffer +{ +public: + void release(void) + { /* nop */ } - sptr get_new(boost::shared_array<uint8_t> mem, size_t* len) { + sptr get_new(boost::shared_array<uint8_t> mem, size_t* len) + { _mem = mem; return make(this, mem.get(), *len); } - private: +private: boost::shared_array<uint8_t> _mem; }; -class mock_mrb : public uhd::transport::managed_recv_buffer { - public: - void release(void) { /* nop */ +class mock_mrb : public uhd::transport::managed_recv_buffer +{ +public: + void release(void) + { /* nop */ } - sptr get_new(boost::shared_array<uint8_t> mem, size_t len) { + sptr get_new(boost::shared_array<uint8_t> mem, size_t len) + { _mem = mem; return make(this, _mem.get(), len); } - private: +private: boost::shared_array<uint8_t> _mem; }; -class mock_zero_copy : public uhd::transport::zero_copy_if { - public: +class mock_zero_copy : public uhd::transport::zero_copy_if +{ +public: typedef boost::shared_ptr<mock_zero_copy> sptr; - mock_zero_copy( - uhd::transport::vrt::if_packet_info_t::link_type_t type, + mock_zero_copy(uhd::transport::vrt::if_packet_info_t::link_type_t type, size_t recv_frame_size = DEFAULT_RECV_FRAME_SIZE, - size_t send_frame_size = DEFAULT_SEND_FRAME_SIZE - ); + size_t send_frame_size = DEFAULT_SEND_FRAME_SIZE); uhd::transport::managed_recv_buffer::sptr get_recv_buff(double); uhd::transport::managed_send_buffer::sptr get_send_buff(double); - size_t get_num_recv_frames(void) const { return 1; } - size_t get_num_send_frames(void) const { return 1; } - size_t get_recv_frame_size(void) const { return _recv_frame_size; } - size_t get_send_frame_size(void) const { return _send_frame_size; } + size_t get_num_recv_frames(void) const + { + return 1; + } + size_t get_num_send_frames(void) const + { + return 1; + } + size_t get_recv_frame_size(void) const + { + return _recv_frame_size; + } + size_t get_send_frame_size(void) const + { + return _send_frame_size; + } template <typename T> - void push_back_packet( - uhd::transport::vrt::if_packet_info_t& ifpi, + void push_back_packet(uhd::transport::vrt::if_packet_info_t& ifpi, const std::vector<T>& otw_data = std::vector<T>(), - uhd::endianness_t endianness = uhd::ENDIANNESS_BIG); + uhd::endianness_t endianness = uhd::ENDIANNESS_BIG); void set_reuse_recv_memory(bool reuse_recv); void set_reuse_send_memory(bool reuse_send); - void set_simulate_io_error(bool status) { _simulate_io_error = status; } + void set_simulate_io_error(bool status) + { + _simulate_io_error = status; + } template <typename T, uhd::endianness_t endianness = uhd::ENDIANNESS_BIG> void push_back_recv_packet( - uhd::transport::vrt::if_packet_info_t& ifpi, - const std::vector<T>& otw_data - ); + uhd::transport::vrt::if_packet_info_t& ifpi, const std::vector<T>& otw_data); template <uhd::endianness_t endianness = uhd::ENDIANNESS_BIG> void push_back_inline_message_packet( - uhd::transport::vrt::if_packet_info_t& ifpi, - const uint32_t message - ); + uhd::transport::vrt::if_packet_info_t& ifpi, const uint32_t message); template <uhd::endianness_t endianness = uhd::ENDIANNESS_BIG> void push_back_flow_ctrl_packet( uhd::transport::vrt::if_packet_info_t::packet_type_t type, uint32_t packet_count, - uint32_t byte_count - ); + uint32_t byte_count); template <uhd::endianness_t endianness = uhd::ENDIANNESS_BIG> - void pop_send_packet( - uhd::transport::vrt::if_packet_info_t &ifpi - ); + void pop_send_packet(uhd::transport::vrt::if_packet_info_t& ifpi); - private: +private: std::list<boost::shared_array<uint8_t>> _tx_mems; std::list<size_t> _tx_lens; @@ -136,27 +147,23 @@ class mock_zero_copy : public uhd::transport::zero_copy_if { bool _reuse_recv_memory = false; bool _reuse_send_memory = false; - }; template <typename T, uhd::endianness_t endianness> void mock_zero_copy::push_back_recv_packet( - uhd::transport::vrt::if_packet_info_t& ifpi, - const std::vector<T>& otw_data -) { + uhd::transport::vrt::if_packet_info_t& ifpi, const std::vector<T>& otw_data) +{ using namespace uhd::transport; UHD_ASSERT_THROW( - ifpi.num_payload_words32 * sizeof(uint32_t) - == otw_data.size() * sizeof(T)); + ifpi.num_payload_words32 * sizeof(uint32_t) == otw_data.size() * sizeof(T)); const size_t max_hdr_len = - _link_type == vrt::if_packet_info_t::LINK_TYPE_CHDR ? - vrt::chdr::max_if_hdr_words64*sizeof(uint64_t) : - (vrt::max_if_hdr_words32 + 1/*tlr*/)*sizeof(uint32_t); + _link_type == vrt::if_packet_info_t::LINK_TYPE_CHDR + ? vrt::chdr::max_if_hdr_words64 * sizeof(uint64_t) + : (vrt::max_if_hdr_words32 + 1 /*tlr*/) * sizeof(uint32_t); - const size_t max_pkt_len = - ifpi.num_payload_words32*sizeof(uint32_t)+max_hdr_len; + const size_t max_pkt_len = ifpi.num_payload_words32 * sizeof(uint32_t) + max_hdr_len; UHD_ASSERT_THROW(max_pkt_len <= _recv_frame_size); @@ -168,15 +175,13 @@ void mock_zero_copy::push_back_recv_packet( if (endianness == uhd::ENDIANNESS_BIG) { if (_link_type == vrt::if_packet_info_t::LINK_TYPE_CHDR) { uhd::transport::vrt::chdr::if_hdr_pack_be(rx_buff_ptr, ifpi); - } - else { + } else { uhd::transport::vrt::if_hdr_pack_be(rx_buff_ptr, ifpi); } } else { if (_link_type == vrt::if_packet_info_t::LINK_TYPE_CHDR) { uhd::transport::vrt::chdr::if_hdr_pack_le(rx_buff_ptr, ifpi); - } - else { + } else { uhd::transport::vrt::if_hdr_pack_le(rx_buff_ptr, ifpi); } } @@ -184,42 +189,37 @@ void mock_zero_copy::push_back_recv_packet( // Copy data uint32_t* data_ptr = (rx_buff_ptr + ifpi.num_header_words32); std::copy(otw_data.begin(), otw_data.end(), reinterpret_cast<T*>(data_ptr)); - _rx_lens.push_back(ifpi.num_packet_words32*sizeof(uint32_t)); + _rx_lens.push_back(ifpi.num_packet_words32 * sizeof(uint32_t)); } template <uhd::endianness_t endianness> void mock_zero_copy::push_back_inline_message_packet( - uhd::transport::vrt::if_packet_info_t& ifpi, - const uint32_t message -) { - const std::vector<uint32_t> data { message | uhd::byteswap(message) }; + uhd::transport::vrt::if_packet_info_t& ifpi, const uint32_t message) +{ + const std::vector<uint32_t> data{message | uhd::byteswap(message)}; push_back_recv_packet<uint32_t, endianness>(ifpi, data); } template <uhd::endianness_t endianness> -void mock_zero_copy::pop_send_packet( - uhd::transport::vrt::if_packet_info_t &ifpi -) { +void mock_zero_copy::pop_send_packet(uhd::transport::vrt::if_packet_info_t& ifpi) +{ using namespace uhd::transport; - ifpi.num_packet_words32 = _tx_lens.front()/sizeof(uint32_t); + ifpi.num_packet_words32 = _tx_lens.front() / sizeof(uint32_t); - uint32_t* tx_buff_ptr = reinterpret_cast<uint32_t *>(_tx_mems.front().get()); + uint32_t* tx_buff_ptr = reinterpret_cast<uint32_t*>(_tx_mems.front().get()); if (endianness == uhd::ENDIANNESS_BIG) { if (_link_type == vrt::if_packet_info_t::LINK_TYPE_CHDR) { uhd::transport::vrt::chdr::if_hdr_unpack_be(tx_buff_ptr, ifpi); - } - else { + } else { uhd::transport::vrt::if_hdr_unpack_be(tx_buff_ptr, ifpi); } - } - else { + } else { if (_link_type == vrt::if_packet_info_t::LINK_TYPE_CHDR) { uhd::transport::vrt::chdr::if_hdr_unpack_le(tx_buff_ptr, ifpi); - } - else { + } else { uhd::transport::vrt::if_hdr_unpack_le(tx_buff_ptr, ifpi); } } @@ -231,14 +231,12 @@ template <uhd::endianness_t endianness> void mock_zero_copy::push_back_flow_ctrl_packet( uhd::transport::vrt::if_packet_info_t::packet_type_t type, uint32_t packet_count, - uint32_t byte_count -) + uint32_t byte_count) { using namespace uhd::transport; - UHD_ASSERT_THROW( - type == vrt::if_packet_info_t::PACKET_TYPE_FC or - type == vrt::if_packet_info_t::PACKET_TYPE_ACK); + UHD_ASSERT_THROW(type == vrt::if_packet_info_t::PACKET_TYPE_FC + or type == vrt::if_packet_info_t::PACKET_TYPE_ACK); // Only implemented for chdr packets currently UHD_ASSERT_THROW(_link_type == vrt::if_packet_info_t::LINK_TYPE_CHDR); @@ -246,18 +244,17 @@ void mock_zero_copy::push_back_flow_ctrl_packet( const size_t packet_len_in_words32 = 2; vrt::if_packet_info_t ifpi; - ifpi.packet_type = type; + ifpi.packet_type = type; ifpi.num_payload_words32 = packet_len_in_words32; - ifpi.num_payload_bytes = ifpi.num_payload_words32*sizeof(uint32_t); - ifpi.has_tsf = false; + ifpi.num_payload_bytes = ifpi.num_payload_words32 * sizeof(uint32_t); + ifpi.has_tsf = false; std::vector<uint32_t> data(packet_len_in_words32, 0); if (endianness == uhd::ENDIANNESS_BIG) { data[0] = uhd::ntohx(packet_count); data[1] = uhd::ntohx(byte_count); - } - else { + } else { data[0] = uhd::wtohx(packet_count); data[1] = uhd::wtohx(byte_count); } diff --git a/host/tests/config_parser_test.cpp b/host/tests/config_parser_test.cpp index ef1686a11..2016776a7 100644 --- a/host/tests/config_parser_test.cpp +++ b/host/tests/config_parser_test.cpp @@ -5,93 +5,68 @@ // #include <uhdlib/utils/config_parser.hpp> -#include <boost/test/unit_test.hpp> #include <boost/assign/list_of.hpp> -#include <fstream> +#include <boost/test/unit_test.hpp> #include <cstdio> +#include <fstream> const std::string INI1_FILENAME = "test1.ini"; -const std::string INI1 = - "[section1]\n" - "key1=value1\n" - "key2=4\n" - "\n" - "; This is a comment\n" - "[section2]\n" - "key3=value with spaces\n" - "key4= leading and trailing spaces \n" -; +const std::string INI1 = "[section1]\n" + "key1=value1\n" + "key2=4\n" + "\n" + "; This is a comment\n" + "[section2]\n" + "key3=value with spaces\n" + "key4= leading and trailing spaces \n"; const std::string INI2_FILENAME = "test2.ini"; -const std::string INI2 = - "[section2]\n" - "key3=value with even more spaces\n" - "\n" - "[section3]\n" - "key4=\"with quotes\"\n"; +const std::string INI2 = "[section2]\n" + "key3=value with even more spaces\n" + "\n" + "[section3]\n" + "key4=\"with quotes\"\n"; namespace { - //! Create files that can be read by the CUT - void make_config_parsers() - { - std::ofstream ini1(INI1_FILENAME); - ini1 << INI1 << std::endl; - ini1.close(); - std::ofstream ini2(INI2_FILENAME); - ini2 << INI2 << std::endl; - ini2.close(); - } +//! Create files that can be read by the CUT +void make_config_parsers() +{ + std::ofstream ini1(INI1_FILENAME); + ini1 << INI1 << std::endl; + ini1.close(); + std::ofstream ini2(INI2_FILENAME); + ini2 << INI2 << std::endl; + ini2.close(); +} - //! Tidy up after us - void cleanup_config_parsers() - { - std::remove(INI1_FILENAME.c_str()); - std::remove(INI2_FILENAME.c_str()); - } +//! Tidy up after us +void cleanup_config_parsers() +{ + std::remove(INI1_FILENAME.c_str()); + std::remove(INI2_FILENAME.c_str()); } +} // namespace -BOOST_AUTO_TEST_CASE(test_config_parser){ +BOOST_AUTO_TEST_CASE(test_config_parser) +{ make_config_parsers(); uhd::config_parser I(INI1_FILENAME); BOOST_CHECK_EQUAL(I.sections().size(), 2); BOOST_CHECK_EQUAL(I.options("section1").size(), 2); + BOOST_CHECK_EQUAL(I.get<std::string>("section1", "key1"), "value1"); + BOOST_CHECK_EQUAL(I.get<int>("section1", "key2"), 4); + BOOST_CHECK_EQUAL(I.get<std::string>("section2", "key3"), "value with spaces"); BOOST_CHECK_EQUAL( - I.get<std::string>("section1", "key1"), - "value1" - ); + I.get<std::string>("section2", "key4"), "leading and trailing spaces"); BOOST_CHECK_EQUAL( - I.get<int>("section1", "key2"), - 4 - ); - BOOST_CHECK_EQUAL( - I.get<std::string>("section2", "key3"), - "value with spaces" - ); - BOOST_CHECK_EQUAL( - I.get<std::string>("section2", "key4"), - "leading and trailing spaces" - ); - BOOST_CHECK_EQUAL( - I.get<std::string>("section2", "non_existent_key", "default"), - "default" - ); + I.get<std::string>("section2", "non_existent_key", "default"), "default"); BOOST_REQUIRE_THROW( - I.get<std::string>("section2", "non_existent_key"), - uhd::key_error - ); + I.get<std::string>("section2", "non_existent_key"), uhd::key_error); I.read_file(INI2_FILENAME); BOOST_CHECK_EQUAL( - I.get<std::string>("section2", "key3"), - "value with even more spaces" - ); - BOOST_CHECK_EQUAL( - I.get<std::string>("section1", "key1"), - "value1" - ); - BOOST_CHECK_EQUAL( - I.get<std::string>("section3", "key4"), - "\"with quotes\"" - ); + I.get<std::string>("section2", "key3"), "value with even more spaces"); + BOOST_CHECK_EQUAL(I.get<std::string>("section1", "key1"), "value1"); + BOOST_CHECK_EQUAL(I.get<std::string>("section3", "key4"), "\"with quotes\""); cleanup_config_parsers(); } diff --git a/host/tests/constrained_device_args_test.cpp b/host/tests/constrained_device_args_test.cpp index 318315739..2fe7e5c16 100644 --- a/host/tests/constrained_device_args_test.cpp +++ b/host/tests/constrained_device_args_test.cpp @@ -4,101 +4,93 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhdlib/usrp/constrained_device_args.hpp> +#include <boost/test/unit_test.hpp> #include <iostream> using uhd::usrp::constrained_device_args_t; namespace { - enum test_enum_t { VALUE1, VALUE2, VALUE3=4 }; +enum test_enum_t { VALUE1, VALUE2, VALUE3 = 4 }; - static constexpr double MAX_DOUBLE_ARG = 1e6; - static constexpr double MIN_DOUBLE_ARG = 0.125; +static constexpr double MAX_DOUBLE_ARG = 1e6; +static constexpr double MIN_DOUBLE_ARG = 0.125; - static constexpr double DEFAULT_DOUBLE_ARG = 2.25; - static constexpr size_t DEFAULT_SIZE_T_ARG = 42; - static constexpr bool DEFAULT_BOOL_ARG = true; - static constexpr test_enum_t DEFAULT_ENUM_ARG = VALUE1; +static constexpr double DEFAULT_DOUBLE_ARG = 2.25; +static constexpr size_t DEFAULT_SIZE_T_ARG = 42; +static constexpr bool DEFAULT_BOOL_ARG = true; +static constexpr test_enum_t DEFAULT_ENUM_ARG = VALUE1; - class test_device_args_t : public constrained_device_args_t +class test_device_args_t : public constrained_device_args_t +{ +public: + test_device_args_t() {} + test_device_args_t(const std::string& dev_args) { - public: - test_device_args_t() {} - test_device_args_t(const std::string& dev_args) { parse(dev_args); } + parse(dev_args); + } - double get_double_arg() const { - return _double_arg.get(); - } - size_t get_size_t_arg() const { - return _size_t_arg.get(); - } - bool get_bool_arg() const { - return _bool_arg.get(); - } - test_enum_t get_enum_arg() const { - return _enum_arg.get(); - } + double get_double_arg() const + { + return _double_arg.get(); + } + size_t get_size_t_arg() const + { + return _size_t_arg.get(); + } + bool get_bool_arg() const + { + return _bool_arg.get(); + } + test_enum_t get_enum_arg() const + { + return _enum_arg.get(); + } - inline virtual std::string to_string() const { - return _double_arg.to_string() + ", " + - _size_t_arg.to_string() + ", " + - _bool_arg.to_string() + ", " + - _enum_arg.to_string(); - } - private: - virtual void _parse(const uhd::device_addr_t& dev_args) { - if (dev_args.has_key(_double_arg.key())) - _double_arg.parse(dev_args[_double_arg.key()]); - if (dev_args.has_key(_size_t_arg.key())) - _size_t_arg.parse(dev_args[_size_t_arg.key()]); - if (dev_args.has_key(_bool_arg.key())) - _bool_arg.parse(dev_args[_bool_arg.key()]); - if (dev_args.has_key(_enum_arg.key())) - _enum_arg.parse(dev_args[_enum_arg.key()]); - _enforce_range(_double_arg, MIN_DOUBLE_ARG, MAX_DOUBLE_ARG); - } + inline virtual std::string to_string() const + { + return _double_arg.to_string() + ", " + _size_t_arg.to_string() + ", " + + _bool_arg.to_string() + ", " + _enum_arg.to_string(); + } - constrained_device_args_t::num_arg<double> _double_arg - {"double_arg", DEFAULT_DOUBLE_ARG}; - constrained_device_args_t::num_arg<size_t> _size_t_arg - {"size_t_arg", DEFAULT_SIZE_T_ARG}; - constrained_device_args_t::bool_arg _bool_arg - {"bool_arg", DEFAULT_BOOL_ARG}; - constrained_device_args_t::enum_arg<test_enum_t> _enum_arg - {"enum_arg", DEFAULT_ENUM_ARG, - {{"value1", VALUE1}, {"value2", VALUE2}, {"VALUE3", VALUE3}}}; - }; +private: + virtual void _parse(const uhd::device_addr_t& dev_args) + { + if (dev_args.has_key(_double_arg.key())) + _double_arg.parse(dev_args[_double_arg.key()]); + if (dev_args.has_key(_size_t_arg.key())) + _size_t_arg.parse(dev_args[_size_t_arg.key()]); + if (dev_args.has_key(_bool_arg.key())) + _bool_arg.parse(dev_args[_bool_arg.key()]); + if (dev_args.has_key(_enum_arg.key())) + _enum_arg.parse(dev_args[_enum_arg.key()]); + _enforce_range(_double_arg, MIN_DOUBLE_ARG, MAX_DOUBLE_ARG); + } -} + constrained_device_args_t::num_arg<double> _double_arg{ + "double_arg", DEFAULT_DOUBLE_ARG}; + constrained_device_args_t::num_arg<size_t> _size_t_arg{ + "size_t_arg", DEFAULT_SIZE_T_ARG}; + constrained_device_args_t::bool_arg _bool_arg{"bool_arg", DEFAULT_BOOL_ARG}; + constrained_device_args_t::enum_arg<test_enum_t> _enum_arg{"enum_arg", + DEFAULT_ENUM_ARG, + {{"value1", VALUE1}, {"value2", VALUE2}, {"VALUE3", VALUE3}}}; +}; -BOOST_AUTO_TEST_CASE(test_constrained_device_args) { +} // namespace + +BOOST_AUTO_TEST_CASE(test_constrained_device_args) +{ test_device_args_t test_dev_args("double_arg=3.5,bool_arg=0,foo=bar"); BOOST_CHECK_EQUAL(test_dev_args.get_double_arg(), 3.5); - BOOST_CHECK_EQUAL( - test_dev_args.get_size_t_arg(), - DEFAULT_SIZE_T_ARG - ); + BOOST_CHECK_EQUAL(test_dev_args.get_size_t_arg(), DEFAULT_SIZE_T_ARG); BOOST_CHECK_EQUAL(test_dev_args.get_bool_arg(), false); - BOOST_CHECK_EQUAL( - test_dev_args.get_enum_arg(), - DEFAULT_ENUM_ARG - ); - BOOST_REQUIRE_THROW( - test_dev_args.parse("double_arg=2e6"), - uhd::value_error - ); // Note: test_dev_args is now in a bad state until we fix it! - test_dev_args.parse("double_arg=2.6"), - test_dev_args.parse("enum_arg=vaLue2"); - BOOST_CHECK_EQUAL( - test_dev_args.get_enum_arg(), - VALUE2 - ); + BOOST_CHECK_EQUAL(test_dev_args.get_enum_arg(), DEFAULT_ENUM_ARG); + BOOST_REQUIRE_THROW(test_dev_args.parse("double_arg=2e6"), + uhd::value_error); // Note: test_dev_args is now in a bad state until we fix it! + test_dev_args.parse("double_arg=2.6"), test_dev_args.parse("enum_arg=vaLue2"); + BOOST_CHECK_EQUAL(test_dev_args.get_enum_arg(), VALUE2); test_dev_args.parse("enum_arg=VALUE3"); - BOOST_CHECK_EQUAL( - test_dev_args.get_enum_arg(), - VALUE3 - ); + BOOST_CHECK_EQUAL(test_dev_args.get_enum_arg(), VALUE3); } - diff --git a/host/tests/convert_test.cpp b/host/tests/convert_test.cpp index 862e02073..67409e310 100644 --- a/host/tests/convert_test.cpp +++ b/host/tests/convert_test.cpp @@ -6,52 +6,54 @@ // #include <uhd/convert.hpp> -#include <boost/test/unit_test.hpp> #include <stdint.h> +#include <boost/test/unit_test.hpp> #include <complex> -#include <vector> #include <cstdlib> #include <iostream> +#include <vector> using namespace uhd; -//typedefs for complex types +// typedefs for complex types typedef std::complex<int16_t> sc16_t; typedef std::complex<float> fc32_t; typedef std::complex<double> fc64_t; -#define MY_CHECK_CLOSE(a, b, f) { \ - BOOST_CHECK_MESSAGE(std::abs((a)-(b)) < f, "\n\t" << #a << " (" << (a) << ") error " << #b << " (" << (b) << ")"); \ -} +#define MY_CHECK_CLOSE(a, b, f) \ + { \ + BOOST_CHECK_MESSAGE(std::abs((a) - (b)) < f, \ + "\n\t" << #a << " (" << (a) << ") error " << #b << " (" << (b) << ")"); \ + } /*********************************************************************** * Loopback runner: * convert input buffer into intermediate buffer * convert intermediate buffer into output buffer **********************************************************************/ -template <typename Range> static void loopback( - size_t nsamps, - convert::id_type &in_id, - convert::id_type &out_id, - const Range &input, - Range &output, - const int prio_in = -1, - const int prio_out = -1 -){ - //make this buffer large enough for all test types +template <typename Range> +static void loopback(size_t nsamps, + convert::id_type& in_id, + convert::id_type& out_id, + const Range& input, + Range& output, + const int prio_in = -1, + const int prio_out = -1) +{ + // make this buffer large enough for all test types std::vector<uint64_t> interm(nsamps); - std::vector<const void *> input0(1, &input[0]), input1(1, &interm[0]); - std::vector<void *> output0(1, &interm[0]), output1(1, &output[0]); + std::vector<const void*> input0(1, &input[0]), input1(1, &interm[0]); + std::vector<void*> output0(1, &interm[0]), output1(1, &output[0]); - //convert to intermediate type + // convert to intermediate type convert::converter::sptr c0 = convert::get_converter(in_id, prio_in)(); c0->set_scalar(32767.); c0->conv(input0, output0, nsamps); - //convert back to host type + // convert back to host type convert::converter::sptr c1 = convert::get_converter(out_id, prio_out)(); - c1->set_scalar(1/32767.); + c1->set_scalar(1 / 32767.); c1->conv(input1, output1, nsamps); } @@ -59,46 +61,51 @@ template <typename Range> static void loopback( * Test short conversion **********************************************************************/ static void test_convert_types_sc16( - size_t nsamps, convert::id_type &id, const int extra_div = 1, int mask = 0xffff -){ - //fill the input samples + size_t nsamps, convert::id_type& id, const int extra_div = 1, int mask = 0xffff) +{ + // fill the input samples std::vector<sc16_t> input(nsamps), output(nsamps); - for(sc16_t &in: input) in = sc16_t( - short((float((std::rand())/(double(RAND_MAX)/2)) - 1)*32767/extra_div) & mask, - short((float((std::rand())/(double(RAND_MAX)/2)) - 1)*32767/extra_div) & mask - ); - - //run the loopback and test - convert::id_type in_id = id; + for (sc16_t& in : input) + in = sc16_t( + short((float((std::rand()) / (double(RAND_MAX) / 2)) - 1) * 32767 / extra_div) + & mask, + short((float((std::rand()) / (double(RAND_MAX) / 2)) - 1) * 32767 / extra_div) + & mask); + + // run the loopback and test + convert::id_type in_id = id; convert::id_type out_id = id; std::swap(out_id.input_format, out_id.output_format); std::swap(out_id.num_inputs, out_id.num_outputs); loopback(nsamps, in_id, out_id, input, output); - BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end()); + BOOST_CHECK_EQUAL_COLLECTIONS( + input.begin(), input.end(), output.begin(), output.end()); } -BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){ +BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16) +{ convert::id_type id; - id.input_format = "sc16"; - id.num_inputs = 1; + id.input_format = "sc16"; + id.num_inputs = 1; id.output_format = "sc16_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_sc16(nsamps, id); } } -BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16){ +BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16) +{ convert::id_type id; - id.input_format = "sc16"; - id.num_inputs = 1; + id.input_format = "sc16"; + id.num_inputs = 1; id.output_format = "sc16_item32_le"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_sc16(nsamps, id); } } @@ -108,90 +115,90 @@ BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16){ **********************************************************************/ template <typename data_type> static void test_convert_types_for_floats( - size_t nsamps, convert::id_type &id, const double extra_scale = 1.0 -){ + size_t nsamps, convert::id_type& id, const double extra_scale = 1.0) +{ typedef typename data_type::value_type value_type; - //fill the input samples + // fill the input samples std::vector<data_type> input(nsamps), output(nsamps); - for(data_type &in: input) in = data_type( - ((std::rand()/(value_type(RAND_MAX)/2)) - 1)*float(extra_scale), - ((std::rand()/(value_type(RAND_MAX)/2)) - 1)*float(extra_scale) - ); + for (data_type& in : input) + in = data_type( + ((std::rand() / (value_type(RAND_MAX) / 2)) - 1) * float(extra_scale), + ((std::rand() / (value_type(RAND_MAX) / 2)) - 1) * float(extra_scale)); - //run the loopback and test - convert::id_type in_id = id; + // run the loopback and test + convert::id_type in_id = id; convert::id_type out_id = id; std::swap(out_id.input_format, out_id.output_format); std::swap(out_id.num_inputs, out_id.num_outputs); - //make a list of all prio: best/generic combos + // make a list of all prio: best/generic combos typedef std::pair<int, int> int_pair_t; const std::vector<int_pair_t> prios{ - int_pair_t(0, 0), - int_pair_t(-1, 0), - int_pair_t(0, -1), - int_pair_t(-1, -1) - }; - - //loopback foreach prio combo (generic vs best) - for (const auto &prio : prios) { + int_pair_t(0, 0), int_pair_t(-1, 0), int_pair_t(0, -1), int_pair_t(-1, -1)}; + + // loopback foreach prio combo (generic vs best) + for (const auto& prio : prios) { loopback(nsamps, in_id, out_id, input, output, prio.first, prio.second); - for (size_t i = 0; i < nsamps; i++){ - MY_CHECK_CLOSE(input[i].real(), output[i].real(), value_type(1./(1 << 14))); - MY_CHECK_CLOSE(input[i].imag(), output[i].imag(), value_type(1./(1 << 14))); + for (size_t i = 0; i < nsamps; i++) { + MY_CHECK_CLOSE(input[i].real(), output[i].real(), value_type(1. / (1 << 14))); + MY_CHECK_CLOSE(input[i].imag(), output[i].imag(), value_type(1. / (1 << 14))); } } } -BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32) +{ convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "sc16_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_for_floats<fc32_t>(nsamps, id); } } -BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32) +{ convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "sc16_item32_le"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_for_floats<fc32_t>(nsamps, id); } } -BOOST_AUTO_TEST_CASE(test_convert_types_be_fc64){ +BOOST_AUTO_TEST_CASE(test_convert_types_be_fc64) +{ convert::id_type id; - id.input_format = "fc64"; - id.num_inputs = 1; + id.input_format = "fc64"; + id.num_inputs = 1; id.output_format = "sc16_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_for_floats<fc64_t>(nsamps, id); } } -BOOST_AUTO_TEST_CASE(test_convert_types_le_fc64){ +BOOST_AUTO_TEST_CASE(test_convert_types_le_fc64) +{ convert::id_type id; - id.input_format = "fc64"; - id.num_inputs = 1; + id.input_format = "fc64"; + id.num_inputs = 1; id.output_format = "sc16_item32_le"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_for_floats<fc64_t>(nsamps, id); } } @@ -200,53 +207,57 @@ BOOST_AUTO_TEST_CASE(test_convert_types_le_fc64){ * Test float to/from sc12 conversion loopback **********************************************************************/ -BOOST_AUTO_TEST_CASE(test_convert_types_le_sc12_with_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_le_sc12_with_fc32) +{ convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "sc12_item32_le"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ - test_convert_types_for_floats<fc32_t>(nsamps, id, 1./16); + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { + test_convert_types_for_floats<fc32_t>(nsamps, id, 1. / 16); } } -BOOST_AUTO_TEST_CASE(test_convert_types_be_sc12_with_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_be_sc12_with_fc32) +{ convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "sc12_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ - test_convert_types_for_floats<fc32_t>(nsamps, id, 1./16); + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { + test_convert_types_for_floats<fc32_t>(nsamps, id, 1. / 16); } } -BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16_and_sc12){ +BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16_and_sc12) +{ convert::id_type id; id.input_format = "sc16"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "sc12_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_sc16(nsamps, id, 1, 0xfff0); } } -BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16_and_sc12){ +BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16_and_sc12) +{ convert::id_type id; id.input_format = "sc16"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; id.output_format = "sc12_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_sc16(nsamps, id, 1, 0xfff0); } } @@ -255,28 +266,30 @@ BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16_and_sc12){ * Test float to/from fc32 conversion loopback **********************************************************************/ -BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32_with_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32_with_fc32) +{ convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "fc32_item32_le"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_for_floats<fc32_t>(nsamps, id); } } -BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32_with_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32_with_fc32) +{ convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "fc32_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + // try various lengths to test edge cases + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_for_floats<fc32_t>(nsamps, id); } } @@ -284,149 +297,151 @@ BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32_with_fc32){ /*********************************************************************** * Test float to short conversion loopback **********************************************************************/ -BOOST_AUTO_TEST_CASE(test_convert_types_fc32_to_sc16){ +BOOST_AUTO_TEST_CASE(test_convert_types_fc32_to_sc16) +{ convert::id_type in_id; - in_id.input_format = "fc32"; - in_id.num_inputs = 1; + in_id.input_format = "fc32"; + in_id.num_inputs = 1; in_id.output_format = "sc16_item32_le"; - in_id.num_outputs = 1; + in_id.num_outputs = 1; convert::id_type out_id; - out_id.input_format = "sc16_item32_le"; - out_id.num_inputs = 1; + out_id.input_format = "sc16_item32_le"; + out_id.num_inputs = 1; out_id.output_format = "sc16"; - out_id.num_outputs = 1; + out_id.num_outputs = 1; const size_t nsamps = 13; std::vector<fc32_t> input(nsamps); - for(fc32_t &in: input) in = fc32_t( - (std::rand()/(RAND_MAX/2.0)) - 1, - (std::rand()/(RAND_MAX/2.0)) - 1 - ); + for (fc32_t& in : input) + in = fc32_t( + (std::rand() / (RAND_MAX / 2.0)) - 1, (std::rand() / (RAND_MAX / 2.0)) - 1); std::vector<uint32_t> interm(nsamps); std::vector<sc16_t> output(nsamps); - std::vector<const void *> input0(1, &input[0]), input1(1, &interm[0]); - std::vector<void *> output0(1, &interm[0]), output1(1, &output[0]); + std::vector<const void*> input0(1, &input[0]), input1(1, &interm[0]); + std::vector<void*> output0(1, &interm[0]), output1(1, &output[0]); - //convert float to intermediate + // convert float to intermediate convert::converter::sptr c0 = convert::get_converter(in_id)(); c0->set_scalar(32767.); c0->conv(input0, output0, nsamps); - //convert intermediate to short + // convert intermediate to short convert::converter::sptr c1 = convert::get_converter(out_id)(); - c1->set_scalar(1/32767.); + c1->set_scalar(1 / 32767.); c1->conv(input1, output1, nsamps); - //test that the inputs and outputs match - for (size_t i = 0; i < nsamps; i++){ - MY_CHECK_CLOSE(input[i].real(), output[i].real()/float(32767), float(0.01)); - MY_CHECK_CLOSE(input[i].imag(), output[i].imag()/float(32767), float(0.01)); + // test that the inputs and outputs match + for (size_t i = 0; i < nsamps; i++) { + MY_CHECK_CLOSE(input[i].real(), output[i].real() / float(32767), float(0.01)); + MY_CHECK_CLOSE(input[i].imag(), output[i].imag() / float(32767), float(0.01)); } } /*********************************************************************** * Test short to float conversion loopback **********************************************************************/ -BOOST_AUTO_TEST_CASE(test_convert_types_sc16_to_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_sc16_to_fc32) +{ convert::id_type in_id; - in_id.input_format = "sc16"; - in_id.num_inputs = 1; + in_id.input_format = "sc16"; + in_id.num_inputs = 1; in_id.output_format = "sc16_item32_le"; - in_id.num_outputs = 1; + in_id.num_outputs = 1; convert::id_type out_id; - out_id.input_format = "sc16_item32_le"; - out_id.num_inputs = 1; + out_id.input_format = "sc16_item32_le"; + out_id.num_inputs = 1; out_id.output_format = "fc32"; - out_id.num_outputs = 1; + out_id.num_outputs = 1; const size_t nsamps = 13; std::vector<sc16_t> input(nsamps); - for(sc16_t &in: input) in = sc16_t( - std::rand()-(RAND_MAX/2), - std::rand()-(RAND_MAX/2) - ); + for (sc16_t& in : input) + in = sc16_t(std::rand() - (RAND_MAX / 2), std::rand() - (RAND_MAX / 2)); std::vector<uint32_t> interm(nsamps); std::vector<fc32_t> output(nsamps); - std::vector<const void *> input0(1, &input[0]), input1(1, &interm[0]); - std::vector<void *> output0(1, &interm[0]), output1(1, &output[0]); + std::vector<const void*> input0(1, &input[0]), input1(1, &interm[0]); + std::vector<void*> output0(1, &interm[0]), output1(1, &output[0]); - //convert short to intermediate + // convert short to intermediate convert::converter::sptr c0 = convert::get_converter(in_id)(); c0->set_scalar(32767.); c0->conv(input0, output0, nsamps); - //convert intermediate to float + // convert intermediate to float convert::converter::sptr c1 = convert::get_converter(out_id)(); - c1->set_scalar(1/32767.); + c1->set_scalar(1 / 32767.); c1->conv(input1, output1, nsamps); - //test that the inputs and outputs match - for (size_t i = 0; i < nsamps; i++){ - MY_CHECK_CLOSE(input[i].real()/float(32767), output[i].real(), float(0.01)); - MY_CHECK_CLOSE(input[i].imag()/float(32767), output[i].imag(), float(0.01)); + // test that the inputs and outputs match + for (size_t i = 0; i < nsamps; i++) { + MY_CHECK_CLOSE(input[i].real() / float(32767), output[i].real(), float(0.01)); + MY_CHECK_CLOSE(input[i].imag() / float(32767), output[i].imag(), float(0.01)); } } /*********************************************************************** * Test sc8 conversions **********************************************************************/ -BOOST_AUTO_TEST_CASE(test_convert_types_fc64_and_sc8){ +BOOST_AUTO_TEST_CASE(test_convert_types_fc64_and_sc8) +{ convert::id_type id; id.input_format = "fc64"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "sc8_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ - test_convert_types_for_floats<fc64_t>(nsamps, id, 1./256); + for (size_t nsamps = 1; nsamps < 16; nsamps++) { + test_convert_types_for_floats<fc64_t>(nsamps, id, 1. / 256); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "sc8_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ - test_convert_types_for_floats<fc64_t>(nsamps, id, 1./256); + for (size_t nsamps = 1; nsamps < 16; nsamps++) { + test_convert_types_for_floats<fc64_t>(nsamps, id, 1. / 256); } } -BOOST_AUTO_TEST_CASE(test_convert_types_fc32_and_sc8){ +BOOST_AUTO_TEST_CASE(test_convert_types_fc32_and_sc8) +{ convert::id_type id; id.input_format = "fc32"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "sc8_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ - test_convert_types_for_floats<fc32_t>(nsamps, id, 1./256); + for (size_t nsamps = 1; nsamps < 16; nsamps++) { + test_convert_types_for_floats<fc32_t>(nsamps, id, 1. / 256); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "sc8_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ - test_convert_types_for_floats<fc32_t>(nsamps, id, 1./256); + for (size_t nsamps = 1; nsamps < 16; nsamps++) { + test_convert_types_for_floats<fc32_t>(nsamps, id, 1. / 256); } } -BOOST_AUTO_TEST_CASE(test_convert_types_sc16_and_sc8){ +BOOST_AUTO_TEST_CASE(test_convert_types_sc16_and_sc8) +{ convert::id_type id; id.input_format = "sc16"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "sc8_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_sc16(nsamps, id, 256); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "sc8_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_sc16(nsamps, id, 256); } } @@ -434,39 +449,41 @@ BOOST_AUTO_TEST_CASE(test_convert_types_sc16_and_sc8){ /*********************************************************************** * Test u8 conversion **********************************************************************/ -static void test_convert_types_u8( - size_t nsamps, convert::id_type &id -){ - //fill the input samples +static void test_convert_types_u8(size_t nsamps, convert::id_type& id) +{ + // fill the input samples std::vector<uint8_t> input(nsamps), output(nsamps); - for(uint8_t &in: input) in = uint8_t(std::rand() & 0xFF); - //uint32_t d = 48; - //for(uint8_t &in: input) in = d++; + for (uint8_t& in : input) + in = uint8_t(std::rand() & 0xFF); + // uint32_t d = 48; + // for(uint8_t &in: input) in = d++; - //run the loopback and test - convert::id_type in_id = id; + // run the loopback and test + convert::id_type in_id = id; convert::id_type out_id = id; std::swap(out_id.input_format, out_id.output_format); std::swap(out_id.num_inputs, out_id.num_outputs); loopback(nsamps, in_id, out_id, input, output); - BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end()); + BOOST_CHECK_EQUAL_COLLECTIONS( + input.begin(), input.end(), output.begin(), output.end()); } -BOOST_AUTO_TEST_CASE(test_convert_types_u8_and_u8){ +BOOST_AUTO_TEST_CASE(test_convert_types_u8_and_u8) +{ convert::id_type id; id.input_format = "u8"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "u8_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_u8(nsamps, id); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "u8_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_u8(nsamps, id); } } @@ -474,37 +491,39 @@ BOOST_AUTO_TEST_CASE(test_convert_types_u8_and_u8){ /*********************************************************************** * Test s8 conversion **********************************************************************/ -static void test_convert_types_s8( - size_t nsamps, convert::id_type &id -){ - //fill the input samples +static void test_convert_types_s8(size_t nsamps, convert::id_type& id) +{ + // fill the input samples std::vector<int8_t> input(nsamps), output(nsamps); - for(int8_t &in: input) in = int8_t(std::rand() & 0xFF); + for (int8_t& in : input) + in = int8_t(std::rand() & 0xFF); - //run the loopback and test - convert::id_type in_id = id; + // run the loopback and test + convert::id_type in_id = id; convert::id_type out_id = id; std::swap(out_id.input_format, out_id.output_format); std::swap(out_id.num_inputs, out_id.num_outputs); loopback(nsamps, in_id, out_id, input, output); - BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end()); + BOOST_CHECK_EQUAL_COLLECTIONS( + input.begin(), input.end(), output.begin(), output.end()); } -BOOST_AUTO_TEST_CASE(test_convert_types_s8_and_s8){ +BOOST_AUTO_TEST_CASE(test_convert_types_s8_and_s8) +{ convert::id_type id; id.input_format = "s8"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "s8_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_s8(nsamps, id); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "s8_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_s8(nsamps, id); } } @@ -512,37 +531,39 @@ BOOST_AUTO_TEST_CASE(test_convert_types_s8_and_s8){ /*********************************************************************** * Test s16 conversion **********************************************************************/ -static void test_convert_types_s16( - size_t nsamps, convert::id_type &id -){ - //fill the input samples +static void test_convert_types_s16(size_t nsamps, convert::id_type& id) +{ + // fill the input samples std::vector<int16_t> input(nsamps), output(nsamps); - for(int16_t &in: input) in = int16_t(std::rand() & 0xFFFF); + for (int16_t& in : input) + in = int16_t(std::rand() & 0xFFFF); - //run the loopback and test - convert::id_type in_id = id; + // run the loopback and test + convert::id_type in_id = id; convert::id_type out_id = id; std::swap(out_id.input_format, out_id.output_format); std::swap(out_id.num_inputs, out_id.num_outputs); loopback(nsamps, in_id, out_id, input, output); - BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end()); + BOOST_CHECK_EQUAL_COLLECTIONS( + input.begin(), input.end(), output.begin(), output.end()); } -BOOST_AUTO_TEST_CASE(test_convert_types_s16_and_s16){ +BOOST_AUTO_TEST_CASE(test_convert_types_s16_and_s16) +{ convert::id_type id; id.input_format = "s16"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "s16_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_s16(nsamps, id); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "s16_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_s16(nsamps, id); } } @@ -550,43 +571,42 @@ BOOST_AUTO_TEST_CASE(test_convert_types_s16_and_s16){ /*********************************************************************** * Test fc32 -> fc32 conversion **********************************************************************/ -static void test_convert_types_fc32( - size_t nsamps, convert::id_type &id -){ - //fill the input samples - std::vector< std::complex<float> > input(nsamps), output(nsamps); - for(fc32_t &in: input) in = fc32_t( - (std::rand()/float(RAND_MAX/2)) - 1, - (std::rand()/float(RAND_MAX/2)) - 1 - ); - - //run the loopback and test - convert::id_type in_id = id; +static void test_convert_types_fc32(size_t nsamps, convert::id_type& id) +{ + // fill the input samples + std::vector<std::complex<float>> input(nsamps), output(nsamps); + for (fc32_t& in : input) + in = fc32_t((std::rand() / float(RAND_MAX / 2)) - 1, + (std::rand() / float(RAND_MAX / 2)) - 1); + + // run the loopback and test + convert::id_type in_id = id; convert::id_type out_id = id; std::swap(out_id.input_format, out_id.output_format); std::swap(out_id.num_inputs, out_id.num_outputs); loopback(nsamps, in_id, out_id, input, output); - for (size_t i = 0; i < nsamps; i++){ - MY_CHECK_CLOSE(input[i].real(), output[i].real(), float(1./(1 << 16))); - MY_CHECK_CLOSE(input[i].imag(), output[i].imag(), float(1./(1 << 16))); + for (size_t i = 0; i < nsamps; i++) { + MY_CHECK_CLOSE(input[i].real(), output[i].real(), float(1. / (1 << 16))); + MY_CHECK_CLOSE(input[i].imag(), output[i].imag(), float(1. / (1 << 16))); } } -BOOST_AUTO_TEST_CASE(test_convert_types_fc32_and_fc32){ +BOOST_AUTO_TEST_CASE(test_convert_types_fc32_and_fc32) +{ convert::id_type id; id.input_format = "fc32"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "fc32_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_fc32(nsamps, id); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "fc32_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_fc32(nsamps, id); } } @@ -594,39 +614,40 @@ BOOST_AUTO_TEST_CASE(test_convert_types_fc32_and_fc32){ /*********************************************************************** * Test f32 -> f32 conversion **********************************************************************/ -static void test_convert_types_f32( - size_t nsamps, convert::id_type &id -){ - //fill the input samples +static void test_convert_types_f32(size_t nsamps, convert::id_type& id) +{ + // fill the input samples std::vector<float> input(nsamps), output(nsamps); - for(float &in: input) in = float((float(std::rand())/float(RAND_MAX/2)) - 1); + for (float& in : input) + in = float((float(std::rand()) / float(RAND_MAX / 2)) - 1); - //run the loopback and test - convert::id_type in_id = id; + // run the loopback and test + convert::id_type in_id = id; convert::id_type out_id = id; std::swap(out_id.input_format, out_id.output_format); std::swap(out_id.num_inputs, out_id.num_outputs); loopback(nsamps, in_id, out_id, input, output); - for (size_t i = 0; i < nsamps; i++){ - MY_CHECK_CLOSE(input[i], output[i], float(1./(1 << 16))); + for (size_t i = 0; i < nsamps; i++) { + MY_CHECK_CLOSE(input[i], output[i], float(1. / (1 << 16))); } } -BOOST_AUTO_TEST_CASE(test_convert_types_f32_and_f32){ +BOOST_AUTO_TEST_CASE(test_convert_types_f32_and_f32) +{ convert::id_type id; id.input_format = "f32"; - id.num_inputs = 1; - id.num_outputs = 1; + id.num_inputs = 1; + id.num_outputs = 1; - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "f32_item32_le"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_f32(nsamps, id); } - //try various lengths to test edge cases + // try various lengths to test edge cases id.output_format = "f32_item32_be"; - for (size_t nsamps = 1; nsamps < 16; nsamps++){ + for (size_t nsamps = 1; nsamps < 16; nsamps++) { test_convert_types_f32(nsamps, id); } } diff --git a/host/tests/device3_test.cpp b/host/tests/device3_test.cpp index 71b3225e1..43f5fe45b 100644 --- a/host/tests/device3_test.cpp +++ b/host/tests/device3_test.cpp @@ -6,8 +6,8 @@ // -#include "mock_zero_copy.hpp" #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> @@ -20,17 +20,17 @@ #include <iostream> - using namespace uhd; using namespace uhd::rfnoc; using namespace uhd::transport::vrt; -using uhd::transport::managed_send_buffer; 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 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(); @@ -42,60 +42,59 @@ uhd::both_xports_t make_mock_transport(const uhd::sid_t& tx_sid) { } // Mock-device -class mock_device3_impl : public uhd::device3, public boost::enable_shared_from_this<mock_device3_impl> +class mock_device3_impl : public uhd::device3, + public boost::enable_shared_from_this<mock_device3_impl> { - public: +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())} - }; + {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.ctrl_ifaces = ctrl_ifaces; make_args.base_address = TEST_SID0.get_dst(); make_args.device_index = 0; - make_args.tree = _tree; + 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) ); + _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) ); + _rfnoc_block_ctrl.push_back(block_ctrl::make(make_args)); } - rx_streamer::sptr get_rx_stream(const stream_args_t &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) { + 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)); + 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) + 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, + 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 - ); + async_xports.endianness); + auto graph = boost::make_shared<uhd::rfnoc::graph_impl>( + name, shared_from_this(), async_msg_handler); return graph; } }; @@ -105,18 +104,21 @@ device3::sptr make_mock_device() return device3::sptr(new mock_device3_impl()); } -class mock_block_ctrl : public block_ctrl { +class mock_block_ctrl : public block_ctrl +{ int foo; }; -BOOST_AUTO_TEST_CASE(test_device3) { +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]); + 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"); @@ -130,7 +132,8 @@ BOOST_AUTO_TEST_CASE(test_device3) { } -BOOST_AUTO_TEST_CASE(test_device3_graph) { +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; @@ -153,28 +156,33 @@ BOOST_AUTO_TEST_CASE(test_device3_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_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) { +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")); + 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")); + 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) { +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"))); @@ -184,13 +192,10 @@ BOOST_AUTO_TEST_CASE(test_device3_fail) { 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 - ); + 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 - ); + uhd::lookup_error); } // vim: sw=4 et: diff --git a/host/tests/dict_test.cpp b/host/tests/dict_test.cpp index 53432d533..99fc2366c 100644 --- a/host/tests/dict_test.cpp +++ b/host/tests/dict_test.cpp @@ -5,15 +5,16 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/types/dict.hpp> #include <boost/assign/list_of.hpp> +#include <boost/test/unit_test.hpp> -BOOST_AUTO_TEST_CASE(test_dict_init){ +BOOST_AUTO_TEST_CASE(test_dict_init) +{ uhd::dict<int, int> d; d[-1] = 3; - d[0] = 4; - d[1] = 5; + d[0] = 4; + d[1] = 5; BOOST_CHECK(d.has_key(0)); BOOST_CHECK(not d.has_key(2)); BOOST_CHECK(d.keys()[1] == 0); @@ -21,12 +22,9 @@ BOOST_AUTO_TEST_CASE(test_dict_init){ BOOST_CHECK_EQUAL(d[-1], 3); } -BOOST_AUTO_TEST_CASE(test_dict_assign){ - uhd::dict<int, int> d = boost::assign::map_list_of - (-1, 3) - (0, 4) - (1, 5) - ; +BOOST_AUTO_TEST_CASE(test_dict_assign) +{ + uhd::dict<int, int> d = boost::assign::map_list_of(-1, 3)(0, 4)(1, 5); BOOST_CHECK(d.has_key(0)); BOOST_CHECK(not d.has_key(2)); BOOST_CHECK(d.keys()[1] == 0); @@ -34,12 +32,9 @@ BOOST_AUTO_TEST_CASE(test_dict_assign){ BOOST_CHECK_EQUAL(d[-1], 3); } -BOOST_AUTO_TEST_CASE(test_const_dict){ - const uhd::dict<int, int> d = boost::assign::map_list_of - (-1, 3) - (0, 4) - (1, 5) - ; +BOOST_AUTO_TEST_CASE(test_const_dict) +{ + const uhd::dict<int, int> d = boost::assign::map_list_of(-1, 3)(0, 4)(1, 5); BOOST_CHECK(d.has_key(0)); BOOST_CHECK(not d.has_key(2)); BOOST_CHECK(d.keys()[1] == 0); @@ -48,12 +43,9 @@ BOOST_AUTO_TEST_CASE(test_const_dict){ BOOST_CHECK_THROW(d[2], std::exception); } -BOOST_AUTO_TEST_CASE(test_dict_pop){ - uhd::dict<int, int> d = boost::assign::map_list_of - (-1, 3) - (0, 4) - (1, 5) - ; +BOOST_AUTO_TEST_CASE(test_dict_pop) +{ + uhd::dict<int, int> d = boost::assign::map_list_of(-1, 3)(0, 4)(1, 5); BOOST_CHECK(d.has_key(0)); BOOST_CHECK_EQUAL(d.pop(0), 4); BOOST_CHECK(not d.has_key(0)); @@ -63,24 +55,18 @@ BOOST_AUTO_TEST_CASE(test_dict_pop){ BOOST_AUTO_TEST_CASE(test_dict_update) { - uhd::dict<std::string, std::string> d1 = boost::assign::map_list_of - ("key1", "val1") - ("key2", "val2") - ; - uhd::dict<std::string, std::string> d2 = boost::assign::map_list_of - ("key2", "val2x") - ("key3", "val3") - ; + uhd::dict<std::string, std::string> d1 = + boost::assign::map_list_of("key1", "val1")("key2", "val2"); + uhd::dict<std::string, std::string> d2 = + boost::assign::map_list_of("key2", "val2x")("key3", "val3"); d1.update(d2, false /* don't throw cause of conflict */); BOOST_CHECK_EQUAL(d1["key1"], "val1"); BOOST_CHECK_EQUAL(d1["key2"], "val2x"); BOOST_CHECK_EQUAL(d1["key3"], "val3"); - uhd::dict<std::string, std::string> d3 = boost::assign::map_list_of - ("key1", "val1") - ("key2", "val2") - ; + uhd::dict<std::string, std::string> d3 = + boost::assign::map_list_of("key1", "val1")("key2", "val2"); BOOST_CHECK_THROW(d3.update(d2), uhd::value_error); } @@ -121,6 +107,6 @@ BOOST_AUTO_TEST_CASE(test_dict_equals) BOOST_CHECK(d0 != d4); BOOST_CHECK(d0 != d5); // Redundant, but just to be sure - BOOST_CHECK(not (d0 == d2)); - BOOST_CHECK(not (d0 == d3)); + BOOST_CHECK(not(d0 == d2)); + BOOST_CHECK(not(d0 == d3)); } diff --git a/host/tests/dpdk_test.cpp b/host/tests/dpdk_test.cpp index 8a4e51af7..43ef3d388 100644 --- a/host/tests/dpdk_test.cpp +++ b/host/tests/dpdk_test.cpp @@ -8,18 +8,18 @@ */ -#include <cstdio> -#include <cstdbool> -#include <cstring> -#include <unistd.h> -#include <sys/time.h> -#include <errno.h> +#include "../transport/dpdk_zero_copy.hpp" #include <arpa/inet.h> +#include <errno.h> #include <sched.h> #include <sys/syscall.h> -#include "../transport/dpdk_zero_copy.hpp" +#include <sys/time.h> +#include <unistd.h> #include <boost/program_options.hpp> #include <boost/regex.hpp> +#include <cstdbool> +#include <cstdio> +#include <cstring> #include <iostream> static const boost::regex colons(":"); @@ -27,28 +27,30 @@ static const boost::regex colons(":"); namespace po = boost::program_options; namespace { - constexpr unsigned int NUM_MBUFS = 4095; /* Total number of mbufs in pool */ - constexpr unsigned int MBUF_CACHE_SIZE = 315; /* Size of cpu-local mbuf cache */ - constexpr unsigned int BURST_SIZE = 64; /* Maximum burst size for RX */ - - constexpr unsigned int NUM_PORTS = 2; /* Number of NIC ports */ - constexpr unsigned int TX_CREDITS = 28; /* Number of TX credits */ - constexpr unsigned int RX_CREDITS = 64; /* Number of RX credits */ - constexpr unsigned int BENCH_SPP = 700; /* "Samples" per packet */ -} +constexpr unsigned int NUM_MBUFS = 4095; /* Total number of mbufs in pool */ +constexpr unsigned int MBUF_CACHE_SIZE = 315; /* Size of cpu-local mbuf cache */ +constexpr unsigned int BURST_SIZE = 64; /* Maximum burst size for RX */ + +constexpr unsigned int NUM_PORTS = 2; /* Number of NIC ports */ +constexpr unsigned int TX_CREDITS = 28; /* Number of TX credits */ +constexpr unsigned int RX_CREDITS = 64; /* Number of RX credits */ +constexpr unsigned int BENCH_SPP = 700; /* "Samples" per packet */ +} // namespace -struct dpdk_test_args { +struct dpdk_test_args +{ unsigned int portid; std::string src_port; std::string dst_ip; std::string dst_port; - pthread_cond_t *cond; + pthread_cond_t* cond; pthread_mutex_t mutex; bool started; int cpu; }; -struct dpdk_test_stats { +struct dpdk_test_stats +{ uint32_t last_seqno; uint32_t dropped_packets; uint32_t lasts[16]; @@ -59,7 +61,7 @@ struct dpdk_test_stats { }; -static void process_udp(int id, uint32_t *udp_data, struct dpdk_test_stats *stats) +static void process_udp(int id, uint32_t* udp_data, struct dpdk_test_stats* stats) { if (udp_data[0] != stats[id].last_seqno + 1) { stats[id].lasts[stats[id].dropped_packets & 0xf] = stats[id].last_seqno; @@ -71,22 +73,24 @@ static void process_udp(int id, uint32_t *udp_data, struct dpdk_test_stats *stat stats[id].last_ackno = udp_data[1]; } -static void send_udp(uhd::transport::dpdk_zero_copy::sptr &stream, int id, - bool fc_only, struct dpdk_test_stats *stats) +static void send_udp(uhd::transport::dpdk_zero_copy::sptr& stream, + int id, + bool fc_only, + struct dpdk_test_stats* stats) { uhd::transport::managed_send_buffer::sptr mbuf = stream->get_send_buff(0); if (mbuf.get() == nullptr) { printf("Could not get TX buffer!\n"); return; } - auto *tx_data = mbuf->cast<uint32_t *>(); - tx_data[0] = fc_only ? stats[id].tx_seqno - 1 : stats[id].tx_seqno; - tx_data[1] = stats[id].last_seqno; + auto* tx_data = mbuf->cast<uint32_t*>(); + tx_data[0] = fc_only ? stats[id].tx_seqno - 1 : stats[id].tx_seqno; + tx_data[1] = stats[id].last_seqno; if (!fc_only) { - memset(&tx_data[2], stats[id].last_seqno, 8*BENCH_SPP); - stats[id].tx_xfer += 8*BENCH_SPP; + memset(&tx_data[2], stats[id].last_seqno, 8 * BENCH_SPP); + stats[id].tx_xfer += 8 * BENCH_SPP; } - size_t num_bytes = 8 + (fc_only ? 0 : 8*BENCH_SPP); + size_t num_bytes = 8 + (fc_only ? 0 : 8 * BENCH_SPP); mbuf->commit(num_bytes); mbuf.reset(); @@ -95,18 +99,20 @@ static void send_udp(uhd::transport::dpdk_zero_copy::sptr &stream, int id, } } -static void bench(uhd::transport::dpdk_zero_copy::sptr *stream, uint32_t nb_ports, double timeout) +static void bench( + uhd::transport::dpdk_zero_copy::sptr* stream, uint32_t nb_ports, double timeout) { uint64_t total_xfer[NUM_PORTS]; uint32_t id; - struct dpdk_test_stats *stats = (struct dpdk_test_stats *) malloc(sizeof(*stats)*nb_ports); + struct dpdk_test_stats* stats = + (struct dpdk_test_stats*)malloc(sizeof(*stats) * nb_ports); for (id = 0; id < nb_ports; id++) { - stats[id].tx_seqno = 1; - stats[id].tx_xfer = 0; - stats[id].last_ackno = 0; - stats[id].last_seqno = 0; + stats[id].tx_seqno = 1; + stats[id].tx_xfer = 0; + stats[id].last_ackno = 0; + stats[id].last_seqno = 0; stats[id].dropped_packets = 0; - total_xfer[id] = 0; + total_xfer[id] = 0; } sleep(1); struct timeval bench_start, bench_end; @@ -115,8 +121,8 @@ static void bench(uhd::transport::dpdk_zero_copy::sptr *stream, uint32_t nb_port * The test... */ uint64_t total_received = 0; - uint32_t consec_no_rx = 0; - while ((total_received / nb_ports) < 1000000 ) { //&& consec_no_rx < 10000) { + uint32_t consec_no_rx = 0; + while ((total_received / nb_ports) < 1000000) { //&& consec_no_rx < 10000) { for (id = 0; id < nb_ports; id++) { unsigned int nb_rx = 0; uhd::transport::managed_recv_buffer::sptr bufs[BURST_SIZE]; @@ -132,7 +138,9 @@ static void bench(uhd::transport::dpdk_zero_copy::sptr *stream, uint32_t nb_port consec_no_rx++; if (consec_no_rx >= 100000) { uint32_t skt_drops = stream[id]->get_drop_count(); - //printf("TX seq %d, TX ack %d, RX seq %d, %d drops!\n", stats[id].tx_seqno, stats[id].last_ackno, stats[id].last_seqno, skt_drops); + // printf("TX seq %d, TX ack %d, RX seq %d, %d drops!\n", + // stats[id].tx_seqno, stats[id].last_ackno, stats[id].last_seqno, + // skt_drops); consec_no_rx = 0; break; } @@ -143,7 +151,7 @@ static void bench(uhd::transport::dpdk_zero_copy::sptr *stream, uint32_t nb_port for (unsigned int buf = 0; buf < nb_rx; buf++) { total_xfer[id] += bufs[buf]->size(); - auto data = bufs[buf]->cast<uint32_t *>(); + auto data = bufs[buf]->cast<uint32_t*>(); process_udp(id, data, stats); } @@ -153,15 +161,17 @@ static void bench(uhd::transport::dpdk_zero_copy::sptr *stream, uint32_t nb_port for (id = 0; id < nb_ports; id++) { /* TX portion */ uint32_t window_end = stats[id].last_ackno + TX_CREDITS; - //uint32_t window_end = last_seqno[port] + TX_CREDITS; + // uint32_t window_end = last_seqno[port] + TX_CREDITS; if (window_end <= stats[id].tx_seqno) { if (consec_no_rx == 9999) { send_udp(stream[id], id, true, stats); } - //send_udp(tx[id], id, true); + // send_udp(tx[id], id, true); ; } else { - for (unsigned int pktno = 0; (pktno < BURST_SIZE) && (stats[id].tx_seqno < window_end); pktno++) { + for (unsigned int pktno = 0; + (pktno < BURST_SIZE) && (stats[id].tx_seqno < window_end); + pktno++) { send_udp(stream[id], id, false, stats); } } @@ -174,13 +184,16 @@ static void bench(uhd::transport::dpdk_zero_copy::sptr *stream, uint32_t nb_port printf("\n"); printf("Bytes received = %ld\n", total_xfer[id]); printf("Bytes sent = %ld\n", stats[id].tx_xfer); - printf("Time taken = %ld us\n", (bench_end.tv_sec - bench_start.tv_sec)*1000000 + (bench_end.tv_usec - bench_start.tv_usec)); - double elapsed_time = (bench_end.tv_sec - bench_start.tv_sec)*1000000 + (bench_end.tv_usec - bench_start.tv_usec); + printf("Time taken = %ld us\n", + (bench_end.tv_sec - bench_start.tv_sec) * 1000000 + + (bench_end.tv_usec - bench_start.tv_usec)); + double elapsed_time = (bench_end.tv_sec - bench_start.tv_sec) * 1000000 + + (bench_end.tv_usec - bench_start.tv_usec); elapsed_time *= 1.0e-6; double elapsed_bytes = total_xfer[id]; - printf("RX Performance = %e Gbps\n", elapsed_bytes*8.0/1.0e9/elapsed_time); + printf("RX Performance = %e Gbps\n", elapsed_bytes * 8.0 / 1.0e9 / elapsed_time); elapsed_bytes = stats[id].tx_xfer; - printf("TX Performance = %e Gbps\n", elapsed_bytes*8.0/1.0e9/elapsed_time); + printf("TX Performance = %e Gbps\n", elapsed_bytes * 8.0 / 1.0e9 / elapsed_time); uint32_t skt_drops = stream[id]->get_drop_count(); printf("Dropped %d packets\n", stats[id].dropped_packets); printf("Socket reports dropped %d packets\n", skt_drops); @@ -189,11 +202,10 @@ static void bench(uhd::transport::dpdk_zero_copy::sptr *stream, uint32_t nb_port break; printf("Last(%u), Recv(%u)\n", stats[id].lasts[i], stats[id].drops[i]); } - //printf("%d missed/dropped packets\n", errors); + // printf("%d missed/dropped packets\n", errors); printf("\n"); } free(stats); - } static inline void set_cpu(pthread_t t, int cpu) @@ -209,31 +221,29 @@ static inline void set_cpu(pthread_t t, int cpu) } } -void *prepare_and_bench_blocking(void *arg) +void* prepare_and_bench_blocking(void* arg) { - struct dpdk_test_args *args = (struct dpdk_test_args *) arg; + struct dpdk_test_args* args = (struct dpdk_test_args*)arg; pthread_mutex_lock(&args->mutex); pthread_t t = pthread_self(); set_cpu(t, args->cpu); args->started = true; pthread_cond_wait(args->cond, &args->mutex); - auto &ctx = uhd::transport::uhd_dpdk_ctx::get(); + auto& ctx = uhd::transport::uhd_dpdk_ctx::get(); uhd::transport::dpdk_zero_copy::sptr eth_data[1]; uhd::transport::zero_copy_xport_params buff_args; buff_args.recv_frame_size = 8000; buff_args.send_frame_size = 8000; buff_args.num_send_frames = 8; buff_args.num_recv_frames = 8; - auto dev_addr = uhd::device_addr_t(); - eth_data[0] = uhd::transport::dpdk_zero_copy::make( - ctx, + auto dev_addr = uhd::device_addr_t(); + eth_data[0] = uhd::transport::dpdk_zero_copy::make(ctx, args->portid, args->dst_ip, args->src_port, args->dst_port, buff_args, - dev_addr - ); + dev_addr); bench(eth_data, 1, 0.1); return 0; @@ -241,19 +251,19 @@ void *prepare_and_bench_blocking(void *arg) void prepare_and_bench_polling(void) { - auto &ctx = uhd::transport::uhd_dpdk_ctx::get(); + auto& ctx = uhd::transport::uhd_dpdk_ctx::get(); struct dpdk_test_args bench_args[2]; - bench_args[0].cond = NULL; - bench_args[0].started = true; - bench_args[0].portid = 0; + bench_args[0].cond = NULL; + bench_args[0].started = true; + bench_args[0].portid = 0; bench_args[0].src_port = "0xBEE7"; - bench_args[0].dst_ip = "192.168.0.4"; + bench_args[0].dst_ip = "192.168.0.4"; bench_args[0].dst_port = "0xBEE7"; - bench_args[1].cond = NULL; - bench_args[1].started = true; - bench_args[1].portid = 1; + bench_args[1].cond = NULL; + bench_args[1].started = true; + bench_args[1].portid = 1; bench_args[1].src_port = "0xBEE7"; - bench_args[1].dst_ip = "192.168.0.3"; + bench_args[1].dst_ip = "192.168.0.3"; bench_args[1].dst_port = "0xBEE7"; uhd::transport::dpdk_zero_copy::sptr eth_data[NUM_PORTS]; @@ -262,45 +272,43 @@ void prepare_and_bench_polling(void) buff_args.send_frame_size = 8000; buff_args.num_send_frames = 8; buff_args.num_recv_frames = 8; - auto dev_addr = uhd::device_addr_t(); + auto dev_addr = uhd::device_addr_t(); for (unsigned int i = 0; i < NUM_PORTS; i++) { - eth_data[i] = uhd::transport::dpdk_zero_copy::make( - ctx, + eth_data[i] = uhd::transport::dpdk_zero_copy::make(ctx, bench_args[i].portid, bench_args[i].dst_ip, bench_args[i].src_port, bench_args[i].dst_port, buff_args, - dev_addr - ); + dev_addr); } bench(eth_data, NUM_PORTS, 0.0); } -int main(int argc, char **argv) +int main(int argc, char** argv) { int retval, io0_cpu = 1, io1_cpu = 1, user0_cpu = 0, user1_cpu = 2; std::string args, cpusets; po::options_description desc("Allowed options"); - desc.add_options() - ("help", "help message") - ("args", po::value<std::string>(&args)->default_value(""), "UHD-DPDK args") - ("polling-mode", "Use polling mode (single thread on own core)") - ("cpusets", po::value<std::string>(&cpusets)->default_value(""), "which core(s) to use for a given thread (specify something like \"io0=1,io1=1,user0=0,user1=2\")") - ; + desc.add_options()("help", "help message")( + "args", po::value<std::string>(&args)->default_value(""), "UHD-DPDK args")( + "polling-mode", "Use polling mode (single thread on own core)")("cpusets", + po::value<std::string>(&cpusets)->default_value(""), + "which core(s) to use for a given thread (specify something like " + "\"io0=1,io1=1,user0=0,user1=2\")"); po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); if (vm.count("help")) { - std::cout << desc << std::endl; - return 0; + std::cout << desc << std::endl; + return 0; } auto dpdk_args = uhd::device_addr_t(args); - for (std::string &key : dpdk_args.keys()) { + for (std::string& key : dpdk_args.keys()) { /* device_addr_t splits on commas, so we use colons and replace */ if (key == "corelist" || key == "coremap") { dpdk_args[key] = boost::regex_replace(dpdk_args[key], colons, ","); @@ -308,7 +316,7 @@ int main(int argc, char **argv) } auto cpuset_map = uhd::device_addr_t(cpusets); - for (std::string &key : cpuset_map.keys()) { + for (std::string& key : cpuset_map.keys()) { if (key == "io0") { io0_cpu = std::stoi(cpuset_map[key], NULL, 0); } else if (key == "io1") { @@ -321,12 +329,12 @@ int main(int argc, char **argv) } int port_thread_mapping[2] = {io0_cpu, io1_cpu}; - auto &ctx = uhd::transport::uhd_dpdk_ctx::get(); + auto& ctx = uhd::transport::uhd_dpdk_ctx::get(); ctx.init(dpdk_args, 2, &port_thread_mapping[0], NUM_MBUFS, MBUF_CACHE_SIZE, 9000); - uint32_t eth_ip = htonl(0xc0a80003); + uint32_t eth_ip = htonl(0xc0a80003); uint32_t eth_mask = htonl(0xffffff00); - int status = ctx.set_ipv4_addr(0, eth_ip, eth_mask); + int status = ctx.set_ipv4_addr(0, eth_ip, eth_mask); if (status) { printf("Error while setting IP0: %d\n", status); return status; @@ -346,19 +354,19 @@ int main(int argc, char **argv) struct dpdk_test_args bench_args[2]; pthread_mutex_init(&bench_args[0].mutex, NULL); pthread_mutex_init(&bench_args[1].mutex, NULL); - bench_args[0].cpu = user0_cpu; - bench_args[0].cond = &cond; - bench_args[0].started = false; - bench_args[0].portid = 0; + bench_args[0].cpu = user0_cpu; + bench_args[0].cond = &cond; + bench_args[0].started = false; + bench_args[0].portid = 0; bench_args[0].src_port = "0xBEE7"; - bench_args[0].dst_ip = "192.168.0.4"; + bench_args[0].dst_ip = "192.168.0.4"; bench_args[0].dst_port = "0xBEE7"; - bench_args[1].cpu = user1_cpu; - bench_args[1].cond = &cond; - bench_args[1].started = false; - bench_args[1].portid = 1; + bench_args[1].cpu = user1_cpu; + bench_args[1].cond = &cond; + bench_args[1].started = false; + bench_args[1].portid = 1; bench_args[1].src_port = "0xBEE7"; - bench_args[1].dst_ip = "192.168.0.3"; + bench_args[1].dst_ip = "192.168.0.3"; bench_args[1].dst_port = "0xBEE7"; pthread_t threads[2]; @@ -366,29 +374,29 @@ int main(int argc, char **argv) pthread_create(&threads[1], NULL, prepare_and_bench_blocking, &bench_args[1]); do { - pthread_mutex_lock(&bench_args[0].mutex); - if (bench_args[0].started) - break; - pthread_mutex_unlock(&bench_args[0].mutex); + pthread_mutex_lock(&bench_args[0].mutex); + if (bench_args[0].started) + break; + pthread_mutex_unlock(&bench_args[0].mutex); } while (true); pthread_mutex_unlock(&bench_args[0].mutex); do { - pthread_mutex_lock(&bench_args[1].mutex); - if (bench_args[1].started) - break; - pthread_mutex_unlock(&bench_args[1].mutex); + pthread_mutex_lock(&bench_args[1].mutex); + if (bench_args[1].started) + break; + pthread_mutex_unlock(&bench_args[1].mutex); } while (true); pthread_mutex_unlock(&bench_args[1].mutex); pthread_cond_broadcast(&cond); - status = pthread_join(threads[0], (void **) &retval); + status = pthread_join(threads[0], (void**)&retval); if (status) { perror("Error while joining thread"); return status; } - status = pthread_join(threads[1], (void **) &retval); + status = pthread_join(threads[1], (void**)&retval); if (status) { perror("Error while joining thread"); return status; diff --git a/host/tests/eeprom_utils_test.cpp b/host/tests/eeprom_utils_test.cpp index 4407ad4e4..728b4b8b6 100644 --- a/host/tests/eeprom_utils_test.cpp +++ b/host/tests/eeprom_utils_test.cpp @@ -4,15 +4,19 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhdlib/utils/eeprom_utils.hpp> #include <boost/assign/list_of.hpp> +#include <boost/test/unit_test.hpp> using namespace boost::assign; -class upper_case_char { +class upper_case_char +{ public: - upper_case_char(char ch) {value = ch;} + upper_case_char(char ch) + { + value = ch; + } static upper_case_char from_string(std::string str) { return upper_case_char(toupper(str[0])); @@ -21,36 +25,28 @@ public: { return std::string(1, value); } + private: char value; }; BOOST_AUTO_TEST_CASE(test_eeprom_duplicate_check) { - const uhd::dict<std::string,std::string> curr_eeprom = map_list_of - ("0","A") - ("1","B") - ("2","C") - ; - const uhd::dict<std::string,std::string> new_eeprom_no_dups = map_list_of - ("0","d") - ("1","e") - ; - const uhd::dict<std::string,std::string> new_eeprom_dups_in_curr = map_list_of - ("0","b") - ; - const uhd::dict<std::string,std::string> new_eeprom_dups_in_new = map_list_of - ("0","c") - ("1","c") - ; - const uhd::dict<std::string,std::string> new_eeprom_dups_in_both = map_list_of - ("0","b") - ("1","B") - ; - const std::vector<std::string> keys = {"0","1","2"}; + const uhd::dict<std::string, std::string> curr_eeprom = + map_list_of("0", "A")("1", "B")("2", "C"); + const uhd::dict<std::string, std::string> new_eeprom_no_dups = + map_list_of("0", "d")("1", "e"); + const uhd::dict<std::string, std::string> new_eeprom_dups_in_curr = + map_list_of("0", "b"); + const uhd::dict<std::string, std::string> new_eeprom_dups_in_new = + map_list_of("0", "c")("1", "c"); + const uhd::dict<std::string, std::string> new_eeprom_dups_in_both = + map_list_of("0", "b")("1", "B"); + const std::vector<std::string> keys = {"0", "1", "2"}; BOOST_CHECK_EQUAL(check_for_duplicates<upper_case_char>( - "TEST", new_eeprom_no_dups, curr_eeprom, "Test Value", keys), false); + "TEST", new_eeprom_no_dups, curr_eeprom, "Test Value", keys), + false); BOOST_CHECK(check_for_duplicates<upper_case_char>( "TEST", new_eeprom_dups_in_curr, curr_eeprom, "Test Value", keys)); BOOST_CHECK(check_for_duplicates<upper_case_char>( diff --git a/host/tests/error_c_test.cpp b/host/tests/error_c_test.cpp index a60abe289..c697ebac7 100644 --- a/host/tests/error_c_test.cpp +++ b/host/tests/error_c_test.cpp @@ -7,11 +7,10 @@ #include <uhd/error.h> #include <uhd/types/dict.hpp> - -#include <boost/test/unit_test.hpp> #include <boost/algorithm/string.hpp> #include <boost/assign.hpp> #include <boost/format.hpp> +#include <boost/test/unit_test.hpp> /* * Test our conversions from exceptions to C-level UHD error codes. @@ -19,97 +18,93 @@ * to test our C++ macro, which returns the error code. */ -typedef struct { +typedef struct +{ std::string last_error; } dummy_handle_t; template <typename error_type> -UHD_INLINE uhd_error throw_uhd_exception(dummy_handle_t *handle, const uhd::exception* except){ - UHD_SAFE_C_SAVE_ERROR(handle, - throw *dynamic_cast<const error_type*>(except); - ) +UHD_INLINE uhd_error throw_uhd_exception( + dummy_handle_t* handle, const uhd::exception* except) +{ + UHD_SAFE_C_SAVE_ERROR(handle, throw *dynamic_cast<const error_type*>(except);) } -UHD_INLINE uhd_error throw_boost_exception(dummy_handle_t *handle){ - UHD_SAFE_C_SAVE_ERROR(handle, +UHD_INLINE uhd_error throw_boost_exception(dummy_handle_t* handle) +{ + UHD_SAFE_C_SAVE_ERROR( + handle, std::runtime_error except("This is a std::runtime_error, thrown by Boost."); - BOOST_THROW_EXCEPTION(except); - ) + BOOST_THROW_EXCEPTION(except);) } -UHD_INLINE uhd_error throw_std_exception(dummy_handle_t *handle){ - UHD_SAFE_C_SAVE_ERROR(handle, - throw std::runtime_error("This is a std::runtime_error."); - ) +UHD_INLINE uhd_error throw_std_exception(dummy_handle_t* handle) +{ + UHD_SAFE_C_SAVE_ERROR( + handle, throw std::runtime_error("This is a std::runtime_error.");) } -UHD_INLINE uhd_error throw_unknown_exception(dummy_handle_t *handle){ - UHD_SAFE_C_SAVE_ERROR(handle, - throw 1; - ) +UHD_INLINE uhd_error throw_unknown_exception(dummy_handle_t* handle) +{ + UHD_SAFE_C_SAVE_ERROR(handle, throw 1;) } // There are enough non-standard names that we can't just use a conversion function static const uhd::dict<std::string, std::string> pretty_exception_names = - boost::assign::map_list_of - ("assertion_error", "AssertionError") - ("lookup_error", "LookupError") - ("index_error", "LookupError: IndexError") - ("key_error", "LookupError: KeyError") - ("type_error", "TypeError") - ("value_error", "ValueError") - ("runtime_error", "RuntimeError") - ("not_implemented_error", "RuntimeError: NotImplementedError") - ("usb_error", "RuntimeError: USBError 1") - ("environment_error", "EnvironmentError") - ("io_error", "EnvironmentError: IOError") - ("os_error", "EnvironmentError: OSError") - ("system_error", "SystemError") - ; - -#define UHD_TEST_CHECK_ERROR_CODE(cpp_exception_type, c_error_code) \ - expected_msg = str(boost::format("This is a uhd::%s.") % BOOST_STRINGIZE(cpp_exception_type)); \ - uhd::cpp_exception_type cpp_exception_type ## _foo(expected_msg); \ - error_code = throw_uhd_exception<uhd::cpp_exception_type>(&handle, &cpp_exception_type ## _foo); \ - BOOST_CHECK_EQUAL(error_code, c_error_code); \ - expected_msg = str(boost::format("%s: %s") \ + boost::assign::map_list_of("assertion_error", "AssertionError")( + "lookup_error", "LookupError")("index_error", "LookupError: IndexError")( + "key_error", "LookupError: KeyError")("type_error", "TypeError")("value_error", + "ValueError")("runtime_error", "RuntimeError")("not_implemented_error", + "RuntimeError: NotImplementedError")("usb_error", "RuntimeError: USBError 1")( + "environment_error", "EnvironmentError")("io_error", "EnvironmentError: IOError")( + "os_error", "EnvironmentError: OSError")("system_error", "SystemError"); + +#define UHD_TEST_CHECK_ERROR_CODE(cpp_exception_type, c_error_code) \ + expected_msg = \ + str(boost::format("This is a uhd::%s.") % BOOST_STRINGIZE(cpp_exception_type)); \ + uhd::cpp_exception_type cpp_exception_type##_foo(expected_msg); \ + error_code = throw_uhd_exception<uhd::cpp_exception_type>( \ + &handle, &cpp_exception_type##_foo); \ + BOOST_CHECK_EQUAL(error_code, c_error_code); \ + expected_msg = str(boost::format("%s: %s") \ % pretty_exception_names.get(BOOST_STRINGIZE(cpp_exception_type)) \ - % expected_msg); \ - BOOST_CHECK_EQUAL(handle.last_error, expected_msg); \ + % expected_msg); \ + BOOST_CHECK_EQUAL(handle.last_error, expected_msg); \ BOOST_CHECK_EQUAL(get_c_global_error_string(), expected_msg); // uhd::usb_error has a different constructor -#define UHD_TEST_CHECK_USB_ERROR_CODE() \ - expected_msg = "This is a uhd::usb_error."; \ - uhd::usb_error usb_error_foo(1, expected_msg); \ - error_code = throw_uhd_exception<uhd::usb_error>(&handle, &usb_error_foo); \ - BOOST_CHECK_EQUAL(error_code, UHD_ERROR_USB); \ - expected_msg = str(boost::format("%s: %s") \ - % pretty_exception_names.get("usb_error") \ - % expected_msg); \ - BOOST_CHECK_EQUAL(handle.last_error, expected_msg); \ +#define UHD_TEST_CHECK_USB_ERROR_CODE() \ + expected_msg = "This is a uhd::usb_error."; \ + uhd::usb_error usb_error_foo(1, expected_msg); \ + error_code = throw_uhd_exception<uhd::usb_error>(&handle, &usb_error_foo); \ + BOOST_CHECK_EQUAL(error_code, UHD_ERROR_USB); \ + expected_msg = str(boost::format("%s: %s") % pretty_exception_names.get("usb_error") \ + % expected_msg); \ + BOOST_CHECK_EQUAL(handle.last_error, expected_msg); \ BOOST_CHECK_EQUAL(get_c_global_error_string(), expected_msg); -BOOST_AUTO_TEST_CASE(test_uhd_exception){ +BOOST_AUTO_TEST_CASE(test_uhd_exception) +{ dummy_handle_t handle; std::string expected_msg; uhd_error error_code; - UHD_TEST_CHECK_ERROR_CODE(assertion_error, UHD_ERROR_ASSERTION); - UHD_TEST_CHECK_ERROR_CODE(lookup_error, UHD_ERROR_LOOKUP); - UHD_TEST_CHECK_ERROR_CODE(index_error, UHD_ERROR_INDEX); - UHD_TEST_CHECK_ERROR_CODE(key_error, UHD_ERROR_KEY); - UHD_TEST_CHECK_ERROR_CODE(type_error, UHD_ERROR_TYPE); - UHD_TEST_CHECK_ERROR_CODE(value_error, UHD_ERROR_VALUE); - UHD_TEST_CHECK_ERROR_CODE(runtime_error, UHD_ERROR_RUNTIME); + UHD_TEST_CHECK_ERROR_CODE(assertion_error, UHD_ERROR_ASSERTION); + UHD_TEST_CHECK_ERROR_CODE(lookup_error, UHD_ERROR_LOOKUP); + UHD_TEST_CHECK_ERROR_CODE(index_error, UHD_ERROR_INDEX); + UHD_TEST_CHECK_ERROR_CODE(key_error, UHD_ERROR_KEY); + UHD_TEST_CHECK_ERROR_CODE(type_error, UHD_ERROR_TYPE); + UHD_TEST_CHECK_ERROR_CODE(value_error, UHD_ERROR_VALUE); + UHD_TEST_CHECK_ERROR_CODE(runtime_error, UHD_ERROR_RUNTIME); UHD_TEST_CHECK_ERROR_CODE(not_implemented_error, UHD_ERROR_NOT_IMPLEMENTED); - UHD_TEST_CHECK_ERROR_CODE(io_error, UHD_ERROR_IO); - UHD_TEST_CHECK_ERROR_CODE(os_error, UHD_ERROR_OS); - UHD_TEST_CHECK_ERROR_CODE(system_error, UHD_ERROR_SYSTEM); + UHD_TEST_CHECK_ERROR_CODE(io_error, UHD_ERROR_IO); + UHD_TEST_CHECK_ERROR_CODE(os_error, UHD_ERROR_OS); + UHD_TEST_CHECK_ERROR_CODE(system_error, UHD_ERROR_SYSTEM); UHD_TEST_CHECK_USB_ERROR_CODE(); } -BOOST_AUTO_TEST_CASE(test_boost_exception){ +BOOST_AUTO_TEST_CASE(test_boost_exception) +{ dummy_handle_t handle; uhd_error error_code = throw_boost_exception(&handle); @@ -117,7 +112,8 @@ BOOST_AUTO_TEST_CASE(test_boost_exception){ BOOST_CHECK_EQUAL(error_code, UHD_ERROR_BOOSTEXCEPT); } -BOOST_AUTO_TEST_CASE(test_std_exception){ +BOOST_AUTO_TEST_CASE(test_std_exception) +{ dummy_handle_t handle; uhd_error error_code = throw_std_exception(&handle); @@ -125,7 +121,8 @@ BOOST_AUTO_TEST_CASE(test_std_exception){ BOOST_CHECK_EQUAL(handle.last_error, "This is a std::runtime_error."); } -BOOST_AUTO_TEST_CASE(test_unknown_exception){ +BOOST_AUTO_TEST_CASE(test_unknown_exception) +{ dummy_handle_t handle; uhd_error error_code = throw_unknown_exception(&handle); diff --git a/host/tests/error_test.cpp b/host/tests/error_test.cpp index b749ca6f4..62411e06d 100644 --- a/host/tests/error_test.cpp +++ b/host/tests/error_test.cpp @@ -5,79 +5,76 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/exception.hpp> #include <uhd/utils/assert_has.hpp> -#include <vector> +#include <boost/test/unit_test.hpp> #include <iostream> +#include <vector> -BOOST_AUTO_TEST_CASE(test_exception_methods){ - try{ +BOOST_AUTO_TEST_CASE(test_exception_methods) +{ + try { throw uhd::assertion_error("your assertion failed: 1 != 2"); - } - catch(const uhd::exception &e){ + } catch (const uhd::exception& e) { std::cout << "what: " << e.what() << std::endl; std::cout << "code: " << e.code() << std::endl; } } -BOOST_AUTO_TEST_CASE(test_assert_has){ +BOOST_AUTO_TEST_CASE(test_assert_has) +{ std::vector<int> vec; vec.push_back(2); vec.push_back(3); vec.push_back(5); - //verify the uhd::has utility + // verify the uhd::has utility BOOST_CHECK(uhd::has(vec, 2)); BOOST_CHECK(not uhd::has(vec, 1)); std::cout << "The output of the assert_has error:" << std::endl; - try{ + try { uhd::assert_has(vec, 1, "prime"); - } - catch(const std::exception &e){ + } catch (const std::exception& e) { std::cout << e.what() << std::endl; } } -BOOST_AUTO_TEST_CASE(test_assert_throw){ +BOOST_AUTO_TEST_CASE(test_assert_throw) +{ std::cout << "The output of the assert throw error:" << std::endl; - try{ + try { UHD_ASSERT_THROW(2 + 2 == 5); - } - catch(const std::exception &e){ + } catch (const std::exception& e) { std::cout << e.what() << std::endl; } } -BOOST_AUTO_TEST_CASE(test_exception_dynamic){ - uhd::exception *exception_clone; +BOOST_AUTO_TEST_CASE(test_exception_dynamic) +{ + uhd::exception* exception_clone; - //throw an exception and dynamically clone it - try{ + // throw an exception and dynamically clone it + try { throw uhd::runtime_error("noooooo"); - } - catch(const uhd::exception &e){ + } catch (const uhd::exception& e) { std::cout << e.what() << std::endl; exception_clone = e.dynamic_clone(); } - //now we dynamically re-throw the exception - try{ + // now we dynamically re-throw the exception + try { exception_clone->dynamic_throw(); - } - catch(const uhd::assertion_error &e){ + } catch (const uhd::assertion_error& e) { std::cout << e.what() << std::endl; BOOST_CHECK(false); - } - catch(const uhd::runtime_error &e){ + } catch (const uhd::runtime_error& e) { std::cout << e.what() << std::endl; BOOST_CHECK(true); - } - catch(const uhd::exception &e){ + } catch (const uhd::exception& e) { std::cout << e.what() << std::endl; BOOST_CHECK(false); } - delete exception_clone; //manual cleanup + delete exception_clone; // manual cleanup } diff --git a/host/tests/expert_test.cpp b/host/tests/expert_test.cpp index efd4f1d08..36a9ef03b 100644 --- a/host/tests/expert_test.cpp +++ b/host/tests/expert_test.cpp @@ -5,20 +5,21 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> -#include <boost/format.hpp> -#include <boost/make_shared.hpp> #include <uhd/property_tree.hpp> #include <uhdlib/experts/expert_container.hpp> #include <uhdlib/experts/expert_factory.hpp> +#include <boost/format.hpp> +#include <boost/make_shared.hpp> +#include <boost/test/unit_test.hpp> #include <fstream> using namespace uhd::experts; -class worker1_t : public worker_node_t { +class worker1_t : public worker_node_t +{ public: worker1_t(const node_retriever_t& db) - : worker_node_t("A+B=C"), _a(db, "A/desired"), _b(db, "B"), _c(db, "C") + : worker_node_t("A+B=C"), _a(db, "A/desired"), _b(db, "B"), _c(db, "C") { bind_accessor(_a); bind_accessor(_b); @@ -26,7 +27,8 @@ public: } private: - void resolve() { + void resolve() + { _c = _a + _b; } @@ -37,10 +39,11 @@ private: //============================================================================= -class worker2_t : public worker_node_t { +class worker2_t : public worker_node_t +{ public: worker2_t(const node_retriever_t& db) - : worker_node_t("C*D=E"), _c(db, "C"), _d(db, "D"), _e(db, "E") + : worker_node_t("C*D=E"), _c(db, "C"), _d(db, "D"), _e(db, "E") { bind_accessor(_c); bind_accessor(_d); @@ -48,7 +51,8 @@ public: } private: - void resolve() { + void resolve() + { _e.set(_c.get() * _d.get()); } @@ -59,17 +63,19 @@ private: //============================================================================= -class worker3_t : public worker_node_t { +class worker3_t : public worker_node_t +{ public: worker3_t(const node_retriever_t& db) - : worker_node_t("-B=F"), _b(db, "B"), _f(db, "F") + : worker_node_t("-B=F"), _b(db, "B"), _f(db, "F") { bind_accessor(_b); bind_accessor(_f); } private: - void resolve() { + void resolve() + { _f.set(-_b.get()); } @@ -79,10 +85,11 @@ private: //============================================================================= -class worker4_t : public worker_node_t { +class worker4_t : public worker_node_t +{ public: worker4_t(const node_retriever_t& db) - : worker_node_t("E-F=G"), _e(db, "E"), _f(db, "F"), _g(db, "G") + : worker_node_t("E-F=G"), _e(db, "E"), _f(db, "F"), _g(db, "G") { bind_accessor(_e); bind_accessor(_f); @@ -90,7 +97,8 @@ public: } private: - void resolve() { + void resolve() + { _g.set(_e.get() - _f.get()); } @@ -101,17 +109,19 @@ private: //============================================================================= -class worker5_t : public worker_node_t { +class worker5_t : public worker_node_t +{ public: worker5_t(const node_retriever_t& db, boost::shared_ptr<int> output) - : worker_node_t("Consume_G"), _g(db, "G"), _c(db, "C"), _output(output) + : worker_node_t("Consume_G"), _g(db, "G"), _c(db, "C"), _output(output) { bind_accessor(_g); -// bind_accessor(_c); + // bind_accessor(_c); } private: - void resolve() { + void resolve() + { *_output = _g; } @@ -121,82 +131,92 @@ private: boost::shared_ptr<int> _output; }; -class worker6_t : public worker_node_t { +class worker6_t : public worker_node_t +{ public: - worker6_t() : worker_node_t("null_worker") - { - } + worker6_t() : worker_node_t("null_worker") {} private: - void resolve() { - } + void resolve() {} }; //============================================================================= -#define DUMP_VARS \ - BOOST_TEST_MESSAGE( str(boost::format("### State = {A=%d%s, B=%d%s, C=%d%s, D=%d%s, E=%d%s, F=%d%s, G=%d%s}\n") % \ - nodeA.get() % (nodeA.is_dirty()?"*":"") % \ - nodeB.get() % (nodeB.is_dirty()?"*":"") % \ - nodeC.get() % (nodeC.is_dirty()?"*":"") % \ - nodeD.get() % (nodeD.is_dirty()?"*":"") % \ - nodeE.get() % (nodeE.is_dirty()?"*":"") % \ - nodeF.get() % (nodeF.is_dirty()?"*":"") % \ - nodeG.get() % (nodeG.is_dirty()?"*":"")) ); - -#define VALIDATE_ALL_DEPENDENCIES \ - BOOST_CHECK(!nodeA.is_dirty()); \ - BOOST_CHECK(!nodeB.is_dirty()); \ - BOOST_CHECK(!nodeC.is_dirty()); \ - BOOST_CHECK(!nodeD.is_dirty()); \ - BOOST_CHECK(!nodeE.is_dirty()); \ - BOOST_CHECK(!nodeF.is_dirty()); \ - BOOST_CHECK(!nodeG.is_dirty()); \ +#define DUMP_VARS \ + BOOST_TEST_MESSAGE(str( \ + boost::format( \ + "### State = {A=%d%s, B=%d%s, C=%d%s, D=%d%s, E=%d%s, F=%d%s, G=%d%s}\n") \ + % nodeA.get() % (nodeA.is_dirty() ? "*" : "") % nodeB.get() \ + % (nodeB.is_dirty() ? "*" : "") % nodeC.get() % (nodeC.is_dirty() ? "*" : "") \ + % nodeD.get() % (nodeD.is_dirty() ? "*" : "") % nodeE.get() \ + % (nodeE.is_dirty() ? "*" : "") % nodeF.get() % (nodeF.is_dirty() ? "*" : "") \ + % nodeG.get() % (nodeG.is_dirty() ? "*" : ""))); + +#define VALIDATE_ALL_DEPENDENCIES \ + BOOST_CHECK(!nodeA.is_dirty()); \ + BOOST_CHECK(!nodeB.is_dirty()); \ + BOOST_CHECK(!nodeC.is_dirty()); \ + BOOST_CHECK(!nodeD.is_dirty()); \ + BOOST_CHECK(!nodeE.is_dirty()); \ + BOOST_CHECK(!nodeF.is_dirty()); \ + BOOST_CHECK(!nodeG.is_dirty()); \ BOOST_CHECK(nodeC.get() == nodeA.get() + nodeB.get()); \ BOOST_CHECK(nodeE.get() == nodeC.get() * nodeD.get()); \ - BOOST_CHECK(nodeF.get() == - nodeB.get()); \ + BOOST_CHECK(nodeF.get() == -nodeB.get()); \ BOOST_CHECK(nodeG.get() == nodeE.get() - nodeF.get()); \ BOOST_CHECK(nodeG.get() == *final_output); -BOOST_AUTO_TEST_CASE(test_experts){ - //Initialize container object +BOOST_AUTO_TEST_CASE(test_experts) +{ + // Initialize container object expert_container::sptr container = expert_factory::create_container("example"); - uhd::property_tree::sptr tree = uhd::property_tree::make(); + uhd::property_tree::sptr tree = uhd::property_tree::make(); - //Output of expert tree + // Output of expert tree boost::shared_ptr<int> final_output = boost::make_shared<int>(); - //Add data nodes to container - expert_factory::add_dual_prop_node<int>(container, tree, "A", 0, uhd::experts::AUTO_RESOLVE_ON_WRITE); + // Add data nodes to container + expert_factory::add_dual_prop_node<int>( + container, tree, "A", 0, uhd::experts::AUTO_RESOLVE_ON_WRITE); expert_factory::add_prop_node<int>(container, tree, "B", 0); expert_factory::add_data_node<int>(container, "C", 0); expert_factory::add_data_node<int>(container, "D", 1); - expert_factory::add_prop_node<int>(container, tree, "E", 0, uhd::experts::AUTO_RESOLVE_ON_READ); + expert_factory::add_prop_node<int>( + container, tree, "E", 0, uhd::experts::AUTO_RESOLVE_ON_READ); expert_factory::add_data_node<int>(container, "F", 0); expert_factory::add_data_node<int>(container, "G", 0); - //Add worker nodes to container + // Add worker nodes to container expert_factory::add_worker_node<worker1_t>(container, container->node_retriever()); expert_factory::add_worker_node<worker2_t>(container, container->node_retriever()); expert_factory::add_worker_node<worker3_t>(container, container->node_retriever()); expert_factory::add_worker_node<worker4_t>(container, container->node_retriever()); - expert_factory::add_worker_node<worker5_t>(container, container->node_retriever(), final_output); + expert_factory::add_worker_node<worker5_t>( + container, container->node_retriever(), final_output); expert_factory::add_worker_node<worker6_t>(container); - //Once initialized, getting modify access to graph nodes is possible (by design) but extremely red-flaggy! - //But we do it here to monitor things - data_node_t<int>& nodeA = *(const_cast< data_node_t<int>* >(dynamic_cast< const data_node_t<int>* >(&container->node_retriever().lookup("A/desired")))); - data_node_t<int>& nodeB = *(const_cast< data_node_t<int>* >(dynamic_cast< const data_node_t<int>* >(&container->node_retriever().lookup("B")))); - data_node_t<int>& nodeC = *(const_cast< data_node_t<int>* >(dynamic_cast< const data_node_t<int>* >(&container->node_retriever().lookup("C")))); - data_node_t<int>& nodeD = *(const_cast< data_node_t<int>* >(dynamic_cast< const data_node_t<int>* >(&container->node_retriever().lookup("D")))); - data_node_t<int>& nodeE = *(const_cast< data_node_t<int>* >(dynamic_cast< const data_node_t<int>* >(&container->node_retriever().lookup("E")))); - data_node_t<int>& nodeF = *(const_cast< data_node_t<int>* >(dynamic_cast< const data_node_t<int>* >(&container->node_retriever().lookup("F")))); - data_node_t<int>& nodeG = *(const_cast< data_node_t<int>* >(dynamic_cast< const data_node_t<int>* >(&container->node_retriever().lookup("G")))); + // Once initialized, getting modify access to graph nodes is possible (by design) but + // extremely red-flaggy! But we do it here to monitor things + data_node_t<int>& nodeA = + *(const_cast<data_node_t<int>*>(dynamic_cast<const data_node_t<int>*>( + &container->node_retriever().lookup("A/desired")))); + data_node_t<int>& nodeB = *(const_cast<data_node_t<int>*>( + dynamic_cast<const data_node_t<int>*>(&container->node_retriever().lookup("B")))); + data_node_t<int>& nodeC = *(const_cast<data_node_t<int>*>( + dynamic_cast<const data_node_t<int>*>(&container->node_retriever().lookup("C")))); + data_node_t<int>& nodeD = *(const_cast<data_node_t<int>*>( + dynamic_cast<const data_node_t<int>*>(&container->node_retriever().lookup("D")))); + data_node_t<int>& nodeE = *(const_cast<data_node_t<int>*>( + dynamic_cast<const data_node_t<int>*>(&container->node_retriever().lookup("E")))); + data_node_t<int>& nodeF = *(const_cast<data_node_t<int>*>( + dynamic_cast<const data_node_t<int>*>(&container->node_retriever().lookup("F")))); + data_node_t<int>& nodeG = *(const_cast<data_node_t<int>*>( + dynamic_cast<const data_node_t<int>*>(&container->node_retriever().lookup("G")))); DUMP_VARS - //Ensure init behavior + // Ensure init behavior BOOST_CHECK(nodeA.is_dirty()); BOOST_CHECK(nodeB.is_dirty()); BOOST_CHECK(nodeC.is_dirty()); @@ -205,18 +225,19 @@ BOOST_AUTO_TEST_CASE(test_experts){ BOOST_CHECK(nodeF.is_dirty()); BOOST_CHECK(nodeG.is_dirty()); container->resolve_all(); - VALIDATE_ALL_DEPENDENCIES //Ensure a default resolve + VALIDATE_ALL_DEPENDENCIES // Ensure a default resolve - //Ensure basic node value propagation - tree->access<int>("B").set(3); - BOOST_CHECK(nodeB.get() == 3); //Ensure value propagated - BOOST_CHECK(nodeB.is_dirty()); //Ensure that nothing got resolved... + // Ensure basic node value propagation + tree->access<int>("B") + .set(3); + BOOST_CHECK(nodeB.get() == 3); // Ensure value propagated + BOOST_CHECK(nodeB.is_dirty()); // Ensure that nothing got resolved... container->resolve_all(); VALIDATE_ALL_DEPENDENCIES - nodeD.set(2); //Hack for testing + nodeD.set(2); // Hack for testing - //Ensure auto-resolve on write + // Ensure auto-resolve on write tree->access<int>("A").set(200); BOOST_CHECK(nodeC.get() == nodeA.get() + nodeB.get()); BOOST_CHECK(nodeE.get() == nodeC.get() * nodeD.get()); @@ -227,7 +248,7 @@ BOOST_AUTO_TEST_CASE(test_experts){ container->resolve_all(); VALIDATE_ALL_DEPENDENCIES - //Ensure auto-resolve on read + // Ensure auto-resolve on read tree->access<int>("E").get(); BOOST_CHECK(nodeC.get() == nodeA.get() + nodeB.get()); BOOST_CHECK(nodeE.get() == nodeC.get() * nodeD.get()); @@ -236,7 +257,7 @@ BOOST_AUTO_TEST_CASE(test_experts){ container->resolve_all(true); VALIDATE_ALL_DEPENDENCIES - //Resolve to/from + // Resolve to/from tree->access<int>("A").set(-1); container->resolve_to("C"); BOOST_CHECK(nodeC.get() == nodeA.get() + nodeB.get()); diff --git a/host/tests/fe_conn_test.cpp b/host/tests/fe_conn_test.cpp index 34ebb7b33..bbf79835f 100644 --- a/host/tests/fe_conn_test.cpp +++ b/host/tests/fe_conn_test.cpp @@ -5,19 +5,20 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <uhd/usrp/fe_connection.hpp> #include <uhd/exception.hpp> +#include <uhd/usrp/fe_connection.hpp> #include <boost/test/unit_test.hpp> using namespace uhd::usrp; -BOOST_AUTO_TEST_CASE(test_quardrature){ +BOOST_AUTO_TEST_CASE(test_quardrature) +{ fe_connection_t IQ("IQ"), QI("QI"), IbQ("IbQ"), QbI("QbI"), QbIb("QbIb"); - BOOST_CHECK(IQ.get_sampling_mode()==fe_connection_t::QUADRATURE); - BOOST_CHECK(QI.get_sampling_mode()==fe_connection_t::QUADRATURE); - BOOST_CHECK(IbQ.get_sampling_mode()==fe_connection_t::QUADRATURE); - BOOST_CHECK(QbI.get_sampling_mode()==fe_connection_t::QUADRATURE); - BOOST_CHECK(QbIb.get_sampling_mode()==fe_connection_t::QUADRATURE); + BOOST_CHECK(IQ.get_sampling_mode() == fe_connection_t::QUADRATURE); + BOOST_CHECK(QI.get_sampling_mode() == fe_connection_t::QUADRATURE); + BOOST_CHECK(IbQ.get_sampling_mode() == fe_connection_t::QUADRATURE); + BOOST_CHECK(QbI.get_sampling_mode() == fe_connection_t::QUADRATURE); + BOOST_CHECK(QbIb.get_sampling_mode() == fe_connection_t::QUADRATURE); BOOST_CHECK(not IQ.is_iq_swapped()); BOOST_CHECK(QI.is_iq_swapped()); @@ -38,12 +39,13 @@ BOOST_AUTO_TEST_CASE(test_quardrature){ BOOST_CHECK(QbIb.is_q_inverted()); } -BOOST_AUTO_TEST_CASE(test_heterodyne){ +BOOST_AUTO_TEST_CASE(test_heterodyne) +{ fe_connection_t II("II"), QQ("QQ"), IbIb("IbIb"), QbQb("QbQb"); - BOOST_CHECK(II.get_sampling_mode()==fe_connection_t::HETERODYNE); - BOOST_CHECK(QQ.get_sampling_mode()==fe_connection_t::HETERODYNE); - BOOST_CHECK(IbIb.get_sampling_mode()==fe_connection_t::HETERODYNE); - BOOST_CHECK(QbQb.get_sampling_mode()==fe_connection_t::HETERODYNE); + BOOST_CHECK(II.get_sampling_mode() == fe_connection_t::HETERODYNE); + BOOST_CHECK(QQ.get_sampling_mode() == fe_connection_t::HETERODYNE); + BOOST_CHECK(IbIb.get_sampling_mode() == fe_connection_t::HETERODYNE); + BOOST_CHECK(QbQb.get_sampling_mode() == fe_connection_t::HETERODYNE); BOOST_CHECK(not II.is_iq_swapped()); BOOST_CHECK(QQ.is_iq_swapped()); @@ -66,12 +68,13 @@ BOOST_AUTO_TEST_CASE(test_heterodyne){ BOOST_CHECK_THROW(fe_connection_t dummy("QbQ"), uhd::value_error); } -BOOST_AUTO_TEST_CASE(test_real){ +BOOST_AUTO_TEST_CASE(test_real) +{ fe_connection_t I("I"), Q("Q"), Ib("Ib"), Qb("Qb"); - BOOST_CHECK(I.get_sampling_mode()==fe_connection_t::REAL); - BOOST_CHECK(Q.get_sampling_mode()==fe_connection_t::REAL); - BOOST_CHECK(Ib.get_sampling_mode()==fe_connection_t::REAL); - BOOST_CHECK(Qb.get_sampling_mode()==fe_connection_t::REAL); + BOOST_CHECK(I.get_sampling_mode() == fe_connection_t::REAL); + BOOST_CHECK(Q.get_sampling_mode() == fe_connection_t::REAL); + BOOST_CHECK(Ib.get_sampling_mode() == fe_connection_t::REAL); + BOOST_CHECK(Qb.get_sampling_mode() == fe_connection_t::REAL); BOOST_CHECK(not I.is_iq_swapped()); BOOST_CHECK(Q.is_iq_swapped()); @@ -89,7 +92,8 @@ BOOST_AUTO_TEST_CASE(test_real){ BOOST_CHECK(not Qb.is_q_inverted()); } -BOOST_AUTO_TEST_CASE(test_invalid){ +BOOST_AUTO_TEST_CASE(test_invalid) +{ BOOST_CHECK_THROW(fe_connection_t dummy("blah"), uhd::value_error); BOOST_CHECK_THROW(fe_connection_t dummy("123456"), uhd::value_error); BOOST_CHECK_THROW(fe_connection_t dummy("ii"), uhd::value_error); diff --git a/host/tests/fp_compare_delta_test.cpp b/host/tests/fp_compare_delta_test.cpp index 5023d660a..ae1f14281 100644 --- a/host/tests/fp_compare_delta_test.cpp +++ b/host/tests/fp_compare_delta_test.cpp @@ -10,20 +10,21 @@ using namespace uhd::math::fp_compare; -BOOST_AUTO_TEST_CASE(fp_compare_delta_constructors) { +BOOST_AUTO_TEST_CASE(fp_compare_delta_constructors) +{ // Test default constructor fp_compare_delta<float> alpha = fp_compare_delta<float>(7457392.0); - fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); + fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); BOOST_CHECK_EQUAL(alpha._value, beta._value); BOOST_CHECK_EQUAL(alpha._delta, beta._delta); // Test constructor with specified delta - fp_compare_delta<float> foxtrot = fp_compare_delta<float>(alpha._value, - uhd::math::SINGLE_PRECISION_DELTA); - fp_compare_delta<float> gamma = fp_compare_delta<float>(alpha._value, - 2 * uhd::math::SINGLE_PRECISION_DELTA); + fp_compare_delta<float> foxtrot = + fp_compare_delta<float>(alpha._value, uhd::math::SINGLE_PRECISION_DELTA); + fp_compare_delta<float> gamma = + fp_compare_delta<float>(alpha._value, 2 * uhd::math::SINGLE_PRECISION_DELTA); BOOST_CHECK_EQUAL(alpha._delta, foxtrot._delta); - BOOST_CHECK(not (alpha._delta == gamma._delta)); + BOOST_CHECK(not(alpha._delta == gamma._delta)); // Test copy-constructor fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha); @@ -36,19 +37,20 @@ BOOST_AUTO_TEST_CASE(fp_compare_delta_constructors) { BOOST_CHECK_EQUAL(alpha._delta, delta._delta); } -BOOST_AUTO_TEST_CASE(double_compare_constructors) { +BOOST_AUTO_TEST_CASE(double_compare_constructors) +{ // Test default constructor fp_compare_delta<double> alpha = fp_compare_delta<double>(45739210286.0101); - fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); + fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); BOOST_CHECK_EQUAL(alpha._value, beta._value); BOOST_CHECK_EQUAL(alpha._delta, beta._delta); // Test constructor with specified delta - fp_compare_delta<double> foxtrot = fp_compare_delta<double>(alpha._value, - uhd::math::DOUBLE_PRECISION_DELTA); + fp_compare_delta<double> foxtrot = + fp_compare_delta<double>(alpha._value, uhd::math::DOUBLE_PRECISION_DELTA); fp_compare_delta<double> gamma = fp_compare_delta<double>(alpha._value, 2.0e-6); BOOST_CHECK_EQUAL(alpha._delta, foxtrot._delta); - BOOST_CHECK(not (alpha._delta == gamma._delta)); + BOOST_CHECK(not(alpha._delta == gamma._delta)); // Test copy-constructor fp_compare_delta<double> charlie = fp_compare_delta<double>(alpha); @@ -61,56 +63,61 @@ BOOST_AUTO_TEST_CASE(double_compare_constructors) { BOOST_CHECK_EQUAL(alpha._delta, delta._delta); } -BOOST_AUTO_TEST_CASE(float_equality_operators) { +BOOST_AUTO_TEST_CASE(float_equality_operators) +{ // Test basic equality operator fp_compare_delta<float> alpha = fp_compare_delta<float>(1.0); - fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); + fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); BOOST_CHECK(alpha == beta); BOOST_CHECK(alpha == float(alpha._value)); // Test equality edge case at difference = delta - fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value - + uhd::math::SINGLE_PRECISION_DELTA); - BOOST_CHECK(not (alpha == charlie)); - BOOST_CHECK(not (alpha == float(alpha._value + uhd::math::SINGLE_PRECISION_DELTA))); + fp_compare_delta<float> charlie = + fp_compare_delta<float>(alpha._value + uhd::math::SINGLE_PRECISION_DELTA); + BOOST_CHECK(not(alpha == charlie)); + BOOST_CHECK(not(alpha == float(alpha._value + uhd::math::SINGLE_PRECISION_DELTA))); } -BOOST_AUTO_TEST_CASE(double_equality_operators) { +BOOST_AUTO_TEST_CASE(double_equality_operators) +{ // Test basic equality operator fp_compare_delta<double> alpha = fp_compare_delta<double>(1.0); - fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); + fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); BOOST_CHECK(alpha == beta); BOOST_CHECK(alpha == double(beta._value)); // Test equality edge case at delta = delta - fp_compare_delta<double> charlie = fp_compare_delta<double>(alpha._value - + uhd::math::DOUBLE_PRECISION_DELTA); - BOOST_CHECK(not (alpha == charlie)); - BOOST_CHECK(not (alpha == double(alpha._value + uhd::math::DOUBLE_PRECISION_DELTA))); + fp_compare_delta<double> charlie = + fp_compare_delta<double>(alpha._value + uhd::math::DOUBLE_PRECISION_DELTA); + BOOST_CHECK(not(alpha == charlie)); + BOOST_CHECK(not(alpha == double(alpha._value + uhd::math::DOUBLE_PRECISION_DELTA))); } -BOOST_AUTO_TEST_CASE(float_inequality_operators) { +BOOST_AUTO_TEST_CASE(float_inequality_operators) +{ // Test inequality operator, which is based on equality operator fp_compare_delta<float> alpha = fp_compare_delta<float>(127.0f); - fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 1.19e-3f); + fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 1.19e-3f); BOOST_CHECK(alpha != beta); BOOST_CHECK(alpha != float(alpha._value + 1.19e-3)); } -BOOST_AUTO_TEST_CASE(double_inequality_operators) { +BOOST_AUTO_TEST_CASE(double_inequality_operators) +{ // Test inequality operator, which is based on equality operator fp_compare_delta<double> alpha = fp_compare_delta<double>(1.0); - fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value + 1.19e-5); + fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value + 1.19e-5); BOOST_CHECK(alpha != beta); BOOST_CHECK(alpha != double(alpha._value + 1.19e-5)); } -BOOST_AUTO_TEST_CASE(float_lessthan_operators) { +BOOST_AUTO_TEST_CASE(float_lessthan_operators) +{ // Test less-than operator fp_compare_delta<float> alpha = fp_compare_delta<float>(274192.7f); - fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value - 0.2f); + fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value - 0.2f); BOOST_CHECK(beta < alpha); BOOST_CHECK(float(alpha._value - 0.2) < alpha); @@ -118,14 +125,15 @@ BOOST_AUTO_TEST_CASE(float_lessthan_operators) { // Confirm false less-than case fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value - 1.2f); - BOOST_CHECK(not (alpha < charlie)); - BOOST_CHECK(not (alpha < float(alpha._value - 1.2f))); + BOOST_CHECK(not(alpha < charlie)); + BOOST_CHECK(not(alpha < float(alpha._value - 1.2f))); } -BOOST_AUTO_TEST_CASE(double_lessthan_operators) { +BOOST_AUTO_TEST_CASE(double_lessthan_operators) +{ // Test less-than operator fp_compare_delta<double> alpha = fp_compare_delta<double>(274192856.762312); - fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value - 0.0002); + fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value - 0.0002); BOOST_CHECK(beta < alpha); BOOST_CHECK(double(alpha._value - 0.0002) < alpha); @@ -133,14 +141,15 @@ BOOST_AUTO_TEST_CASE(double_lessthan_operators) { // Confirm false less-than case fp_compare_delta<double> charlie = fp_compare_delta<double>(alpha._value - 1.0012); - BOOST_CHECK(not (alpha < charlie)); - BOOST_CHECK(not (alpha < double(alpha._value - 1.0012))); + BOOST_CHECK(not(alpha < charlie)); + BOOST_CHECK(not(alpha < double(alpha._value - 1.0012))); } -BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) { +BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) +{ // Test that <= correctly reports for equal values fp_compare_delta<float> alpha = fp_compare_delta<float>(827.3f); - fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); + fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); BOOST_CHECK(alpha <= beta); BOOST_CHECK(alpha <= float(alpha._value)); @@ -152,10 +161,11 @@ BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) { BOOST_CHECK(float(alpha._value - 1.2) <= alpha); } -BOOST_AUTO_TEST_CASE(double_lessthanequals_operators) { +BOOST_AUTO_TEST_CASE(double_lessthanequals_operators) +{ // Test that <= correctly reports for equal values fp_compare_delta<double> alpha = fp_compare_delta<double>(837652123.383764); - fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); + fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); BOOST_CHECK(alpha <= beta); BOOST_CHECK(alpha <= double(alpha._value)); @@ -167,10 +177,11 @@ BOOST_AUTO_TEST_CASE(double_lessthanequals_operators) { BOOST_CHECK(double(alpha._value - 0.0012) <= alpha); } -BOOST_AUTO_TEST_CASE(float_greaterthan_operators) { +BOOST_AUTO_TEST_CASE(float_greaterthan_operators) +{ // Test basic greater-than functionality fp_compare_delta<float> alpha = fp_compare_delta<float>(98325.4f); - fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 0.15f); + fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 0.15f); BOOST_CHECK(beta > alpha); BOOST_CHECK(float(alpha._value + 0.15) > alpha); @@ -178,14 +189,15 @@ BOOST_AUTO_TEST_CASE(float_greaterthan_operators) { // Test false greater-than case fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value + 1.2f); - BOOST_CHECK(not (alpha > charlie)); - BOOST_CHECK(not (alpha > float(alpha._value + 1.2))); + BOOST_CHECK(not(alpha > charlie)); + BOOST_CHECK(not(alpha > float(alpha._value + 1.2))); } -BOOST_AUTO_TEST_CASE(double_greaterthan_operators) { +BOOST_AUTO_TEST_CASE(double_greaterthan_operators) +{ // Test basic greater-than functionality fp_compare_delta<double> alpha = fp_compare_delta<double>(643907213.428475); - fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value + 0.0002); + fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value + 0.0002); BOOST_CHECK(beta > alpha); BOOST_CHECK(double(alpha._value + 0.0002) > alpha); @@ -193,14 +205,15 @@ BOOST_AUTO_TEST_CASE(double_greaterthan_operators) { // Test false greater-than case fp_compare_delta<double> charlie = fp_compare_delta<double>(alpha._value + 0.0012); - BOOST_CHECK(not (alpha > charlie)); - BOOST_CHECK(not (alpha > double(alpha._value + 0.0012))); + BOOST_CHECK(not(alpha > charlie)); + BOOST_CHECK(not(alpha > double(alpha._value + 0.0012))); } -BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) { +BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) +{ // Test that >= correctly reports for equal values fp_compare_delta<float> alpha = fp_compare_delta<float>(7834.89f); - fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); + fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value); BOOST_CHECK(alpha >= beta); BOOST_CHECK(alpha >= float(alpha._value)); @@ -212,10 +225,11 @@ BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) { BOOST_CHECK(float(alpha._value + 4.8) >= alpha); } -BOOST_AUTO_TEST_CASE(double_greaterthanequals_operators) { +BOOST_AUTO_TEST_CASE(double_greaterthanequals_operators) +{ // Test that >= correctly reports for equal values fp_compare_delta<double> alpha = fp_compare_delta<double>(737623834.89843); - fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); + fp_compare_delta<double> beta = fp_compare_delta<double>(alpha._value); BOOST_CHECK(alpha >= beta); BOOST_CHECK(alpha >= double(alpha._value)); @@ -227,16 +241,20 @@ BOOST_AUTO_TEST_CASE(double_greaterthanequals_operators) { BOOST_CHECK(double(alpha._value + 3.0008) >= alpha); } -BOOST_AUTO_TEST_CASE(fp_compare_large_delta) { - BOOST_CHECK(fp_compare_delta<double>(61440000.047870710492, 0.1) == 61440000.000000000000); - BOOST_CHECK(fp_compare_delta<double>(61440000.047870710492, 0.1) <= 61440000.000000000000); - BOOST_CHECK(fp_compare_delta<double>(61440000.047870710492, 0.1) >= 61440000.000000000000); +BOOST_AUTO_TEST_CASE(fp_compare_large_delta) +{ + BOOST_CHECK( + fp_compare_delta<double>(61440000.047870710492, 0.1) == 61440000.000000000000); + BOOST_CHECK( + fp_compare_delta<double>(61440000.047870710492, 0.1) <= 61440000.000000000000); + BOOST_CHECK( + fp_compare_delta<double>(61440000.047870710492, 0.1) >= 61440000.000000000000); BOOST_CHECK(fp_compare_delta<double>(1.0, 10.0) == 2.0); } -BOOST_AUTO_TEST_CASE(frequency_compare_function) { - +BOOST_AUTO_TEST_CASE(frequency_compare_function) +{ BOOST_CHECK(uhd::math::frequencies_are_equal(6817333232.0, 6817333232.0)); BOOST_CHECK(!uhd::math::frequencies_are_equal(6817333233.0, 6817333232.0)); BOOST_CHECK(uhd::math::frequencies_are_equal(6817333232.1, 6817333232.1)); diff --git a/host/tests/fp_compare_epsilon_test.cpp b/host/tests/fp_compare_epsilon_test.cpp index 5e5971586..0c2a7f1cb 100644 --- a/host/tests/fp_compare_epsilon_test.cpp +++ b/host/tests/fp_compare_epsilon_test.cpp @@ -10,19 +10,20 @@ using namespace uhd::math::fp_compare; -BOOST_AUTO_TEST_CASE(fp_compare_epsilon_constructors) { +BOOST_AUTO_TEST_CASE(fp_compare_epsilon_constructors) +{ // Test default constructor fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(7457392.0); - fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); + fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); BOOST_CHECK_EQUAL(alpha._value, beta._value); BOOST_CHECK_EQUAL(alpha._epsilon, beta._epsilon); // Test constructor with specified epsilon - fp_compare_epsilon<float> foxtrot = fp_compare_epsilon<float>(alpha._value, - uhd::math::SINGLE_PRECISION_EPSILON); + fp_compare_epsilon<float> foxtrot = + fp_compare_epsilon<float>(alpha._value, uhd::math::SINGLE_PRECISION_EPSILON); fp_compare_epsilon<float> gamma = fp_compare_epsilon<float>(alpha._value, 2.0e-1f); BOOST_CHECK_EQUAL(alpha._epsilon, foxtrot._epsilon); - BOOST_CHECK(not (alpha._epsilon == gamma._epsilon)); + BOOST_CHECK(not(alpha._epsilon == gamma._epsilon)); // Test copy-constructor fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha); @@ -35,19 +36,20 @@ BOOST_AUTO_TEST_CASE(fp_compare_epsilon_constructors) { BOOST_CHECK_EQUAL(alpha._epsilon, delta._epsilon); } -BOOST_AUTO_TEST_CASE(double_compare_constructors) { +BOOST_AUTO_TEST_CASE(double_compare_constructors) +{ // Test default constructor fp_compare_epsilon<double> alpha = fp_compare_epsilon<double>(45739210286.0101); - fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); + fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); BOOST_CHECK_EQUAL(alpha._value, beta._value); BOOST_CHECK_EQUAL(alpha._epsilon, beta._epsilon); // Test constructor with specified epsilon - fp_compare_epsilon<double> foxtrot = fp_compare_epsilon<double>(alpha._value, - uhd::math::DOUBLE_PRECISION_EPSILON); + fp_compare_epsilon<double> foxtrot = + fp_compare_epsilon<double>(alpha._value, uhd::math::DOUBLE_PRECISION_EPSILON); fp_compare_epsilon<double> gamma = fp_compare_epsilon<double>(alpha._value, 2.0e-6); BOOST_CHECK_EQUAL(alpha._epsilon, foxtrot._epsilon); - BOOST_CHECK(not (alpha._epsilon == gamma._epsilon)); + BOOST_CHECK(not(alpha._epsilon == gamma._epsilon)); // Test copy-constructor fp_compare_epsilon<double> charlie = fp_compare_epsilon<double>(alpha); @@ -60,45 +62,48 @@ BOOST_AUTO_TEST_CASE(double_compare_constructors) { BOOST_CHECK_EQUAL(alpha._epsilon, delta._epsilon); } -BOOST_AUTO_TEST_CASE(float_equality_operators) { +BOOST_AUTO_TEST_CASE(float_equality_operators) +{ // Test basic equality operator fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(1.0); - fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); + fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); BOOST_CHECK(alpha == beta); BOOST_CHECK(alpha == float(alpha._value)); // Test equality edge case at delta = epsilon - fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value - + uhd::math::SINGLE_PRECISION_EPSILON); - BOOST_CHECK(not (alpha == charlie)); - BOOST_CHECK(not (alpha == float(alpha._value + uhd::math::SINGLE_PRECISION_EPSILON))); + fp_compare_epsilon<float> charlie = + fp_compare_epsilon<float>(alpha._value + uhd::math::SINGLE_PRECISION_EPSILON); + BOOST_CHECK(not(alpha == charlie)); + BOOST_CHECK(not(alpha == float(alpha._value + uhd::math::SINGLE_PRECISION_EPSILON))); } -BOOST_AUTO_TEST_CASE(double_equality_operators) { +BOOST_AUTO_TEST_CASE(double_equality_operators) +{ // Test basic equality operator fp_compare_epsilon<double> alpha = fp_compare_epsilon<double>(1.0); - fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); + fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); BOOST_CHECK(alpha == beta); BOOST_CHECK(alpha == double(beta._value)); // Test equality edge case at delta = epsilon - fp_compare_epsilon<double> charlie = fp_compare_epsilon<double>(alpha._value - + uhd::math::DOUBLE_PRECISION_EPSILON); - BOOST_CHECK(not (alpha == charlie)); - BOOST_CHECK(not (alpha == double(alpha._value - + uhd::math::DOUBLE_PRECISION_EPSILON))); + fp_compare_epsilon<double> charlie = + fp_compare_epsilon<double>(alpha._value + uhd::math::DOUBLE_PRECISION_EPSILON); + BOOST_CHECK(not(alpha == charlie)); + BOOST_CHECK(not(alpha == double(alpha._value + uhd::math::DOUBLE_PRECISION_EPSILON))); } -BOOST_AUTO_TEST_CASE(float_inequality_operators) { +BOOST_AUTO_TEST_CASE(float_inequality_operators) +{ // Test inequality operator, which is based on equality operator fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(127.0); - fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 1.19e-5f); + fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 1.19e-5f); BOOST_CHECK(alpha != beta); BOOST_CHECK(alpha != float(alpha._value + 1.19e-5f)); } -BOOST_AUTO_TEST_CASE(double_inequality_operators) { +BOOST_AUTO_TEST_CASE(double_inequality_operators) +{ // Test inequality operator, which is based on equality operator fp_compare_epsilon<double> alpha = fp_compare_epsilon<double>(1.0); fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value + 1.19e-10); @@ -107,10 +112,11 @@ BOOST_AUTO_TEST_CASE(double_inequality_operators) { BOOST_CHECK(alpha != double(alpha._value + 1.19e-10)); } -BOOST_AUTO_TEST_CASE(float_lessthan_operators) { +BOOST_AUTO_TEST_CASE(float_lessthan_operators) +{ // Test less-than operator fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(274192.7f); - fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value - 0.15f); + fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value - 0.15f); BOOST_CHECK(beta < alpha); BOOST_CHECK(float(alpha._value - 0.15) < alpha); @@ -118,29 +124,32 @@ BOOST_AUTO_TEST_CASE(float_lessthan_operators) { // Confirm false less-than case fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value - 1.2f); - BOOST_CHECK(not (alpha < charlie)); - BOOST_CHECK(not (alpha < float(alpha._value - 1.2f))); + BOOST_CHECK(not(alpha < charlie)); + BOOST_CHECK(not(alpha < float(alpha._value - 1.2f))); } -BOOST_AUTO_TEST_CASE(double_lessthan_operators) { +BOOST_AUTO_TEST_CASE(double_lessthan_operators) +{ // Test less-than operator fp_compare_epsilon<double> alpha = fp_compare_epsilon<double>(274192856.762312); - fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value - 0.0002); + fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value - 0.0002); BOOST_CHECK(beta < alpha); BOOST_CHECK(double(alpha._value - 0.0002) < alpha); // Confirm false less-than case - fp_compare_epsilon<double> charlie = fp_compare_epsilon<double>(alpha._value - 1.0012); + fp_compare_epsilon<double> charlie = + fp_compare_epsilon<double>(alpha._value - 1.0012); - BOOST_CHECK(not (alpha < charlie)); - BOOST_CHECK(not (alpha < double(alpha._value - 1.0012))); + BOOST_CHECK(not(alpha < charlie)); + BOOST_CHECK(not(alpha < double(alpha._value - 1.0012))); } -BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) { +BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) +{ // Test that <= correctly reports for equal values fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(827.3f); - fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); + fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); BOOST_CHECK(alpha <= beta); BOOST_CHECK(alpha <= float(alpha._value)); @@ -152,25 +161,28 @@ BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) { BOOST_CHECK(float(alpha._value - 1.2) <= alpha); } -BOOST_AUTO_TEST_CASE(double_lessthanequals_operators) { +BOOST_AUTO_TEST_CASE(double_lessthanequals_operators) +{ // Test that <= correctly reports for equal values fp_compare_epsilon<double> alpha = fp_compare_epsilon<double>(837652123.383764); - fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); + fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); BOOST_CHECK(alpha <= beta); BOOST_CHECK(alpha <= double(alpha._value)); // Test that <= correctly reports for less-than values - fp_compare_epsilon<double> charlie = fp_compare_epsilon<double>(alpha._value - 0.0012); + fp_compare_epsilon<double> charlie = + fp_compare_epsilon<double>(alpha._value - 0.0012); BOOST_CHECK(charlie <= alpha); BOOST_CHECK(double(alpha._value - 0.0012) <= alpha); } -BOOST_AUTO_TEST_CASE(float_greaterthan_operators) { +BOOST_AUTO_TEST_CASE(float_greaterthan_operators) +{ // Test basic greater-than functionality fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(98325.4f); - fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 0.15f); + fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 0.15f); BOOST_CHECK(beta > alpha); BOOST_CHECK(float(alpha._value + 0.15) > alpha); @@ -178,29 +190,32 @@ BOOST_AUTO_TEST_CASE(float_greaterthan_operators) { // Test false greater-than case fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value + 1.2f); - BOOST_CHECK(not (alpha > charlie)); - BOOST_CHECK(not (alpha > float(alpha._value + 1.2f))); + BOOST_CHECK(not(alpha > charlie)); + BOOST_CHECK(not(alpha > float(alpha._value + 1.2f))); } -BOOST_AUTO_TEST_CASE(double_greaterthan_operators) { +BOOST_AUTO_TEST_CASE(double_greaterthan_operators) +{ // Test basic greater-than functionality fp_compare_epsilon<double> alpha = fp_compare_epsilon<double>(643907213.428475); - fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value + 0.0002); + fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value + 0.0002); BOOST_CHECK(beta > alpha); BOOST_CHECK(double(alpha._value + 0.0002) > alpha); // Test false greater-than case - fp_compare_epsilon<double> charlie = fp_compare_epsilon<double>(alpha._value + 0.0012); + fp_compare_epsilon<double> charlie = + fp_compare_epsilon<double>(alpha._value + 0.0012); - BOOST_CHECK(not (alpha > charlie)); - BOOST_CHECK(not (alpha > double(alpha._value + 0.0012))); + BOOST_CHECK(not(alpha > charlie)); + BOOST_CHECK(not(alpha > double(alpha._value + 0.0012))); } -BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) { +BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) +{ // Test that >= correctly reports for equal values fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(7834.89f); - fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); + fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value); BOOST_CHECK(alpha >= beta); BOOST_CHECK(alpha >= float(alpha._value)); @@ -212,16 +227,18 @@ BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) { BOOST_CHECK(float(alpha._value + 4.8f) >= alpha); } -BOOST_AUTO_TEST_CASE(double_greaterthanequals_operators) { +BOOST_AUTO_TEST_CASE(double_greaterthanequals_operators) +{ // Test that >= correctly reports for equal values fp_compare_epsilon<double> alpha = fp_compare_epsilon<double>(737623834.89843); - fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); + fp_compare_epsilon<double> beta = fp_compare_epsilon<double>(alpha._value); BOOST_CHECK(alpha >= beta); BOOST_CHECK(alpha >= double(alpha._value)); // Test that >= correctly reports for greater-than values - fp_compare_epsilon<double> charlie = fp_compare_epsilon<double>(alpha._value + 3.0008); + fp_compare_epsilon<double> charlie = + fp_compare_epsilon<double>(alpha._value + 3.0008); BOOST_CHECK(charlie >= alpha); BOOST_CHECK(double(alpha._value + 3.0008) >= alpha); diff --git a/host/tests/gain_group_test.cpp b/host/tests/gain_group_test.cpp index b8c15b479..2608f292d 100644 --- a/host/tests/gain_group_test.cpp +++ b/host/tests/gain_group_test.cpp @@ -5,10 +5,10 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/utils/gain_group.hpp> #include <boost/bind.hpp> #include <boost/math/special_functions/round.hpp> +#include <boost/test/unit_test.hpp> #include <iostream> #define rint(x) boost::math::iround(x) @@ -18,56 +18,63 @@ using namespace uhd; /*********************************************************************** * Define gain element classes with needed functions **********************************************************************/ -class gain_element1{ +class gain_element1 +{ public: - - gain_range_t get_range(void){ + gain_range_t get_range(void) + { return gain_range_t(0, 90, 1); } - double get_value(void){ + double get_value(void) + { return _gain; } - void set_value(double gain){ + void set_value(double gain) + { double step = get_range().step(); - _gain = step*rint(gain/step); + _gain = step * rint(gain / step); } private: double _gain; }; -class gain_element2{ +class gain_element2 +{ public: - - gain_range_t get_range(void){ + gain_range_t get_range(void) + { return gain_range_t(-20, 10, 0.1); } - double get_value(void){ + double get_value(void) + { return _gain; } - void set_value(double gain){ + void set_value(double gain) + { double step = get_range().step(); - _gain = step*rint(gain/step); + _gain = step * rint(gain / step); } private: double _gain; }; -//create static instances of gain elements to be shared by the tests +// create static instances of gain elements to be shared by the tests static gain_element1 g1; static gain_element2 g2; -static gain_group::sptr get_gain_group(size_t pri1 = 0, size_t pri2 = 0){ - //create instance of gain group +static gain_group::sptr get_gain_group(size_t pri1 = 0, size_t pri2 = 0) +{ + // create instance of gain group gain_fcns_t gain_fcns; gain_group::sptr gg(gain_group::make()); - //load gain group with function sets + // load gain group with function sets gain_fcns.get_range = boost::bind(&gain_element1::get_range, &g1); gain_fcns.get_value = boost::bind(&gain_element1::get_value, &g1); gain_fcns.set_value = boost::bind(&gain_element1::set_value, &g1, _1); @@ -86,10 +93,11 @@ static gain_group::sptr get_gain_group(size_t pri1 = 0, size_t pri2 = 0){ **********************************************************************/ static const double tolerance = 0.001; -BOOST_AUTO_TEST_CASE(test_gain_group_overall){ +BOOST_AUTO_TEST_CASE(test_gain_group_overall) +{ gain_group::sptr gg = get_gain_group(); - //test the overall stuff + // test the overall stuff gg->set_value(80); BOOST_CHECK_CLOSE(gg->get_value(), 80.0, tolerance); BOOST_CHECK_CLOSE(gg->get_range().start(), -20.0, tolerance); @@ -97,16 +105,17 @@ BOOST_AUTO_TEST_CASE(test_gain_group_overall){ BOOST_CHECK_CLOSE(gg->get_range().step(), 0.1, tolerance); } -BOOST_AUTO_TEST_CASE(test_gain_group_priority){ +BOOST_AUTO_TEST_CASE(test_gain_group_priority) +{ gain_group::sptr gg = get_gain_group(0, 1); - //test the overall stuff + // test the overall stuff gg->set_value(80); BOOST_CHECK_CLOSE(gg->get_value(), 80.0, tolerance); BOOST_CHECK_CLOSE(gg->get_range().start(), -20.0, tolerance); BOOST_CHECK_CLOSE(gg->get_range().stop(), 100.0, tolerance); BOOST_CHECK_CLOSE(gg->get_range().step(), 0.1, tolerance); - //test the the higher priority gain got filled first (gain 2) + // test the the higher priority gain got filled first (gain 2) BOOST_CHECK_CLOSE(g2.get_value(), g2.get_range().stop(), tolerance); } diff --git a/host/tests/graph.hpp b/host/tests/graph.hpp index 50a87d307..fb36ae510 100644 --- a/host/tests/graph.hpp +++ b/host/tests/graph.hpp @@ -15,23 +15,28 @@ #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 +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) {}; + test_node(const std::string& test_id) : _test_id(test_id){}; - void issue_stream_cmd(const uhd::stream_cmd_t &, const size_t) {/* nop */}; + void issue_stream_cmd(const uhd::stream_cmd_t&, const size_t){/* nop */}; - std::string get_test_id() const { return _test_id; }; + 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) +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); diff --git a/host/tests/graph_search_test.cpp b/host/tests/graph_search_test.cpp index 8d35b3b1a..932647d98 100644 --- a/host/tests/graph_search_test.cpp +++ b/host/tests/graph_search_test.cpp @@ -17,7 +17,7 @@ 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) {}; + result_node(const std::string& test_id) : test_node(test_id){}; }; /* class result_node */ @@ -49,12 +49,12 @@ BOOST_AUTO_TEST_CASE(test_simple_downstream_search) 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>(); + 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") - ); + (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); } @@ -69,11 +69,11 @@ BOOST_AUTO_TEST_CASE(test_linear_downstream_search) 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::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) { + for (const result_node::sptr& node : result) { std::cout << node->get_test_id() << std::endl; } } @@ -99,9 +99,9 @@ BOOST_AUTO_TEST_CASE(test_multi_iter_downstream_search) 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>(); + 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) { + for (const result_node::sptr& node : result) { std::cout << node->get_test_id() << std::endl; } } @@ -120,7 +120,8 @@ BOOST_AUTO_TEST_CASE(test_multi_iter_cycle_downstream_search) // 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_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); @@ -128,9 +129,9 @@ BOOST_AUTO_TEST_CASE(test_multi_iter_cycle_downstream_search) 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>(); + 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) { + for (const result_node::sptr& node : result) { std::cout << node->get_test_id() << std::endl; } } @@ -141,9 +142,10 @@ BOOST_AUTO_TEST_CASE(test_mini_cycle_downstream_and_upstream) MAKE_NODE(node_B); // Connect them in a loop - connect_nodes(node_A, node_B); connect_nodes(node_B, node_A); + connect_nodes(node_A, node_B); + connect_nodes(node_B, node_A); - std::vector< test_node::sptr > result; + 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); diff --git a/host/tests/log_test.cpp b/host/tests/log_test.cpp index 5e3ce0199..d9eae09f1 100644 --- a/host/tests/log_test.cpp +++ b/host/tests/log_test.cpp @@ -5,34 +5,25 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/utils/log.hpp> #include <uhd/utils/log_add.hpp> +#include <boost/test/unit_test.hpp> #include <iostream> -BOOST_AUTO_TEST_CASE(test_messages){ +BOOST_AUTO_TEST_CASE(test_messages) +{ UHD_LOG_FASTPATH("foo"); UHD_LOG_FASTPATH("bar"); uhd::log::set_log_level(uhd::log::debug); uhd::log::set_console_level(uhd::log::info); - uhd::log::add_logger("test", - [](const uhd::log::logging_info &I){ - std::cout << "<TEST> " << I.message << std::endl; - } - ); + uhd::log::add_logger("test", [](const uhd::log::logging_info& I) { + std::cout << "<TEST> " << I.message << std::endl; + }); uhd::log::set_logger_level("test", uhd::log::debug); - UHD_LOGGER_DEBUG("logger_test") << - "This is a test print for a debug log." - ; - UHD_LOGGER_INFO("logger_test") << - "This is a test print for a info log." - ; - UHD_LOGGER_WARNING("logger_test") << - "This is a test print for a warning log." - ; - UHD_LOGGER_ERROR("logger_test") << - "This is a test print for an error log." - ; + UHD_LOGGER_DEBUG("logger_test") << "This is a test print for a debug log."; + UHD_LOGGER_INFO("logger_test") << "This is a test print for a info log."; + UHD_LOGGER_WARNING("logger_test") << "This is a test print for a warning log."; + UHD_LOGGER_ERROR("logger_test") << "This is a test print for an error log."; UHD_HERE(); const int x = 42; UHD_VAR(x); diff --git a/host/tests/math_test.cpp b/host/tests/math_test.cpp index 131016091..ffdcbb086 100644 --- a/host/tests/math_test.cpp +++ b/host/tests/math_test.cpp @@ -5,15 +5,15 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> -#include <stdint.h> #include <uhd/utils/math.hpp> +#include <stdint.h> +#include <boost/test/unit_test.hpp> // NOTE: This is not the only math test case, see e.g. special tests // for fp comparison. -BOOST_AUTO_TEST_CASE(test_log2){ +BOOST_AUTO_TEST_CASE(test_log2) +{ double y = uhd::math::log2(16.0); BOOST_CHECK_EQUAL(y, 4.0); } - diff --git a/host/tests/module_test.cpp b/host/tests/module_test.cpp index 8914c56a1..c81d8563f 100644 --- a/host/tests/module_test.cpp +++ b/host/tests/module_test.cpp @@ -8,7 +8,8 @@ #include <uhd/utils/static.hpp> #include <iostream> -UHD_STATIC_BLOCK(module_test){ +UHD_STATIC_BLOCK(module_test) +{ std::cout << "---------------------------------------" << std::endl; std::cout << "-- Good news, everyone!" << std::endl; std::cout << "-- The test module has been loaded." << std::endl; diff --git a/host/tests/narrow_cast_test.cpp b/host/tests/narrow_cast_test.cpp index c108c310e..3ea7db1bf 100644 --- a/host/tests/narrow_cast_test.cpp +++ b/host/tests/narrow_cast_test.cpp @@ -11,11 +11,12 @@ using namespace uhd; -BOOST_AUTO_TEST_CASE(test_narrow){ +BOOST_AUTO_TEST_CASE(test_narrow) +{ uint16_t x = 5; - uint8_t y = narrow_cast<uint8_t>(x); + uint8_t y = narrow_cast<uint8_t>(x); BOOST_CHECK_EQUAL(x, y); - BOOST_CHECK_THROW(narrow<uint8_t>(uint16_t(1<<10)), narrowing_error); + BOOST_CHECK_THROW(narrow<uint8_t>(uint16_t(1 << 10)), narrowing_error); BOOST_CHECK_THROW(narrow<uint8_t>(int8_t(-1)), narrowing_error); } diff --git a/host/tests/nocscript_common.hpp b/host/tests/nocscript_common.hpp index 4176fec6f..ad254fa0e 100644 --- a/host/tests/nocscript_common.hpp +++ b/host/tests/nocscript_common.hpp @@ -11,15 +11,20 @@ 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 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 index 19b4345c2..ed5f6598d 100644 --- a/host/tests/nocscript_expr_test.cpp +++ b/host/tests/nocscript_expr_test.cpp @@ -6,16 +6,15 @@ // #include "../lib/rfnoc/nocscript/function_table.hpp" -#include <boost/test/unit_test.hpp> -#include <boost/test/floating_point_comparison.hpp> +#include "nocscript_common.hpp" #include <boost/bind.hpp> -#include <boost/make_shared.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> -#include "nocscript_common.hpp" - // We need this global variable for one of the later tests int and_counter = 0; @@ -65,15 +64,15 @@ BOOST_AUTO_TEST_CASE(test_literals) 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_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) +expression::type_t variable_get_type(const std::string& var_name) { if (var_name == "spp") { std::cout << "Returning type for $spp..." << std::endl; @@ -87,7 +86,7 @@ expression::type_t variable_get_type(const std::string &var_name) throw uhd::syntax_error("Cannot infer type (unknown variable)"); } -expression_literal variable_get_value(const std::string &var_name) +expression_literal variable_get_value(const std::string& var_name) { if (var_name == "spp") { std::cout << "Returning value for $spp..." << std::endl; @@ -103,18 +102,14 @@ expression_literal variable_get_value(const std::string &var_name) 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_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); @@ -123,23 +118,21 @@ BOOST_AUTO_TEST_CASE(test_variables) BOOST_AUTO_TEST_CASE(test_container) { // Create some sub-expressions: - expression_literal::sptr l_true = E(true); + expression_literal::sptr l_true = E(true); expression_literal::sptr l_false = E(false); - expression_literal::sptr l_int = E(5); + 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) - ); + 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_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; @@ -196,38 +189,32 @@ BOOST_AUTO_TEST_CASE(test_container) // be defined for INT and DOUBLE class functable_mockup_impl : public function_table { - public: - functable_mockup_impl(void) {}; +public: + functable_mockup_impl(void){}; - bool function_exists(const std::string &name) const { + 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 { + 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 - ) { + 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 - ) { + 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 - ) { + if (arg_types.size() == 2 and arg_types[0] == expression::TYPE_BOOL + and arg_types[1] == expression::TYPE_BOOL) { return true; } return false; @@ -236,15 +223,14 @@ class functable_mockup_impl : public function_table return false; } - expression::type_t get_type( - const std::string &name, - const expression_function::argtype_list_type &arg_types - ) const { + 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() - )); + 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") { @@ -256,58 +242,48 @@ class functable_mockup_impl : public function_table 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 - ) { + 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 + 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 - ) { + 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() - )); + 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 + 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 - ) { + 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() - )); + 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() - )); + 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"); } @@ -315,13 +291,10 @@ class functable_mockup_impl : public function_table } // 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 & - ) {}; - + void register_function(const std::string&, + const function_table::function_ptr&, + const expression::type_t, + const expression_function::argtype_list_type&){}; }; @@ -342,16 +315,20 @@ BOOST_AUTO_TEST_CASE(test_functable_mockup) 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("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_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) @@ -402,7 +379,7 @@ BOOST_AUTO_TEST_CASE(test_function_expression_laziness) f3->add(E(false)); BOOST_CHECK(not f3->eval().get_bool()); - and_counter = 0; + and_counter = 0; expression_function::sptr f1 = boost::make_shared<expression_function>("AND", ft); f1->add(f2); f1->add(f3); @@ -417,14 +394,12 @@ BOOST_AUTO_TEST_CASE(test_sptrs) 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 + 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 index 99ac2231a..36aa314f2 100644 --- a/host/tests/nocscript_ftable_test.cpp +++ b/host/tests/nocscript_ftable_test.cpp @@ -6,15 +6,14 @@ // #include "../lib/rfnoc/nocscript/function_table.hpp" -#include <boost/test/unit_test.hpp> -#include <boost/test/floating_point_comparison.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> -#include "nocscript_common.hpp" - BOOST_AUTO_TEST_CASE(test_basic_funcs) { function_table::sptr ft = function_table::make(); @@ -49,7 +48,7 @@ BOOST_AUTO_TEST_CASE(test_basic_funcs) 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_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); @@ -103,15 +102,11 @@ BOOST_AUTO_TEST_CASE(test_add_funcs) 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, - expression::TYPE_INT - }; - ft->register_function( - "ADD_PLUS_2", - boost::bind(&add_plus2_int, _1), - expression::TYPE_INT, - add_int_args - ); + add_int_args); BOOST_CHECK(ft->function_exists("ADD_PLUS_2")); BOOST_CHECK(ft->function_exists("ADD_PLUS_2", add_int_args)); @@ -144,22 +139,16 @@ 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 - ); + "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 - ); + "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); + 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); @@ -170,7 +159,8 @@ BOOST_AUTO_TEST_CASE(test_conditionals) 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); + 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; @@ -178,12 +168,14 @@ BOOST_AUTO_TEST_CASE(test_conditionals) 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); + 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_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()); @@ -191,11 +183,12 @@ BOOST_AUTO_TEST_CASE(test_conditionals) 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); + 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_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()); @@ -221,33 +214,35 @@ BOOST_AUTO_TEST_CASE(test_bitwise_funcs) // Bitwise Math int int_value1 = 0x2; int int_value2 = 0x3; - expression_container::expr_list_type two_int_values{ - E(int_value1), - E(int_value2) - }; + 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); + 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); + 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); + 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); + 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); + 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 index caa2ae6e0..eb9352995 100644 --- a/host/tests/nocscript_parser_test.cpp +++ b/host/tests/nocscript_parser_test.cpp @@ -7,21 +7,20 @@ #include "../lib/rfnoc/nocscript/function_table.hpp" #include "../lib/rfnoc/nocscript/parser.hpp" +#include "nocscript_common.hpp" #include <uhd/exception.hpp> -#include <boost/test/unit_test.hpp> -#include <boost/test/floating_point_comparison.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> -#include "nocscript_common.hpp" - const int SPP_VALUE = 64; // Need those for the variable testing: -expression::type_t variable_get_type(const std::string &var_name) +expression::type_t variable_get_type(const std::string& var_name) { if (var_name == "spp") { std::cout << "Returning type for $spp..." << std::endl; @@ -35,7 +34,7 @@ expression::type_t variable_get_type(const std::string &var_name) throw uhd::syntax_error("Cannot infer type (unknown variable)"); } -expression_literal variable_get_value(const std::string &var_name) +expression_literal variable_get_value(const std::string& var_name) { if (var_name == "spp") { std::cout << "Returning value for $spp..." << std::endl; @@ -49,13 +48,10 @@ expression_literal variable_get_value(const std::string &var_name) throw uhd::syntax_error("Cannot read value (unknown variable)"); } -#define SETUP_FT_AND_PARSER() \ +#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) \ - ); + parser::sptr p = parser::make( \ + ft, boost::bind(&variable_get_type, _1), boost::bind(&variable_get_value, _1)); BOOST_AUTO_TEST_CASE(test_fail) { @@ -79,11 +75,11 @@ BOOST_AUTO_TEST_CASE(test_adds_no_vars) 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::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_CHECK_EQUAL(result.get_int(), 1 + 2 + 3 + 4); } BOOST_AUTO_TEST_CASE(test_adds_with_vars) @@ -91,11 +87,11 @@ 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::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_CHECK_EQUAL(result.get_int(), 1 + 2 + SPP_VALUE); } BOOST_AUTO_TEST_CASE(test_fft_check) @@ -103,7 +99,7 @@ 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::sptr e = p->create_expr_tree(line); expression_literal result = e->eval(); BOOST_REQUIRE_EQUAL(result.infer_type(), expression::TYPE_BOOL); @@ -135,11 +131,7 @@ 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", boost::bind(&dummy_false, _1), expression::TYPE_BOOL, no_args); dummy_false_counter = 0; p->create_expr_tree("DUMMY(), DUMMY(), DUMMY()")->eval(); @@ -153,4 +145,3 @@ BOOST_AUTO_TEST_CASE(test_multi_commmand) 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 index dd3d8d08a..97d052a06 100644 --- a/host/tests/node_connect_test.cpp +++ b/host/tests/node_connect_test.cpp @@ -16,25 +16,22 @@ 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) {}; + 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; + 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 { + size_t _request_output_port(const size_t, const uhd::device_addr_t&) const + { return _output_port; } @@ -47,25 +44,22 @@ 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) {}; + 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; + 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 { + size_t _request_input_port(const size_t, const uhd::device_addr_t&) const + { return _input_port; } diff --git a/host/tests/packet_handler_benchmark.cpp b/host/tests/packet_handler_benchmark.cpp index 37c6861bb..21e1430ae 100644 --- a/host/tests/packet_handler_benchmark.cpp +++ b/host/tests/packet_handler_benchmark.cpp @@ -11,16 +11,16 @@ // This should have very little effect on packet handler performance. #define SRPH_DONT_CHECK_SEQUENCE 1 -#include "common/mock_zero_copy.hpp" -#include "../lib/transport/super_send_packet_handler.hpp" #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 <uhd/utils/safe_main.hpp> -#include <uhd/utils/thread.hpp> +#include "common/mock_zero_copy.hpp" #include <uhd/convert.hpp> #include <uhd/transport/chdr.hpp> #include <uhd/transport/zero_copy.hpp> #include <uhd/types/sid.hpp> +#include <uhd/utils/safe_main.hpp> +#include <uhd/utils/thread.hpp> #include <boost/program_options.hpp> #include <chrono> #include <vector> @@ -29,18 +29,13 @@ namespace po = boost::program_options; using namespace uhd::transport; using namespace uhd::usrp; -void benchmark_recv_packet_handler( - const size_t spp, - const std::string& format -) { - const size_t bpi = uhd::convert::get_bytes_per_item(format); +void benchmark_recv_packet_handler(const size_t spp, const std::string& format) +{ + const size_t bpi = uhd::convert::get_bytes_per_item(format); const size_t frame_size = bpi * spp + DEVICE3_RX_MAX_HDR_LEN; - mock_zero_copy::sptr xport( - new mock_zero_copy( - vrt::if_packet_info_t::LINK_TYPE_CHDR, - frame_size, - frame_size)); + mock_zero_copy::sptr xport(new mock_zero_copy( + vrt::if_packet_info_t::LINK_TYPE_CHDR, frame_size, frame_size)); xport->set_reuse_recv_memory(true); @@ -51,38 +46,35 @@ void benchmark_recv_packet_handler( uhd::convert::id_type id; id.output_format = format; - id.num_inputs = 1; - id.input_format = "sc16_item32_be"; - id.num_outputs = 1; + id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_outputs = 1; streamer.set_converter(id); - streamer.set_xport_chan_get_buff( - 0, - [xport](double timeout) { - return xport->get_recv_buff(timeout); - }, + streamer.set_xport_chan_get_buff(0, + [xport](double timeout) { return xport->get_recv_buff(timeout); }, false // flush ); // Create packet for packet handler to read vrt::if_packet_info_t packet_info; - packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; packet_info.num_payload_words32 = spp; - packet_info.num_payload_bytes = packet_info.num_payload_words32*sizeof(uint32_t); - packet_info.has_tsf = true; - packet_info.tsf = 1; + packet_info.num_payload_bytes = packet_info.num_payload_words32 * sizeof(uint32_t); + packet_info.has_tsf = true; + packet_info.tsf = 1; std::vector<uint32_t> recv_data(spp, 0); xport->push_back_recv_packet(packet_info, recv_data); // Allocate buffer - std::vector<uint8_t> buffer(spp*bpi); + std::vector<uint8_t> buffer(spp * bpi); std::vector<void*> buffers; buffers.push_back(buffer.data()); // Run benchmark uhd::rx_metadata_t md; - const auto start_time = std::chrono::steady_clock::now(); + const auto start_time = std::chrono::steady_clock::now(); const size_t iterations = 1e7; for (size_t i = 0; i < iterations; i++) { @@ -90,29 +82,21 @@ void benchmark_recv_packet_handler( } const auto end_time = std::chrono::steady_clock::now(); - const std::chrono::duration<double> elapsed_time(end_time-start_time); + const std::chrono::duration<double> elapsed_time(end_time - start_time); const double time_per_packet = elapsed_time.count() / iterations; - std::cout << format << ": " - << time_per_packet / spp * 1e9 - << " ns/sample, " - << time_per_packet * 1e9 - << " ns/packet\n"; + std::cout << format << ": " << time_per_packet / spp * 1e9 << " ns/sample, " + << time_per_packet * 1e9 << " ns/packet\n"; } void benchmark_send_packet_handler( - const size_t spp, - const std::string& format, - bool use_time_spec -) { - const size_t bpi = uhd::convert::get_bytes_per_item(format); + const size_t spp, const std::string& format, bool use_time_spec) +{ + const size_t bpi = uhd::convert::get_bytes_per_item(format); const size_t frame_size = bpi * spp + DEVICE3_TX_MAX_HDR_LEN; - mock_zero_copy::sptr xport( - new mock_zero_copy( - vrt::if_packet_info_t::LINK_TYPE_CHDR, - frame_size, - frame_size)); + mock_zero_copy::sptr xport(new mock_zero_copy( + vrt::if_packet_info_t::LINK_TYPE_CHDR, frame_size, frame_size)); xport->set_reuse_send_memory(true); @@ -120,21 +104,18 @@ void benchmark_send_packet_handler( streamer.set_vrt_packer(&vrt::chdr::if_hdr_pack_be); uhd::convert::id_type id; - id.input_format = format; - id.num_inputs = 1; + id.input_format = format; + id.num_inputs = 1; id.output_format = "sc16_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; streamer.set_converter(id); streamer.set_enable_trailer(false); streamer.set_xport_chan_get_buff( - 0, - [xport](double timeout) { - return xport->get_send_buff(timeout); - }); + 0, [xport](double timeout) { return xport->get_send_buff(timeout); }); // Allocate buffer - std::vector<uint8_t> buffer(spp*bpi); + std::vector<uint8_t> buffer(spp * bpi); std::vector<void*> buffers; buffers.push_back(buffer.data()); @@ -142,7 +123,7 @@ void benchmark_send_packet_handler( uhd::tx_metadata_t md; md.has_time_spec = use_time_spec; - const auto start_time = std::chrono::steady_clock::now(); + const auto start_time = std::chrono::steady_clock::now(); const size_t iterations = 1e7; for (size_t i = 0; i < iterations; i++) { @@ -153,44 +134,38 @@ void benchmark_send_packet_handler( } const auto end_time = std::chrono::steady_clock::now(); - const std::chrono::duration<double> elapsed_time(end_time-start_time); + const std::chrono::duration<double> elapsed_time(end_time - start_time); const double time_per_packet = elapsed_time.count() / iterations; - std::cout << format << ": " - << time_per_packet / spp * 1e9 - << " ns/sample, " - << time_per_packet * 1e9 - << " ns/packet\n"; + std::cout << format << ": " << time_per_packet / spp * 1e9 << " ns/sample, " + << time_per_packet * 1e9 << " ns/packet\n"; } -void benchmark_device3_rx_flow_ctrl( - bool send_flow_control_packet -) { +void benchmark_device3_rx_flow_ctrl(bool send_flow_control_packet) +{ // Arbitrary sizes constexpr uint32_t fc_window = 10000; - mock_zero_copy::sptr xport( - new mock_zero_copy( - vrt::if_packet_info_t::LINK_TYPE_CHDR)); + mock_zero_copy::sptr xport(new mock_zero_copy(vrt::if_packet_info_t::LINK_TYPE_CHDR)); xport->set_reuse_recv_memory(true); xport->set_reuse_send_memory(true); boost::shared_ptr<rx_fc_cache_t> fc_cache(new rx_fc_cache_t()); - fc_cache->to_host = uhd::ntohx<uint32_t>; + fc_cache->to_host = uhd::ntohx<uint32_t>; fc_cache->from_host = uhd::htonx<uint32_t>; - fc_cache->pack = vrt::chdr::if_hdr_pack_be; - fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; - fc_cache->xport = xport; - fc_cache->interval = fc_window; + fc_cache->pack = vrt::chdr::if_hdr_pack_be; + fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; + fc_cache->xport = xport; + fc_cache->interval = fc_window; // Create data buffer to pass to flow control function. Number of payload // words is arbitrary, just has to fit in the buffer. vrt::if_packet_info_t packet_info; - packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; packet_info.num_payload_words32 = 100; - packet_info.num_payload_bytes = packet_info.num_payload_words32*sizeof(uint32_t); - packet_info.has_tsf = false; + packet_info.num_payload_bytes = packet_info.num_payload_words32 * sizeof(uint32_t); + packet_info.has_tsf = false; std::vector<uint32_t> recv_data(packet_info.num_payload_words32, 0); xport->push_back_recv_packet(packet_info, recv_data); @@ -203,46 +178,44 @@ void benchmark_device3_rx_flow_ctrl( constexpr size_t iterations = 1e7; for (size_t i = 0; i < iterations; i++) { - fc_cache->total_bytes_consumed = send_flow_control_packet? fc_window:0; - fc_cache->last_byte_count = 0; + fc_cache->total_bytes_consumed = send_flow_control_packet ? fc_window : 0; + fc_cache->last_byte_count = 0; rx_flow_ctrl(fc_cache, recv_buffer); } const auto end_time = std::chrono::steady_clock::now(); - const std::chrono::duration<double> elapsed_time(end_time-start_time); + const std::chrono::duration<double> elapsed_time(end_time - start_time); - std::cout << elapsed_time.count() / iterations * 1e9 - << " ns per call\n"; + std::cout << elapsed_time.count() / iterations * 1e9 << " ns per call\n"; } -void benchmark_device3_handle_rx_flow_ctrl_ack() { +void benchmark_device3_handle_rx_flow_ctrl_ack() +{ // Arbitrary sizes constexpr uint32_t fc_window = 10000; - mock_zero_copy::sptr xport( - new mock_zero_copy( - vrt::if_packet_info_t::LINK_TYPE_CHDR)); + mock_zero_copy::sptr xport(new mock_zero_copy(vrt::if_packet_info_t::LINK_TYPE_CHDR)); xport->set_reuse_recv_memory(true); xport->set_reuse_send_memory(true); boost::shared_ptr<rx_fc_cache_t> fc_cache(new rx_fc_cache_t()); - fc_cache->to_host = uhd::ntohx<uint32_t>; - fc_cache->from_host = uhd::htonx<uint32_t>; - fc_cache->pack = vrt::chdr::if_hdr_pack_be; - fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; - fc_cache->xport = xport; - fc_cache->interval = fc_window; + fc_cache->to_host = uhd::ntohx<uint32_t>; + fc_cache->from_host = uhd::htonx<uint32_t>; + fc_cache->pack = vrt::chdr::if_hdr_pack_be; + fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; + fc_cache->xport = xport; + fc_cache->interval = fc_window; fc_cache->total_bytes_consumed = 100; // Payload should contain packet count and byte count std::vector<uint32_t> payload_data; - payload_data.push_back(fc_cache->to_host(10)); // packet count + payload_data.push_back(fc_cache->to_host(10)); // packet count payload_data.push_back(fc_cache->to_host(100)); // byte count // Run benchmark - const auto start_time = std::chrono::steady_clock::now(); + const auto start_time = std::chrono::steady_clock::now(); constexpr size_t iterations = 1e7; for (size_t i = 0; i < iterations; i++) { @@ -250,75 +223,66 @@ void benchmark_device3_handle_rx_flow_ctrl_ack() { } const auto end_time = std::chrono::steady_clock::now(); - const std::chrono::duration<double> elapsed_time(end_time-start_time); + const std::chrono::duration<double> elapsed_time(end_time - start_time); - std::cout << elapsed_time.count() / iterations * 1e9 - << " ns per call\n"; + std::cout << elapsed_time.count() / iterations * 1e9 << " ns per call\n"; } -void benchmark_device3_tx_flow_ctrl( - bool send_flow_control_packet -) { +void benchmark_device3_tx_flow_ctrl(bool send_flow_control_packet) +{ // Arbitrary sizes constexpr uint32_t fc_window = 10000; - mock_zero_copy::sptr xport( - new mock_zero_copy( - vrt::if_packet_info_t::LINK_TYPE_CHDR)); + mock_zero_copy::sptr xport(new mock_zero_copy(vrt::if_packet_info_t::LINK_TYPE_CHDR)); xport->set_reuse_recv_memory(true); - boost::shared_ptr<tx_fc_cache_t> - fc_cache(new tx_fc_cache_t(fc_window)); + boost::shared_ptr<tx_fc_cache_t> fc_cache(new tx_fc_cache_t(fc_window)); - fc_cache->to_host = uhd::ntohx<uint32_t>; + fc_cache->to_host = uhd::ntohx<uint32_t>; fc_cache->from_host = uhd::htonx<uint32_t>; - fc_cache->pack = vrt::chdr::if_hdr_pack_be; - fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; + fc_cache->pack = vrt::chdr::if_hdr_pack_be; + fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; xport->push_back_flow_ctrl_packet( - vrt::if_packet_info_t::PACKET_TYPE_FC, - 1 /*packet*/, - fc_window /*bytes*/); + vrt::if_packet_info_t::PACKET_TYPE_FC, 1 /*packet*/, fc_window /*bytes*/); // Run benchmark - const auto start_time = std::chrono::steady_clock::now(); - constexpr size_t iterations = 1e7; + const auto start_time = std::chrono::steady_clock::now(); + constexpr size_t iterations = 1e7; managed_send_buffer::sptr send_buffer = xport->get_send_buff(0.0); for (size_t i = 0; i < iterations; i++) { - fc_cache->byte_count = send_flow_control_packet? fc_window:0; + fc_cache->byte_count = send_flow_control_packet ? fc_window : 0; fc_cache->last_byte_ack = 0; tx_flow_ctrl(fc_cache, xport, send_buffer); } const auto end_time = std::chrono::steady_clock::now(); - const std::chrono::duration<double> elapsed_time(end_time-start_time); + const std::chrono::duration<double> elapsed_time(end_time - start_time); - std::cout << elapsed_time.count() / iterations * 1e9 - << " ns per call\n"; + std::cout << elapsed_time.count() / iterations * 1e9 << " ns per call\n"; } -void benchmark_device3_tx_flow_ctrl_ack() { +void benchmark_device3_tx_flow_ctrl_ack() +{ // Arbitrary sizes constexpr uint32_t fc_window = 10000; - mock_zero_copy::sptr xport( - new mock_zero_copy( - vrt::if_packet_info_t::LINK_TYPE_CHDR)); + mock_zero_copy::sptr xport(new mock_zero_copy(vrt::if_packet_info_t::LINK_TYPE_CHDR)); xport->set_reuse_send_memory(true); boost::shared_ptr<tx_fc_cache_t> fc_cache(new tx_fc_cache_t(fc_window)); - fc_cache->to_host = uhd::ntohx<uint32_t>; + fc_cache->to_host = uhd::ntohx<uint32_t>; fc_cache->from_host = uhd::htonx<uint32_t>; - fc_cache->pack = vrt::chdr::if_hdr_pack_be; - fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; + fc_cache->pack = vrt::chdr::if_hdr_pack_be; + fc_cache->unpack = vrt::chdr::if_hdr_unpack_be; // Run benchmark - const auto start_time = std::chrono::steady_clock::now(); + const auto start_time = std::chrono::steady_clock::now(); constexpr size_t iterations = 1e7; uhd::sid_t send_sid; @@ -330,18 +294,15 @@ void benchmark_device3_tx_flow_ctrl_ack() { } const auto end_time = std::chrono::steady_clock::now(); - const std::chrono::duration<double> elapsed_time(end_time-start_time); + const std::chrono::duration<double> elapsed_time(end_time - start_time); - std::cout << elapsed_time.count() / iterations * 1e9 - << " ns per call\n"; + std::cout << elapsed_time.count() / iterations * 1e9 << " ns per call\n"; } -int UHD_SAFE_MAIN(int argc, char *argv[]) +int UHD_SAFE_MAIN(int argc, char* argv[]) { po::options_description desc("Allowed options"); - desc.add_options() - ("help", "help message") - ; + desc.add_options()("help", "help message"); po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); @@ -350,17 +311,17 @@ int UHD_SAFE_MAIN(int argc, char *argv[]) // Print the help message if (vm.count("help")) { std::cout << boost::format("UHD Packet Handler Benchmark %s") % desc << std::endl; - std::cout << - " Benchmark of send and receive packet handlers and flow control\n" - " functions. All benchmarks use mock transport objects. No\n" - " parameters are needed to run this benchmark.\n" - << std::endl; + std::cout + << " Benchmark of send and receive packet handlers and flow control\n" + " functions. All benchmarks use mock transport objects. No\n" + " parameters are needed to run this benchmark.\n" + << std::endl; return EXIT_FAILURE; } uhd::set_thread_priority_safe(); - const char* formats[] = {"sc16", "fc32", "fc64" }; + const char* formats[] = {"sc16", "fc32", "fc64"}; constexpr size_t rx_spp = 2000; constexpr size_t tx_spp = 1000; diff --git a/host/tests/paths_test.cpp b/host/tests/paths_test.cpp index 0ccebd333..ef10414c7 100644 --- a/host/tests/paths_test.cpp +++ b/host/tests/paths_test.cpp @@ -8,12 +8,13 @@ #include <uhd/exception.hpp> #include <uhd/utils/paths.hpp> #include <uhdlib/utils/paths.hpp> -#include <boost/test/unit_test.hpp> #include <boost/filesystem/operations.hpp> -#include <vector> +#include <boost/test/unit_test.hpp> #include <iostream> +#include <vector> -BOOST_AUTO_TEST_CASE(test_paths_expandvars) { +BOOST_AUTO_TEST_CASE(test_paths_expandvars) +{ #ifdef UHD_PLATFORM_WIN32 const std::string path_to_expand("\%programdata%/uhd/uhd.conf"); #else @@ -21,8 +22,8 @@ BOOST_AUTO_TEST_CASE(test_paths_expandvars) { #endif const std::string expanded_path = uhd::path_expandvars(path_to_expand); - std::cout << "Expanded path: " << path_to_expand << " -> " - << expanded_path << std::endl; + std::cout << "Expanded path: " << path_to_expand << " -> " << expanded_path + << std::endl; BOOST_CHECK(path_to_expand != expanded_path); #ifdef UHD_PLATFORM_WIN32 @@ -35,13 +36,14 @@ BOOST_AUTO_TEST_CASE(test_paths_expandvars) { } -BOOST_AUTO_TEST_CASE(test_get_paths) { +BOOST_AUTO_TEST_CASE(test_get_paths) +{ using namespace uhd; const std::string tmp_path = get_tmp_path(); const std::string app_path = get_app_path(); const std::string pkg_path = get_pkg_path(); - const auto module_paths = get_module_paths(); + const auto module_paths = get_module_paths(); std::cout << "tmp_path: " << tmp_path << std::endl; std::cout << "app_path: " << app_path << std::endl; @@ -51,22 +53,14 @@ BOOST_AUTO_TEST_CASE(test_get_paths) { } const std::string images_dir_search_path = ""; - const std::string images_dir = get_images_dir(images_dir_search_path); + const std::string images_dir = get_images_dir(images_dir_search_path); BOOST_REQUIRE_THROW( - find_image_path("this_device_does_not_exist.bit", ""), - uhd::io_error - ); + find_image_path("this_device_does_not_exist.bit", ""), uhd::io_error); - const std::string utility_path = find_utility( - "uhd_images_downloader" - ); + const std::string utility_path = find_utility("uhd_images_downloader"); std::cout << "utility_path: " << utility_path << std::endl; - const std::string utility_error = print_utility_error( - "uhd_images_downloader", - "--help" - ); + const std::string utility_error = + print_utility_error("uhd_images_downloader", "--help"); std::cout << "utility_error: " << tmp_path << std::endl; - } - diff --git a/host/tests/property_test.cpp b/host/tests/property_test.cpp index 3daeed510..b2086f288 100644 --- a/host/tests/property_test.cpp +++ b/host/tests/property_test.cpp @@ -5,22 +5,26 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/property_tree.hpp> #include <boost/bind.hpp> +#include <boost/test/unit_test.hpp> #include <exception> #include <iostream> -struct coercer_type{ - int doit(int x){ +struct coercer_type +{ + int doit(int x) + { return x & ~0x3; } }; -struct setter_type{ +struct setter_type +{ setter_type() : _count(0), _x(0) {} - void doit(int x){ + void doit(int x) + { _count++; _x = x; } @@ -29,10 +33,12 @@ struct setter_type{ int _x; }; -struct getter_type{ +struct getter_type +{ getter_type() : _count(0), _x(0) {} - int doit(void){ + int doit(void) + { _count++; return _x; } @@ -41,9 +47,10 @@ struct getter_type{ int _x; }; -BOOST_AUTO_TEST_CASE(test_prop_simple){ +BOOST_AUTO_TEST_CASE(test_prop_simple) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); - uhd::property<int> &prop = tree->create<int>("/"); + uhd::property<int>& prop = tree->create<int>("/"); BOOST_CHECK(prop.empty()); prop.set(0); @@ -55,9 +62,10 @@ BOOST_AUTO_TEST_CASE(test_prop_simple){ BOOST_CHECK_EQUAL(prop.get(), 34); } -BOOST_AUTO_TEST_CASE(test_prop_with_desired_subscriber){ +BOOST_AUTO_TEST_CASE(test_prop_with_desired_subscriber) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); - uhd::property<int> &prop = tree->create<int>("/"); + uhd::property<int>& prop = tree->create<int>("/"); setter_type setter; prop.add_desired_subscriber(boost::bind(&setter_type::doit, &setter, _1)); @@ -73,9 +81,10 @@ BOOST_AUTO_TEST_CASE(test_prop_with_desired_subscriber){ BOOST_CHECK_EQUAL(setter._x, 34); } -BOOST_AUTO_TEST_CASE(test_prop_with_coerced_subscriber){ +BOOST_AUTO_TEST_CASE(test_prop_with_coerced_subscriber) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); - uhd::property<int> &prop = tree->create<int>("/"); + uhd::property<int>& prop = tree->create<int>("/"); setter_type setter; prop.add_coerced_subscriber(boost::bind(&setter_type::doit, &setter, _1)); @@ -91,9 +100,10 @@ BOOST_AUTO_TEST_CASE(test_prop_with_coerced_subscriber){ BOOST_CHECK_EQUAL(setter._x, 34); } -BOOST_AUTO_TEST_CASE(test_prop_manual_coercion){ +BOOST_AUTO_TEST_CASE(test_prop_manual_coercion) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); - uhd::property<int> &prop = tree->create<int>("/", uhd::property_tree::MANUAL_COERCE); + uhd::property<int>& prop = tree->create<int>("/", uhd::property_tree::MANUAL_COERCE); setter_type dsetter, csetter; prop.add_desired_subscriber(boost::bind(&setter_type::doit, &dsetter, _1)); @@ -114,9 +124,10 @@ BOOST_AUTO_TEST_CASE(test_prop_manual_coercion){ BOOST_CHECK_EQUAL(csetter._x, 34); } -BOOST_AUTO_TEST_CASE(test_prop_with_publisher){ +BOOST_AUTO_TEST_CASE(test_prop_with_publisher) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); - uhd::property<int> &prop = tree->create<int>("/"); + uhd::property<int>& prop = tree->create<int>("/"); BOOST_CHECK(prop.empty()); getter_type getter; @@ -124,17 +135,18 @@ BOOST_AUTO_TEST_CASE(test_prop_with_publisher){ BOOST_CHECK(not prop.empty()); getter._x = 42; - prop.set(0); //should not change + prop.set(0); // should not change BOOST_CHECK_EQUAL(prop.get(), 42); getter._x = 34; - prop.set(0); //should not change + prop.set(0); // should not change BOOST_CHECK_EQUAL(prop.get(), 34); } -BOOST_AUTO_TEST_CASE(test_prop_with_publisher_and_subscriber){ +BOOST_AUTO_TEST_CASE(test_prop_with_publisher_and_subscriber) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); - uhd::property<int> &prop = tree->create<int>("/"); + uhd::property<int>& prop = tree->create<int>("/"); getter_type getter; prop.set_publisher(boost::bind(&getter_type::doit, &getter)); @@ -153,9 +165,10 @@ BOOST_AUTO_TEST_CASE(test_prop_with_publisher_and_subscriber){ BOOST_CHECK_EQUAL(setter._x, 1); } -BOOST_AUTO_TEST_CASE(test_prop_with_coercion){ +BOOST_AUTO_TEST_CASE(test_prop_with_coercion) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); - uhd::property<int> &prop = tree->create<int>("/"); + uhd::property<int>& prop = tree->create<int>("/"); setter_type setter; prop.add_coerced_subscriber(boost::bind(&setter_type::doit, &setter, _1)); @@ -172,7 +185,8 @@ BOOST_AUTO_TEST_CASE(test_prop_with_coercion){ BOOST_CHECK_EQUAL(setter._x, 32); } -BOOST_AUTO_TEST_CASE(test_prop_tree){ +BOOST_AUTO_TEST_CASE(test_prop_tree) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); tree->create<int>("/test/prop0"); @@ -196,42 +210,43 @@ BOOST_AUTO_TEST_CASE(test_prop_tree){ tree->remove("/test"); BOOST_CHECK(not tree->exists("/test/prop0")); BOOST_CHECK(not tree->exists("/test/prop1")); - } -BOOST_AUTO_TEST_CASE(test_prop_subtree){ +BOOST_AUTO_TEST_CASE(test_prop_subtree) +{ uhd::property_tree::sptr tree = uhd::property_tree::make(); tree->create<int>("/subdir1/subdir2"); - uhd::property_tree::sptr subtree1 = tree->subtree("/"); - const std::vector<std::string> tree_dirs1 = tree->list("/"); + uhd::property_tree::sptr subtree1 = tree->subtree("/"); + const std::vector<std::string> tree_dirs1 = tree->list("/"); const std::vector<std::string> subtree1_dirs = subtree1->list(""); - BOOST_CHECK_EQUAL_COLLECTIONS(tree_dirs1.begin(), tree_dirs1.end(), subtree1_dirs.begin(), subtree1_dirs.end()); + BOOST_CHECK_EQUAL_COLLECTIONS( + tree_dirs1.begin(), tree_dirs1.end(), subtree1_dirs.begin(), subtree1_dirs.end()); - uhd::property_tree::sptr subtree2 = subtree1->subtree("subdir1"); - const std::vector<std::string> tree_dirs2 = tree->list("/subdir1"); + uhd::property_tree::sptr subtree2 = subtree1->subtree("subdir1"); + const std::vector<std::string> tree_dirs2 = tree->list("/subdir1"); const std::vector<std::string> subtree2_dirs = subtree2->list(""); - BOOST_CHECK_EQUAL_COLLECTIONS(tree_dirs2.begin(), tree_dirs2.end(), subtree2_dirs.begin(), subtree2_dirs.end()); - + BOOST_CHECK_EQUAL_COLLECTIONS( + tree_dirs2.begin(), tree_dirs2.end(), subtree2_dirs.begin(), subtree2_dirs.end()); } BOOST_AUTO_TEST_CASE(test_prop_operators) { uhd::fs_path path1 = "/root/"; - path1 = path1 / "leaf"; + path1 = path1 / "leaf"; BOOST_CHECK_EQUAL(path1, "/root/leaf"); uhd::fs_path path2 = "/root"; - path2 = path2 / "leaf"; + path2 = path2 / "leaf"; BOOST_CHECK_EQUAL(path2, "/root/leaf"); uhd::fs_path path3 = "/root/"; - path3 = path3 / "/leaf/"; + path3 = path3 / "/leaf/"; BOOST_CHECK_EQUAL(path3, "/root/leaf/"); uhd::fs_path path4 = "/root/"; - size_t x = 2; - path4 = path4 / x; + size_t x = 2; + path4 = path4 / x; BOOST_CHECK_EQUAL(path4, "/root/2"); } diff --git a/host/tests/ranges_test.cpp b/host/tests/ranges_test.cpp index fd6336a55..223560289 100644 --- a/host/tests/ranges_test.cpp +++ b/host/tests/ranges_test.cpp @@ -5,8 +5,8 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/types/ranges.hpp> +#include <boost/test/unit_test.hpp> #include <iostream> using namespace uhd; @@ -14,7 +14,8 @@ using namespace uhd; static const double tolerance = 0.001; // % -BOOST_AUTO_TEST_CASE(test_ranges_bounds){ +BOOST_AUTO_TEST_CASE(test_ranges_bounds) +{ meta_range_t mr; mr.push_back(range_t(-1.0, +1.0, 0.1)); BOOST_CHECK_CLOSE(mr.start(), -1.0, tolerance); @@ -33,7 +34,8 @@ BOOST_AUTO_TEST_CASE(test_ranges_bounds){ BOOST_CHECK_CLOSE(mr[0].step(), 0.1, tolerance); } -BOOST_AUTO_TEST_CASE(test_ranges_clip){ +BOOST_AUTO_TEST_CASE(test_ranges_clip) +{ meta_range_t mr; mr.push_back(range_t(-1.0, +1.0, 0.1)); mr.push_back(range_t(40.0, 60.0, 1.0)); @@ -47,7 +49,8 @@ BOOST_AUTO_TEST_CASE(test_ranges_clip){ BOOST_CHECK_CLOSE(mr.clip(50.9, true), 51.0, tolerance); } -BOOST_AUTO_TEST_CASE(test_meta_range_t_ctor){ +BOOST_AUTO_TEST_CASE(test_meta_range_t_ctor) +{ meta_range_t mr1(0.0, 10.0, 1.0); BOOST_CHECK_CLOSE(mr1.clip(5.0), 5.0, tolerance); BOOST_CHECK_CLOSE(mr1.clip(11.0), 10.0, tolerance); @@ -64,7 +67,8 @@ BOOST_AUTO_TEST_CASE(test_meta_range_t_ctor){ BOOST_CHECK_CLOSE(mr3.clip(5.1, true), 5.1, tolerance); } -BOOST_AUTO_TEST_CASE(test_ranges_clip2){ +BOOST_AUTO_TEST_CASE(test_ranges_clip2) +{ meta_range_t mr; mr.push_back(range_t(1.)); mr.push_back(range_t(2.)); @@ -77,7 +81,8 @@ BOOST_AUTO_TEST_CASE(test_ranges_clip2){ BOOST_CHECK_CLOSE(mr.clip(4., true), 3., tolerance); } -BOOST_AUTO_TEST_CASE(test_ranges_compare){ +BOOST_AUTO_TEST_CASE(test_ranges_compare) +{ range_t range(1); range_t n_range(1); range_t d_range(2); diff --git a/host/tests/rate_node_test.cpp b/host/tests/rate_node_test.cpp index f7e1bf30b..85502c325 100644 --- a/host/tests/rate_node_test.cpp +++ b/host/tests/rate_node_test.cpp @@ -18,7 +18,7 @@ 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) {}; + rate_aware_node(const std::string& test_id) : test_node(test_id){}; }; /* class rate_aware_node */ @@ -28,10 +28,17 @@ 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) {}; + 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; }; + double get_input_samp_rate(size_t) + { + return _samp_rate; + }; + double get_output_samp_rate(size_t) + { + return _samp_rate; + }; private: double _samp_rate; @@ -39,7 +46,8 @@ private: }; /* 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)); +#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) { @@ -126,4 +134,3 @@ BOOST_AUTO_TEST_CASE(test_skip_upstream_search) double result_rate = node_C->get_output_samp_rate(); BOOST_CHECK_EQUAL(result_rate, test_rate); } - diff --git a/host/tests/sensors_test.cpp b/host/tests/sensors_test.cpp index 2136ca13b..925f1a711 100644 --- a/host/tests/sensors_test.cpp +++ b/host/tests/sensors_test.cpp @@ -4,20 +4,16 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/types/sensors.hpp> +#include <boost/test/unit_test.hpp> #include <map> #include <string> using uhd::sensor_value_t; -BOOST_AUTO_TEST_CASE(test_sensor_bool) { - auto sensor_bool = sensor_value_t( - "bool_sensor", - true, - "true_unit", - "false_unit" - ); +BOOST_AUTO_TEST_CASE(test_sensor_bool) +{ + auto sensor_bool = sensor_value_t("bool_sensor", true, "true_unit", "false_unit"); BOOST_CHECK(sensor_bool.to_bool()); BOOST_CHECK_EQUAL(sensor_bool.unit, "true_unit"); @@ -34,11 +30,12 @@ BOOST_AUTO_TEST_CASE(test_sensor_bool) { } -BOOST_AUTO_TEST_CASE(test_sensor_real) { - const double sens_val = 2.25; +BOOST_AUTO_TEST_CASE(test_sensor_real) +{ + const double sens_val = 2.25; const std::string sens_units = "floats"; - const std::string sens_name = "real_sensor"; - auto sensor_real = sensor_value_t(sens_name, sens_val, sens_units); + const std::string sens_name = "real_sensor"; + auto sensor_real = sensor_value_t(sens_name, sens_val, sens_units); BOOST_CHECK_EQUAL(sensor_real.to_real(), sens_val); BOOST_CHECK_EQUAL(sensor_real.unit, sens_units); @@ -54,11 +51,12 @@ BOOST_AUTO_TEST_CASE(test_sensor_real) { BOOST_CHECK_EQUAL(sensor_real2.unit, sens_units); } -BOOST_AUTO_TEST_CASE(test_sensor_int) { - const int sens_val = 5; +BOOST_AUTO_TEST_CASE(test_sensor_int) +{ + const int sens_val = 5; const std::string sens_units = "ints"; - const std::string sens_name = "int_sensor"; - auto sensor_int = sensor_value_t(sens_name, sens_val, sens_units); + const std::string sens_name = "int_sensor"; + auto sensor_int = sensor_value_t(sens_name, sens_val, sens_units); BOOST_CHECK_EQUAL(sensor_int.to_int(), sens_val); BOOST_CHECK_EQUAL(sensor_int.unit, sens_units); @@ -74,11 +72,12 @@ BOOST_AUTO_TEST_CASE(test_sensor_int) { BOOST_CHECK_EQUAL(sensor_int2.unit, sens_units); } -BOOST_AUTO_TEST_CASE(test_sensor_string) { - const std::string sens_val = "foo"; +BOOST_AUTO_TEST_CASE(test_sensor_string) +{ + const std::string sens_val = "foo"; const std::string sens_units = "strings"; - const std::string sens_name = "str_sensor"; - auto sensor_str = sensor_value_t(sens_name, sens_val, sens_units); + const std::string sens_name = "str_sensor"; + auto sensor_str = sensor_value_t(sens_name, sens_val, sens_units); BOOST_CHECK_EQUAL(sensor_str.value, sens_val); BOOST_CHECK_EQUAL(sensor_str.unit, sens_units); @@ -97,6 +96,4 @@ BOOST_AUTO_TEST_CASE(test_sensor_string) { BOOST_CHECK_EQUAL(sensor_str2.value, sensor_str3.value); BOOST_CHECK_EQUAL(sensor_str2.unit, sensor_str3.unit); BOOST_CHECK_EQUAL(sensor_str2.type, sensor_str3.type); - } - diff --git a/host/tests/sid_t_test.cpp b/host/tests/sid_t_test.cpp index 1e643e059..85d33c45e 100644 --- a/host/tests/sid_t_test.cpp +++ b/host/tests/sid_t_test.cpp @@ -5,15 +5,16 @@ // 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> -#include <boost/test/unit_test.hpp> -#include <uhd/types/sid.hpp> -#include <uhd/exception.hpp> using uhd::sid_t; -BOOST_AUTO_TEST_CASE(test_sid_t) { +BOOST_AUTO_TEST_CASE(test_sid_t) +{ uint32_t sid_value = 0x01020310; sid_t sid(sid_value); @@ -29,7 +30,7 @@ BOOST_AUTO_TEST_CASE(test_sid_t) { BOOST_CHECK_EQUAL(sid == sid, true); BOOST_CHECK_EQUAL(sid == sid_value, true); - uint32_t check_sid_val = (uint32_t) sid; + uint32_t check_sid_val = (uint32_t)sid; BOOST_CHECK_EQUAL(check_sid_val, sid_value); std::stringstream ss_dec; @@ -46,20 +47,21 @@ BOOST_AUTO_TEST_CASE(test_sid_t) { 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); + 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) { +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_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); @@ -117,7 +119,8 @@ BOOST_AUTO_TEST_CASE(test_sid_t_set) { BOOST_CHECK_EQUAL(sid.get(), (uint32_t)0x0cbc0a0b); } -BOOST_AUTO_TEST_CASE(test_sid_t_from_str) { +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); diff --git a/host/tests/soft_reg_test.cpp b/host/tests/soft_reg_test.cpp index 8e53c61ca..2c1766cfe 100644 --- a/host/tests/soft_reg_test.cpp +++ b/host/tests/soft_reg_test.cpp @@ -9,21 +9,22 @@ using namespace uhd; -BOOST_AUTO_TEST_CASE(test_soft_reg_field) { +BOOST_AUTO_TEST_CASE(test_soft_reg_field) +{ UHD_DEFINE_SOFT_REG_FIELD(test_reg1, /* width */ 1, /* shift */ 0); BOOST_CHECK_EQUAL(soft_reg_field::width(test_reg1), 1); BOOST_CHECK_EQUAL(soft_reg_field::shift(test_reg1), 0); - BOOST_CHECK_EQUAL(soft_reg_field::mask<uint32_t>(test_reg1), 1<<0); + BOOST_CHECK_EQUAL(soft_reg_field::mask<uint32_t>(test_reg1), 1 << 0); UHD_DEFINE_SOFT_REG_FIELD(test_reg2, /* width */ 5, /* shift */ 4); BOOST_CHECK_EQUAL(soft_reg_field::width(test_reg2), 5); BOOST_CHECK_EQUAL(soft_reg_field::shift(test_reg2), 4); - BOOST_CHECK_EQUAL(soft_reg_field::mask<uint32_t>(test_reg2), 0x1F<<4); + BOOST_CHECK_EQUAL(soft_reg_field::mask<uint32_t>(test_reg2), 0x1F << 4); UHD_DEFINE_SOFT_REG_FIELD(test_reg3, /* width */ 9, /* shift */ 0); BOOST_CHECK_EQUAL(soft_reg_field::width(test_reg3), 9); BOOST_CHECK_EQUAL(soft_reg_field::shift(test_reg3), 0); - BOOST_CHECK_EQUAL(soft_reg_field::mask<uint8_t>(test_reg3), 0xFF); + BOOST_CHECK_EQUAL(soft_reg_field::mask<uint8_t>(test_reg3), 0xFF); // This one is platform dependent: UHD_DEFINE_SOFT_REG_FIELD(test_reg4, /* width */ 33, /* shift */ 0); diff --git a/host/tests/sph_recv_test.cpp b/host/tests/sph_recv_test.cpp index 705fd4f83..3c185d21a 100644 --- a/host/tests/sph_recv_test.cpp +++ b/host/tests/sph_recv_test.cpp @@ -5,14 +5,14 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> -#include "../lib/transport/super_recv_packet_handler.hpp" #include "../common/mock_zero_copy.hpp" -#include <boost/shared_array.hpp> +#include "../lib/transport/super_recv_packet_handler.hpp" #include <boost/bind.hpp> +#include <boost/shared_array.hpp> +#include <boost/test/unit_test.hpp> #include <complex> -#include <vector> #include <list> +#include <vector> using namespace uhd::transport; @@ -22,797 +22,775 @@ using namespace uhd::transport; /*********************************************************************** * A dummy overflow handler for testing **********************************************************************/ -struct overflow_handler_type{ - overflow_handler_type(void){ +struct overflow_handler_type +{ + overflow_handler_type(void) + { num_overflow = 0; } - void handle(void){ + void handle(void) + { num_overflow++; } size_t num_overflow; }; //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_normal) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; mock_zero_copy xport(vrt::if_packet_info_t::LINK_TYPE_VRLP); vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; static const size_t NUM_PKTS_TO_TEST = 30; - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.num_payload_words32 = 10 + i%10; + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.num_payload_words32 = 10 + i % 10; std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xport.push_back_recv_packet(ifpi, data); ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); } - //create the super receive packet handler + // create the super receive packet handler uhd::transport::sph::recv_packet_handler handler(1); handler.set_vrt_unpacker(&uhd::transport::vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); handler.set_xport_chan_get_buff( - 0, - [&xport](double timeout) { - return xport.get_recv_buff(timeout); - }); + 0, [&xport](double timeout) { return xport.get_recv_buff(timeout); }); handler.set_converter(id); - //check the received packets + // check the received packets size_t num_accum_samps = 0; - std::vector<std::complex<float> > buff(20); + std::vector<std::complex<float>> buff(20); uhd::rx_metadata_t metadata; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; - size_t num_samps_ret = handler.recv( - &buff.front(), buff.size(), metadata, 1.0, true - ); + size_t num_samps_ret = + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(not metadata.more_fragments); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - BOOST_CHECK_EQUAL(num_samps_ret, 10 + i%10); + BOOST_CHECK_TS_CLOSE( + metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_EQUAL(num_samps_ret, 10 + i % 10); num_accum_samps += num_samps_ret; } - //subsequent receives should be a timeout - for (size_t i = 0; i < 3; i++){ + // subsequent receives should be a timeout + for (size_t i = 0; i < 3; i++) { std::cout << "timeout check " << i << std::endl; - handler.recv( - &buff.front(), buff.size(), metadata, 1.0, true - ); + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT); } - //simulate the transport failing + // simulate the transport failing xport.set_simulate_io_error(true); - BOOST_REQUIRE_THROW(handler.recv(&buff.front(), buff.size(), metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true), uhd::io_error); } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_sequence_error) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; mock_zero_copy xport(vrt::if_packet_info_t::LINK_TYPE_VRLP); vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; static const size_t NUM_PKTS_TO_TEST = 30; - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.num_payload_words32 = 10 + i%10; - if (i != NUM_PKTS_TO_TEST/2){ //simulate a lost packet + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.num_payload_words32 = 10 + i % 10; + if (i != NUM_PKTS_TO_TEST / 2) { // simulate a lost packet std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xport.push_back_recv_packet(ifpi, data); } ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); } - //create the super receive packet handler + // create the super receive packet handler sph::recv_packet_handler handler(1); handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); handler.set_xport_chan_get_buff( - 0, - [&xport](double timeout) { - return xport.get_recv_buff(timeout); - } - ); + 0, [&xport](double timeout) { return xport.get_recv_buff(timeout); }); handler.set_converter(id); - //check the received packets + // check the received packets size_t num_accum_samps = 0; - std::vector<std::complex<float> > buff(20); + std::vector<std::complex<float>> buff(20); uhd::rx_metadata_t metadata; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; - size_t num_samps_ret = handler.recv( - &buff.front(), buff.size(), metadata, 1.0, true - ); - if (i == NUM_PKTS_TO_TEST/2){ - //must get the soft overflow here + size_t num_samps_ret = + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true); + if (i == NUM_PKTS_TO_TEST / 2) { + // must get the soft overflow here BOOST_REQUIRE(metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW); BOOST_REQUIRE(metadata.out_of_sequence == true); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - num_accum_samps += 10 + i%10; - } - else{ + BOOST_CHECK_TS_CLOSE(metadata.time_spec, + uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + num_accum_samps += 10 + i % 10; + } else { BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(not metadata.more_fragments); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - BOOST_CHECK_EQUAL(num_samps_ret, 10 + i%10); + BOOST_CHECK_TS_CLOSE(metadata.time_spec, + uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_EQUAL(num_samps_ret, 10 + i % 10); num_accum_samps += num_samps_ret; } } - //subsequent receives should be a timeout - for (size_t i = 0; i < 3; i++){ + // subsequent receives should be a timeout + for (size_t i = 0; i < 3; i++) { std::cout << "timeout check " << i << std::endl; - handler.recv( - &buff.front(), buff.size(), metadata, 1.0, true - ); + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT); } - //simulate the transport failing + // simulate the transport failing xport.set_simulate_io_error(true); - BOOST_REQUIRE_THROW(handler.recv(&buff.front(), buff.size(), metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true), uhd::io_error); } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_one_channel_inline_message) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; mock_zero_copy xport(vrt::if_packet_info_t::LINK_TYPE_VRLP); vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; static const size_t NUM_PKTS_TO_TEST = 30; - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; - ifpi.num_payload_words32 = 10 + i%10; + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.num_payload_words32 = 10 + i % 10; std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xport.push_back_recv_packet(ifpi, data); ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); - //simulate overflow - if (i == NUM_PKTS_TO_TEST/2){ - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_CONTEXT; + // simulate overflow + if (i == NUM_PKTS_TO_TEST / 2) { + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_CONTEXT; ifpi.num_payload_words32 = 1; xport.push_back_inline_message_packet( - ifpi, - uhd::rx_metadata_t::ERROR_CODE_OVERFLOW); + ifpi, uhd::rx_metadata_t::ERROR_CODE_OVERFLOW); } } - //create the super receive packet handler + // create the super receive packet handler sph::recv_packet_handler handler(1); handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); handler.set_xport_chan_get_buff( - 0, - [&xport](double timeout) { - return xport.get_recv_buff(timeout); - } - ); + 0, [&xport](double timeout) { return xport.get_recv_buff(timeout); }); handler.set_converter(id); - //create an overflow handler + // create an overflow handler overflow_handler_type overflow_handler; - handler.set_overflow_handler(0, boost::bind(&overflow_handler_type::handle, &overflow_handler)); + handler.set_overflow_handler( + 0, boost::bind(&overflow_handler_type::handle, &overflow_handler)); - //check the received packets + // check the received packets size_t num_accum_samps = 0; - std::vector<std::complex<float> > buff(20); + std::vector<std::complex<float>> buff(20); uhd::rx_metadata_t metadata; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; - size_t num_samps_ret = handler.recv( - &buff.front(), buff.size(), metadata, 1.0, true - ); + size_t num_samps_ret = + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(not metadata.more_fragments); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - BOOST_CHECK_EQUAL(num_samps_ret, 10 + i%10); + BOOST_CHECK_TS_CLOSE( + metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_EQUAL(num_samps_ret, 10 + i % 10); num_accum_samps += num_samps_ret; - if (i == NUM_PKTS_TO_TEST/2){ - handler.recv( - &buff.front(), buff.size(), metadata, 1.0, true - ); + if (i == NUM_PKTS_TO_TEST / 2) { + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true); std::cout << "metadata.error_code " << metadata.error_code << std::endl; BOOST_REQUIRE(metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_TS_CLOSE(metadata.time_spec, + uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); BOOST_CHECK_EQUAL(overflow_handler.num_overflow, size_t(1)); } } - //subsequent receives should be a timeout - for (size_t i = 0; i < 3; i++){ + // subsequent receives should be a timeout + for (size_t i = 0; i < 3; i++) { std::cout << "timeout check " << i << std::endl; - handler.recv( - &buff.front(), buff.size(), metadata, 1.0, true - ); + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT); } - //simulate the transport failing + // simulate the transport failing xport.set_simulate_io_error(true); - BOOST_REQUIRE_THROW(handler.recv(&buff.front(), buff.size(), metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(&buff.front(), buff.size(), metadata, 1.0, true), uhd::io_error); } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_normal) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; - static const size_t NUM_PKTS_TO_TEST = 30; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; + static const size_t NUM_PKTS_TO_TEST = 30; static const size_t NUM_SAMPS_PER_BUFF = 20; - static const size_t NCHANNELS = 4; + static const size_t NCHANNELS = 4; std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { - xports.push_back(boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + xports.push_back( + boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.num_payload_words32 = 10 + i%10; - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.num_payload_words32 = 10 + i % 10; + for (size_t ch = 0; ch < NCHANNELS; ch++) { std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xports[ch]->push_back_recv_packet(ifpi, data); } ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); } - //create the super receive packet handler + // create the super receive packet handler sph::recv_packet_handler handler(NCHANNELS); handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); - for (size_t ch = 0; ch < NCHANNELS; ch++){ + for (size_t ch = 0; ch < NCHANNELS; ch++) { mock_zero_copy::sptr xport = xports[ch]; handler.set_xport_chan_get_buff( - ch, - [xport](double timeout) { - return xport->get_recv_buff(timeout); - } - ); + ch, [xport](double timeout) { return xport->get_recv_buff(timeout); }); } handler.set_converter(id); - //check the received packets + // check the received packets size_t num_accum_samps = 0; - std::complex<float> mem[NUM_SAMPS_PER_BUFF*NCHANNELS]; - std::vector<std::complex<float> *> buffs(NCHANNELS); - for (size_t ch = 0; ch < NCHANNELS; ch++){ - buffs[ch] = &mem[ch*NUM_SAMPS_PER_BUFF]; + std::complex<float> mem[NUM_SAMPS_PER_BUFF * NCHANNELS]; + std::vector<std::complex<float>*> buffs(NCHANNELS); + for (size_t ch = 0; ch < NCHANNELS; ch++) { + buffs[ch] = &mem[ch * NUM_SAMPS_PER_BUFF]; } uhd::rx_metadata_t metadata; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; - size_t num_samps_ret = handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + size_t num_samps_ret = + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(not metadata.more_fragments); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - BOOST_CHECK_EQUAL(num_samps_ret, 10 + i%10); + BOOST_CHECK_TS_CLOSE( + metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_EQUAL(num_samps_ret, 10 + i % 10); num_accum_samps += num_samps_ret; } - //subsequent receives should be a timeout - for (size_t i = 0; i < 3; i++){ + // subsequent receives should be a timeout + for (size_t i = 0; i < 3; i++) { std::cout << "timeout check " << i << std::endl; - handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT); } - //simulate the transport failing - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // simulate the transport failing + for (size_t ch = 0; ch < NCHANNELS; ch++) { xports[ch]->set_simulate_io_error(true); } - BOOST_REQUIRE_THROW(handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_sequence_error) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; - static const size_t NUM_PKTS_TO_TEST = 30; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; + static const size_t NUM_PKTS_TO_TEST = 30; static const size_t NUM_SAMPS_PER_BUFF = 20; - static const size_t NCHANNELS = 4; + static const size_t NCHANNELS = 4; std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { - xports.push_back(boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + xports.push_back( + boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.num_payload_words32 = 10 + i%10; - for (size_t ch = 0; ch < NCHANNELS; ch++){ - if (i == NUM_PKTS_TO_TEST/2 and ch == 2){ - continue; //simulates a lost packet + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.num_payload_words32 = 10 + i % 10; + for (size_t ch = 0; ch < NCHANNELS; ch++) { + if (i == NUM_PKTS_TO_TEST / 2 and ch == 2) { + continue; // simulates a lost packet } std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xports[ch]->push_back_recv_packet(ifpi, data); } ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); } - //create the super receive packet handler + // create the super receive packet handler sph::recv_packet_handler handler(NCHANNELS); handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); - for (size_t ch = 0; ch < NCHANNELS; ch++){ + for (size_t ch = 0; ch < NCHANNELS; ch++) { mock_zero_copy::sptr xport = xports[ch]; handler.set_xport_chan_get_buff( - ch, - [xport](double timeout) { - return xport->get_recv_buff(timeout); - } - ); + ch, [xport](double timeout) { return xport->get_recv_buff(timeout); }); } handler.set_converter(id); - //check the received packets + // check the received packets size_t num_accum_samps = 0; - std::complex<float> mem[NUM_SAMPS_PER_BUFF*NCHANNELS]; - std::vector<std::complex<float> *> buffs(NCHANNELS); - for (size_t ch = 0; ch < NCHANNELS; ch++){ - buffs[ch] = &mem[ch*NUM_SAMPS_PER_BUFF]; + std::complex<float> mem[NUM_SAMPS_PER_BUFF * NCHANNELS]; + std::vector<std::complex<float>*> buffs(NCHANNELS); + for (size_t ch = 0; ch < NCHANNELS; ch++) { + buffs[ch] = &mem[ch * NUM_SAMPS_PER_BUFF]; } uhd::rx_metadata_t metadata; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; - size_t num_samps_ret = handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); - if (i == NUM_PKTS_TO_TEST/2){ - //must get the soft overflow here + size_t num_samps_ret = + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); + if (i == NUM_PKTS_TO_TEST / 2) { + // must get the soft overflow here BOOST_REQUIRE(metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW); BOOST_REQUIRE(metadata.out_of_sequence == true); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - num_accum_samps += 10 + i%10; - } - else{ + BOOST_CHECK_TS_CLOSE(metadata.time_spec, + uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + num_accum_samps += 10 + i % 10; + } else { BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(not metadata.more_fragments); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - BOOST_CHECK_EQUAL(num_samps_ret, 10 + i%10); + BOOST_CHECK_TS_CLOSE(metadata.time_spec, + uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_EQUAL(num_samps_ret, 10 + i % 10); num_accum_samps += num_samps_ret; } } - //subsequent receives should be a timeout - for (size_t i = 0; i < 3; i++){ + // subsequent receives should be a timeout + for (size_t i = 0; i < 3; i++) { std::cout << "timeout check " << i << std::endl; - handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT); } - //simulate the transport failing - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // simulate the transport failing + for (size_t ch = 0; ch < NCHANNELS; ch++) { xports[ch]->set_simulate_io_error(true); } - BOOST_REQUIRE_THROW(handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_time_error) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; - static const size_t NUM_PKTS_TO_TEST = 30; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; + static const size_t NUM_PKTS_TO_TEST = 30; static const size_t NUM_SAMPS_PER_BUFF = 20; - static const size_t NCHANNELS = 4; + static const size_t NCHANNELS = 4; std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { - xports.push_back(boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + xports.push_back( + boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.num_payload_words32 = 10 + i%10; - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.num_payload_words32 = 10 + i % 10; + for (size_t ch = 0; ch < NCHANNELS; ch++) { std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xports[ch]->push_back_recv_packet(ifpi, data); } ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); - if (i == NUM_PKTS_TO_TEST/2){ - ifpi.tsf = 0; //simulate the user changing the time + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); + if (i == NUM_PKTS_TO_TEST / 2) { + ifpi.tsf = 0; // simulate the user changing the time } } - //create the super receive packet handler + // create the super receive packet handler sph::recv_packet_handler handler(NCHANNELS); handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); - for (size_t ch = 0; ch < NCHANNELS; ch++){ + for (size_t ch = 0; ch < NCHANNELS; ch++) { mock_zero_copy::sptr xport = xports[ch]; handler.set_xport_chan_get_buff( - ch, - [xport](double timeout) { - return xport->get_recv_buff(timeout); - } - ); + ch, [xport](double timeout) { return xport->get_recv_buff(timeout); }); } handler.set_converter(id); - //check the received packets + // check the received packets size_t num_accum_samps = 0; - std::complex<float> mem[NUM_SAMPS_PER_BUFF*NCHANNELS]; - std::vector<std::complex<float> *> buffs(NCHANNELS); - for (size_t ch = 0; ch < NCHANNELS; ch++){ - buffs[ch] = &mem[ch*NUM_SAMPS_PER_BUFF]; + std::complex<float> mem[NUM_SAMPS_PER_BUFF * NCHANNELS]; + std::vector<std::complex<float>*> buffs(NCHANNELS); + for (size_t ch = 0; ch < NCHANNELS; ch++) { + buffs[ch] = &mem[ch * NUM_SAMPS_PER_BUFF]; } uhd::rx_metadata_t metadata; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; - size_t num_samps_ret = handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + size_t num_samps_ret = + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(not metadata.more_fragments); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - BOOST_CHECK_EQUAL(num_samps_ret, 10 + i%10); + BOOST_CHECK_TS_CLOSE( + metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_EQUAL(num_samps_ret, 10 + i % 10); num_accum_samps += num_samps_ret; - if (i == NUM_PKTS_TO_TEST/2){ - num_accum_samps = 0; //simulate the user changing the time + if (i == NUM_PKTS_TO_TEST / 2) { + num_accum_samps = 0; // simulate the user changing the time } } - //subsequent receives should be a timeout - for (size_t i = 0; i < 3; i++){ + // subsequent receives should be a timeout + for (size_t i = 0; i < 3; i++) { std::cout << "timeout check " << i << std::endl; - handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT); } - //simulate the transport failing - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // simulate the transport failing + for (size_t ch = 0; ch < NCHANNELS; ch++) { xports[ch]->set_simulate_io_error(true); } - BOOST_REQUIRE_THROW(handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_exception){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_exception) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; - static const size_t NUM_PKTS_TO_TEST = 30; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; + static const size_t NUM_PKTS_TO_TEST = 30; static const size_t NUM_SAMPS_PER_BUFF = 20; - static const size_t NCHANNELS = 4; + static const size_t NCHANNELS = 4; std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { - xports.push_back(boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + xports.push_back( + boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.num_payload_words32 = 10 + i%10; - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.num_payload_words32 = 10 + i % 10; + for (size_t ch = 0; ch < NCHANNELS; ch++) { std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xports[ch]->push_back_recv_packet(ifpi, data); } ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); - if (i == NUM_PKTS_TO_TEST/2){ - ifpi.tsf = 0; //simulate the user changing the time + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); + if (i == NUM_PKTS_TO_TEST / 2) { + ifpi.tsf = 0; // simulate the user changing the time } } - //create the super receive packet handler + // create the super receive packet handler sph::recv_packet_handler handler(NCHANNELS); handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); - for (size_t ch = 0; ch < NCHANNELS; ch++){ + for (size_t ch = 0; ch < NCHANNELS; ch++) { mock_zero_copy::sptr xport = xports[ch]; handler.set_xport_chan_get_buff( - ch, - [xport](double timeout) { - return xport->get_recv_buff(timeout); - } - ); + ch, [xport](double timeout) { return xport->get_recv_buff(timeout); }); } handler.set_converter(id); - std::complex<float> mem[NUM_SAMPS_PER_BUFF*NCHANNELS]; - std::vector<std::complex<float> *> buffs(NCHANNELS); - for (size_t ch = 0; ch < NCHANNELS; ch++){ - buffs[ch] = &mem[ch*NUM_SAMPS_PER_BUFF]; + std::complex<float> mem[NUM_SAMPS_PER_BUFF * NCHANNELS]; + std::vector<std::complex<float>*> buffs(NCHANNELS); + for (size_t ch = 0; ch < NCHANNELS; ch++) { + buffs[ch] = &mem[ch * NUM_SAMPS_PER_BUFF]; } // simulate a failure on a channel (the last one) uhd::rx_metadata_t metadata; - xports[NCHANNELS-1]->set_simulate_io_error(true); + xports[NCHANNELS - 1]->set_simulate_io_error(true); std::cout << "exception check" << std::endl; - BOOST_REQUIRE_THROW(handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_recv_multi_channel_fragment) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "sc16_item32_be"; - id.num_inputs = 1; + id.input_format = "sc16_item32_be"; + id.num_inputs = 1; id.output_format = "fc32"; - id.num_outputs = 1; + id.num_outputs = 1; vrt::if_packet_info_t ifpi; - ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; + ifpi.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA; ifpi.num_payload_words32 = 0; - ifpi.packet_count = 0; - ifpi.sob = true; - ifpi.eob = false; - ifpi.has_sid = false; - ifpi.has_cid = false; - ifpi.has_tsi = true; - ifpi.has_tsf = true; - ifpi.tsi = 0; - ifpi.tsf = 0; - ifpi.has_tlr = false; - - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; - static const size_t NUM_PKTS_TO_TEST = 30; + ifpi.packet_count = 0; + ifpi.sob = true; + ifpi.eob = false; + ifpi.has_sid = false; + ifpi.has_cid = false; + ifpi.has_tsi = true; + ifpi.has_tsf = true; + ifpi.tsi = 0; + ifpi.tsf = 0; + ifpi.has_tlr = false; + + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; + static const size_t NUM_PKTS_TO_TEST = 30; static const size_t NUM_SAMPS_PER_BUFF = 10; - static const size_t NCHANNELS = 4; + static const size_t NCHANNELS = 4; std::vector<mock_zero_copy::sptr> xports; for (size_t i = 0; i < NCHANNELS; i++) { - xports.push_back(boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); + xports.push_back( + boost::make_shared<mock_zero_copy>(vrt::if_packet_info_t::LINK_TYPE_VRLP)); } - //generate a bunch of packets - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ - ifpi.num_payload_words32 = 10 + i%10; - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // generate a bunch of packets + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { + ifpi.num_payload_words32 = 10 + i % 10; + for (size_t ch = 0; ch < NCHANNELS; ch++) { std::vector<uint32_t> data(ifpi.num_payload_words32, 0); xports[ch]->push_back_recv_packet(ifpi, data); } ifpi.packet_count++; - ifpi.tsf += ifpi.num_payload_words32*size_t(TICK_RATE/SAMP_RATE); + ifpi.tsf += ifpi.num_payload_words32 * size_t(TICK_RATE / SAMP_RATE); } - //create the super receive packet handler + // create the super receive packet handler sph::recv_packet_handler handler(NCHANNELS); handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); - for (size_t ch = 0; ch < NCHANNELS; ch++){ + for (size_t ch = 0; ch < NCHANNELS; ch++) { mock_zero_copy::sptr xport = xports[ch]; handler.set_xport_chan_get_buff( - ch, - [xport](double timeout) { - return xport->get_recv_buff(timeout); - } - ); + ch, [xport](double timeout) { return xport->get_recv_buff(timeout); }); } handler.set_converter(id); - //check the received packets + // check the received packets size_t num_accum_samps = 0; - std::complex<float> mem[NUM_SAMPS_PER_BUFF*NCHANNELS]; - std::vector<std::complex<float> *> buffs(NCHANNELS); - for (size_t ch = 0; ch < NCHANNELS; ch++){ - buffs[ch] = &mem[ch*NUM_SAMPS_PER_BUFF]; + std::complex<float> mem[NUM_SAMPS_PER_BUFF * NCHANNELS]; + std::vector<std::complex<float>*> buffs(NCHANNELS); + for (size_t ch = 0; ch < NCHANNELS; ch++) { + buffs[ch] = &mem[ch * NUM_SAMPS_PER_BUFF]; } uhd::rx_metadata_t metadata; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; - size_t num_samps_ret = handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + size_t num_samps_ret = + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_TS_CLOSE( + metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); BOOST_CHECK_EQUAL(num_samps_ret, 10UL); num_accum_samps += num_samps_ret; - if (not metadata.more_fragments) continue; + if (not metadata.more_fragments) + continue; - num_samps_ret = handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + num_samps_ret = handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_NONE); BOOST_CHECK(not metadata.more_fragments); BOOST_CHECK_EQUAL(metadata.fragment_offset, 10UL); BOOST_CHECK(metadata.has_time_spec); - BOOST_CHECK_TS_CLOSE(metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); - BOOST_CHECK_EQUAL(num_samps_ret, i%10); + BOOST_CHECK_TS_CLOSE( + metadata.time_spec, uhd::time_spec_t::from_ticks(num_accum_samps, SAMP_RATE)); + BOOST_CHECK_EQUAL(num_samps_ret, i % 10); num_accum_samps += num_samps_ret; } - //subsequent receives should be a timeout - for (size_t i = 0; i < 3; i++){ + // subsequent receives should be a timeout + for (size_t i = 0; i < 3; i++) { std::cout << "timeout check " << i << std::endl; - handler.recv( - buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true - ); + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true); BOOST_CHECK_EQUAL(metadata.error_code, uhd::rx_metadata_t::ERROR_CODE_TIMEOUT); } - //simulate the transport failing - for (size_t ch = 0; ch < NCHANNELS; ch++){ + // simulate the transport failing + for (size_t ch = 0; ch < NCHANNELS; ch++) { xports[ch]->set_simulate_io_error(true); } - BOOST_REQUIRE_THROW(handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); + BOOST_REQUIRE_THROW( + handler.recv(buffs, NUM_SAMPS_PER_BUFF, metadata, 1.0, true), uhd::io_error); } diff --git a/host/tests/sph_send_test.cpp b/host/tests/sph_send_test.cpp index 2db80c8de..6de4c9ffa 100644 --- a/host/tests/sph_send_test.cpp +++ b/host/tests/sph_send_test.cpp @@ -5,14 +5,14 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> -#include "../lib/transport/super_send_packet_handler.hpp" #include "../common/mock_zero_copy.hpp" -#include <boost/shared_array.hpp> +#include "../lib/transport/super_send_packet_handler.hpp" #include <boost/bind.hpp> +#include <boost/shared_array.hpp> +#include <boost/test/unit_test.hpp> #include <complex> -#include <vector> #include <list> +#include <vector> using namespace uhd::transport; @@ -20,120 +20,110 @@ using namespace uhd::transport; BOOST_CHECK_CLOSE((a).get_real_secs(), (b).get_real_secs(), 0.001) //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_one_packet_mode){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_one_packet_mode) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "sc16_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; mock_zero_copy xport(vrt::if_packet_info_t::LINK_TYPE_VRLP); - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; static const size_t NUM_PKTS_TO_TEST = 30; - //create the super send packet handler + // create the super send packet handler sph::send_packet_handler handler(1); handler.set_vrt_packer(&vrt::if_hdr_pack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); handler.set_xport_chan_get_buff( - 0, - [&xport](double timeout) { - return xport.get_send_buff(timeout); - } - ); + 0, [&xport](double timeout) { return xport.get_send_buff(timeout); }); handler.set_converter(id); handler.set_max_samples_per_packet(20); - //allocate metadata and buffer - std::vector<std::complex<float> > buff(20); + // allocate metadata and buffer + std::vector<std::complex<float>> buff(20); uhd::tx_metadata_t metadata; metadata.has_time_spec = true; - metadata.time_spec = uhd::time_spec_t(0.0); + metadata.time_spec = uhd::time_spec_t(0.0); - //generate the test data - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + // generate the test data + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { metadata.start_of_burst = (i == 0); - metadata.end_of_burst = (i == NUM_PKTS_TO_TEST-1); - const size_t num_sent = handler.send( - &buff.front(), 10 + i%10, metadata, 1.0 - ); - BOOST_CHECK_EQUAL(num_sent, 10 + i%10); + metadata.end_of_burst = (i == NUM_PKTS_TO_TEST - 1); + const size_t num_sent = handler.send(&buff.front(), 10 + i % 10, metadata, 1.0); + BOOST_CHECK_EQUAL(num_sent, 10 + i % 10); metadata.time_spec += uhd::time_spec_t(0, num_sent, SAMP_RATE); } - //check the sent packets + // check the sent packets size_t num_accum_samps = 0; vrt::if_packet_info_t ifpi; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; xport.pop_send_packet(ifpi); - BOOST_CHECK_EQUAL(ifpi.num_payload_words32, 10+i%10); + BOOST_CHECK_EQUAL(ifpi.num_payload_words32, 10 + i % 10); BOOST_CHECK(ifpi.has_tsf); - BOOST_CHECK_EQUAL(ifpi.tsf, num_accum_samps*TICK_RATE/SAMP_RATE); + BOOST_CHECK_EQUAL(ifpi.tsf, num_accum_samps * TICK_RATE / SAMP_RATE); BOOST_CHECK_EQUAL(ifpi.sob, i == 0); - BOOST_CHECK_EQUAL(ifpi.eob, i == NUM_PKTS_TO_TEST-1); + BOOST_CHECK_EQUAL(ifpi.eob, i == NUM_PKTS_TO_TEST - 1); num_accum_samps += ifpi.num_payload_words32; } } //////////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_full_buffer_mode){ -//////////////////////////////////////////////////////////////////////// +BOOST_AUTO_TEST_CASE(test_sph_send_one_channel_full_buffer_mode) +{ + //////////////////////////////////////////////////////////////////////// uhd::convert::id_type id; - id.input_format = "fc32"; - id.num_inputs = 1; + id.input_format = "fc32"; + id.num_inputs = 1; id.output_format = "sc16_item32_be"; - id.num_outputs = 1; + id.num_outputs = 1; mock_zero_copy xport(vrt::if_packet_info_t::LINK_TYPE_VRLP); - static const double TICK_RATE = 100e6; - static const double SAMP_RATE = 10e6; + static const double TICK_RATE = 100e6; + static const double SAMP_RATE = 10e6; static const size_t NUM_PKTS_TO_TEST = 30; - //create the super send packet handler + // create the super send packet handler sph::send_packet_handler handler(1); handler.set_vrt_packer(&vrt::if_hdr_pack_be); handler.set_tick_rate(TICK_RATE); handler.set_samp_rate(SAMP_RATE); handler.set_xport_chan_get_buff( - 0, - [&xport](double timeout) { - return xport.get_send_buff(timeout); - } - ); + 0, [&xport](double timeout) { return xport.get_send_buff(timeout); }); handler.set_converter(id); handler.set_max_samples_per_packet(20); - //allocate metadata and buffer - std::vector<std::complex<float> > buff(20*NUM_PKTS_TO_TEST); + // allocate metadata and buffer + std::vector<std::complex<float>> buff(20 * NUM_PKTS_TO_TEST); uhd::tx_metadata_t metadata; metadata.start_of_burst = true; - metadata.end_of_burst = true; - metadata.has_time_spec = true; - metadata.time_spec = uhd::time_spec_t(0.0); + metadata.end_of_burst = true; + metadata.has_time_spec = true; + metadata.time_spec = uhd::time_spec_t(0.0); - //generate the test data - const size_t num_sent = handler.send( - &buff.front(), buff.size(), metadata, 1.0 - ); + // generate the test data + const size_t num_sent = handler.send(&buff.front(), buff.size(), metadata, 1.0); BOOST_CHECK_EQUAL(num_sent, buff.size()); - //check the sent packets + // check the sent packets size_t num_accum_samps = 0; vrt::if_packet_info_t ifpi; - for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++){ + for (size_t i = 0; i < NUM_PKTS_TO_TEST; i++) { std::cout << "data check " << i << std::endl; xport.pop_send_packet(ifpi); BOOST_CHECK_EQUAL(ifpi.num_payload_words32, 20UL); BOOST_CHECK(ifpi.has_tsf); - BOOST_CHECK_EQUAL(ifpi.tsf, num_accum_samps*TICK_RATE/SAMP_RATE); + BOOST_CHECK_EQUAL(ifpi.tsf, num_accum_samps * TICK_RATE / SAMP_RATE); BOOST_CHECK_EQUAL(ifpi.sob, i == 0); - BOOST_CHECK_EQUAL(ifpi.eob, i == NUM_PKTS_TO_TEST-1); + BOOST_CHECK_EQUAL(ifpi.eob, i == NUM_PKTS_TO_TEST - 1); num_accum_samps += ifpi.num_payload_words32; } } diff --git a/host/tests/stream_sig_test.cpp b/host/tests/stream_sig_test.cpp index 88344faf5..41c07c14f 100644 --- a/host/tests/stream_sig_test.cpp +++ b/host/tests/stream_sig_test.cpp @@ -5,14 +5,15 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <iostream> -#include <boost/test/unit_test.hpp> #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) { +BOOST_AUTO_TEST_CASE(test_stream_sig) +{ stream_sig_t stream_sig; BOOST_CHECK_EQUAL(stream_sig.item_type, ""); @@ -26,7 +27,8 @@ BOOST_AUTO_TEST_CASE(test_stream_sig) { std::cout << ss.str() << std::endl; } -BOOST_AUTO_TEST_CASE(test_stream_sig_compat) { +BOOST_AUTO_TEST_CASE(test_stream_sig_compat) +{ stream_sig_t upstream_sig; stream_sig_t downstream_sig; @@ -47,12 +49,13 @@ BOOST_AUTO_TEST_CASE(test_stream_sig_compat) { 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"; + 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) { +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"; diff --git a/host/tests/subdev_spec_test.cpp b/host/tests/subdev_spec_test.cpp index b87981392..533e8f90d 100644 --- a/host/tests/subdev_spec_test.cpp +++ b/host/tests/subdev_spec_test.cpp @@ -5,34 +5,35 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/usrp/subdev_spec.hpp> +#include <boost/test/unit_test.hpp> #include <iostream> -BOOST_AUTO_TEST_CASE(test_subdevice_spec){ +BOOST_AUTO_TEST_CASE(test_subdevice_spec) +{ std::cout << "Testing subdevice specification..." << std::endl; - //load the subdev spec with something + // load the subdev spec with something uhd::usrp::subdev_spec_t sd_spec; sd_spec.push_back(uhd::usrp::subdev_spec_pair_t("A", "AB")); sd_spec.push_back(uhd::usrp::subdev_spec_pair_t("B", "AB")); - //create a subdev_spec with something different + // create a subdev_spec with something different uhd::usrp::subdev_spec_t diff_sd_spec; diff_sd_spec.push_back(uhd::usrp::subdev_spec_pair_t("B", "BA")); diff_sd_spec.push_back(uhd::usrp::subdev_spec_pair_t("B", "BA")); - //convert to and from args string + // convert to and from args string std::cout << "Pretty Print: " << std::endl << sd_spec.to_pp_string(); std::string markup_str = sd_spec.to_string(); std::cout << "Markup String: " << markup_str << std::endl; uhd::usrp::subdev_spec_t new_sd_spec(markup_str); - //they should be the same size + // they should be the same size BOOST_REQUIRE_EQUAL(sd_spec.size(), new_sd_spec.size()); - //the contents should match - for (size_t i = 0; i < sd_spec.size(); i++){ + // the contents should match + for (size_t i = 0; i < sd_spec.size(); i++) { BOOST_CHECK_EQUAL(sd_spec.at(i).db_name, new_sd_spec.at(i).db_name); BOOST_CHECK_EQUAL(sd_spec.at(i).sd_name, new_sd_spec.at(i).sd_name); diff --git a/host/tests/system_time_test.cpp b/host/tests/system_time_test.cpp index 3fc759391..3f4f8a814 100644 --- a/host/tests/system_time_test.cpp +++ b/host/tests/system_time_test.cpp @@ -4,20 +4,21 @@ // SPDX-License-Identifier: GPL-3.0+ // -#include <boost/test/unit_test.hpp> -#include <uhd/types/time_spec.hpp> #include "system_time.hpp" -#include <iostream> -#include <iomanip> -#include <cstdint> +#include <uhd/types/time_spec.hpp> +#include <boost/test/unit_test.hpp> #include <chrono> +#include <cstdint> +#include <iomanip> +#include <iostream> #include <thread> -BOOST_AUTO_TEST_CASE(test_time_spec_get_system_time){ +BOOST_AUTO_TEST_CASE(test_time_spec_get_system_time) +{ std::cout << "Testing time specification get system time..." << std::endl; - //Not really checking for high resolution timing here, - //just need to check that system time is minimally working. + // Not really checking for high resolution timing here, + // just need to check that system time is minimally working. auto start = uhd::get_system_time(); std::this_thread::sleep_for(std::chrono::milliseconds(500)); @@ -27,7 +28,6 @@ BOOST_AUTO_TEST_CASE(test_time_spec_get_system_time){ std::cout << "start: " << start.get_real_secs() << std::endl; std::cout << "stop: " << stop.get_real_secs() << std::endl; std::cout << "diff: " << diff.get_real_secs() << std::endl; - BOOST_CHECK(diff.get_real_secs() > 0); //assert positive - BOOST_CHECK(diff.get_real_secs() < 1.0); //assert under 1s + BOOST_CHECK(diff.get_real_secs() > 0); // assert positive + BOOST_CHECK(diff.get_real_secs() < 1.0); // assert under 1s } - diff --git a/host/tests/tasks_test.cpp b/host/tests/tasks_test.cpp index f3bb07653..c236287e3 100644 --- a/host/tests/tasks_test.cpp +++ b/host/tests/tasks_test.cpp @@ -5,24 +5,24 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/utils/tasks.hpp> -#include <thread> +#include <boost/test/unit_test.hpp> #include <chrono> -#include <vector> #include <iostream> +#include <thread> +#include <vector> void test_tasks_sleep(size_t usecs) { std::this_thread::sleep_for(std::chrono::milliseconds(usecs)); } -BOOST_AUTO_TEST_CASE(tasks_test) { - +BOOST_AUTO_TEST_CASE(tasks_test) +{ static const size_t N_TASKS = 100; std::vector<uhd::task::sptr> test_vec; for (size_t i = 0; i < N_TASKS; i++) { - test_vec.push_back(uhd::task::make([i](){ test_tasks_sleep(i); })); + test_vec.push_back(uhd::task::make([i]() { test_tasks_sleep(i); })); } } diff --git a/host/tests/tick_node_test.cpp b/host/tests/tick_node_test.cpp index 173481fb1..ccec67c43 100644 --- a/host/tests/tick_node_test.cpp +++ b/host/tests/tick_node_test.cpp @@ -18,7 +18,7 @@ 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) {}; + tick_aware_node(const std::string& test_id) : test_node(test_id){}; }; /* class tick_aware_node */ @@ -28,10 +28,14 @@ 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) {}; + 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; }; + double _get_tick_rate() + { + return _tick_rate; + }; private: const double _tick_rate; @@ -39,7 +43,8 @@ private: }; /* 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)); +#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) { diff --git a/host/tests/time_spec_test.cpp b/host/tests/time_spec_test.cpp index 89a5370bd..dee8d414e 100644 --- a/host/tests/time_spec_test.cpp +++ b/host/tests/time_spec_test.cpp @@ -5,14 +5,15 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/types/time_spec.hpp> +#include <stdint.h> +#include <boost/test/unit_test.hpp> #include <boost/thread.hpp> //sleep -#include <iostream> #include <iomanip> -#include <stdint.h> +#include <iostream> -BOOST_AUTO_TEST_CASE(test_time_spec_compare){ +BOOST_AUTO_TEST_CASE(test_time_spec_compare) +{ std::cout << "Testing time specification compare..." << std::endl; BOOST_CHECK(uhd::time_spec_t(2.0) == uhd::time_spec_t(2.0)); @@ -31,7 +32,8 @@ BOOST_AUTO_TEST_CASE(test_time_spec_compare){ #define CHECK_TS_EQUAL(lhs, rhs) \ BOOST_CHECK_CLOSE((lhs).get_real_secs(), (rhs).get_real_secs(), 0.001) -BOOST_AUTO_TEST_CASE(test_time_spec_arithmetic){ +BOOST_AUTO_TEST_CASE(test_time_spec_arithmetic) +{ std::cout << "Testing time specification arithmetic..." << std::endl; CHECK_TS_EQUAL(uhd::time_spec_t(2.3) + uhd::time_spec_t(1.0), uhd::time_spec_t(3.3)); @@ -40,7 +42,8 @@ BOOST_AUTO_TEST_CASE(test_time_spec_arithmetic){ CHECK_TS_EQUAL(uhd::time_spec_t(1.0) - uhd::time_spec_t(2.3), uhd::time_spec_t(-1.3)); } -BOOST_AUTO_TEST_CASE(test_time_spec_parts){ +BOOST_AUTO_TEST_CASE(test_time_spec_parts) +{ std::cout << "Testing time specification parts..." << std::endl; BOOST_CHECK_EQUAL(uhd::time_spec_t(1.1).get_full_secs(), 1); @@ -52,7 +55,8 @@ BOOST_AUTO_TEST_CASE(test_time_spec_parts){ BOOST_CHECK_EQUAL(uhd::time_spec_t(-1.1).to_ticks(100), -110); } -BOOST_AUTO_TEST_CASE(test_time_spec_neg_values){ +BOOST_AUTO_TEST_CASE(test_time_spec_neg_values) +{ uhd::time_spec_t ts1(0.3); uhd::time_spec_t ts2(1, -0.9); std::cout << "ts1 " << ts1.get_real_secs() << std::endl; @@ -74,7 +78,7 @@ BOOST_AUTO_TEST_CASE(test_time_spec_neg_values){ BOOST_AUTO_TEST_CASE(test_time_large_ticks_to_time_spec) { std::cout << "sizeof(time_t) " << sizeof(time_t) << std::endl; - const uint64_t ticks0 = uint64_t(100e6*1360217663.739296); + const uint64_t ticks0 = uint64_t(100e6 * 1360217663.739296); const uhd::time_spec_t t0 = uhd::time_spec_t::from_ticks(ticks0, 100e6); std::cout << "t0.get_real_secs() " << t0.get_real_secs() << std::endl; std::cout << "t0.get_full_secs() " << t0.get_full_secs() << std::endl; @@ -84,11 +88,11 @@ BOOST_AUTO_TEST_CASE(test_time_large_ticks_to_time_spec) BOOST_AUTO_TEST_CASE(test_time_error_irrational_rate) { - static const double rate = 1625e3/6.0; - const long long tick_in = 23423436291667ll; + static const double rate = 1625e3 / 6.0; + const long long tick_in = 23423436291667ll; const uhd::time_spec_t ts = uhd::time_spec_t::from_ticks(tick_in, rate); - const long long tick_out = ts.to_ticks(rate); - const long long err = tick_in - tick_out; + const long long tick_out = ts.to_ticks(rate); + const long long err = tick_in - tick_out; std::streamsize precision = std::cout.precision(); std::cout << std::setprecision(18); diff --git a/host/tests/vrt_test.cpp b/host/tests/vrt_test.cpp index 1b4df8fc7..ea639c65c 100644 --- a/host/tests/vrt_test.cpp +++ b/host/tests/vrt_test.cpp @@ -5,65 +5,63 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include <boost/test/unit_test.hpp> #include <uhd/transport/vrt_if_packet.hpp> #include <uhd/utils/byteswap.hpp> #include <boost/format.hpp> +#include <boost/test/unit_test.hpp> #include <cstdlib> #include <iostream> using namespace uhd::transport; -static void pack_and_unpack( - vrt::if_packet_info_t &if_packet_info_in -){ - if (if_packet_info_in.num_payload_bytes == 0) - { - if_packet_info_in.num_payload_bytes = if_packet_info_in.num_payload_words32 * sizeof(uint32_t); +static void pack_and_unpack(vrt::if_packet_info_t& if_packet_info_in) +{ + if (if_packet_info_in.num_payload_bytes == 0) { + if_packet_info_in.num_payload_bytes = + if_packet_info_in.num_payload_words32 * sizeof(uint32_t); } uint32_t packet_buff[2048]; - //pack metadata into a vrt header - vrt::if_hdr_pack_be( - packet_buff, if_packet_info_in - ); + // pack metadata into a vrt header + vrt::if_hdr_pack_be(packet_buff, if_packet_info_in); std::cout << std::endl; - for (size_t i = 0; i < 5; i++) - { - std::cout << boost::format("packet_buff[%u] = 0x%.8x") % i % uhd::byteswap(packet_buff[i]) << std::endl; + for (size_t i = 0; i < 5; i++) { + std::cout << boost::format("packet_buff[%u] = 0x%.8x") % i + % uhd::byteswap(packet_buff[i]) + << std::endl; } vrt::if_packet_info_t if_packet_info_out; - if_packet_info_out.link_type = if_packet_info_in.link_type; + if_packet_info_out.link_type = if_packet_info_in.link_type; if_packet_info_out.num_packet_words32 = if_packet_info_in.num_packet_words32; - //unpack the vrt header back into metadata - vrt::if_hdr_unpack_be( - packet_buff, if_packet_info_out - ); + // unpack the vrt header back into metadata + vrt::if_hdr_unpack_be(packet_buff, if_packet_info_out); - //check the the unpacked metadata is the same + // check the the unpacked metadata is the same BOOST_CHECK_EQUAL(if_packet_info_in.packet_count, if_packet_info_out.packet_count); - BOOST_CHECK_EQUAL(if_packet_info_in.num_header_words32, if_packet_info_out.num_header_words32); - BOOST_CHECK_EQUAL(if_packet_info_in.num_payload_words32, if_packet_info_out.num_payload_words32); + BOOST_CHECK_EQUAL( + if_packet_info_in.num_header_words32, if_packet_info_out.num_header_words32); + BOOST_CHECK_EQUAL( + if_packet_info_in.num_payload_words32, if_packet_info_out.num_payload_words32); BOOST_CHECK_EQUAL(if_packet_info_in.has_sid, if_packet_info_out.has_sid); - if (if_packet_info_in.has_sid and if_packet_info_out.has_sid){ + if (if_packet_info_in.has_sid and if_packet_info_out.has_sid) { BOOST_CHECK_EQUAL(if_packet_info_in.sid, if_packet_info_out.sid); } BOOST_CHECK_EQUAL(if_packet_info_in.has_cid, if_packet_info_out.has_cid); - if (if_packet_info_in.has_cid and if_packet_info_out.has_cid){ + if (if_packet_info_in.has_cid and if_packet_info_out.has_cid) { BOOST_CHECK_EQUAL(if_packet_info_in.cid, if_packet_info_out.cid); } BOOST_CHECK_EQUAL(if_packet_info_in.has_tsi, if_packet_info_out.has_tsi); - if (if_packet_info_in.has_tsi and if_packet_info_out.has_tsi){ + if (if_packet_info_in.has_tsi and if_packet_info_out.has_tsi) { BOOST_CHECK_EQUAL(if_packet_info_in.tsi, if_packet_info_out.tsi); } BOOST_CHECK_EQUAL(if_packet_info_in.has_tsf, if_packet_info_out.has_tsf); - if (if_packet_info_in.has_tsf and if_packet_info_out.has_tsf){ + if (if_packet_info_in.has_tsf and if_packet_info_out.has_tsf) { BOOST_CHECK_EQUAL(if_packet_info_in.tsf, if_packet_info_out.tsf); } BOOST_CHECK_EQUAL(if_packet_info_in.has_tlr, if_packet_info_out.has_tlr); - if (if_packet_info_in.has_tlr and if_packet_info_out.has_tlr){ + if (if_packet_info_in.has_tlr and if_packet_info_out.has_tlr) { BOOST_CHECK_EQUAL(if_packet_info_in.tlr, if_packet_info_out.tlr); } } @@ -73,102 +71,109 @@ static void pack_and_unpack( * The trailer is not tested as it is not convenient to do so. **********************************************************************/ -BOOST_AUTO_TEST_CASE(test_with_none){ +BOOST_AUTO_TEST_CASE(test_with_none) +{ vrt::if_packet_info_t if_packet_info; - if_packet_info.packet_count = 0; - if_packet_info.has_sid = false; - if_packet_info.has_cid = false; - if_packet_info.has_tsi = false; - if_packet_info.has_tsf = false; - if_packet_info.has_tlr = false; + if_packet_info.packet_count = 0; + if_packet_info.has_sid = false; + if_packet_info.has_cid = false; + if_packet_info.has_tsi = false; + if_packet_info.has_tsf = false; + if_packet_info.has_tlr = false; if_packet_info.num_payload_words32 = 0; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_sid){ +BOOST_AUTO_TEST_CASE(test_with_sid) +{ vrt::if_packet_info_t if_packet_info; - if_packet_info.packet_count = 1; - if_packet_info.has_sid = true; - if_packet_info.has_cid = false; - if_packet_info.has_tsi = false; - if_packet_info.has_tsf = false; - if_packet_info.has_tlr = false; - if_packet_info.sid = std::rand(); + if_packet_info.packet_count = 1; + if_packet_info.has_sid = true; + if_packet_info.has_cid = false; + if_packet_info.has_tsi = false; + if_packet_info.has_tsf = false; + if_packet_info.has_tlr = false; + if_packet_info.sid = std::rand(); if_packet_info.num_payload_words32 = 11; pack_and_unpack(if_packet_info); } static const bool cid_enb = false; -BOOST_AUTO_TEST_CASE(test_with_cid){ +BOOST_AUTO_TEST_CASE(test_with_cid) +{ vrt::if_packet_info_t if_packet_info; - if_packet_info.packet_count = 2; - if_packet_info.has_sid = false; - if_packet_info.has_cid = cid_enb; - if_packet_info.has_tsi = false; - if_packet_info.has_tsf = false; - if_packet_info.has_tlr = false; - if_packet_info.cid = std::rand(); + if_packet_info.packet_count = 2; + if_packet_info.has_sid = false; + if_packet_info.has_cid = cid_enb; + if_packet_info.has_tsi = false; + if_packet_info.has_tsf = false; + if_packet_info.has_tlr = false; + if_packet_info.cid = std::rand(); if_packet_info.num_payload_words32 = 22; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_time){ +BOOST_AUTO_TEST_CASE(test_with_time) +{ vrt::if_packet_info_t if_packet_info; - if_packet_info.packet_count = 3; - if_packet_info.has_sid = false; - if_packet_info.has_cid = false; - if_packet_info.has_tsi = true; - if_packet_info.has_tsf = true; - if_packet_info.has_tlr = false; - if_packet_info.tsi = std::rand(); - if_packet_info.tsf = std::rand(); + if_packet_info.packet_count = 3; + if_packet_info.has_sid = false; + if_packet_info.has_cid = false; + if_packet_info.has_tsi = true; + if_packet_info.has_tsf = true; + if_packet_info.has_tlr = false; + if_packet_info.tsi = std::rand(); + if_packet_info.tsf = std::rand(); if_packet_info.num_payload_words32 = 33; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_all){ +BOOST_AUTO_TEST_CASE(test_with_all) +{ vrt::if_packet_info_t if_packet_info; - if_packet_info.packet_count = 4; - if_packet_info.has_sid = true; - if_packet_info.has_cid = cid_enb; - if_packet_info.has_tsi = true; - if_packet_info.has_tsf = true; - if_packet_info.has_tlr = false; - if_packet_info.sid = std::rand(); - if_packet_info.cid = std::rand(); - if_packet_info.tsi = std::rand(); - if_packet_info.tsf = std::rand(); + if_packet_info.packet_count = 4; + if_packet_info.has_sid = true; + if_packet_info.has_cid = cid_enb; + if_packet_info.has_tsi = true; + if_packet_info.has_tsf = true; + if_packet_info.has_tlr = false; + if_packet_info.sid = std::rand(); + if_packet_info.cid = std::rand(); + if_packet_info.tsi = std::rand(); + if_packet_info.tsf = std::rand(); if_packet_info.num_payload_words32 = 44; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_vrlp){ +BOOST_AUTO_TEST_CASE(test_with_vrlp) +{ vrt::if_packet_info_t if_packet_info; - if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_VRLP; - if_packet_info.packet_count = 3; - if_packet_info.has_sid = true; - if_packet_info.has_cid = false; - if_packet_info.has_tsi = false; - if_packet_info.has_tsf = true; - if_packet_info.has_tlr = true; - if_packet_info.tsi = std::rand(); - if_packet_info.tsf = std::rand(); + if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_VRLP; + if_packet_info.packet_count = 3; + if_packet_info.has_sid = true; + if_packet_info.has_cid = false; + if_packet_info.has_tsi = false; + if_packet_info.has_tsf = true; + if_packet_info.has_tlr = true; + if_packet_info.tsi = std::rand(); + if_packet_info.tsf = std::rand(); if_packet_info.num_payload_words32 = 42; pack_and_unpack(if_packet_info); } -BOOST_AUTO_TEST_CASE(test_with_chdr){ +BOOST_AUTO_TEST_CASE(test_with_chdr) +{ vrt::if_packet_info_t if_packet_info; - if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR; - if_packet_info.packet_count = 7; - if_packet_info.has_sid = true; - if_packet_info.has_cid = false; - if_packet_info.has_tsi = false; - if_packet_info.has_tsf = true; - if_packet_info.has_tlr = false; //tlr not suported in CHDR - if_packet_info.tsi = std::rand(); - if_packet_info.tsf = std::rand(); + if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR; + if_packet_info.packet_count = 7; + if_packet_info.has_sid = true; + if_packet_info.has_cid = false; + if_packet_info.has_tsi = false; + if_packet_info.has_tsf = true; + if_packet_info.has_tlr = false; // tlr not suported in CHDR + if_packet_info.tsi = std::rand(); + if_packet_info.tsf = std::rand(); if_packet_info.num_payload_words32 = 24; pack_and_unpack(if_packet_info); } |