aboutsummaryrefslogtreecommitdiff
path: root/tests/unit_tests/epee_utils.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/unit_tests/epee_utils.cpp')
-rw-r--r--tests/unit_tests/epee_utils.cpp421
1 files changed, 421 insertions, 0 deletions
diff --git a/tests/unit_tests/epee_utils.cpp b/tests/unit_tests/epee_utils.cpp
new file mode 100644
index 000000000..e8ddbe3f5
--- /dev/null
+++ b/tests/unit_tests/epee_utils.cpp
@@ -0,0 +1,421 @@
+// Copyright (c) 2014-2017, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+// of conditions and the following disclaimer in the documentation and/or other
+// materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <array>
+#include <boost/range/algorithm/equal.hpp>
+#include <boost/range/algorithm_ext/iota.hpp>
+#include <cstdint>
+#include <gtest/gtest.h>
+#include <iterator>
+#include <string>
+#include <sstream>
+#include <vector>
+
+#ifdef _WIN32
+# include <winsock.h>
+#else
+# include <arpa/inet.h>
+#endif
+
+#include "hex.h"
+#include "span.h"
+#include "string_tools.h"
+
+namespace
+{
+ template<typename Destination, typename Source>
+ bool can_construct()
+ {
+ const unsigned count =
+ unsigned(std::is_constructible<Destination, Source>()) +
+ unsigned(std::is_constructible<Destination, Source&>()) +
+ unsigned(std::is_convertible<Source, Destination>()) +
+ unsigned(std::is_convertible<Source&, Destination>()) +
+ unsigned(std::is_assignable<Destination, Source>()) +
+ unsigned(std::is_assignable<Destination, Source&>());
+ EXPECT_TRUE(count == 6 || count == 0) <<
+ "Mismatch on construction results - " << count << " were true";
+ return count == 6;
+ }
+
+ // This is probably stressing the compiler more than the implementation ...
+ constexpr const epee::span<const char> test_string("a string");
+ static_assert(!test_string.empty(), "test failure");
+ static_assert(test_string.size() == 9, "test failure");
+ static_assert(test_string.size_bytes() == 9, "test_failure");
+ static_assert(test_string.begin() == test_string.cbegin(), "test failure");
+ static_assert(test_string.end() == test_string.cend(), "test failure");
+ static_assert(test_string.cend() - test_string.cbegin() == 9, "test failure");
+ static_assert(*test_string.cbegin() == 'a', "test failure");
+ static_assert(*(test_string.cend() - 2) == 'g', "test failure");
+ static_assert(
+ epee::span<const char>(test_string).cbegin() + 3 == test_string.cbegin() + 3,
+ "test failure"
+ );
+
+ static_assert(epee::span<char>().empty(), "test failure");
+ static_assert(epee::span<char>(nullptr).empty(), "test failure");
+ static_assert(epee::span<const char>("foo", 2).size() == 2, "test failure");
+
+ std::string std_to_hex(const std::vector<unsigned char>& source)
+ {
+ std::stringstream out;
+ out << std::hex;
+ for (const unsigned char byte : source)
+ {
+ out << std::setw(2) << std::setfill('0') << int(byte);
+ }
+ return out.str();
+ }
+
+ std::vector<unsigned char> get_all_bytes()
+ {
+ std::vector<unsigned char> out;
+ out.resize(256);
+ boost::range::iota(out, 0);
+ return out;
+ }
+}
+
+TEST(Span, Traits)
+{
+ EXPECT_TRUE((std::is_same<std::size_t, typename epee::span<char>::size_type>()));
+ EXPECT_TRUE((std::is_same<std::ptrdiff_t, typename epee::span<char>::difference_type>()));
+ EXPECT_TRUE((std::is_same<char, typename epee::span<char>::value_type>()));
+ EXPECT_TRUE((std::is_same<char*, typename epee::span<char>::pointer>()));
+ EXPECT_TRUE((std::is_same<const char*, typename epee::span<char>::const_pointer>()));
+ EXPECT_TRUE((std::is_same<char*, typename epee::span<char>::iterator>()));
+ EXPECT_TRUE((std::is_same<const char*, typename epee::span<char>::const_iterator>()));
+ EXPECT_TRUE((std::is_same<char&, typename epee::span<char>::reference>()));
+ EXPECT_TRUE((std::is_same<const char&, typename epee::span<char>::const_reference>()));
+
+ EXPECT_TRUE((std::is_same<std::size_t, typename epee::span<const char>::size_type>()));
+ EXPECT_TRUE((std::is_same<std::ptrdiff_t, typename epee::span<const char>::difference_type>()));
+ EXPECT_TRUE((std::is_same<const char, typename epee::span<const char>::value_type>()));
+ EXPECT_TRUE((std::is_same<const char*, typename epee::span<const char>::pointer>()));
+ EXPECT_TRUE((std::is_same<const char*, typename epee::span<const char>::const_pointer>()));
+ EXPECT_TRUE((std::is_same<const char*, typename epee::span<const char>::iterator>()));
+ EXPECT_TRUE((std::is_same<const char*, typename epee::span<const char>::const_iterator>()));
+ EXPECT_TRUE((std::is_same<const char&, typename epee::span<const char>::reference>()));
+ EXPECT_TRUE((std::is_same<const char&, typename epee::span<const char>::const_reference>()));
+}
+
+TEST(Span, MutableConstruction)
+{
+ struct no_conversion{};
+
+ EXPECT_TRUE(std::is_constructible<epee::span<char>>());
+ EXPECT_TRUE((std::is_constructible<epee::span<char>, char*, std::size_t>()));
+ EXPECT_FALSE((std::is_constructible<epee::span<char>, const char*, std::size_t>()));
+ EXPECT_FALSE((std::is_constructible<epee::span<char>, unsigned char*, std::size_t>()));
+
+ EXPECT_TRUE((can_construct<epee::span<char>, std::nullptr_t>()));
+ EXPECT_TRUE((can_construct<epee::span<char>, char(&)[1]>()));
+
+ EXPECT_FALSE((can_construct<epee::span<char>, std::vector<char>>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, std::array<char, 1>>()));
+
+ EXPECT_FALSE((can_construct<epee::span<char>, std::wstring>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, const std::vector<char>>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, std::vector<unsigned char>>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, const std::array<char, 1>>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, std::array<unsigned char, 1>>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, const char[1]>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, unsigned char[1]>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, epee::span<const char>>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, epee::span<unsigned char>>()));
+ EXPECT_FALSE((can_construct<epee::span<char>, no_conversion>()));
+}
+
+TEST(Span, ImmutableConstruction)
+{
+ struct no_conversion{};
+
+ EXPECT_TRUE(std::is_constructible<epee::span<const char>>());
+ EXPECT_TRUE((std::is_constructible<epee::span<const char>, char*, std::size_t>()));
+ EXPECT_TRUE((std::is_constructible<epee::span<const char>, const char*, std::size_t>()));
+ EXPECT_FALSE((std::is_constructible<epee::span<const char>, unsigned char*, std::size_t>()));
+
+ EXPECT_FALSE((can_construct<epee::span<const char>, std::string>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, std::vector<char>>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, const std::vector<char>>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, std::array<char, 1>>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, const std::array<char, 1>>()));
+
+ EXPECT_TRUE((can_construct<epee::span<const char>, std::nullptr_t>()));
+ EXPECT_TRUE((can_construct<epee::span<const char>, char[1]>()));
+ EXPECT_TRUE((can_construct<epee::span<const char>, const char[1]>()));
+ EXPECT_TRUE((can_construct<epee::span<const char>, epee::span<const char>>()));
+
+ EXPECT_FALSE((can_construct<epee::span<const char>, std::wstring>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, std::vector<unsigned char>>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, std::array<unsigned char, 1>>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, unsigned char[1]>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, epee::span<unsigned char>>()));
+ EXPECT_FALSE((can_construct<epee::span<const char>, no_conversion>()));
+}
+
+TEST(Span, NoExcept)
+{
+ EXPECT_TRUE(std::is_nothrow_default_constructible<epee::span<char>>());
+ EXPECT_TRUE(std::is_nothrow_move_constructible<epee::span<char>>());
+ EXPECT_TRUE(std::is_nothrow_copy_constructible<epee::span<char>>());
+ EXPECT_TRUE(std::is_move_assignable<epee::span<char>>());
+ EXPECT_TRUE(std::is_copy_assignable<epee::span<char>>());
+
+ char data[10];
+ epee::span<char> lvalue(data);
+ const epee::span<char> clvalue(data);
+ EXPECT_TRUE(noexcept(epee::span<char>()));
+ EXPECT_TRUE(noexcept(epee::span<char>(nullptr)));
+ EXPECT_TRUE(noexcept(epee::span<char>(nullptr, 0)));
+ EXPECT_TRUE(noexcept(epee::span<char>(data)));
+ EXPECT_TRUE(noexcept(epee::span<char>(lvalue)));
+ EXPECT_TRUE(noexcept(epee::span<char>(clvalue)));
+
+ // conversion from mutable to immutable not yet implemented
+ // EXPECT_TRUE(noexcept(epee::span<const char>(lvalue)));
+ // EXPECT_TRUE(noexcept(epee::span<const char>(clvalue)));
+
+ EXPECT_TRUE(noexcept(epee::span<char>(epee::span<char>(lvalue))));
+ EXPECT_TRUE(noexcept(lvalue = lvalue));
+ EXPECT_TRUE(noexcept(lvalue = clvalue));
+ EXPECT_TRUE(noexcept(lvalue = epee::span<char>(lvalue)));
+}
+
+TEST(Span, Nullptr)
+{
+ const auto check_empty = [](epee::span<const char> data)
+ {
+ EXPECT_TRUE(data.empty());
+ EXPECT_EQ(data.cbegin(), data.begin());
+ EXPECT_EQ(data.cend(), data.end());
+ EXPECT_EQ(data.cend(), data.cbegin());
+ EXPECT_EQ(0, data.size());
+ EXPECT_EQ(0, data.size_bytes());
+ };
+ check_empty({});
+ check_empty(nullptr);
+}
+
+TEST(Span, Writing)
+{
+ const int expected[] = {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<int> source;
+
+ epee::span<int> span;
+ EXPECT_TRUE(span.empty());
+ EXPECT_EQ(0, span.size());
+ EXPECT_EQ(0, span.size_bytes());
+
+ source.resize(15);
+ span = {source.data(), source.size()};
+ EXPECT_FALSE(span.empty());
+ EXPECT_EQ(15, span.size());
+ EXPECT_EQ(15 * 4, span.size_bytes());
+
+ boost::range::iota(span, -5);
+ EXPECT_EQ(span.begin(), span.cbegin());
+ EXPECT_EQ(span.end(), span.cend());
+ EXPECT_TRUE(boost::range::equal(expected, source));
+ EXPECT_TRUE(boost::range::equal(expected, span));
+}
+
+TEST(Span, ToByteSpan)
+{
+ const char expected[] = {56, 44, 11, 5};
+ EXPECT_TRUE(
+ boost::range::equal(
+ std::array<std::uint8_t, 4>{{56, 44, 11, 5}},
+ epee::to_byte_span<char>(expected)
+ )
+ );
+ EXPECT_TRUE(
+ boost::range::equal(
+ std::array<char, 4>{{56, 44, 11, 5}},
+ epee::to_byte_span(epee::span<const char>{expected})
+ )
+ );
+}
+
+TEST(Span, AsByteSpan)
+{
+ struct some_pod { char value[4]; };
+ const some_pod immutable {{ 5, 10, 12, 127 }};
+ EXPECT_TRUE(
+ boost::range::equal(
+ std::array<unsigned char, 4>{{5, 10, 12, 127}},
+ epee::as_byte_span(immutable)
+ )
+ );
+ EXPECT_TRUE(
+ boost::range::equal(
+ std::array<std::uint8_t, 3>{{'a', 'y', 0x00}}, epee::as_byte_span("ay")
+ )
+ );
+}
+
+TEST(ToHex, String)
+{
+ EXPECT_TRUE(epee::to_hex::string(nullptr).empty());
+ EXPECT_EQ(
+ std::string{"ffab0100"},
+ epee::to_hex::string(epee::as_byte_span("\xff\xab\x01"))
+ );
+
+ const std::vector<unsigned char> all_bytes = get_all_bytes();
+ EXPECT_EQ(
+ std_to_hex(all_bytes), epee::to_hex::string(epee::to_span(all_bytes))
+ );
+}
+
+TEST(ToHex, Array)
+{
+ EXPECT_EQ(
+ (std::array<char, 8>{{'f', 'f', 'a', 'b', '0', '1', '0', '0'}}),
+ (epee::to_hex::array(std::array<unsigned char, 4>{{0xFF, 0xAB, 0x01, 0x00}}))
+ );
+}
+
+TEST(ToHex, Ostream)
+{
+ std::stringstream out;
+ epee::to_hex::buffer(out, nullptr);
+ EXPECT_TRUE(out.str().empty());
+
+ {
+ const std::uint8_t source[] = {0xff, 0xab, 0x01, 0x00};
+ epee::to_hex::buffer(out, source);
+ }
+
+ std::string expected{"ffab0100"};
+ EXPECT_EQ(expected, out.str());
+
+ const std::vector<unsigned char> all_bytes = get_all_bytes();
+
+ expected.append(std_to_hex(all_bytes));
+ epee::to_hex::buffer(out, epee::to_span(all_bytes));
+ EXPECT_EQ(expected, out.str());
+}
+
+TEST(ToHex, Formatted)
+{
+ std::stringstream out;
+ std::string expected{"<>"};
+
+ epee::to_hex::formatted(out, nullptr);
+ EXPECT_EQ(expected, out.str());
+
+ expected.append("<ffab0100>");
+ epee::to_hex::formatted(out, epee::as_byte_span("\xFF\xAB\x01"));
+ EXPECT_EQ(expected, out.str());
+
+ const std::vector<unsigned char> all_bytes = get_all_bytes();
+
+ expected.append("<").append(std_to_hex(all_bytes)).append(">");
+ epee::to_hex::formatted(out, epee::to_span(all_bytes));
+ EXPECT_EQ(expected, out.str());
+}
+
+TEST(StringTools, BuffToHex)
+{
+ const std::vector<unsigned char> all_bytes = get_all_bytes();
+
+ EXPECT_EQ(
+ std_to_hex(all_bytes),
+ (epee::string_tools::buff_to_hex_nodelimer(
+ std::string{reinterpret_cast<const char*>(all_bytes.data()), all_bytes.size()}
+ ))
+ );
+}
+
+TEST(StringTools, PodToHex)
+{
+ struct some_pod { unsigned char data[4]; };
+ EXPECT_EQ(
+ std::string{"ffab0100"},
+ (epee::string_tools::pod_to_hex(some_pod{{0xFF, 0xAB, 0x01, 0x00}}))
+ );
+}
+
+TEST(StringTools, GetIpString)
+{
+ EXPECT_EQ(
+ std::string{"0.0.0.0"}, epee::string_tools::get_ip_string_from_int32(0)
+ );
+ EXPECT_EQ(
+ std::string{"255.0.255.0"},
+ epee::string_tools::get_ip_string_from_int32(htonl(0xff00ff00))
+ );
+ EXPECT_EQ(
+ std::string{"255.255.255.255"},
+ epee::string_tools::get_ip_string_from_int32(htonl(0xffffffff))
+ );
+}
+
+TEST(StringTools, GetIpInt32)
+{
+ std::uint32_t ip = 0;
+ EXPECT_FALSE(epee::string_tools::get_ip_int32_from_string(ip, ""));
+ EXPECT_FALSE(epee::string_tools::get_ip_int32_from_string(ip, "1."));
+ EXPECT_FALSE(epee::string_tools::get_ip_int32_from_string(ip, "1.1."));
+ EXPECT_FALSE(epee::string_tools::get_ip_int32_from_string(ip, "1.1.1."));
+ EXPECT_FALSE(epee::string_tools::get_ip_int32_from_string(ip, "ff.0.ff.0"));
+ EXPECT_FALSE(epee::string_tools::get_ip_int32_from_string(ip, "1.1.1.256"));
+
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "1"));
+ EXPECT_EQ(htonl(1), ip);
+
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "1.1"));
+ EXPECT_EQ(htonl(0x1000001), ip);
+
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "1.1.1"));
+ EXPECT_EQ(htonl(0x1010001), ip);
+
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "0.0.0.0"));
+ EXPECT_EQ(0, ip);
+
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "1.1.1.1"));
+ EXPECT_EQ(htonl(0x01010101), ip);
+
+/*
+ The existing epee conversion function does not work with 255.255.255.255, for
+ the reasons specified in the inet_addr documentation. Consider fixing in a
+ future patch. This address is not likely to be used for purposes within
+ monero.
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "255.255.255.255"));
+ EXPECT_EQ(htonl(0xffffffff), ip);
+*/
+
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "10.0377.0.0377"));
+ EXPECT_EQ(htonl(0xaff00ff), ip);
+
+ EXPECT_TRUE(epee::string_tools::get_ip_int32_from_string(ip, "0xff.10.0xff.0"));
+ EXPECT_EQ(htonl(0xff0aff00), ip);
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-08 04:08:04 +0000