aboutsummaryrefslogtreecommitdiffstats
path: root/host/tests
diff options
context:
space:
mode:
Diffstat (limited to 'host/tests')
-rw-r--r--host/tests/CMakeLists.txt7
-rw-r--r--host/tests/addr_test.cpp7
-rw-r--r--host/tests/chdr_test.cpp144
-rw-r--r--host/tests/convert_test.cpp40
-rw-r--r--host/tests/dict_test.cpp25
-rw-r--r--host/tests/fp_compare_delta_test.cpp6
-rw-r--r--host/tests/math_test.cpp29
-rw-r--r--host/tests/sid_t_test.cpp158
-rw-r--r--host/tests/time_spec_test.cpp4
9 files changed, 413 insertions, 7 deletions
diff --git a/host/tests/CMakeLists.txt b/host/tests/CMakeLists.txt
index 62544b69b..1fb1a1951 100644
--- a/host/tests/CMakeLists.txt
+++ b/host/tests/CMakeLists.txt
@@ -27,16 +27,19 @@ SET(test_sources
addr_test.cpp
buffer_test.cpp
byteswap_test.cpp
- convert_test.cpp
cast_test.cpp
+ chdr_test.cpp
+ convert_test.cpp
dict_test.cpp
error_test.cpp
fp_compare_delta_test.cpp
fp_compare_epsilon_test.cpp
gain_group_test.cpp
+ math_test.cpp
msg_test.cpp
property_test.cpp
ranges_test.cpp
+ sid_t_test.cpp
sph_recv_test.cpp
sph_send_test.cpp
subdev_spec_test.cpp
@@ -54,7 +57,7 @@ SET(UHD_TEST_LIBRARY_DIRS ${Boost_LIBRARY_DIRS})
FOREACH(test_source ${test_sources})
GET_FILENAME_COMPONENT(test_name ${test_source} NAME_WE)
ADD_EXECUTABLE(${test_name} ${test_source})
- TARGET_LINK_LIBRARIES(${test_name} uhd)
+ TARGET_LINK_LIBRARIES(${test_name} uhd ${Boost_LIBRARIES})
UHD_ADD_TEST(${test_name} ${test_name})
UHD_INSTALL(TARGETS ${test_name} RUNTIME DESTINATION ${PKG_LIB_DIR}/tests COMPONENT tests)
ENDFOREACH(test_source)
diff --git a/host/tests/addr_test.cpp b/host/tests/addr_test.cpp
index cea2f224c..61bb6d049 100644
--- a/host/tests/addr_test.cpp
+++ b/host/tests/addr_test.cpp
@@ -66,6 +66,13 @@ BOOST_AUTO_TEST_CASE(test_device_addr){
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);
+ BOOST_CHECK_EQUAL(dev_addr_lhs1["key1"], "val1");
+ BOOST_CHECK_EQUAL(dev_addr_lhs1["key2"], "val2x");
+ BOOST_CHECK_EQUAL(dev_addr_lhs1["key3"], "val3");
+ std::cout << "Merged: " << dev_addr_lhs1.to_string() << std::endl;
}
BOOST_AUTO_TEST_CASE(test_dboard_id){
diff --git a/host/tests/chdr_test.cpp b/host/tests/chdr_test.cpp
new file mode 100644
index 000000000..f48073a09
--- /dev/null
+++ b/host/tests/chdr_test.cpp
@@ -0,0 +1,144 @@
+//
+// Copyright 2014 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/transport/chdr.hpp>
+#include <uhd/utils/byteswap.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/format.hpp>
+#include <cstdlib>
+#include <iostream>
+
+using namespace uhd::transport::vrt;
+
+static void pack_and_unpack(
+ if_packet_info_t &if_packet_info_in
+){
+ // Temp buffer for packed packet
+ boost::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)
+ );
+ 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));
+ }
+
+ //pack metadata into a vrt header
+ chdr::if_hdr_pack_be(
+ packet_buff, if_packet_info_in
+ );
+ std::cout << std::endl;
+ boost::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;
+ }
+
+ 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
+ );
+
+ //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(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){
+ BOOST_CHECK_EQUAL(if_packet_info_in.tsf, if_packet_info_out.tsf);
+ }
+}
+
+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.num_payload_words32 = 24;
+ if_packet_info.num_payload_bytes = 95;
+ pack_and_unpack(if_packet_info);
+}
+
+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.num_payload_words32 = 4;
+ if_packet_info.num_payload_bytes = 16;
+ pack_and_unpack(if_packet_info);
+}
+
+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.num_payload_words32 = 4;
+ if_packet_info.num_payload_bytes = 16;
+ pack_and_unpack(if_packet_info);
+}
+
+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.num_payload_words32 = 4;
+ if_packet_info.num_payload_bytes = 16;
+ pack_and_unpack(if_packet_info);
+}
+
+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.num_payload_words32 = 4;
+ if_packet_info.num_payload_bytes = 16;
+ pack_and_unpack(if_packet_info);
+}
+
diff --git a/host/tests/convert_test.cpp b/host/tests/convert_test.cpp
index 8ef1e74cc..d71d756dd 100644
--- a/host/tests/convert_test.cpp
+++ b/host/tests/convert_test.cpp
@@ -415,3 +415,43 @@ BOOST_AUTO_TEST_CASE(test_convert_types_sc16_and_sc8){
test_convert_types_sc16(nsamps, id, 256);
}
}
+
+/***********************************************************************
+ * Test short conversion
+ **********************************************************************/
+static void test_convert_types_u8(
+ size_t nsamps, convert::id_type &id
+){
+ //fill the input samples
+ std::vector<boost::uint8_t> input(nsamps), output(nsamps);
+ //BOOST_FOREACH(boost::uint8_t &in, input) in = boost::uint8_t(std::rand() & 0xFF);
+ boost::uint32_t d = 48;
+ BOOST_FOREACH(boost::uint8_t &in, input) in = d++;
+
+ //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_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;
+
+ //try various lengths to test edge cases
+ id.output_format = "u8_item32_le";
+ for (size_t nsamps = 1; nsamps < 16; nsamps++){
+ test_convert_types_u8(nsamps, id);
+ }
+
+ //try various lengths to test edge cases
+ id.output_format = "u8_item32_be";
+ for (size_t nsamps = 1; nsamps < 16; nsamps++){
+ test_convert_types_u8(nsamps, id);
+ }
+}
diff --git a/host/tests/dict_test.cpp b/host/tests/dict_test.cpp
index 7b388d090..333aadbba 100644
--- a/host/tests/dict_test.cpp
+++ b/host/tests/dict_test.cpp
@@ -70,3 +70,28 @@ BOOST_AUTO_TEST_CASE(test_dict_pop){
BOOST_CHECK(d.keys()[0] == -1);
BOOST_CHECK(d.keys()[1] == 1);
}
+
+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")
+ ;
+
+ 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")
+ ;
+ BOOST_CHECK_THROW(d3.update(d2), uhd::value_error);
+}
+
+
diff --git a/host/tests/fp_compare_delta_test.cpp b/host/tests/fp_compare_delta_test.cpp
index 0ac4e257d..36ff14756 100644
--- a/host/tests/fp_compare_delta_test.cpp
+++ b/host/tests/fp_compare_delta_test.cpp
@@ -239,12 +239,12 @@ BOOST_AUTO_TEST_CASE(double_greaterthanequals_operators) {
BOOST_AUTO_TEST_CASE(frequency_compare_function) {
- BOOST_CHECK(uhd::math::frequencies_are_equal(6817333232, 6817333232));
- BOOST_CHECK(!uhd::math::frequencies_are_equal(6817333233, 6817333232));
+ 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));
BOOST_CHECK(!uhd::math::frequencies_are_equal(6817333232.5, 6817333232.6));
BOOST_CHECK(uhd::math::frequencies_are_equal(16.8173332321e9, 16.8173332321e9));
BOOST_CHECK(!uhd::math::frequencies_are_equal(16.8173332322e9, 16.8173332321e9));
BOOST_CHECK(!uhd::math::frequencies_are_equal(5.0, 4.0));
- BOOST_CHECK(uhd::math::frequencies_are_equal(48750000, 48749999.9946));
+ BOOST_CHECK(uhd::math::frequencies_are_equal(48750000.0, 48749999.9946));
}
diff --git a/host/tests/math_test.cpp b/host/tests/math_test.cpp
new file mode 100644
index 000000000..6c890c484
--- /dev/null
+++ b/host/tests/math_test.cpp
@@ -0,0 +1,29 @@
+//
+// Copyright 2014 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <boost/test/unit_test.hpp>
+#include <boost/cstdint.hpp>
+#include <uhd/utils/math.hpp>
+
+// NOTE: This is not the only math test case, see e.g. special tests
+// for fp comparison.
+
+BOOST_AUTO_TEST_CASE(test_log2){
+ double y = uhd::math::log2(16.0);
+ BOOST_CHECK_EQUAL(y, 4.0);
+}
+
diff --git a/host/tests/sid_t_test.cpp b/host/tests/sid_t_test.cpp
new file mode 100644
index 000000000..31eb4b458
--- /dev/null
+++ b/host/tests/sid_t_test.cpp
@@ -0,0 +1,158 @@
+//
+// Copyright 2014 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+#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::uint32_t sid_value = 0x01020310;
+ sid_t sid(sid_value);
+
+ BOOST_CHECK_EQUAL(sid.is_set(), true);
+ BOOST_CHECK_EQUAL(sid.to_pp_string(), "1.2>3.16");
+ BOOST_CHECK_EQUAL(sid.to_pp_string_hex(), "01:02>03:10");
+ BOOST_CHECK_EQUAL(sid.get_src(), (boost::uint32_t)0x0102);
+ BOOST_CHECK_EQUAL(sid.get_dst(), (boost::uint32_t)0x0310);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)0x01);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x02);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x03);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0x10);
+ BOOST_CHECK_EQUAL(sid == sid, true);
+ BOOST_CHECK_EQUAL(sid == sid_value, true);
+
+ boost::uint32_t check_sid_val = (boost::uint32_t) sid;
+ BOOST_CHECK_EQUAL(check_sid_val, sid_value);
+
+ std::stringstream ss_dec;
+ ss_dec << sid;
+ BOOST_CHECK_EQUAL(ss_dec.str(), "1.2>3.16");
+
+ std::stringstream ss_hex;
+ ss_hex << std::hex << sid;
+ BOOST_CHECK_EQUAL(ss_hex.str(), "01:02>03:10");
+
+ sid_t empty_sid;
+ BOOST_CHECK_EQUAL(empty_sid.is_set(), false);
+ BOOST_CHECK_EQUAL(empty_sid.to_pp_string(), "x.x>x.x");
+ BOOST_CHECK_EQUAL(empty_sid.to_pp_string_hex(), "xx:xx>xx:xx");
+ BOOST_CHECK_EQUAL(empty_sid == sid, false);
+ BOOST_CHECK_EQUAL(empty_sid == sid_value, false);
+ BOOST_CHECK_EQUAL((bool) empty_sid, false);
+
+ empty_sid = sid_value; // No longer empty
+ BOOST_CHECK_EQUAL(empty_sid.is_set(), true);
+ BOOST_CHECK_EQUAL(empty_sid == sid, true);
+}
+
+BOOST_AUTO_TEST_CASE(test_sid_t_set) {
+ boost::uint32_t sid_value = 0x0;
+ sid_t sid(sid_value);
+
+ sid.set(0x01020304);
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x01020304);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(),(boost::uint32_t)0x01);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x02);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x03);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0x04);
+ BOOST_CHECK_EQUAL(sid.get_dst_xbarport(), (boost::uint32_t)0x0);
+ BOOST_CHECK_EQUAL(sid.get_dst_blockport(), (boost::uint32_t)0x4);
+
+ sid.set_src_addr(0x0a);
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x0a020304);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)0x0a);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x02);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x03);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0x04);
+
+ sid.set_src_endpoint(0x0b);
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x0a0b0304);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)0x0a);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x0b);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x03);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0x04);
+
+ sid.set_dst_addr(0x0c);
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x0a0b0c04);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)0x0a);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x0b);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x0c);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0x04);
+
+ sid.set_dst_endpoint(0x0d);
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x0a0b0c0d);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)0x0a);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x0b);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x0c);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0x0d);
+
+ sid.set_dst_xbarport(0xb);
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x0a0b0cbd);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)0x0a);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x0b);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x0c);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0xbd);
+
+ sid.set_dst_blockport(0xc);
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x0a0b0cbc);
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)0x0a);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)0x0b);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)0x0c);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)0xbc);
+
+ sid_t flipped_sid = sid.reversed();
+ BOOST_CHECK_EQUAL(flipped_sid.get(), (boost::uint32_t)0x0cbc0a0b);
+
+ // In-place
+ sid.reverse();
+ BOOST_CHECK_EQUAL(sid.get(), (boost::uint32_t)0x0cbc0a0b);
+}
+
+BOOST_AUTO_TEST_CASE(test_sid_t_from_str) {
+ sid_t sid("1.2>3.4");
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)1);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)2);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)3);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)4);
+
+ sid = "01:02>03:10";
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)1);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)2);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)3);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)16);
+
+ sid = "01:06/03:10";
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)1);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)6);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)3);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)16);
+
+ sid = "01:02:04:10";
+ BOOST_CHECK_EQUAL(sid.get_src_addr(), (boost::uint32_t)1);
+ BOOST_CHECK_EQUAL(sid.get_src_endpoint(), (boost::uint32_t)2);
+ BOOST_CHECK_EQUAL(sid.get_dst_addr(), (boost::uint32_t)4);
+ BOOST_CHECK_EQUAL(sid.get_dst_endpoint(), (boost::uint32_t)16);
+
+ BOOST_REQUIRE_THROW(sid_t fail_sid("foobar"), uhd::value_error);
+ BOOST_REQUIRE_THROW(sid_t fail_sid("01:02:03:4"), uhd::value_error);
+ BOOST_REQUIRE_THROW(sid_t fail_sid("01:02:03:004"), uhd::value_error);
+ BOOST_REQUIRE_THROW(sid_t fail_sid("1.2.3.0004"), uhd::value_error);
+}
diff --git a/host/tests/time_spec_test.cpp b/host/tests/time_spec_test.cpp
index c9b9652f9..b98bea7d9 100644
--- a/host/tests/time_spec_test.cpp
+++ b/host/tests/time_spec_test.cpp
@@ -112,8 +112,8 @@ 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;
- const long long tick_in = 23423436291667;
+ 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;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 23:45:51 +0000