aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/difficulty/difficulty.cpp1
-rw-r--r--tests/functional_tests/transactions_flow_test.cpp16
-rw-r--r--tests/fuzz/fuzzer.cpp4
-rw-r--r--tests/unit_tests/CMakeLists.txt1
-rw-r--r--tests/unit_tests/epee_utils.cpp57
-rw-r--r--tests/unit_tests/expect.cpp915
-rw-r--r--tests/unit_tests/multisig.cpp2
-rw-r--r--tests/unit_tests/ringdb.cpp8
-rw-r--r--tests/unit_tests/wipeable_string.cpp7
9 files changed, 997 insertions, 14 deletions
diff --git a/tests/difficulty/difficulty.cpp b/tests/difficulty/difficulty.cpp
index 736a58237..996913a19 100644
--- a/tests/difficulty/difficulty.cpp
+++ b/tests/difficulty/difficulty.cpp
@@ -34,6 +34,7 @@
#include <iostream>
#include <vector>
#include <algorithm>
+#include <stdexcept>
#include "cryptonote_config.h"
#include "cryptonote_basic/difficulty.h"
diff --git a/tests/functional_tests/transactions_flow_test.cpp b/tests/functional_tests/transactions_flow_test.cpp
index 7248efade..ffe500d21 100644
--- a/tests/functional_tests/transactions_flow_test.cpp
+++ b/tests/functional_tests/transactions_flow_test.cpp
@@ -84,10 +84,10 @@ bool do_send_money(tools::wallet2& w1, tools::wallet2& w2, size_t mix_in_factor,
try
{
- tools::wallet2::pending_tx ptx;
- std::vector<size_t> indices = w1.select_available_outputs([](const tools::wallet2::transfer_details&) { return true; });
- w1.transfer(dsts, mix_in_factor, indices, 0, TEST_FEE, std::vector<uint8_t>(), tools::detail::null_split_strategy, tools::tx_dust_policy(TEST_DUST_THRESHOLD), tx, ptx);
- w1.commit_tx(ptx);
+ std::vector<tools::wallet2::pending_tx> ptx;
+ ptx = w1.create_transactions_2(dsts, mix_in_factor, 0, 0, std::vector<uint8_t>(), 0, {});
+ for (auto &p: ptx)
+ w1.commit_tx(p);
return true;
}
catch (const std::exception&)
@@ -138,7 +138,7 @@ bool transactions_flow_test(std::string& working_folder,
return false;
}
- w1.init(true, daemon_addr_a);
+ w1.init(daemon_addr_a);
uint64_t blocks_fetched = 0;
bool received_money;
@@ -149,7 +149,7 @@ bool transactions_flow_test(std::string& working_folder,
return false;
}
- w2.init(true, daemon_addr_b);
+ w2.init(daemon_addr_b);
MGINFO_GREEN("Using wallets: " << ENDL
<< "Source: " << w1.get_account().get_public_address_str(MAINNET) << ENDL << "Path: " << working_folder + "/" + path_source_wallet << ENDL
@@ -167,8 +167,8 @@ bool transactions_flow_test(std::string& working_folder,
daemon_req.miner_address = w1.get_account().get_public_address_str(MAINNET);
daemon_req.threads_count = 9;
r = net_utils::invoke_http_json("/start_mining", daemon_req, daemon_rsp, http_client, std::chrono::seconds(10));
- CHECK_AND_ASSERT_MES(r, false, "failed to get getrandom_outs");
- CHECK_AND_ASSERT_MES(daemon_rsp.status == CORE_RPC_STATUS_OK, false, "failed to getrandom_outs.bin");
+ CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
+ CHECK_AND_ASSERT_MES(daemon_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
//wait for money, until balance will have enough money
w1.refresh(true, blocks_fetched, received_money, ok);
diff --git a/tests/fuzz/fuzzer.cpp b/tests/fuzz/fuzzer.cpp
index b81bf80fe..032ff049a 100644
--- a/tests/fuzz/fuzzer.cpp
+++ b/tests/fuzz/fuzzer.cpp
@@ -52,6 +52,10 @@ int run_fuzzer(int argc, const char **argv, Fuzzer &fuzzer)
return 1;
}
+#ifdef __AFL_HAVE_MANUAL_CONTROL
+ __AFL_INIT();
+#endif
+
int ret = fuzzer.init();
if (ret)
return ret;
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 741bb1882..d6bcbde46 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -47,6 +47,7 @@ set(unit_tests_sources
epee_boosted_tcp_server.cpp
epee_levin_protocol_handler_async.cpp
epee_utils.cpp
+ expect.cpp
fee.cpp
json_serialization.cpp
get_xtype_from_string.cpp
diff --git a/tests/unit_tests/epee_utils.cpp b/tests/unit_tests/epee_utils.cpp
index 3474000d8..c2b0b7647 100644
--- a/tests/unit_tests/epee_utils.cpp
+++ b/tests/unit_tests/epee_utils.cpp
@@ -166,12 +166,17 @@ TEST(Span, Traits)
TEST(Span, MutableConstruction)
{
struct no_conversion{};
+ struct inherited : 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(std::is_constructible<epee::span<no_conversion>>());
+ EXPECT_TRUE((std::is_constructible<epee::span<no_conversion>, no_conversion*, std::size_t>()));
+ EXPECT_FALSE((std::is_constructible<epee::span<no_conversion>, inherited*, std::size_t>()));
+
EXPECT_TRUE((can_construct<epee::span<char>, std::nullptr_t>()));
EXPECT_TRUE((can_construct<epee::span<char>, char(&)[1]>()));
@@ -193,12 +198,19 @@ TEST(Span, MutableConstruction)
TEST(Span, ImmutableConstruction)
{
struct no_conversion{};
+ struct inherited : 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_TRUE(std::is_constructible<epee::span<const no_conversion>>());
+ EXPECT_TRUE((std::is_constructible<epee::span<const no_conversion>, const no_conversion*, std::size_t>()));
+ EXPECT_TRUE((std::is_constructible<epee::span<const no_conversion>, no_conversion*, std::size_t>()));
+ EXPECT_FALSE((std::is_constructible<epee::span<const no_conversion>, const inherited*, std::size_t>()));
+ EXPECT_FALSE((std::is_constructible<epee::span<const no_conversion>, inherited*, 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>>()));
@@ -231,7 +243,6 @@ TEST(Span, NoExcept)
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)));
@@ -284,6 +295,25 @@ TEST(Span, Writing)
EXPECT_TRUE(boost::range::equal(expected, span));
}
+TEST(Span, RemovePrefix)
+{
+ const std::array<unsigned, 4> expected{0, 1, 2, 3};
+ auto span = epee::to_span(expected);
+
+ EXPECT_EQ(expected.begin(), span.begin());
+ EXPECT_EQ(expected.end(), span.end());
+
+ EXPECT_EQ(2u, span.remove_prefix(2));
+ EXPECT_EQ(expected.begin() + 2, span.begin());
+ EXPECT_EQ(expected.end(), span.end());
+
+ EXPECT_EQ(2u, span.remove_prefix(3));
+ EXPECT_EQ(span.begin(), span.end());
+ EXPECT_EQ(expected.end(), span.begin());
+
+ EXPECT_EQ(0u, span.remove_prefix(100));
+}
+
TEST(Span, ToByteSpan)
{
const char expected[] = {56, 44, 11, 5};
@@ -318,6 +348,30 @@ TEST(Span, AsByteSpan)
);
}
+TEST(Span, AsMutByteSpan)
+{
+ struct some_pod { char value[4]; };
+ some_pod actual {};
+
+ auto span = epee::as_mut_byte_span(actual);
+ boost::range::iota(span, 1);
+ EXPECT_TRUE(
+ boost::range::equal(
+ std::array<unsigned char, 4>{{1, 2, 3, 4}}, actual.value
+ )
+ );
+}
+
+TEST(Span, ToMutSpan)
+{
+ std::vector<unsigned> mut;
+ mut.resize(4);
+
+ auto span = epee::to_mut_span(mut);
+ boost::range::iota(span, 1);
+ EXPECT_EQ((std::vector<unsigned>{1, 2, 3, 4}), mut);
+}
+
TEST(ToHex, String)
{
EXPECT_TRUE(epee::to_hex::string(nullptr).empty());
@@ -330,6 +384,7 @@ TEST(ToHex, String)
EXPECT_EQ(
std_to_hex(all_bytes), epee::to_hex::string(epee::to_span(all_bytes))
);
+
}
TEST(ToHex, Array)
diff --git a/tests/unit_tests/expect.cpp b/tests/unit_tests/expect.cpp
new file mode 100644
index 000000000..efa843496
--- /dev/null
+++ b/tests/unit_tests/expect.cpp
@@ -0,0 +1,915 @@
+// Copyright (c) 2018, 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 <gtest/gtest.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/utility/string_ref.hpp>
+#include <string>
+#include <system_error>
+#include <type_traits>
+
+#include "common/expect.h"
+
+namespace
+{
+ struct move_only;
+ struct throw_construct;
+ struct throw_copies;
+ struct throw_moves;
+
+ struct move_only
+ {
+ move_only() = default;
+ move_only(move_only const&) = delete;
+ move_only(move_only&&) = default;
+ ~move_only() = default;
+ move_only& operator=(move_only const&) = delete;
+ move_only& operator=(move_only&&) = default;
+ };
+
+ struct throw_construct
+ {
+ throw_construct() {}
+ throw_construct(int) {}
+ throw_construct(throw_construct const&) = default;
+ throw_construct(throw_construct&&) = default;
+ ~throw_construct() = default;
+ throw_construct& operator=(throw_construct const&) = default;
+ throw_construct& operator=(throw_construct&&) = default;
+ };
+
+ struct throw_copies
+ {
+ throw_copies() noexcept {}
+ throw_copies(throw_copies const&) {}
+ throw_copies(throw_copies&&) = default;
+ ~throw_copies() = default;
+ throw_copies& operator=(throw_copies const&) { return *this; }
+ throw_copies& operator=(throw_copies&&) = default;
+ bool operator==(throw_copies const&) noexcept { return true; }
+ bool operator==(throw_moves const&) noexcept { return true; }
+ };
+
+ struct throw_moves
+ {
+ throw_moves() noexcept {}
+ throw_moves(throw_moves const&) = default;
+ throw_moves(throw_moves&&) {}
+ ~throw_moves() = default;
+ throw_moves& operator=(throw_moves const&) = default;
+ throw_moves& operator=(throw_moves&&) { return *this; }
+ bool operator==(throw_moves const&) { return true; }
+ bool operator==(throw_copies const&) { return true; }
+ };
+
+ template<typename T>
+ void construction_bench()
+ {
+ EXPECT_TRUE(std::is_copy_constructible<expect<T>>());
+ EXPECT_TRUE(std::is_move_constructible<expect<T>>());
+ EXPECT_TRUE(std::is_copy_assignable<expect<T>>());
+ EXPECT_TRUE(std::is_move_assignable<expect<T>>());
+ EXPECT_TRUE(std::is_destructible<expect<T>>());
+ }
+
+ template<typename T>
+ void noexcept_bench()
+ {
+ EXPECT_TRUE(std::is_nothrow_copy_constructible<expect<T>>());
+ EXPECT_TRUE(std::is_nothrow_move_constructible<expect<T>>());
+ EXPECT_TRUE(std::is_nothrow_copy_assignable<expect<T>>());
+ EXPECT_TRUE(std::is_nothrow_move_assignable<expect<T>>());
+ EXPECT_TRUE(std::is_nothrow_destructible<expect<T>>());
+
+ EXPECT_TRUE(noexcept(bool(std::declval<expect<T>>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<T>>().has_error()));
+ EXPECT_TRUE(noexcept(std::declval<expect<T>>().error()));
+ EXPECT_TRUE(noexcept(std::declval<expect<T>>().equal(std::declval<expect<T>>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<T>>() == std::declval<expect<T>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<T>>() != std::declval<expect<T>>()));
+ }
+
+ template<typename T>
+ void conversion_bench()
+ {
+ EXPECT_TRUE((std::is_convertible<std::error_code, expect<T>>()));
+ EXPECT_TRUE((std::is_convertible<std::error_code&&, expect<T>>()));
+ EXPECT_TRUE((std::is_convertible<std::error_code&, expect<T>>()));
+ EXPECT_TRUE((std::is_convertible<std::error_code const&, expect<T>>()));
+
+ EXPECT_TRUE((std::is_constructible<expect<T>, std::error_code>()));
+ EXPECT_TRUE((std::is_constructible<expect<T>, std::error_code&&>()));
+ EXPECT_TRUE((std::is_constructible<expect<T>, std::error_code&>()));
+ EXPECT_TRUE((std::is_constructible<expect<T>, std::error_code const&>()));
+ }
+}
+
+
+TEST(Expect, Constructions)
+{
+ construction_bench<void>();
+ construction_bench<int>();
+
+ EXPECT_TRUE(std::is_constructible<expect<void>>());
+
+ EXPECT_TRUE((std::is_constructible<expect<throw_construct>, expect<int>>()));
+
+ EXPECT_TRUE(std::is_move_constructible<expect<move_only>>());
+ EXPECT_TRUE(std::is_move_assignable<expect<move_only>>());
+}
+
+TEST(Expect, Conversions)
+{
+ struct implicit { implicit(int) {} };
+ struct explicit_only { explicit explicit_only(int) {} };
+
+ conversion_bench<void>();
+ conversion_bench<int>();
+
+ EXPECT_TRUE((std::is_convertible<int, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<int&&, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<int&, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<int const, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<expect<unsigned>, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<expect<unsigned>&&, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<expect<unsigned>&, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<expect<unsigned> const&, expect<int>>()));
+ EXPECT_TRUE((std::is_convertible<expect<int>, expect<implicit>>()));
+ EXPECT_TRUE((std::is_convertible<expect<int>&&, expect<implicit>>()));
+ EXPECT_TRUE((std::is_convertible<expect<int>&, expect<implicit>>()));
+ EXPECT_TRUE((std::is_convertible<expect<int> const&, expect<implicit>>()));
+ EXPECT_TRUE(!(std::is_convertible<expect<int>, expect<explicit_only>>()));
+ EXPECT_TRUE(!(std::is_convertible<expect<int>&&, expect<explicit_only>>()));
+ EXPECT_TRUE(!(std::is_convertible<expect<int>&, expect<explicit_only>>()));
+ EXPECT_TRUE(!(std::is_convertible<expect<int> const&, expect<explicit_only>>()));
+
+ EXPECT_TRUE((std::is_constructible<expect<int>, int>()));
+ EXPECT_TRUE((std::is_constructible<expect<int>, int&&>()));
+ EXPECT_TRUE((std::is_constructible<expect<int>, int&>()));
+ EXPECT_TRUE((std::is_constructible<expect<int>, int const&>()));
+ EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned>>()));
+ EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned>&&>()));
+ EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned>&>()));
+ EXPECT_TRUE((std::is_constructible<expect<int>, expect<unsigned> const&>()));
+ EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int>>()));
+ EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int>&&>()));
+ EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int>&>()));
+ EXPECT_TRUE((std::is_constructible<expect<implicit>, expect<int> const&>()));
+ EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int>>()));
+ EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int>&&>()));
+ EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int>&>()));
+ EXPECT_TRUE(!(std::is_constructible<expect<explicit_only>, expect<int> const&>()));
+
+ EXPECT_EQ(expect<int>{expect<short>{100}}.value(), 100);
+
+ expect<std::string> val1{std::string{}};
+ expect<const char*> val2{"foo"};
+
+ EXPECT_EQ(val1.value(), std::string{});
+ EXPECT_EQ(val2.value(), std::string{"foo"});
+
+ const expect<std::string> val3{val2};
+
+ EXPECT_EQ(val1.value(), std::string{});
+ EXPECT_EQ(val2.value(), std::string{"foo"});
+ EXPECT_EQ(val3.value(), std::string{"foo"});
+
+ val1 = val2;
+
+ EXPECT_EQ(val1.value(), "foo");
+ EXPECT_EQ(val2.value(), std::string{"foo"});
+ EXPECT_EQ(val3.value(), "foo");
+}
+
+TEST(Expect, NoExcept)
+{
+ noexcept_bench<void>();
+ noexcept_bench<int>();
+
+ EXPECT_TRUE(std::is_nothrow_constructible<expect<void>>());
+
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, int>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned>>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned>&&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned>&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<int>, expect<unsigned> const&>()));
+
+ EXPECT_TRUE(noexcept(expect<int>{std::declval<expect<unsigned>&&>()}));
+ EXPECT_TRUE(noexcept(expect<int>{std::declval<expect<unsigned> const&>()}));
+ EXPECT_TRUE(noexcept(std::declval<expect<int>>().has_value()));
+ EXPECT_TRUE(noexcept(*std::declval<expect<int>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<int>>().equal(std::declval<expect<unsigned>>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<unsigned>>().equal(std::declval<expect<int>>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<int>>().equal(0)));
+ EXPECT_TRUE(noexcept(std::declval<expect<int>>() == std::declval<expect<unsigned>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<unsigned>>() == std::declval<expect<int>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<int>>() == 0));
+ EXPECT_TRUE(noexcept(0 == std::declval<expect<int>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<int>>() != std::declval<expect<unsigned>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<unsigned>>() != std::declval<expect<int>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<int>>() != 0));
+ EXPECT_TRUE(noexcept(0 != std::declval<expect<int>>()));
+
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code&&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, std::error_code const&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct&&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_construct>, throw_construct const&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int>>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int>&&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int>&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_construct>, expect<int> const&>()));
+ EXPECT_TRUE(std::is_nothrow_copy_constructible<expect<throw_construct>>());
+ EXPECT_TRUE(std::is_nothrow_move_constructible<expect<throw_construct>>());
+ EXPECT_TRUE(std::is_nothrow_copy_assignable<expect<throw_construct>>());
+ EXPECT_TRUE(std::is_nothrow_move_assignable<expect<throw_construct>>());
+ EXPECT_TRUE(std::is_nothrow_destructible<expect<throw_construct>>());
+
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code&&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, std::error_code const&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, throw_copies>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_copies>, throw_copies&&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_copies>, throw_copies&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_copies>, throw_copies const&>()));
+ EXPECT_TRUE(!std::is_nothrow_copy_constructible<expect<throw_copies>>());
+ EXPECT_TRUE(std::is_nothrow_move_constructible<expect<throw_copies>>());
+ EXPECT_TRUE(!std::is_nothrow_copy_assignable<expect<throw_copies>>());
+ EXPECT_TRUE(std::is_nothrow_move_assignable<expect<throw_copies>>());
+ EXPECT_TRUE(std::is_nothrow_destructible<expect<throw_copies>>());
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<expect<throw_copies>>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<throw_copies>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<expect<throw_copies>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<throw_copies>()));
+ EXPECT_TRUE(noexcept(std::declval<throw_copies>() == std::declval<expect<throw_copies>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<expect<throw_copies>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<throw_copies>()));
+ EXPECT_TRUE(noexcept(std::declval<throw_copies>() != std::declval<expect<throw_copies>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<expect<throw_moves>>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>().equal(std::declval<throw_moves>())));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<expect<throw_moves>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() == std::declval<throw_moves>()));
+ EXPECT_TRUE(noexcept(std::declval<throw_moves>() == std::declval<expect<throw_copies>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<expect<throw_moves>>()));
+ EXPECT_TRUE(noexcept(std::declval<expect<throw_copies>>() != std::declval<throw_moves>()));
+ EXPECT_TRUE(noexcept(std::declval<throw_moves>() != std::declval<expect<throw_copies>>()));
+
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code&&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code&>()));
+ EXPECT_TRUE((std::is_nothrow_constructible<expect<throw_moves>, std::error_code const&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves&&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves&>()));
+ EXPECT_TRUE(!(std::is_nothrow_constructible<expect<throw_moves>, throw_moves const&>()));
+ EXPECT_TRUE(std::is_nothrow_copy_constructible<expect<throw_moves>>());
+ EXPECT_TRUE(!std::is_nothrow_move_constructible<expect<throw_moves>>());
+ EXPECT_TRUE(std::is_nothrow_copy_assignable<expect<throw_moves>>());
+ EXPECT_TRUE(!std::is_nothrow_move_assignable<expect<throw_moves>>());
+ EXPECT_TRUE(std::is_nothrow_destructible<expect<throw_copies>>());
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<expect<throw_moves>>())));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<throw_moves>())));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<expect<throw_moves>>()));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<throw_moves>()));
+ EXPECT_TRUE(!noexcept(std::declval<throw_moves>() == std::declval<expect<throw_moves>>()));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<expect<throw_moves>>()));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<throw_moves>()));
+ EXPECT_TRUE(!noexcept(std::declval<throw_moves>() != std::declval<expect<throw_moves>>()));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<expect<throw_copies>>())));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>().equal(std::declval<throw_copies>())));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<expect<throw_copies>>()));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() == std::declval<throw_copies>()));
+ EXPECT_TRUE(!noexcept(std::declval<throw_copies>() == std::declval<expect<throw_moves>>()));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<expect<throw_copies>>()));
+ EXPECT_TRUE(!noexcept(std::declval<expect<throw_moves>>() != std::declval<throw_copies>()));
+ EXPECT_TRUE(!noexcept(std::declval<throw_copies>() != std::declval<expect<throw_moves>>()));
+}
+
+TEST(Expect, Trivial)
+{
+ EXPECT_TRUE(std::is_trivially_copy_constructible<expect<void>>());
+ EXPECT_TRUE(std::is_trivially_move_constructible<expect<void>>());
+ EXPECT_TRUE(std::is_trivially_destructible<expect<void>>());
+}
+
+TEST(Expect, Assignment)
+{
+ expect<std::string> val1{std::string{}};
+ expect<std::string> val2{"foobar"};
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_value());
+ EXPECT_TRUE(bool(val1));
+ EXPECT_TRUE(bool(val2));
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_error());
+ EXPECT_EQ(val1.value(), std::string{});
+ EXPECT_TRUE(*val1 == std::string{});
+ EXPECT_TRUE(boost::equals(val1->c_str(), ""));
+ EXPECT_TRUE(val2.value() == "foobar");
+ EXPECT_TRUE(*val2 == "foobar");
+ EXPECT_TRUE(boost::equals(val2->c_str(), "foobar"));
+ EXPECT_EQ(val1.error(), std::error_code{});
+ EXPECT_EQ(val2.error(), std::error_code{});
+ EXPECT_TRUE(!val1.equal(std::error_code{}));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+
+ val1 = std::move(val2);
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_value());
+ EXPECT_TRUE(bool(val1));
+ EXPECT_TRUE(bool(val2));
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_error());
+ EXPECT_EQ(val1.value(), "foobar");
+ EXPECT_TRUE(*val1 == "foobar");
+ EXPECT_TRUE(boost::equals(val1->c_str(), "foobar"));
+ EXPECT_EQ(val2.value(), std::string{});
+ EXPECT_TRUE(*val2 == std::string{});
+ EXPECT_TRUE(boost::equals(val2->c_str(), ""));
+ EXPECT_EQ(val1.error(), std::error_code{});
+ EXPECT_EQ(val2.error(), std::error_code{});
+ EXPECT_TRUE(!val1.equal(std::error_code{}));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+
+ val2 = val1;
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_value());
+ EXPECT_TRUE(bool(val1));
+ EXPECT_TRUE(bool(val2));
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_error());
+ EXPECT_EQ(val1.value(), "foobar");
+ EXPECT_TRUE(*val1 == "foobar");
+ EXPECT_TRUE(boost::equals(val1->c_str(), "foobar"));
+ EXPECT_EQ(val2.value(), "foobar");
+ EXPECT_TRUE(*val2 == "foobar");
+ EXPECT_TRUE(boost::equals(val2->c_str(), "foobar"));
+ EXPECT_EQ(val1.error(), std::error_code{});
+ EXPECT_EQ(val2.error(), std::error_code{});
+ EXPECT_TRUE(!val1.equal(std::error_code{}));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+
+ val1 = make_error_code(common_error::kInvalidArgument);
+
+ ASSERT_TRUE(val1.has_error());
+ ASSERT_TRUE(val2.has_value());
+ EXPECT_TRUE(!val1);
+ EXPECT_TRUE(bool(val2));
+ EXPECT_TRUE(!val1.has_value());
+ EXPECT_TRUE(!val2.has_error());
+ EXPECT_EQ(val1.error(), common_error::kInvalidArgument);
+ EXPECT_TRUE(val1 == common_error::kInvalidArgument);
+ EXPECT_TRUE(common_error::kInvalidArgument == val1);
+ EXPECT_STREQ(val2.value().c_str(), "foobar");
+ EXPECT_TRUE(*val2 == "foobar");
+ EXPECT_TRUE(boost::equals(val2->c_str(), "foobar"));
+ EXPECT_NE(val1.error(), std::error_code{});
+ EXPECT_EQ(val2.error(), std::error_code{});
+ EXPECT_TRUE(val1.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(val1.matches(std::errc::invalid_argument));
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+
+ val2 = val1;
+
+ ASSERT_TRUE(val1.has_error());
+ ASSERT_TRUE(val2.has_error());
+ EXPECT_TRUE(!val1);
+ EXPECT_TRUE(!val2);
+ EXPECT_TRUE(!val1.has_value());
+ EXPECT_TRUE(!val2.has_value());
+ EXPECT_EQ(val1.error(), common_error::kInvalidArgument);
+ EXPECT_TRUE(val1 == common_error::kInvalidArgument);
+ EXPECT_TRUE(common_error::kInvalidArgument == val1);
+ EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
+ EXPECT_TRUE(val2 == common_error::kInvalidArgument);
+ EXPECT_TRUE(common_error::kInvalidArgument == val2);
+ EXPECT_NE(val1.error(), std::error_code{});
+ EXPECT_NE(val2.error(), std::error_code{});
+ EXPECT_TRUE(val1.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(val1.matches(std::errc::invalid_argument));
+ EXPECT_TRUE(val2.matches(std::errc::invalid_argument));
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+
+ val1 = std::string{"barfoo"};
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_error());
+ EXPECT_TRUE(bool(val1));
+ EXPECT_TRUE(!val2);
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_value());
+ EXPECT_STREQ(val1.value().c_str(), "barfoo");
+ EXPECT_TRUE(*val1 == "barfoo");
+ EXPECT_TRUE(boost::equals(val1->c_str(), "barfoo"));
+ EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
+ EXPECT_TRUE(val2 == common_error::kInvalidArgument);
+ EXPECT_TRUE(common_error::kInvalidArgument == val2);
+ EXPECT_EQ(val1.error(), std::error_code{});
+ EXPECT_NE(val2.error(), std::error_code{});
+ EXPECT_TRUE(!val1.equal(std::error_code{}));
+ EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(val2.matches(std::errc::invalid_argument));
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+
+ val2 = val1;
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_value());
+ EXPECT_TRUE(bool(val1));
+ EXPECT_TRUE(bool(val2));
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_error());
+ EXPECT_EQ(val1.value(), "barfoo");
+ EXPECT_TRUE(*val1 == "barfoo");
+ EXPECT_TRUE(boost::equals(val1->c_str(), "barfoo"));
+ EXPECT_EQ(val2.value(), "barfoo");
+ EXPECT_TRUE(*val2 == "barfoo");
+ EXPECT_TRUE(boost::equals(val2->c_str(), "barfoo"));
+ EXPECT_EQ(val1.error(), std::error_code{});
+ EXPECT_EQ(val2.error(), std::error_code{});
+ EXPECT_TRUE(!val1.equal(std::error_code{}));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+}
+
+TEST(Expect, AssignmentThrowsOnMove)
+{
+ struct construct_error {};
+ struct assignment_error {};
+
+ struct throw_on_move {
+ std::string msg;
+
+ throw_on_move(const char* msg) : msg(msg) {}
+ throw_on_move(throw_on_move&&) {
+ throw construct_error{};
+ }
+ throw_on_move(throw_on_move const&) = default;
+ ~throw_on_move() = default;
+ throw_on_move& operator=(throw_on_move&&) {
+ throw assignment_error{};
+ }
+ throw_on_move& operator=(throw_on_move const&) = default;
+ };
+
+ expect<throw_on_move> val1{expect<const char*>{"foobar"}};
+ expect<throw_on_move> val2{common_error::kInvalidArgument};
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_error());
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_value());
+ EXPECT_STREQ(val1->msg.c_str(), "foobar");
+ EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
+
+ EXPECT_THROW(val2 = std::move(val1), construct_error);
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_error());
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_value());
+ EXPECT_STREQ(val1->msg.c_str(), "foobar");
+ EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
+
+ EXPECT_THROW(val1 = expect<const char*>{"barfoo"}, assignment_error);
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_error());
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_value());
+ EXPECT_STREQ(val1->msg.c_str(), "foobar");
+ EXPECT_EQ(val2.error(), common_error::kInvalidArgument);
+
+ EXPECT_NO_THROW(val2 = val1);
+
+ ASSERT_TRUE(val1.has_value());
+ ASSERT_TRUE(val2.has_value());
+ EXPECT_TRUE(!val1.has_error());
+ EXPECT_TRUE(!val2.has_error());
+ EXPECT_STREQ(val1->msg.c_str(), "foobar");
+ EXPECT_STREQ(val2->msg.c_str(), "foobar");
+}
+
+TEST(Expect, EqualWithStrings)
+{
+ expect<std::string> val1{std::string{}};
+ expect<std::string> val2{"barfoo"};
+ expect<boost::string_ref> val3{boost::string_ref{}};
+
+ EXPECT_TRUE(!val1.equal(val2));
+ EXPECT_TRUE(val1.equal(val3));
+ EXPECT_TRUE(!val2.equal(val1));
+ EXPECT_TRUE(!val2.equal(val3));
+ EXPECT_TRUE(val3.equal(val1));
+ EXPECT_TRUE(!val3.equal(val2));
+ EXPECT_TRUE(!(val1 == val2));
+ EXPECT_TRUE(!(val2 == val1));
+ EXPECT_TRUE(val1 == val3);
+ EXPECT_TRUE(val3 == val1);
+ EXPECT_TRUE(!(val2 == val3));
+ EXPECT_TRUE(!(val3 == val2));
+ EXPECT_TRUE(val1 != val2);
+ EXPECT_TRUE(val2 != val1);
+ EXPECT_TRUE(!(val1 != val3));
+ EXPECT_TRUE(!(val3 != val1));
+ EXPECT_TRUE(val2 != val3);
+ EXPECT_TRUE(val3 != val2);
+
+ EXPECT_TRUE(val1.equal(""));
+ EXPECT_TRUE(val2.equal("barfoo"));
+ EXPECT_TRUE(val3.equal(""));
+ EXPECT_TRUE(!val1.equal(std::error_code{}));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(!val3.equal(std::error_code{}));
+ EXPECT_TRUE(val1 == "");
+ EXPECT_TRUE("" == val1);
+ EXPECT_TRUE(val2 == "barfoo");
+ EXPECT_TRUE("barfoo" == val2);
+ EXPECT_TRUE(val3 == "");
+ EXPECT_TRUE("" == val3);
+ EXPECT_TRUE(!(val1 != ""));
+ EXPECT_TRUE(!("" != val1));
+ EXPECT_TRUE(!(val2 != "barfoo"));
+ EXPECT_TRUE(!("barfoo" != val2));
+ EXPECT_TRUE(!(val3 != ""));
+ EXPECT_TRUE(!("" != val3));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(!(val3 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val3));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+ EXPECT_TRUE(val3 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val3);
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+ EXPECT_TRUE(!val3.matches(std::error_condition{}));
+
+ val2 = make_error_code(common_error::kInvalidArgument);
+
+ EXPECT_TRUE(!val1.equal(val2));
+ EXPECT_TRUE(val1.equal(val3));
+ EXPECT_TRUE(!val2.equal(val1));
+ EXPECT_TRUE(!val2.equal(val3));
+ EXPECT_TRUE(val3.equal(val1));
+ EXPECT_TRUE(!val3.equal(val2));
+ EXPECT_TRUE(!(val1 == val2));
+ EXPECT_TRUE(!(val2 == val1));
+ EXPECT_TRUE(val1 == val3);
+ EXPECT_TRUE(val3 == val1);
+ EXPECT_TRUE(!(val2 == val3));
+ EXPECT_TRUE(!(val3 == val2));
+ EXPECT_TRUE(val1 != val2);
+ EXPECT_TRUE(val2 != val1);
+ EXPECT_TRUE(!(val1 != val3));
+ EXPECT_TRUE(!(val3 != val1));
+ EXPECT_TRUE(val2 != val3);
+ EXPECT_TRUE(val3 != val2);
+
+ EXPECT_TRUE(!val1.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(!val3.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(val2 == common_error::kInvalidArgument);
+ EXPECT_TRUE(common_error::kInvalidArgument == val2);
+ EXPECT_TRUE(!(val2 != common_error::kInvalidArgument));
+ EXPECT_TRUE(!(common_error::kInvalidArgument != val2));
+ EXPECT_TRUE(val2.matches(std::errc::invalid_argument));
+ EXPECT_TRUE(!val2.matches(std::error_condition{}));
+
+ val1 = expect<std::string>{"barfoo"};
+
+ EXPECT_TRUE(!val1.equal(val2));
+ EXPECT_TRUE(!val1.equal(val3));
+ EXPECT_TRUE(!val2.equal(val1));
+ EXPECT_TRUE(!val2.equal(val3));
+ EXPECT_TRUE(!val3.equal(val1));
+ EXPECT_TRUE(!val3.equal(val2));
+ EXPECT_TRUE(!(val1 == val2));
+ EXPECT_TRUE(!(val2 == val1));
+ EXPECT_TRUE(!(val1 == val3));
+ EXPECT_TRUE(!(val3 == val1));
+ EXPECT_TRUE(!(val2 == val3));
+ EXPECT_TRUE(!(val3 == val2));
+ EXPECT_TRUE(val1 != val2);
+ EXPECT_TRUE(val2 != val1);
+ EXPECT_TRUE(val1 != val3);
+ EXPECT_TRUE(val3 != val1);
+ EXPECT_TRUE(val2 != val3);
+ EXPECT_TRUE(val3 != val2);
+
+ EXPECT_TRUE(val1.equal("barfoo"));
+ EXPECT_TRUE(val1 == "barfoo");
+ EXPECT_TRUE("barfoo" == val1);
+ EXPECT_TRUE(!(val1 != "barfoo"));
+ EXPECT_TRUE(!("barfoo" != val1));
+ EXPECT_TRUE(!val1.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(!(val1 == common_error::kInvalidArgument));
+ EXPECT_TRUE(!(common_error::kInvalidArgument == val1));
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!val1.matches(std::error_condition{}));
+ EXPECT_TRUE(!val1.matches(std::errc::invalid_argument));
+}
+
+TEST(Expect, EqualWithVoid)
+{
+ const expect<void> val1;
+ expect<void> val2;
+
+ EXPECT_TRUE(val1.equal(val2));
+ EXPECT_TRUE(val2.equal(val1));
+ EXPECT_TRUE(!val1.equal(std::error_code{}));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(val1 == val2);
+ EXPECT_TRUE(val2 == val1);
+ EXPECT_TRUE(!(val1 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val1));
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(!(val1 != val2));
+ EXPECT_TRUE(!(val2 != val1));
+ EXPECT_TRUE(val1 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val1);
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+
+ val2 = make_error_code(common_error::kInvalidArgument);
+
+ EXPECT_TRUE(!val1.equal(val2));
+ EXPECT_TRUE(!val2.equal(val1));
+ EXPECT_TRUE(!val1.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(val2.equal(common_error::kInvalidArgument));
+ EXPECT_TRUE(!val2.equal(std::error_code{}));
+ EXPECT_TRUE(!(val1 == val2));
+ EXPECT_TRUE(!(val2 == val1));
+ EXPECT_TRUE(val2 == common_error::kInvalidArgument);
+ EXPECT_TRUE(common_error::kInvalidArgument == val2);
+ EXPECT_TRUE(!(val2 == std::error_code{}));
+ EXPECT_TRUE(!(std::error_code{} == val2));
+ EXPECT_TRUE(val1 != val2);
+ EXPECT_TRUE(val2 != val1);
+ EXPECT_TRUE(!(val2 != common_error::kInvalidArgument));
+ EXPECT_TRUE(!(common_error::kInvalidArgument != val2));
+ EXPECT_TRUE(val2 != std::error_code{});
+ EXPECT_TRUE(std::error_code{} != val2);
+}
+
+TEST(Expect, EqualNoCopies)
+{
+ struct copy_error {};
+
+ struct throw_on_copy {
+ throw_on_copy() = default;
+ throw_on_copy(int) noexcept {}
+ throw_on_copy(throw_on_copy const&) {
+ throw copy_error{};
+ }
+ ~throw_on_copy() = default;
+ throw_on_copy& operator=(throw_on_copy const&) {
+ throw copy_error{};
+ }
+
+ bool operator==(throw_on_copy const&) const noexcept { return true; }
+ };
+
+ expect<throw_on_copy> val1{expect<int>{0}};
+ expect<throw_on_copy> val2{expect<int>{0}};
+
+ EXPECT_TRUE(val1.equal(val2));
+ EXPECT_TRUE(val2.equal(val1));
+ EXPECT_TRUE(val1 == val2);
+ EXPECT_TRUE(val2 == val1);
+ EXPECT_TRUE(!(val1 != val2));
+ EXPECT_TRUE(!(val2 != val1));
+
+ EXPECT_TRUE(val1.equal(throw_on_copy{}));
+ EXPECT_TRUE(val1 == throw_on_copy{});
+ EXPECT_TRUE(throw_on_copy{} == val1);
+ EXPECT_TRUE(!(val1 != throw_on_copy{}));
+ EXPECT_TRUE(!(throw_on_copy{} != val1));
+
+ throw_on_copy val3;
+
+ EXPECT_TRUE(val1.equal(val3));
+ EXPECT_TRUE(val1 == val3);
+ EXPECT_TRUE(val3 == val1);
+ EXPECT_TRUE(!(val1 != val3));
+ EXPECT_TRUE(!(val3 != val1));
+
+ expect<throw_on_copy> val4{common_error::kInvalidArgument};
+
+ EXPECT_TRUE(!val4.equal(throw_on_copy{}));
+ EXPECT_TRUE(!(val4 == throw_on_copy{}));
+ EXPECT_TRUE(!(throw_on_copy{} == val4));
+ EXPECT_TRUE(val4 != throw_on_copy{});
+ EXPECT_TRUE(throw_on_copy{} != val4);
+ EXPECT_TRUE(!val4.equal(val3));
+ EXPECT_TRUE(!(val4 == val3));
+ EXPECT_TRUE(!(val3 == val4));
+ EXPECT_TRUE(val4 != val3);
+ EXPECT_TRUE(val3 != val4);
+}
+
+TEST(Expect, Macros) {
+ EXPECT_TRUE(
+ [] () -> ::common_error {
+ MONERO_PRECOND(true);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidErrorCode
+ );
+ EXPECT_TRUE(
+ [] () -> ::common_error {
+ MONERO_PRECOND(false);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidArgument
+ );
+ EXPECT_TRUE(
+ [] () -> std::error_code {
+ MONERO_PRECOND(true);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidErrorCode
+ );
+ EXPECT_TRUE(
+ [] () -> std::error_code {
+ MONERO_PRECOND(false);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidArgument
+ );
+ EXPECT_TRUE(
+ [] () -> expect<void> {
+ MONERO_PRECOND(true);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidErrorCode
+ );
+ EXPECT_TRUE(
+ [] () -> expect<void> {
+ MONERO_PRECOND(false);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidArgument
+ );
+ EXPECT_TRUE(
+ [] () -> expect<int> {
+ MONERO_PRECOND(true);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidErrorCode
+ );
+ EXPECT_TRUE(
+ [] () -> expect<int> {
+ MONERO_PRECOND(false);
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidArgument
+ );
+
+ EXPECT_TRUE(
+ [] () -> std::error_code {
+ MONERO_CHECK(expect<void>{});
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidErrorCode
+ );
+ EXPECT_TRUE(
+ [] () -> std::error_code {
+ MONERO_CHECK(expect<void>{common_error::kInvalidArgument});
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidArgument
+ );
+ EXPECT_TRUE(
+ [] () -> expect<void> {
+ MONERO_CHECK(expect<void>{});
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidErrorCode
+ );
+ EXPECT_TRUE(
+ [] () -> expect<void> {
+ MONERO_CHECK(expect<void>{common_error::kInvalidArgument});
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidArgument
+ );
+ EXPECT_TRUE(
+ [] () -> expect<int> {
+ MONERO_CHECK(expect<void>{});
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidErrorCode
+ );
+ EXPECT_TRUE(
+ [] () -> expect<int> {
+ MONERO_CHECK(expect<void>{common_error::kInvalidArgument});
+ return {common_error::kInvalidErrorCode};
+ } () == common_error::kInvalidArgument
+ );
+
+ EXPECT_NO_THROW(MONERO_UNWRAP(success()));
+ EXPECT_NO_THROW(MONERO_UNWRAP(expect<void>{}));
+ EXPECT_NO_THROW(MONERO_UNWRAP(expect<int>{0}));
+ EXPECT_THROW(
+ MONERO_UNWRAP(expect<void>{common_error::kInvalidArgument}), std::system_error
+ );
+ EXPECT_THROW(
+ MONERO_UNWRAP(expect<int>{common_error::kInvalidArgument}), std::system_error
+ );
+}
+
diff --git a/tests/unit_tests/multisig.cpp b/tests/unit_tests/multisig.cpp
index eb453b960..83924c7af 100644
--- a/tests/unit_tests/multisig.cpp
+++ b/tests/unit_tests/multisig.cpp
@@ -61,7 +61,7 @@ static void make_wallet(unsigned int idx, tools::wallet2 &wallet)
try
{
- wallet.init(false, "");
+ wallet.init("");
wallet.set_subaddress_lookahead(1, 1);
wallet.generate("", "", spendkey, true, false);
ASSERT_TRUE(test_addresses[idx].address == wallet.get_account().get_public_address_str(cryptonote::TESTNET));
diff --git a/tests/unit_tests/ringdb.cpp b/tests/unit_tests/ringdb.cpp
index 9b842569a..416ae0890 100644
--- a/tests/unit_tests/ringdb.cpp
+++ b/tests/unit_tests/ringdb.cpp
@@ -59,17 +59,17 @@ static crypto::key_image generate_key_image()
return key_image;
}
-static crypto::public_key generate_output()
+static std::pair<uint64_t, uint64_t> generate_output()
{
- return rct::rct2pk(rct::scalarmultBase(rct::skGen()));
+ return std::make_pair(rand(), rand());
}
static const crypto::chacha_key KEY_1 = generate_chacha_key();
static const crypto::chacha_key KEY_2 = generate_chacha_key();
static const crypto::key_image KEY_IMAGE_1 = generate_key_image();
-static const crypto::public_key OUTPUT_1 = generate_output();
-static const crypto::public_key OUTPUT_2 = generate_output();
+static const std::pair<uint64_t, uint64_t> OUTPUT_1 = generate_output();
+static const std::pair<uint64_t, uint64_t> OUTPUT_2 = generate_output();
class RingDB: public tools::ringdb
{
diff --git a/tests/unit_tests/wipeable_string.cpp b/tests/unit_tests/wipeable_string.cpp
index 5ea1c1729..65718fd45 100644
--- a/tests/unit_tests/wipeable_string.cpp
+++ b/tests/unit_tests/wipeable_string.cpp
@@ -32,6 +32,7 @@
#include "misc_log_ex.h"
#include "wipeable_string.h"
+#include "hex.h"
TEST(wipeable_string, ctor)
{
@@ -202,3 +203,9 @@ TEST(wipeable_string, parse_hexstr)
ASSERT_TRUE((s = epee::wipeable_string("414243").parse_hexstr()));
ASSERT_EQ(*s, epee::wipeable_string("ABC"));
}
+
+TEST(wipeable_string, to_hex)
+{
+ ASSERT_TRUE(epee::to_hex::wipeable_string(epee::span<const uint8_t>((const uint8_t*)"", 0)) == epee::wipeable_string(""));
+ ASSERT_TRUE(epee::to_hex::wipeable_string(epee::span<const uint8_t>((const uint8_t*)"abc", 3)) == epee::wipeable_string("616263"));
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 05:22:41 +0000