mirror of
https://github.com/monero-project/monero.git
synced 2025-05-05 10:35:04 -04:00
Improvements for epee binary to hex functions:
- Performance improvements - Added `span` for zero-copy pointer+length arguments - Added `std::ostream` overload for direct writing to output buffers - Removal of unused `string_tools::buff_to_hex`
This commit is contained in:
Lee Clagett
parent
9ed496bbc5
commit
4a8f96f95d
14 changed files with 767 additions and 76 deletions
|
|
@ -27,18 +27,342 @@
|
|||
// 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 <cstdint>
|
||||
#include <gtest/gtest.h>
|
||||
#include <string>
|
||||
|
||||
#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(
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue