aboutsummaryrefslogtreecommitdiff
path: root/tests/unit_tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests/unit_tests')
-rw-r--r--tests/unit_tests/CMakeLists.txt6
-rw-r--r--tests/unit_tests/apply_permutation.cpp74
-rw-r--r--tests/unit_tests/ban.cpp5
-rw-r--r--tests/unit_tests/base58.cpp32
-rw-r--r--tests/unit_tests/checkpoints.cpp2
-rw-r--r--tests/unit_tests/dns_resolver.cpp14
-rw-r--r--tests/unit_tests/epee_utils.cpp235
-rw-r--r--tests/unit_tests/hardfork.cpp2
-rw-r--r--tests/unit_tests/hashchain.cpp129
-rw-r--r--tests/unit_tests/main.cpp31
-rw-r--r--tests/unit_tests/mnemonics.cpp4
-rw-r--r--tests/unit_tests/output_selection.cpp2
-rw-r--r--tests/unit_tests/serialization.cpp37
-rw-r--r--tests/unit_tests/sha256.cpp45
-rw-r--r--tests/unit_tests/test_peerlist.cpp2
-rw-r--r--tests/unit_tests/test_tx_utils.cpp2
-rw-r--r--tests/unit_tests/unit_tests_utils.h3
17 files changed, 579 insertions, 46 deletions
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index f5e08b102..c7efcf074 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -27,6 +27,7 @@
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
set(unit_tests_sources
+ apply_permutation.cpp
address_from_url.cpp
ban.cpp
base58.cpp
@@ -45,12 +46,14 @@ set(unit_tests_sources
epee_utils.cpp
fee.cpp
get_xtype_from_string.cpp
+ hashchain.cpp
http.cpp
main.cpp
mnemonics.cpp
mul_div.cpp
parse_amount.cpp
serialization.cpp
+ sha256.cpp
slow_memmem.cpp
test_tx_utils.cpp
test_peerlist.cpp
@@ -78,6 +81,7 @@ target_link_libraries(unit_tests
rpc
wallet
p2p
+ version
epee
${Boost_CHRONO_LIBRARY}
${Boost_THREAD_LIBRARY}
@@ -97,4 +101,4 @@ endif ()
add_test(
NAME unit_tests
- COMMAND unit_tests)
+ COMMAND unit_tests --data-dir "${TEST_DATA_DIR}")
diff --git a/tests/unit_tests/apply_permutation.cpp b/tests/unit_tests/apply_permutation.cpp
new file mode 100644
index 000000000..a008b74ee
--- /dev/null
+++ b/tests/unit_tests/apply_permutation.cpp
@@ -0,0 +1,74 @@
+// Copyright (c) 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 "gtest/gtest.h"
+#include "common/apply_permutation.h"
+
+TEST(apply_permutation, empty)
+{
+ std::vector<int> v = {};
+ tools::apply_permutation({}, v);
+ ASSERT_EQ(v, std::vector<int>({}));
+}
+
+TEST(apply_permutation, reorder)
+{
+ // 0 1 2 3 4 5 6
+ std::vector<int> v = {8, 4, 6, 1, 7, 2, 4};
+ tools::apply_permutation({3, 5, 6, 1, 2, 4, 0}, v);
+ ASSERT_EQ(v, std::vector<int>({1, 2, 4, 4, 6, 7, 8}));
+}
+
+TEST(apply_permutation, bad_size)
+{
+ std::vector<int> v_large = {8, 4, 6, 1, 7, 2, 4, 9};
+ std::vector<int> v_small = {8, 4, 6, 1, 7, 2};
+ try
+ {
+ tools::apply_permutation({3, 5, 6, 1, 2, 4, 0}, v_large);
+ ASSERT_FALSE(true);
+ }
+ catch (const std::exception &e) {}
+ try
+ {
+ tools::apply_permutation({3, 5, 6, 1, 2, 4, 0}, v_small);
+ ASSERT_FALSE(true);
+ }
+ catch (const std::exception &e) {}
+}
+
+TEST(apply_permutation, bad_permutation)
+{
+ std::vector<int> v = {8, 4, 6, 1, 7, 2, 4};
+ try
+ {
+ tools::apply_permutation({3, 5, 6, 1, 2, 4, 1}, v);
+ ASSERT_FALSE(true);
+ }
+ catch (const std::exception &e) {}
+}
diff --git a/tests/unit_tests/ban.cpp b/tests/unit_tests/ban.cpp
index 82ff058b1..242e5fe1c 100644
--- a/tests/unit_tests/ban.cpp
+++ b/tests/unit_tests/ban.cpp
@@ -33,7 +33,7 @@
#include "p2p/net_node.h"
#include "cryptonote_protocol/cryptonote_protocol_handler.h"
-#define MAKE_IPV4_ADDRESS(a,b,c,d) new epee::net_utils::ipv4_network_address(MAKE_IP(a,b,c,d),0)
+#define MAKE_IPV4_ADDRESS(a,b,c,d) epee::net_utils::ipv4_network_address{MAKE_IP(a,b,c,d),0}
namespace cryptonote {
class blockchain_storage;
@@ -51,7 +51,7 @@ public:
bool get_short_chain_history(std::list<crypto::hash>& ids) const { return true; }
bool get_stat_info(cryptonote::core_stat_info& st_inf) const {return true;}
bool have_block(const crypto::hash& id) const {return true;}
- bool get_blockchain_top(uint64_t& height, crypto::hash& top_id)const{height=0;top_id=cryptonote::null_hash;return true;}
+ void get_blockchain_top(uint64_t& height, crypto::hash& top_id)const{height=0;top_id=crypto::null_hash;}
bool handle_incoming_tx(const cryptonote::blobdata& tx_blob, cryptonote::tx_verification_context& tvc, bool keeped_by_block, bool relayed, bool do_not_relay) { return true; }
bool handle_incoming_txs(const std::list<cryptonote::blobdata>& tx_blob, std::vector<cryptonote::tx_verification_context>& tvc, bool keeped_by_block, bool relayed, bool do_not_relay) { return true; }
bool handle_incoming_block(const cryptonote::blobdata& block_blob, cryptonote::block_verification_context& bvc, bool update_miner_blocktemplate = true) { return true; }
@@ -78,6 +78,7 @@ public:
uint8_t get_hard_fork_version(uint64_t height) const { return 0; }
cryptonote::difficulty_type get_block_cumulative_difficulty(uint64_t height) const { return 0; }
bool fluffy_blocks_enabled() const { return false; }
+ uint64_t prevalidate_block_hashes(uint64_t height, const std::list<crypto::hash> &hashes) { return 0; }
};
typedef nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<test_core>> Server;
diff --git a/tests/unit_tests/base58.cpp b/tests/unit_tests/base58.cpp
index c9d6245cb..75a1930b5 100644
--- a/tests/unit_tests/base58.cpp
+++ b/tests/unit_tests/base58.cpp
@@ -474,43 +474,43 @@ TEST(get_account_address_as_str, works_correctly)
{
cryptonote::account_public_address addr;
ASSERT_TRUE(serialization::parse_binary(test_serialized_keys, addr));
- std::string addr_str = cryptonote::get_account_address_as_str(false, addr);
+ std::string addr_str = cryptonote::get_account_address_as_str(false, false, addr);
ASSERT_EQ(addr_str, test_keys_addr_str);
}
TEST(get_account_address_from_str, handles_valid_address)
{
- cryptonote::account_public_address addr;
- ASSERT_TRUE(cryptonote::get_account_address_from_str(addr, false, test_keys_addr_str));
+ cryptonote::address_parse_info info;
+ ASSERT_TRUE(cryptonote::get_account_address_from_str(info, false, test_keys_addr_str));
std::string blob;
- ASSERT_TRUE(serialization::dump_binary(addr, blob));
+ ASSERT_TRUE(serialization::dump_binary(info.address, blob));
ASSERT_EQ(blob, test_serialized_keys);
}
TEST(get_account_address_from_str, fails_on_invalid_address_format)
{
- cryptonote::account_public_address addr;
+ cryptonote::address_parse_info info;
std::string addr_str = test_keys_addr_str;
addr_str[0] = '0';
- ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, false, addr_str));
+ ASSERT_FALSE(cryptonote::get_account_address_from_str(info, false, addr_str));
}
TEST(get_account_address_from_str, fails_on_invalid_address_prefix)
{
std::string addr_str = base58::encode_addr(0, test_serialized_keys);
- cryptonote::account_public_address addr;
- ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, false, addr_str));
+ cryptonote::address_parse_info info;
+ ASSERT_FALSE(cryptonote::get_account_address_from_str(info, false, addr_str));
}
TEST(get_account_address_from_str, fails_on_invalid_address_content)
{
std::string addr_str = base58::encode_addr(config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, test_serialized_keys.substr(1));
- cryptonote::account_public_address addr;
- ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, false, addr_str));
+ cryptonote::address_parse_info info;
+ ASSERT_FALSE(cryptonote::get_account_address_from_str(info, false, addr_str));
}
TEST(get_account_address_from_str, fails_on_invalid_address_spend_key)
@@ -519,8 +519,8 @@ TEST(get_account_address_from_str, fails_on_invalid_address_spend_key)
serialized_keys_copy[0] = '\0';
std::string addr_str = base58::encode_addr(config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, serialized_keys_copy);
- cryptonote::account_public_address addr;
- ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, false, addr_str));
+ cryptonote::address_parse_info info;
+ ASSERT_FALSE(cryptonote::get_account_address_from_str(info, false, addr_str));
}
TEST(get_account_address_from_str, fails_on_invalid_address_view_key)
@@ -529,12 +529,12 @@ TEST(get_account_address_from_str, fails_on_invalid_address_view_key)
serialized_keys_copy.back() = '\x01';
std::string addr_str = base58::encode_addr(config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, serialized_keys_copy);
- cryptonote::account_public_address addr;
- ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, false, addr_str));
+ cryptonote::address_parse_info info;
+ ASSERT_FALSE(cryptonote::get_account_address_from_str(info, false, addr_str));
}
TEST(get_account_address_from_str, parses_old_address_format)
{
- cryptonote::account_public_address addr;
- ASSERT_TRUE(cryptonote::get_account_address_from_str(addr, false, "002391bbbb24dea6fd95232e97594a27769d0153d053d2102b789c498f57a2b00b69cd6f2f5c529c1660f2f4a2b50178d6640c20ce71fe26373041af97c5b10236fc"));
+ cryptonote::address_parse_info info;
+ ASSERT_TRUE(cryptonote::get_account_address_from_str(info, false, "002391bbbb24dea6fd95232e97594a27769d0153d053d2102b789c498f57a2b00b69cd6f2f5c529c1660f2f4a2b50178d6640c20ce71fe26373041af97c5b10236fc"));
}
diff --git a/tests/unit_tests/checkpoints.cpp b/tests/unit_tests/checkpoints.cpp
index d3c4d3b2b..f6015db2f 100644
--- a/tests/unit_tests/checkpoints.cpp
+++ b/tests/unit_tests/checkpoints.cpp
@@ -30,7 +30,7 @@
#include "gtest/gtest.h"
-#include "cryptonote_basic/checkpoints.cpp"
+#include "checkpoints/checkpoints.cpp"
using namespace cryptonote;
diff --git a/tests/unit_tests/dns_resolver.cpp b/tests/unit_tests/dns_resolver.cpp
index aca74a93f..8ac86146e 100644
--- a/tests/unit_tests/dns_resolver.cpp
+++ b/tests/unit_tests/dns_resolver.cpp
@@ -157,3 +157,17 @@ TEST(DNSResolver, GetTXTRecord)
addr = tools::DNSResolver::instance().get_dns_format_from_oa_address("donate.getmonero.org");
EXPECT_STREQ("donate.getmonero.org", addr.c_str());
}
+
+TEST(DNS_PUBLIC, empty) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("").c_str()); }
+TEST(DNS_PUBLIC, default) { EXPECT_STREQ("8.8.4.4", tools::dns_utils::parse_dns_public("tcp").c_str()); }
+TEST(DNS_PUBLIC, invalid_scheme) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("invalid").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_alpha) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://invalid").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_num1) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://3").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_num3) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://3.4.5").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_num4_extra) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://3.4.5.6x").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_num4_range) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://3.4.542.6").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_dot) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://3.4.5.6.").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_num5) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://3.4.5.6.7").c_str()); }
+TEST(DNS_PUBLIC, invalid_ip_4_missing) { EXPECT_STREQ("", tools::dns_utils::parse_dns_public("tcp://3.4..7").c_str()); }
+TEST(DNS_PUBLIC, valid_ip_lo) { EXPECT_STREQ("127.0.0.1", tools::dns_utils::parse_dns_public("tcp://127.0.0.1").c_str()); }
+TEST(DNS_PUBLIC, valid_ip) { EXPECT_STREQ("3.4.5.6", tools::dns_utils::parse_dns_public("tcp://3.4.5.6").c_str()); }
diff --git a/tests/unit_tests/epee_utils.cpp b/tests/unit_tests/epee_utils.cpp
index e8ddbe3f5..a13081491 100644
--- a/tests/unit_tests/epee_utils.cpp
+++ b/tests/unit_tests/epee_utils.cpp
@@ -27,6 +27,7 @@
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <array>
+#include <boost/endian/conversion.hpp>
#include <boost/range/algorithm/equal.hpp>
#include <boost/range/algorithm_ext/iota.hpp>
#include <cstdint>
@@ -36,13 +37,15 @@
#include <sstream>
#include <vector>
-#ifdef _WIN32
-# include <winsock.h>
-#else
+#ifndef _WIN32
# include <arpa/inet.h>
#endif
+#include "boost/archive/portable_binary_iarchive.hpp"
+#include "boost/archive/portable_binary_oarchive.hpp"
#include "hex.h"
+#include "net/net_utils_base.h"
+#include "p2p/net_peerlist_boost_serialization.h"
#include "span.h"
#include "string_tools.h"
@@ -100,6 +103,40 @@ namespace
boost::range::iota(out, 0);
return out;
}
+
+ #define CHECK_EQUAL(lhs, rhs) \
+ EXPECT_TRUE( lhs == rhs ); \
+ EXPECT_TRUE( rhs == lhs ); \
+ EXPECT_FALSE( lhs != rhs ); \
+ EXPECT_FALSE( rhs != lhs ); \
+ EXPECT_FALSE( lhs < rhs ); \
+ EXPECT_FALSE( rhs < lhs ); \
+ EXPECT_TRUE( lhs <= rhs ); \
+ EXPECT_TRUE( rhs <= lhs ); \
+ EXPECT_FALSE( lhs > rhs ); \
+ EXPECT_FALSE( rhs > lhs ); \
+ EXPECT_TRUE( lhs >= rhs ); \
+ EXPECT_TRUE( rhs >= lhs )
+
+ #define CHECK_LESS(lhs, rhs) \
+ EXPECT_FALSE( lhs == rhs ); \
+ EXPECT_FALSE( rhs == lhs ); \
+ EXPECT_TRUE( lhs != rhs ); \
+ EXPECT_TRUE( rhs != lhs ); \
+ EXPECT_TRUE( lhs < rhs ); \
+ EXPECT_FALSE( rhs < lhs ); \
+ EXPECT_TRUE( lhs <= rhs ); \
+ EXPECT_FALSE( rhs <= lhs ); \
+ EXPECT_FALSE( lhs > rhs ); \
+ EXPECT_TRUE( rhs > lhs ); \
+ EXPECT_FALSE( lhs >= rhs ); \
+ EXPECT_TRUE( rhs >= lhs )
+
+ #ifdef BOOST_LITTLE_ENDIAN
+ #define CHECK_LESS_ENDIAN(lhs, rhs) CHECK_LESS( rhs , lhs )
+ #else
+ #define CHECK_LESS_ENDIAN(lhs, rhs) CHECK_LESS( lhs , rhs )
+ #endif
}
TEST(Span, Traits)
@@ -419,3 +456,195 @@ TEST(StringTools, GetIpInt32)
EXPECT_EQ(htonl(0xff0aff00), ip);
}
+TEST(NetUtils, IPv4NetworkAddress)
+{
+ const auto ip1 = boost::endian::native_to_big(0x330012FFu);
+ const auto ip_loopback = boost::endian::native_to_big(0x7F000001u);
+ const auto ip_local = boost::endian::native_to_big(0x0A000000u);
+
+ epee::net_utils::ipv4_network_address address1{ip1, 65535};
+ CHECK_EQUAL(address1, address1);
+ EXPECT_STREQ("51.0.18.255:65535", address1.str().c_str());
+ EXPECT_STREQ("51.0.18.255", address1.host_str().c_str());
+ EXPECT_FALSE(address1.is_loopback());
+ EXPECT_FALSE(address1.is_local());
+ EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+ EXPECT_EQ(ip1, address1.ip());
+ EXPECT_EQ(65535, address1.port());
+ EXPECT_TRUE(epee::net_utils::ipv4_network_address{std::move(address1)} == address1);
+ EXPECT_TRUE(epee::net_utils::ipv4_network_address{address1} == address1);
+
+ const epee::net_utils::ipv4_network_address loopback{ip_loopback, 0};
+ CHECK_EQUAL(loopback, loopback);
+ CHECK_LESS_ENDIAN(address1, loopback);
+ EXPECT_STREQ("127.0.0.1:0", loopback.str().c_str());
+ EXPECT_STREQ("127.0.0.1", loopback.host_str().c_str());
+ EXPECT_TRUE(loopback.is_loopback());
+ EXPECT_FALSE(loopback.is_local());
+ EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+ EXPECT_EQ(ip_loopback, loopback.ip());
+ EXPECT_EQ(0, loopback.port());
+
+ const epee::net_utils::ipv4_network_address local{ip_local, 8080};
+ CHECK_EQUAL(local, local);
+ CHECK_LESS(local, address1);
+ CHECK_LESS(local, loopback);
+ EXPECT_FALSE(local.is_loopback());
+ EXPECT_TRUE(local.is_local());
+
+ epee::net_utils::ipv4_network_address address2{ip1, 55};
+ CHECK_EQUAL(address2, address2);
+ CHECK_LESS_ENDIAN(address2, loopback);
+ CHECK_LESS(local, address2);
+ EXPECT_STREQ("51.0.18.255:55", address2.str().c_str());
+ EXPECT_STREQ("51.0.18.255", address2.host_str().c_str());
+
+
+ address2 = std::move(address1);
+ CHECK_EQUAL(address2, address1);
+
+ address2 = local;
+ CHECK_EQUAL(address2, local);
+ CHECK_LESS(address2, address1);
+
+ {
+ std::stringstream stream;
+ {
+ boost::archive::portable_binary_oarchive ostream{stream};
+ ostream << address1;
+ }
+ {
+ boost::archive::portable_binary_iarchive istream{stream};
+ istream >> address2;
+ }
+ }
+ CHECK_EQUAL(address1, address2);
+ EXPECT_EQ(ip1, address2.ip());
+ EXPECT_EQ(65535, address2.port());
+}
+
+TEST(NetUtils, NetworkAddress)
+{
+ const auto ip1 = boost::endian::native_to_big(0x330012FFu);
+ const auto ip_loopback = boost::endian::native_to_big(0x7F000001u);
+ const auto ip_local = boost::endian::native_to_big(0x0A000000u);
+
+ struct custom_address {
+ constexpr static bool equal(const custom_address&) noexcept { return false; }
+ constexpr static bool less(const custom_address&) noexcept { return false; }
+ constexpr static bool is_same_host(const custom_address&) noexcept { return false; }
+ constexpr static bool is_loopback() noexcept { return false; }
+ constexpr static bool is_local() noexcept { return false; }
+ static std::string str() { return {}; }
+ static std::string host_str() { return {}; }
+ constexpr static uint8_t get_type_id() noexcept { return uint8_t(-1); }
+ };
+
+ const epee::net_utils::network_address empty;
+ CHECK_EQUAL(empty, empty);
+ EXPECT_TRUE(empty.is_same_host(empty));
+ EXPECT_STREQ("<none>", empty.str().c_str());
+ EXPECT_STREQ("<none>", empty.host_str().c_str());
+ EXPECT_FALSE(empty.is_loopback());
+ EXPECT_FALSE(empty.is_local());
+ EXPECT_EQ(0, empty.get_type_id());
+ EXPECT_THROW(empty.as<custom_address>(), std::bad_cast);
+
+ epee::net_utils::network_address address1{
+ epee::net_utils::ipv4_network_address{ip1, 65535}
+ };
+ CHECK_EQUAL(address1, address1);
+ CHECK_EQUAL(epee::net_utils::network_address{address1}, address1);
+ CHECK_LESS(empty, address1);
+ EXPECT_TRUE(address1.is_same_host(address1));
+ EXPECT_FALSE(empty.is_same_host(address1));
+ EXPECT_FALSE(address1.is_same_host(empty));
+ EXPECT_STREQ("51.0.18.255:65535", address1.str().c_str());
+ EXPECT_STREQ("51.0.18.255", address1.host_str().c_str());
+ EXPECT_FALSE(address1.is_loopback());
+ EXPECT_FALSE(address1.is_local());
+ EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+ EXPECT_NO_THROW(address1.as<epee::net_utils::ipv4_network_address>());
+ EXPECT_THROW(address1.as<custom_address>(), std::bad_cast);
+
+ const epee::net_utils::network_address loopback{
+ epee::net_utils::ipv4_network_address{ip_loopback, 0}
+ };
+ CHECK_EQUAL(loopback, loopback);
+ CHECK_LESS(empty, loopback);
+ CHECK_LESS_ENDIAN(address1, loopback);
+ EXPECT_TRUE(loopback.is_same_host(loopback));
+ EXPECT_FALSE(loopback.is_same_host(address1));
+ EXPECT_FALSE(address1.is_same_host(loopback));
+ EXPECT_STREQ("127.0.0.1:0", loopback.str().c_str());
+ EXPECT_STREQ("127.0.0.1", loopback.host_str().c_str());
+ EXPECT_TRUE(loopback.is_loopback());
+ EXPECT_FALSE(loopback.is_local());
+ EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+
+ const epee::net_utils::network_address local{
+ epee::net_utils::ipv4_network_address{ip_local, 8080}
+ };
+ CHECK_EQUAL(local, local);
+ CHECK_LESS(local, loopback);
+ CHECK_LESS(local, address1);
+ EXPECT_FALSE(local.is_loopback());
+ EXPECT_TRUE(local.is_local());
+
+ epee::net_utils::network_address address2{
+ epee::net_utils::ipv4_network_address{ip1, 55}
+ };
+ CHECK_EQUAL(address2, address2);
+ CHECK_LESS(address2, address1);
+ CHECK_LESS(local, address2);
+ CHECK_LESS_ENDIAN(address2, loopback);
+ EXPECT_TRUE(address1.is_same_host(address2));
+ EXPECT_TRUE(address2.is_same_host(address1));
+ EXPECT_STREQ("51.0.18.255:55", address2.str().c_str());
+ EXPECT_STREQ("51.0.18.255", address2.host_str().c_str());
+
+ address2 = std::move(address1);
+ CHECK_EQUAL(address1, address1);
+ CHECK_EQUAL(empty, address1);
+ CHECK_LESS(address1, address2);
+ EXPECT_FALSE(address1.is_same_host(address2));
+ EXPECT_FALSE(address2.is_same_host(address1));
+ EXPECT_STREQ("51.0.18.255:65535", address2.str().c_str());
+ EXPECT_STREQ("51.0.18.255", address2.host_str().c_str());
+ EXPECT_FALSE(address1.is_loopback());
+ EXPECT_FALSE(address1.is_local());
+ EXPECT_THROW(address1.as<epee::net_utils::ipv4_network_address>(), std::bad_cast);
+ EXPECT_NO_THROW(address2.as<epee::net_utils::ipv4_network_address>());
+
+ address2 = local;
+ CHECK_EQUAL(address2, local);
+ CHECK_LESS(address1, address2);
+ EXPECT_TRUE(address2.is_same_host(local));
+ EXPECT_TRUE(local.is_same_host(address2));
+ EXPECT_FALSE(address2.is_same_host(address1));
+ EXPECT_FALSE(address1.is_same_host(address2));
+
+ {
+ std::stringstream stream;
+ {
+ boost::archive::portable_binary_oarchive ostream{stream};
+ ostream << address2;
+ }
+ {
+ boost::archive::portable_binary_iarchive istream{stream};
+ istream >> address1;
+ }
+ }
+ CHECK_EQUAL(address1, address2);
+ EXPECT_TRUE(address1.is_same_host(address2));
+ EXPECT_TRUE(address2.is_same_host(address1));
+ EXPECT_NO_THROW(address1.as<epee::net_utils::ipv4_network_address>());
+
+ address1 = custom_address{};
+ CHECK_EQUAL(address1, address1);
+ CHECK_LESS(address2, address1);
+ EXPECT_FALSE(address1.is_same_host(loopback));
+ EXPECT_FALSE(loopback.is_same_host(address1));
+ EXPECT_THROW(address1.as<epee::net_utils::ipv4_network_address>(), std::bad_cast);
+ EXPECT_NO_THROW(address1.as<custom_address>());
+}
diff --git a/tests/unit_tests/hardfork.cpp b/tests/unit_tests/hardfork.cpp
index c30feb461..2b0904224 100644
--- a/tests/unit_tests/hardfork.cpp
+++ b/tests/unit_tests/hardfork.cpp
@@ -53,7 +53,7 @@ public:
virtual std::string get_db_name() const { return std::string(); }
virtual bool lock() { return true; }
virtual void unlock() { }
- virtual bool batch_start(uint64_t batch_num_blocks=0) { return true; }
+ virtual bool batch_start(uint64_t batch_num_blocks=0, uint64_t batch_bytes=0) { return true; }
virtual void batch_stop() {}
virtual void set_batch_transactions(bool) {}
virtual void block_txn_start(bool readonly=false) {}
diff --git a/tests/unit_tests/hashchain.cpp b/tests/unit_tests/hashchain.cpp
new file mode 100644
index 000000000..e764f6afc
--- /dev/null
+++ b/tests/unit_tests/hashchain.cpp
@@ -0,0 +1,129 @@
+// 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.
+
+// FIXME: move this into a full wallet2 unit test suite, if possible
+
+#include "gtest/gtest.h"
+
+#include "wallet/wallet2.h"
+
+static crypto::hash make_hash(uint64_t n)
+{
+ union
+ {
+ crypto::hash hash;
+ uint64_t n;
+ } hash;
+ hash.hash = crypto::null_hash;
+ hash.n = n;
+ return hash.hash;
+}
+
+TEST(hashchain, empty)
+{
+ tools::hashchain hashchain;
+ ASSERT_EQ(hashchain.size(), 0);
+ ASSERT_EQ(hashchain.offset(), 0);
+}
+
+TEST(hashchain, genesis)
+{
+ tools::hashchain hashchain;
+ hashchain.push_back(make_hash(1));
+ ASSERT_EQ(hashchain.size(), 1);
+ ASSERT_EQ(hashchain.genesis(), make_hash(1));
+ hashchain.push_back(make_hash(2));
+ ASSERT_EQ(hashchain.size(), 2);
+ ASSERT_EQ(hashchain.genesis(), make_hash(1));
+}
+
+TEST(hashchain, push_back)
+{
+ tools::hashchain hashchain;
+ hashchain.push_back(make_hash(1));
+ hashchain.push_back(make_hash(2));
+ hashchain.push_back(make_hash(3));
+ ASSERT_EQ(hashchain[0], make_hash(1));
+ ASSERT_EQ(hashchain[1], make_hash(2));
+ ASSERT_EQ(hashchain[2], make_hash(3));
+}
+
+TEST(hashchain, clear_empty)
+{
+ tools::hashchain hashchain;
+ ASSERT_TRUE(hashchain.empty());
+ hashchain.push_back(make_hash(1));
+ ASSERT_FALSE(hashchain.empty());
+ hashchain.push_back(make_hash(2));
+ ASSERT_FALSE(hashchain.empty());
+ hashchain.clear();
+ ASSERT_TRUE(hashchain.empty());
+}
+
+TEST(hashchain, crop)
+{
+ tools::hashchain hashchain;
+ hashchain.push_back(make_hash(1));
+ hashchain.push_back(make_hash(2));
+ hashchain.push_back(make_hash(3));
+ ASSERT_EQ(hashchain.size(), 3);
+ ASSERT_EQ(hashchain[0], make_hash(1));
+ ASSERT_EQ(hashchain[1], make_hash(2));
+ ASSERT_EQ(hashchain[2], make_hash(3));
+ hashchain.crop(3);
+ ASSERT_EQ(hashchain.size(), 3);
+ hashchain.crop(2);
+ ASSERT_EQ(hashchain.size(), 2);
+ ASSERT_EQ(hashchain[0], make_hash(1));
+ ASSERT_EQ(hashchain[1], make_hash(2));
+ ASSERT_EQ(hashchain.genesis(), make_hash(1));
+ hashchain.crop(0);
+ ASSERT_TRUE(hashchain.empty());
+ ASSERT_EQ(hashchain.size(), 0);
+ hashchain.push_back(make_hash(5));
+ ASSERT_EQ(hashchain.genesis(), make_hash(5));
+ ASSERT_EQ(hashchain.size(), 1);
+}
+
+TEST(hashchain, trim)
+{
+ tools::hashchain hashchain;
+ hashchain.push_back(make_hash(1));
+ hashchain.push_back(make_hash(2));
+ hashchain.push_back(make_hash(3));
+ ASSERT_EQ(hashchain.offset(), 0);
+ hashchain.trim(2);
+ ASSERT_EQ(hashchain.offset(), 2);
+ ASSERT_EQ(hashchain.size(), 3);
+ ASSERT_EQ(hashchain[2], make_hash(3));
+ hashchain.trim(3);
+ ASSERT_EQ(hashchain.offset(), 2); // never gets it empty
+ ASSERT_EQ(hashchain.size(), 3);
+ ASSERT_FALSE(hashchain.empty());
+ ASSERT_EQ(hashchain.genesis(), make_hash(1));
+}
diff --git a/tests/unit_tests/main.cpp b/tests/unit_tests/main.cpp
index b470249a3..1706c43c9 100644
--- a/tests/unit_tests/main.cpp
+++ b/tests/unit_tests/main.cpp
@@ -30,7 +30,16 @@
#include "gtest/gtest.h"
+#include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+
#include "include_base_utils.h"
+#include "common/command_line.h"
+#include "unit_tests_utils.h"
+
+namespace po = boost::program_options;
+
+boost::filesystem::path unit_test::data_dir;
int main(int argc, char** argv)
{
@@ -39,5 +48,27 @@ int main(int argc, char** argv)
epee::debug::get_set_enable_assert(true, false);
::testing::InitGoogleTest(&argc, argv);
+
+ po::options_description desc_options("Command line options");
+ const command_line::arg_descriptor<std::string> arg_data_dir = {"data-dir", "Data files directory", "", true};
+ command_line::add_arg(desc_options, command_line::arg_data_dir, "");
+
+ po::variables_map vm;
+ bool r = command_line::handle_error_helper(desc_options, [&]()
+ {
+ po::store(po::parse_command_line(argc, argv, desc_options), vm);
+ po::notify(vm);
+ return true;
+ });
+ if (! r)
+ return 1;
+
+ if (vm["data-dir"].defaulted())
+ unit_test::data_dir = boost::filesystem::path(epee::string_tools::get_current_module_folder())
+ .parent_path().parent_path().parent_path().parent_path()
+ .append("tests").append("data");
+ else
+ unit_test::data_dir = command_line::get_arg(vm, arg_data_dir);
+
return RUN_ALL_TESTS();
}
diff --git a/tests/unit_tests/mnemonics.cpp b/tests/unit_tests/mnemonics.cpp
index 05894adf4..39ec394a1 100644
--- a/tests/unit_tests/mnemonics.cpp
+++ b/tests/unit_tests/mnemonics.cpp
@@ -45,6 +45,7 @@
#include "mnemonics/french.h"
#include "mnemonics/dutch.h"
#include "mnemonics/esperanto.h"
+#include "mnemonics/lojban.h"
#include "mnemonics/english_old.h"
#include "mnemonics/language_base.h"
#include "mnemonics/singleton.h"
@@ -167,7 +168,8 @@ TEST(mnemonics, all_languages)
Language::Singleton<Language::Russian>::instance(),
Language::Singleton<Language::French>::instance(),
Language::Singleton<Language::Dutch>::instance(),
- Language::Singleton<Language::Esperanto>::instance()
+ Language::Singleton<Language::Esperanto>::instance(),
+ Language::Singleton<Language::Lojban>::instance()
});
for (std::vector<Language::Base*>::iterator it = languages.begin(); it != languages.end(); it++)
diff --git a/tests/unit_tests/output_selection.cpp b/tests/unit_tests/output_selection.cpp
index ed436dffd..6ff73b107 100644
--- a/tests/unit_tests/output_selection.cpp
+++ b/tests/unit_tests/output_selection.cpp
@@ -42,7 +42,7 @@ static tools::wallet2::transfer_container make_transfers_container(size_t N)
tools::wallet2::transfer_details &td = transfers.back();
td.m_block_height = 1000;
td.m_spent = false;
- td.m_txid = cryptonote::null_hash;
+ td.m_txid = crypto::null_hash;
td.m_txid.data[0] = n & 0xff;
td.m_txid.data[1] = (n >> 8) & 0xff;
td.m_txid.data[2] = (n >> 16) & 0xff;
diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index 6f9fe7d11..011082d1c 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -47,6 +47,7 @@
#include "serialization/binary_utils.h"
#include "wallet/wallet2.h"
#include "gtest/gtest.h"
+#include "unit_tests_utils.h"
using namespace std;
struct Struct
@@ -671,12 +672,12 @@ TEST(Serialization, portability_wallet)
const bool testnet = true;
const bool restricted = false;
tools::wallet2 w(testnet, restricted);
- string wallet_file = epee::string_tools::get_current_module_folder() + "/../../../../tests/data/wallet_9svHk1";
+ const boost::filesystem::path wallet_file = unit_test::data_dir / "wallet_9svHk1";
string password = "test";
bool r = false;
try
{
- w.load(wallet_file, password);
+ w.load(wallet_file.string(), password);
r = true;
}
catch (const exception& e)
@@ -791,9 +792,9 @@ TEST(Serialization, portability_wallet)
TEST(Serialization, portability_outputs)
{
// read file
- const std::string filename = epee::string_tools::get_current_module_folder() + "/../../../../tests/data/outputs";
+ const boost::filesystem::path filename = unit_test::data_dir / "outputs";
std::string data;
- bool r = epee::file_io_utils::load_file_to_string(filename, data);
+ bool r = epee::file_io_utils::load_file_to_string(filename.string(), data);
ASSERT_TRUE(r);
const size_t magiclen = strlen(OUTPUT_EXPORT_FILE_MAGIC);
ASSERT_FALSE(data.size() < magiclen || memcmp(data.data(), OUTPUT_EXPORT_FILE_MAGIC, magiclen));
@@ -906,10 +907,10 @@ TEST(Serialization, portability_outputs)
#define UNSIGNED_TX_PREFIX "Monero unsigned tx set\003"
TEST(Serialization, portability_unsigned_tx)
{
- const string filename = epee::string_tools::get_current_module_folder() + "/../../../../tests/data/unsigned_monero_tx";
+ const boost::filesystem::path filename = unit_test::data_dir / "unsigned_monero_tx";
std::string s;
const bool testnet = true;
- bool r = epee::file_io_utils::load_file_to_string(filename, s);
+ bool r = epee::file_io_utils::load_file_to_string(filename.string(), s);
ASSERT_TRUE(r);
const size_t magiclen = strlen(UNSIGNED_TX_PREFIX);
ASSERT_FALSE(strncmp(s.c_str(), UNSIGNED_TX_PREFIX, magiclen));
@@ -986,15 +987,15 @@ TEST(Serialization, portability_unsigned_tx)
ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
// tcd.change_dts
ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
// tcd.splitted_dsts
ASSERT_TRUE(tcd.splitted_dsts.size() == 2);
auto& splitted_dst0 = tcd.splitted_dsts[0];
auto& splitted_dst1 = tcd.splitted_dsts[1];
ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
// tcd.selected_transfers
ASSERT_TRUE(tcd.selected_transfers.size() == 1);
ASSERT_TRUE(tcd.selected_transfers.front() == 2);
@@ -1007,7 +1008,7 @@ TEST(Serialization, portability_unsigned_tx)
ASSERT_TRUE(tcd.dests.size() == 1);
auto& dest = tcd.dests[0];
ASSERT_TRUE(dest.amount == 1400000000000);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
// transfers
ASSERT_TRUE(exported_txs.transfers.size() == 3);
auto& td0 = exported_txs.transfers[0];
@@ -1054,10 +1055,10 @@ TEST(Serialization, portability_unsigned_tx)
#define SIGNED_TX_PREFIX "Monero signed tx set\003"
TEST(Serialization, portability_signed_tx)
{
- const string filename = epee::string_tools::get_current_module_folder() + "/../../../../tests/data/signed_monero_tx";
+ const boost::filesystem::path filename = unit_test::data_dir / "signed_monero_tx";
const bool testnet = true;
std::string s;
- bool r = epee::file_io_utils::load_file_to_string(filename, s);
+ bool r = epee::file_io_utils::load_file_to_string(filename.string(), s);
ASSERT_TRUE(r);
const size_t magiclen = strlen(SIGNED_TX_PREFIX);
ASSERT_FALSE(strncmp(s.c_str(), SIGNED_TX_PREFIX, magiclen));
@@ -1100,7 +1101,7 @@ TEST(Serialization, portability_signed_tx)
ASSERT_FALSE(ptx.dust_added_to_fee);
// ptx.change.{amount, addr}
ASSERT_TRUE(ptx.change_dts.amount == 9631208773403);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, ptx.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, ptx.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
// ptx.selected_transfers
ASSERT_TRUE(ptx.selected_transfers.size() == 1);
ASSERT_TRUE(ptx.selected_transfers.front() == 2);
@@ -1110,7 +1111,7 @@ TEST(Serialization, portability_signed_tx)
// ptx.dests
ASSERT_TRUE(ptx.dests.size() == 1);
ASSERT_TRUE(ptx.dests[0].amount == 1400000000000);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, ptx.dests[0].addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, ptx.dests[0].addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
// ptx.construction_data
auto& tcd = ptx.construction_data;
ASSERT_TRUE(tcd.sources.size() == 1);
@@ -1141,15 +1142,15 @@ TEST(Serialization, portability_signed_tx)
ASSERT_TRUE(epee::string_tools::pod_to_hex(tse.mask) == "789bafff169ef206aa21219342c69ca52ce1d78d776c10b21d14bdd960fc7703");
// ptx.construction_data.change_dts
ASSERT_TRUE(tcd.change_dts.amount == 9631208773403);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, tcd.change_dts.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
// ptx.construction_data.splitted_dsts
ASSERT_TRUE(tcd.splitted_dsts.size() == 2);
auto& splitted_dst0 = tcd.splitted_dsts[0];
auto& splitted_dst1 = tcd.splitted_dsts[1];
ASSERT_TRUE(splitted_dst0.amount == 1400000000000);
ASSERT_TRUE(splitted_dst1.amount == 9631208773403);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, splitted_dst0.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, splitted_dst1.addr) == "9svHk1wHPo3ULf2AZykghzcye6sitaRE4MaDjPC6uanTHCynHjJHZaiAb922PojE1GexhhRt1LVf5DC43feyrRZMLXQr3mk");
// ptx.construction_data.selected_transfers
ASSERT_TRUE(tcd.selected_transfers.size() == 1);
ASSERT_TRUE(tcd.selected_transfers.front() == 2);
@@ -1162,7 +1163,7 @@ TEST(Serialization, portability_signed_tx)
ASSERT_TRUE(tcd.dests.size() == 1);
auto& dest = tcd.dests[0];
ASSERT_TRUE(dest.amount == 1400000000000);
- ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
+ ASSERT_TRUE(cryptonote::get_account_address_as_str(testnet, false, dest.addr) == "9xnhrMczQkPeoGi6dyu6BgKAYX4tZsDs6KHCkyTStDBKL4M4pM1gfCR3utmTAcSaKHGa1R5o266FbdnubErmij3oMdLyYgA");
// key_images
ASSERT_TRUE(exported_txs.key_images.size() == 3);
auto& ki0 = exported_txs.key_images[0];
diff --git a/tests/unit_tests/sha256.cpp b/tests/unit_tests/sha256.cpp
new file mode 100644
index 000000000..0d657a1a9
--- /dev/null
+++ b/tests/unit_tests/sha256.cpp
@@ -0,0 +1,45 @@
+// Copyright (c) 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 "gtest/gtest.h"
+
+#include "common/util.h"
+#include "string_tools.h"
+
+static bool check(const std::string &data, const char *expected_hash_hex)
+{
+ crypto::hash hash, expected_hash;
+ if (!epee::string_tools::hex_to_pod(expected_hash_hex, expected_hash))
+ return false;
+ return tools::sha256sum((const uint8_t*)data.data(), data.size(), hash) && hash == expected_hash;
+}
+
+TEST(sha256, empty) { ASSERT_TRUE(check(std::string(), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")); }
+TEST(sha256, small) { ASSERT_TRUE(check("0123456789", "84d89877f0d4041efb6bf91a16f0248f2fd573e6af05c19f96bedb9f882f7882")); }
+TEST(sha256, large) { ASSERT_TRUE(check(std::string(65536*256, 0), "080acf35a507ac9849cfcba47dc2ad83e01b75663a516279c8b9d243b719643e")); }
+
diff --git a/tests/unit_tests/test_peerlist.cpp b/tests/unit_tests/test_peerlist.cpp
index 4a546b50d..849020d25 100644
--- a/tests/unit_tests/test_peerlist.cpp
+++ b/tests/unit_tests/test_peerlist.cpp
@@ -38,7 +38,7 @@ TEST(peer_list, peer_list_general)
{
nodetool::peerlist_manager plm;
plm.init(false);
-#define MAKE_IPV4_ADDRESS(a,b,c,d,e) new epee::net_utils::ipv4_network_address(MAKE_IP(a,b,c,d),e)
+#define MAKE_IPV4_ADDRESS(a,b,c,d,e) epee::net_utils::ipv4_network_address{MAKE_IP(a,b,c,d),e}
#define ADD_GRAY_NODE(addr_, id_, last_seen_) { nodetool::peerlist_entry ple; ple.last_seen=last_seen_;ple.adr = addr_; ple.id = id_;plm.append_with_peer_gray(ple);}
#define ADD_WHITE_NODE(addr_, id_, last_seen_) { nodetool::peerlist_entry ple;ple.last_seen=last_seen_; ple.adr = addr_; ple.id = id_;plm.append_with_peer_white(ple);}
diff --git a/tests/unit_tests/test_tx_utils.cpp b/tests/unit_tests/test_tx_utils.cpp
index 0ff91c247..4ce62e2f5 100644
--- a/tests/unit_tests/test_tx_utils.cpp
+++ b/tests/unit_tests/test_tx_utils.cpp
@@ -141,7 +141,7 @@ TEST(parse_and_validate_tx_extra, is_valid_tx_extra_parsed)
cryptonote::blobdata b = "dsdsdfsdfsf";
ASSERT_TRUE(cryptonote::construct_miner_tx(0, 0, 10000000000000, 1000, TEST_FEE, acc.get_keys().m_account_address, tx, b, 1));
crypto::public_key tx_pub_key = cryptonote::get_tx_pub_key_from_extra(tx);
- ASSERT_NE(tx_pub_key, cryptonote::null_pkey);
+ ASSERT_NE(tx_pub_key, crypto::null_pkey);
}
TEST(parse_and_validate_tx_extra, fails_on_big_extra_nonce)
{
diff --git a/tests/unit_tests/unit_tests_utils.h b/tests/unit_tests/unit_tests_utils.h
index 11230c0db..a07eaf02b 100644
--- a/tests/unit_tests/unit_tests_utils.h
+++ b/tests/unit_tests/unit_tests_utils.h
@@ -31,9 +31,12 @@
#pragma once
#include <atomic>
+#include <boost/filesystem.hpp>
namespace unit_test
{
+ extern boost::filesystem::path data_dir;
+
class call_counter
{
public:
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 01:30:26 +0000