aboutsummaryrefslogtreecommitdiff
path: root/tests/unit_tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests/unit_tests')
-rw-r--r--tests/unit_tests/CMakeLists.txt11
-rw-r--r--tests/unit_tests/account.cpp71
-rw-r--r--tests/unit_tests/aligned.cpp86
-rw-r--r--tests/unit_tests/block_reward.cpp84
-rw-r--r--tests/unit_tests/blockchain_db.cpp2
-rw-r--r--tests/unit_tests/bulletproofs.cpp175
-rw-r--r--tests/unit_tests/crypto.cpp23
-rw-r--r--tests/unit_tests/fee.cpp54
-rw-r--r--tests/unit_tests/hardfork.cpp5
-rw-r--r--tests/unit_tests/is_hdd.cpp17
-rw-r--r--tests/unit_tests/json_serialization.cpp217
-rw-r--r--tests/unit_tests/keccak.cpp150
-rw-r--r--tests/unit_tests/mlocker.cpp194
-rw-r--r--tests/unit_tests/mnemonics.cpp30
-rw-r--r--tests/unit_tests/multiexp.cpp254
-rw-r--r--tests/unit_tests/multisig.cpp15
-rw-r--r--tests/unit_tests/ringct.cpp31
-rw-r--r--tests/unit_tests/ringdb.cpp22
-rw-r--r--tests/unit_tests/serialization.cpp7
-rw-r--r--tests/unit_tests/wipeable_string.cpp204
20 files changed, 1559 insertions, 93 deletions
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 3c7414640..741bb1882 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
+ account.cpp
apply_permutation.cpp
address_from_url.cpp
ban.cpp
@@ -47,13 +48,17 @@ set(unit_tests_sources
epee_levin_protocol_handler_async.cpp
epee_utils.cpp
fee.cpp
+ json_serialization.cpp
get_xtype_from_string.cpp
hashchain.cpp
http.cpp
+ keccak.cpp
main.cpp
memwipe.cpp
+ mlocker.cpp
mnemonics.cpp
mul_div.cpp
+ multiexp.cpp
multisig.cpp
parse_amount.cpp
random.cpp
@@ -72,7 +77,10 @@ set(unit_tests_sources
ringct.cpp
output_selection.cpp
vercmp.cpp
- ringdb.cpp)
+ ringdb.cpp
+ wipeable_string.cpp
+ is_hdd.cpp
+ aligned.cpp)
set(unit_tests_headers
unit_tests_utils.h)
@@ -87,6 +95,7 @@ target_link_libraries(unit_tests
cryptonote_core
blockchain_db
rpc
+ serialization
wallet
p2p
version
diff --git a/tests/unit_tests/account.cpp b/tests/unit_tests/account.cpp
new file mode 100644
index 000000000..113622b5e
--- /dev/null
+++ b/tests/unit_tests/account.cpp
@@ -0,0 +1,71 @@
+// Copyright (c) 2014-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 "cryptonote_basic/account.h"
+
+TEST(account, encrypt_keys)
+{
+ cryptonote::keypair recovery_key = cryptonote::keypair::generate(hw::get_device("default"));
+ cryptonote::account_base account;
+ crypto::secret_key key = account.generate(recovery_key.sec);
+ const cryptonote::account_keys keys = account.get_keys();
+
+ ASSERT_EQ(account.get_keys().m_account_address, keys.m_account_address);
+ ASSERT_EQ(account.get_keys().m_spend_secret_key, keys.m_spend_secret_key);
+ ASSERT_EQ(account.get_keys().m_view_secret_key, keys.m_view_secret_key);
+ ASSERT_EQ(account.get_keys().m_multisig_keys, keys.m_multisig_keys);
+
+ crypto::chacha_key chacha_key;
+ crypto::generate_chacha_key(&recovery_key, sizeof(recovery_key), chacha_key, 1);
+
+ account.encrypt_keys(chacha_key);
+
+ ASSERT_EQ(account.get_keys().m_account_address, keys.m_account_address);
+ ASSERT_NE(account.get_keys().m_spend_secret_key, keys.m_spend_secret_key);
+ ASSERT_NE(account.get_keys().m_view_secret_key, keys.m_view_secret_key);
+
+ account.decrypt_viewkey(chacha_key);
+
+ ASSERT_EQ(account.get_keys().m_account_address, keys.m_account_address);
+ ASSERT_NE(account.get_keys().m_spend_secret_key, keys.m_spend_secret_key);
+ ASSERT_EQ(account.get_keys().m_view_secret_key, keys.m_view_secret_key);
+
+ account.encrypt_viewkey(chacha_key);
+
+ ASSERT_EQ(account.get_keys().m_account_address, keys.m_account_address);
+ ASSERT_NE(account.get_keys().m_spend_secret_key, keys.m_spend_secret_key);
+ ASSERT_NE(account.get_keys().m_view_secret_key, keys.m_view_secret_key);
+
+ account.decrypt_keys(chacha_key);
+
+ ASSERT_EQ(account.get_keys().m_account_address, keys.m_account_address);
+ ASSERT_EQ(account.get_keys().m_spend_secret_key, keys.m_spend_secret_key);
+ ASSERT_EQ(account.get_keys().m_view_secret_key, keys.m_view_secret_key);
+}
diff --git a/tests/unit_tests/aligned.cpp b/tests/unit_tests/aligned.cpp
new file mode 100644
index 000000000..ad4837bec
--- /dev/null
+++ b/tests/unit_tests/aligned.cpp
@@ -0,0 +1,86 @@
+// 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 "common/aligned.h"
+
+TEST(aligned, large_null) { ASSERT_TRUE(aligned_malloc((size_t)-1, 1) == NULL); }
+TEST(aligned, free_null) { aligned_free(NULL); }
+TEST(aligned, zero) { void *ptr = aligned_malloc(0, 1); ASSERT_TRUE(ptr); aligned_free(ptr); }
+TEST(aligned, aligned1) { void *ptr = aligned_malloc(1, 1); ASSERT_TRUE(ptr); aligned_free(ptr); }
+TEST(aligned, aligned4096) { void *ptr = aligned_malloc(1, 4096); ASSERT_TRUE(ptr && ((uintptr_t)ptr & 4095) == 0); aligned_free(ptr); }
+TEST(aligned, aligned8) { void *ptr = aligned_malloc(1, 8); ASSERT_TRUE(ptr && ((uintptr_t)ptr & 7) == 0); aligned_free(ptr); }
+TEST(aligned, realloc_null) { void *ptr = aligned_realloc(NULL, 1, 4096); ASSERT_TRUE(ptr && ((uintptr_t)ptr & 4095) == 0); aligned_free(ptr); }
+TEST(aligned, realloc_diff_align) { void *ptr = aligned_malloc(1, 4096); ASSERT_TRUE(!aligned_realloc(ptr, 1, 2048)); aligned_free(ptr); }
+TEST(aligned, realloc_same) { void *ptr = aligned_malloc(1, 4096), *ptr2 = aligned_realloc(ptr, 1, 4096); ASSERT_TRUE(ptr == ptr2); aligned_free(ptr2); }
+TEST(aligned, realloc_larger) { void *ptr = aligned_malloc(1, 4096), *ptr2 = aligned_realloc(ptr, 2, 4096); ASSERT_TRUE(ptr != ptr2); aligned_free(ptr2); }
+TEST(aligned, realloc_zero) { void *ptr = aligned_malloc(1, 4096), *ptr2 = aligned_realloc(ptr, 0, 4096); ASSERT_TRUE(ptr && !ptr2); }
+
+TEST(aligned, contents_larger)
+{
+ unsigned char *ptr = (unsigned char*)aligned_malloc(50, 256);
+ ASSERT_TRUE(ptr);
+ for (int n = 0; n < 50; ++n)
+ ptr[n] = n;
+ unsigned char *ptr2 = (unsigned char*)aligned_realloc(ptr, 51, 256);
+ for (int n = 0; n < 50; ++n)
+ {
+ ASSERT_TRUE(ptr2[n] == n);
+ }
+ aligned_free(ptr2);
+}
+
+TEST(aligned, contents_same)
+{
+ unsigned char *ptr = (unsigned char*)aligned_malloc(50, 256);
+ ASSERT_TRUE(ptr);
+ for (int n = 0; n < 50; ++n)
+ ptr[n] = n;
+ unsigned char *ptr2 = (unsigned char*)aligned_realloc(ptr, 50, 256);
+ for (int n = 0; n < 50; ++n)
+ {
+ ASSERT_TRUE(ptr2[n] == n);
+ }
+ aligned_free(ptr2);
+}
+
+TEST(aligned, contents_smaller)
+{
+ unsigned char *ptr = (unsigned char*)aligned_malloc(50, 256);
+ ASSERT_TRUE(ptr);
+ for (int n = 0; n < 50; ++n)
+ ptr[n] = n;
+ unsigned char *ptr2 = (unsigned char*)aligned_realloc(ptr, 49, 256);
+ for (int n = 0; n < 49; ++n)
+ {
+ ASSERT_TRUE(ptr2[n] == n);
+ }
+ aligned_free(ptr2);
+}
+
diff --git a/tests/unit_tests/block_reward.cpp b/tests/unit_tests/block_reward.cpp
index ca863ded9..a897e4140 100644
--- a/tests/unit_tests/block_reward.cpp
+++ b/tests/unit_tests/block_reward.cpp
@@ -40,14 +40,14 @@ namespace
class block_reward_and_already_generated_coins : public ::testing::Test
{
protected:
- static const size_t current_block_size = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 / 2;
+ static const size_t current_block_weight = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 / 2;
bool m_block_not_too_big;
uint64_t m_block_reward;
};
#define TEST_ALREADY_GENERATED_COINS(already_generated_coins, expected_reward) \
- m_block_not_too_big = get_block_reward(0, current_block_size, already_generated_coins, m_block_reward,1); \
+ m_block_not_too_big = get_block_reward(0, current_block_weight, already_generated_coins, m_block_reward,1); \
ASSERT_TRUE(m_block_not_too_big); \
ASSERT_EQ(m_block_reward, expected_reward);
@@ -74,7 +74,7 @@ namespace
}
//--------------------------------------------------------------------------------------------------------------------
- class block_reward_and_current_block_size : public ::testing::Test
+ class block_reward_and_current_block_weight : public ::testing::Test
{
protected:
virtual void SetUp()
@@ -84,9 +84,9 @@ namespace
ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1, m_standard_block_reward);
}
- void do_test(size_t median_block_size, size_t current_block_size)
+ void do_test(size_t median_block_weight, size_t current_block_weight)
{
- m_block_not_too_big = get_block_reward(median_block_size, current_block_size, already_generated_coins, m_block_reward, 1);
+ m_block_not_too_big = get_block_reward(median_block_weight, current_block_weight, already_generated_coins, m_block_reward, 1);
}
static const uint64_t already_generated_coins = 0;
@@ -96,28 +96,28 @@ namespace
uint64_t m_standard_block_reward;
};
- TEST_F(block_reward_and_current_block_size, handles_block_size_less_relevance_level)
+ TEST_F(block_reward_and_current_block_weight, handles_block_weight_less_relevance_level)
{
do_test(0, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 - 1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(m_block_reward, m_standard_block_reward);
}
- TEST_F(block_reward_and_current_block_size, handles_block_size_eq_relevance_level)
+ TEST_F(block_reward_and_current_block_weight, handles_block_weight_eq_relevance_level)
{
do_test(0, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(m_block_reward, m_standard_block_reward);
}
- TEST_F(block_reward_and_current_block_size, handles_block_size_gt_relevance_level)
+ TEST_F(block_reward_and_current_block_weight, handles_block_weight_gt_relevance_level)
{
do_test(0, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 + 1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_LT(m_block_reward, m_standard_block_reward);
}
- TEST_F(block_reward_and_current_block_size, handles_block_size_less_2_relevance_level)
+ TEST_F(block_reward_and_current_block_weight, handles_block_weight_less_2_relevance_level)
{
do_test(0, 2 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 - 1);
ASSERT_TRUE(m_block_not_too_big);
@@ -125,21 +125,21 @@ namespace
ASSERT_LT(0, m_block_reward);
}
- TEST_F(block_reward_and_current_block_size, handles_block_size_eq_2_relevance_level)
+ TEST_F(block_reward_and_current_block_weight, handles_block_weight_eq_2_relevance_level)
{
do_test(0, 2 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(0, m_block_reward);
}
- TEST_F(block_reward_and_current_block_size, handles_block_size_gt_2_relevance_level)
+ TEST_F(block_reward_and_current_block_weight, handles_block_weight_gt_2_relevance_level)
{
do_test(0, 2 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 + 1);
ASSERT_FALSE(m_block_not_too_big);
}
#ifdef __x86_64__ // For 64-bit systems only, because block size is limited to size_t.
- TEST_F(block_reward_and_current_block_size, fails_on_huge_median_size)
+ TEST_F(block_reward_and_current_block_weight, fails_on_huge_median_size)
{
#if !defined(NDEBUG)
size_t huge_size = std::numeric_limits<uint32_t>::max() + UINT64_C(2);
@@ -147,7 +147,7 @@ namespace
#endif
}
- TEST_F(block_reward_and_current_block_size, fails_on_huge_block_size)
+ TEST_F(block_reward_and_current_block_weight, fails_on_huge_block_weight)
{
#if !defined(NDEBUG)
size_t huge_size = std::numeric_limits<uint32_t>::max() + UINT64_C(2);
@@ -157,94 +157,94 @@ namespace
#endif // __x86_64__
//--------------------------------------------------------------------------------------------------------------------
- class block_reward_and_last_block_sizes : public ::testing::Test
+ class block_reward_and_last_block_weights : public ::testing::Test
{
protected:
virtual void SetUp()
{
- m_last_block_sizes.push_back(3 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
- m_last_block_sizes.push_back(5 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
- m_last_block_sizes.push_back(7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
- m_last_block_sizes.push_back(11 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
- m_last_block_sizes.push_back(13 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
+ m_last_block_weights.push_back(3 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
+ m_last_block_weights.push_back(5 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
+ m_last_block_weights.push_back(7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
+ m_last_block_weights.push_back(11 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
+ m_last_block_weights.push_back(13 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1);
- m_last_block_sizes_median = 7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1;
+ m_last_block_weights_median = 7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1;
- m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_sizes), 0, already_generated_coins, m_standard_block_reward, 1);
+ m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_weights), 0, already_generated_coins, m_standard_block_reward, 1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1, m_standard_block_reward);
}
- void do_test(size_t current_block_size)
+ void do_test(size_t current_block_weight)
{
- m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_sizes), current_block_size, already_generated_coins, m_block_reward, 1);
+ m_block_not_too_big = get_block_reward(epee::misc_utils::median(m_last_block_weights), current_block_weight, already_generated_coins, m_block_reward, 1);
}
static const uint64_t already_generated_coins = 0;
- std::vector<size_t> m_last_block_sizes;
- uint64_t m_last_block_sizes_median;
+ std::vector<size_t> m_last_block_weights;
+ uint64_t m_last_block_weights_median;
bool m_block_not_too_big;
uint64_t m_block_reward;
uint64_t m_standard_block_reward;
};
- TEST_F(block_reward_and_last_block_sizes, handles_block_size_less_median)
+ TEST_F(block_reward_and_last_block_weights, handles_block_weight_less_median)
{
- do_test(m_last_block_sizes_median - 1);
+ do_test(m_last_block_weights_median - 1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(m_block_reward, m_standard_block_reward);
}
- TEST_F(block_reward_and_last_block_sizes, handles_block_size_eq_median)
+ TEST_F(block_reward_and_last_block_weights, handles_block_weight_eq_median)
{
- do_test(m_last_block_sizes_median);
+ do_test(m_last_block_weights_median);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(m_block_reward, m_standard_block_reward);
}
- TEST_F(block_reward_and_last_block_sizes, handles_block_size_gt_median)
+ TEST_F(block_reward_and_last_block_weights, handles_block_weight_gt_median)
{
- do_test(m_last_block_sizes_median + 1);
+ do_test(m_last_block_weights_median + 1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_LT(m_block_reward, m_standard_block_reward);
}
- TEST_F(block_reward_and_last_block_sizes, handles_block_size_less_2_medians)
+ TEST_F(block_reward_and_last_block_weights, handles_block_weight_less_2_medians)
{
- do_test(2 * m_last_block_sizes_median - 1);
+ do_test(2 * m_last_block_weights_median - 1);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_LT(m_block_reward, m_standard_block_reward);
ASSERT_LT(0, m_block_reward);
}
- TEST_F(block_reward_and_last_block_sizes, handles_block_size_eq_2_medians)
+ TEST_F(block_reward_and_last_block_weights, handles_block_weight_eq_2_medians)
{
- do_test(2 * m_last_block_sizes_median);
+ do_test(2 * m_last_block_weights_median);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(0, m_block_reward);
}
- TEST_F(block_reward_and_last_block_sizes, handles_block_size_gt_2_medians)
+ TEST_F(block_reward_and_last_block_weights, handles_block_weight_gt_2_medians)
{
- do_test(2 * m_last_block_sizes_median + 1);
+ do_test(2 * m_last_block_weights_median + 1);
ASSERT_FALSE(m_block_not_too_big);
}
- TEST_F(block_reward_and_last_block_sizes, calculates_correctly)
+ TEST_F(block_reward_and_last_block_weights, calculates_correctly)
{
- ASSERT_EQ(0, m_last_block_sizes_median % 8);
+ ASSERT_EQ(0, m_last_block_weights_median % 8);
- do_test(m_last_block_sizes_median * 9 / 8);
+ do_test(m_last_block_weights_median * 9 / 8);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(m_block_reward, m_standard_block_reward * 63 / 64);
// 3/2 = 12/8
- do_test(m_last_block_sizes_median * 3 / 2);
+ do_test(m_last_block_weights_median * 3 / 2);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(m_block_reward, m_standard_block_reward * 3 / 4);
- do_test(m_last_block_sizes_median * 15 / 8);
+ do_test(m_last_block_weights_median * 15 / 8);
ASSERT_TRUE(m_block_not_too_big);
ASSERT_EQ(m_block_reward, m_standard_block_reward * 15 / 64);
}
diff --git a/tests/unit_tests/blockchain_db.cpp b/tests/unit_tests/blockchain_db.cpp
index 3a62fba69..7e7ce9bf7 100644
--- a/tests/unit_tests/blockchain_db.cpp
+++ b/tests/unit_tests/blockchain_db.cpp
@@ -319,7 +319,7 @@ TYPED_TEST(BlockchainDBTest, RetrieveBlockData)
ASSERT_NO_THROW(this->m_db->add_block(this->m_blocks[0], t_sizes[0], t_diffs[0], t_coins[0], this->m_txs[0]));
- ASSERT_EQ(t_sizes[0], this->m_db->get_block_size(0));
+ ASSERT_EQ(t_sizes[0], this->m_db->get_block_weight(0));
ASSERT_EQ(t_diffs[0], this->m_db->get_block_cumulative_difficulty(0));
ASSERT_EQ(t_diffs[0], this->m_db->get_block_difficulty(0));
ASSERT_EQ(t_coins[0], this->m_db->get_block_already_generated_coins(0));
diff --git a/tests/unit_tests/bulletproofs.cpp b/tests/unit_tests/bulletproofs.cpp
index 00595a4c7..45075c63d 100644
--- a/tests/unit_tests/bulletproofs.cpp
+++ b/tests/unit_tests/bulletproofs.cpp
@@ -30,8 +30,12 @@
#include "gtest/gtest.h"
+#include "string_tools.h"
#include "ringct/rctOps.h"
+#include "ringct/rctSigs.h"
#include "ringct/bulletproofs.h"
+#include "device/device.hpp"
+#include "misc_log_ex.h"
TEST(bulletproofs, valid_zero)
{
@@ -54,6 +58,108 @@ TEST(bulletproofs, valid_random)
}
}
+TEST(bulletproofs, valid_multi_random)
+{
+ for (int n = 0; n < 8; ++n)
+ {
+ size_t outputs = 2 + n;
+ std::vector<uint64_t> amounts;
+ rct::keyV gamma;
+ for (size_t i = 0; i < outputs; ++i)
+ {
+ amounts.push_back(crypto::rand<uint64_t>());
+ gamma.push_back(rct::skGen());
+ }
+ rct::Bulletproof proof = bulletproof_PROVE(amounts, gamma);
+ ASSERT_TRUE(rct::bulletproof_VERIFY(proof));
+ }
+}
+
+TEST(bulletproofs, multi_splitting)
+{
+ rct::ctkeyV sc, pc;
+ rct::ctkey sctmp, pctmp;
+ std::vector<unsigned int> index;
+ std::vector<uint64_t> inamounts, outamounts;
+
+ std::tie(sctmp, pctmp) = rct::ctskpkGen(6000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ inamounts.push_back(6000);
+ index.push_back(1);
+
+ std::tie(sctmp, pctmp) = rct::ctskpkGen(7000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ inamounts.push_back(7000);
+ index.push_back(1);
+
+ const int mixin = 3, max_outputs = 16;
+
+ for (int n_outputs = 1; n_outputs <= max_outputs; ++n_outputs)
+ {
+ std::vector<uint64_t> outamounts;
+ rct::keyV amount_keys;
+ rct::keyV destinations;
+ rct::key Sk, Pk;
+ uint64_t available = 6000 + 7000;
+ uint64_t amount;
+ rct::ctkeyM mixRing(sc.size());
+
+ //add output
+ for (size_t i = 0; i < n_outputs; ++i)
+ {
+ amount = rct::randXmrAmount(available);
+ outamounts.push_back(amount);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ rct::skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+ available -= amount;
+ }
+
+ for (size_t i = 0; i < sc.size(); ++i)
+ {
+ for (size_t j = 0; j <= mixin; ++j)
+ {
+ if (j == 1)
+ mixRing[i].push_back(pc[i]);
+ else
+ mixRing[i].push_back({rct::scalarmultBase(rct::skGen()), rct::scalarmultBase(rct::skGen())});
+ }
+ }
+
+ rct::ctkeyV outSk;
+ rct::rctSig s = rct::genRctSimple(rct::zero(), sc, destinations, inamounts, outamounts, available, mixRing, amount_keys, NULL, NULL, index, outSk, rct::RangeProofPaddedBulletproof, hw::get_device("default"));
+ ASSERT_TRUE(rct::verRctSimple(s));
+ for (size_t i = 0; i < n_outputs; ++i)
+ {
+ rct::key mask;
+ rct::decodeRctSimple(s, amount_keys[i], i, mask, hw::get_device("default"));
+ ASSERT_TRUE(mask == outSk[i].mask);
+ }
+ }
+}
+
+TEST(bulletproofs, valid_aggregated)
+{
+ static const size_t N_PROOFS = 8;
+ std::vector<rct::Bulletproof> proofs(N_PROOFS);
+ for (size_t n = 0; n < N_PROOFS; ++n)
+ {
+ size_t outputs = 2 + n;
+ std::vector<uint64_t> amounts;
+ rct::keyV gamma;
+ for (size_t i = 0; i < outputs; ++i)
+ {
+ amounts.push_back(crypto::rand<uint64_t>());
+ gamma.push_back(rct::skGen());
+ }
+ proofs[n] = bulletproof_PROVE(amounts, gamma);
+ }
+ ASSERT_TRUE(rct::bulletproof_VERIFY(proofs));
+}
+
+
TEST(bulletproofs, invalid_8)
{
rct::key invalid_amount = rct::zero();
@@ -69,3 +175,72 @@ TEST(bulletproofs, invalid_31)
rct::Bulletproof proof = bulletproof_PROVE(invalid_amount, rct::skGen());
ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
}
+
+TEST(bulletproofs, invalid_gamma_0)
+{
+ rct::key invalid_amount = rct::zero();
+ invalid_amount[8] = 1;
+ rct::key gamma = rct::zero();
+ rct::Bulletproof proof = bulletproof_PROVE(invalid_amount, gamma);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+}
+
+static const char * const torsion_elements[] =
+{
+ "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa",
+ "0000000000000000000000000000000000000000000000000000000000000000",
+ "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85",
+ "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+ "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05",
+ "0000000000000000000000000000000000000000000000000000000000000080",
+ "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a",
+};
+
+TEST(bulletproofs, invalid_torsion)
+{
+ rct::Bulletproof proof = bulletproof_PROVE(7329838943733, rct::skGen());
+ ASSERT_TRUE(rct::bulletproof_VERIFY(proof));
+ for (const auto &xs: torsion_elements)
+ {
+ rct::key x;
+ ASSERT_TRUE(epee::string_tools::hex_to_pod(xs, x));
+ ASSERT_FALSE(rct::isInMainSubgroup(x));
+ for (auto &k: proof.V)
+ {
+ const rct::key org_k = k;
+ rct::addKeys(k, org_k, x);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+ k = org_k;
+ }
+ for (auto &k: proof.L)
+ {
+ const rct::key org_k = k;
+ rct::addKeys(k, org_k, x);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+ k = org_k;
+ }
+ for (auto &k: proof.R)
+ {
+ const rct::key org_k = k;
+ rct::addKeys(k, org_k, x);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+ k = org_k;
+ }
+ const rct::key org_A = proof.A;
+ rct::addKeys(proof.A, org_A, x);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+ proof.A = org_A;
+ const rct::key org_S = proof.S;
+ rct::addKeys(proof.S, org_S, x);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+ proof.S = org_S;
+ const rct::key org_T1 = proof.T1;
+ rct::addKeys(proof.T1, org_T1, x);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+ proof.T1 = org_T1;
+ const rct::key org_T2 = proof.T2;
+ rct::addKeys(proof.T2, org_T2, x);
+ ASSERT_FALSE(rct::bulletproof_VERIFY(proof));
+ proof.T2 = org_T2;
+ }
+}
diff --git a/tests/unit_tests/crypto.cpp b/tests/unit_tests/crypto.cpp
index 4bed06173..29fa88f9d 100644
--- a/tests/unit_tests/crypto.cpp
+++ b/tests/unit_tests/crypto.cpp
@@ -73,3 +73,26 @@ TEST(Crypto, Ostream)
EXPECT_TRUE(is_formatted<crypto::key_derivation>());
EXPECT_TRUE(is_formatted<crypto::key_image>());
}
+
+TEST(Crypto, null_keys)
+{
+ char zero[32];
+ memset(zero, 0, 32);
+ ASSERT_EQ(memcmp(crypto::null_skey.data, zero, 32), 0);
+ ASSERT_EQ(memcmp(crypto::null_pkey.data, zero, 32), 0);
+}
+
+TEST(Crypto, verify_32)
+{
+ // all bytes are treated the same, so we can brute force just one byte
+ unsigned char k0[32] = {0}, k1[32] = {0};
+ for (unsigned int i0 = 0; i0 < 256; ++i0)
+ {
+ k0[0] = i0;
+ for (unsigned int i1 = 0; i1 < 256; ++i1)
+ {
+ k1[0] = i1;
+ ASSERT_EQ(!crypto_verify_32(k0, k1), i0 == i1);
+ }
+ }
+}
diff --git a/tests/unit_tests/fee.cpp b/tests/unit_tests/fee.cpp
index c5589ab96..8ccb38fc9 100644
--- a/tests/unit_tests/fee.cpp
+++ b/tests/unit_tests/fee.cpp
@@ -58,46 +58,46 @@ namespace
TEST_F(fee, 10xmr)
{
// CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 and lower are clamped
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2, 3), clamp_fee(2000000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 2, 3), clamp_fee(2000000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 100, 3), clamp_fee(2000000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, 1, 3), 2000000000);
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2, 3), clamp_fee(2000000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 2, 3), clamp_fee(2000000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 100, 3), clamp_fee(2000000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, 1, 3), 2000000000);
// higher is inverse proportional
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 2, 3), clamp_fee(2000000000 / 2));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 10, 3), clamp_fee(2000000000 / 10));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 1000, 3), clamp_fee(2000000000 / 1000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 20000ull, 3), clamp_fee(2000000000 / 20000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 2, 3), clamp_fee(2000000000 / 2));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 10, 3), clamp_fee(2000000000 / 10));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 1000, 3), clamp_fee(2000000000 / 1000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(10000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 20000ull, 3), clamp_fee(2000000000 / 20000));
}
TEST_F(fee, 1xmr)
{
// CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 and lower are clamped
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2, 3), clamp_fee(200000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 2, 3), clamp_fee(200000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 100, 3), clamp_fee(200000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, 1, 3), 200000000);
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2, 3), clamp_fee(200000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 2, 3), clamp_fee(200000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 100, 3), clamp_fee(200000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, 1, 3), 200000000);
// higher is inverse proportional
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 2, 3), clamp_fee(200000000 / 2));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 10, 3), clamp_fee(200000000 / 10));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 1000, 3), clamp_fee(200000000 / 1000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 20000ull, 3), clamp_fee(200000000 / 20000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 2, 3), clamp_fee(200000000 / 2));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 10, 3), clamp_fee(200000000 / 10));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 1000, 3), clamp_fee(200000000 / 1000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(1000000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 20000ull, 3), clamp_fee(200000000 / 20000));
}
TEST_F(fee, dot3xmr)
{
// CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 and lower are clamped
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2, 3), clamp_fee(60000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 2, 3), clamp_fee(60000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 100, 3), clamp_fee(60000000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, 1, 3), 60000000);
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2, 3), clamp_fee(60000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 2, 3), clamp_fee(60000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 / 100, 3), clamp_fee(60000000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, 1, 3), 60000000);
// higher is inverse proportional
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 2, 3), clamp_fee(60000000 / 2));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 10, 3), clamp_fee(60000000 / 10));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 1000, 3), clamp_fee(60000000 / 1000));
- ASSERT_EQ(Blockchain::get_dynamic_per_kb_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 20000ull, 3), clamp_fee(60000000 / 20000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 2, 3), clamp_fee(60000000 / 2));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 10, 3), clamp_fee(60000000 / 10));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 1000, 3), clamp_fee(60000000 / 1000));
+ ASSERT_EQ(Blockchain::get_dynamic_base_fee(300000000000, CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 20000ull, 3), clamp_fee(60000000 / 20000));
}
static bool is_more_or_less(double x, double y)
@@ -116,7 +116,7 @@ namespace
600000000000ull, // .6 monero, minimum reward per block at 2min
300000000000ull, // .3 monero, minimum reward per block at 1min
};
- static const uint64_t median_block_sizes[] = {
+ static const uint64_t median_block_weights[] = {
CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2,
CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 2,
CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2 * 10,
@@ -127,9 +127,9 @@ namespace
for (uint64_t block_reward: block_rewards)
{
- for (uint64_t median_block_size: median_block_sizes)
+ for (uint64_t median_block_weight: median_block_weights)
{
- ASSERT_TRUE(is_more_or_less(Blockchain::get_dynamic_per_kb_fee(block_reward, median_block_size, 3) * (median_block_size / 1024.) * MAX_MULTIPLIER / (double)block_reward, 1.992 * 1000 / 1024));
+ ASSERT_TRUE(is_more_or_less(Blockchain::get_dynamic_base_fee(block_reward, median_block_weight, 3) * (median_block_weight / 1024.) * MAX_MULTIPLIER / (double)block_reward, 1.992 * 1000 / 1024));
}
}
}
diff --git a/tests/unit_tests/hardfork.cpp b/tests/unit_tests/hardfork.cpp
index 930aeb782..47177db1c 100644
--- a/tests/unit_tests/hardfork.cpp
+++ b/tests/unit_tests/hardfork.cpp
@@ -72,7 +72,7 @@ public:
virtual uint64_t get_block_timestamp(const uint64_t& height) const { return 0; }
virtual std::vector<uint64_t> get_block_cumulative_rct_outputs(const std::vector<uint64_t> &heights) const { return {}; }
virtual uint64_t get_top_block_timestamp() const { return 0; }
- virtual size_t get_block_size(const uint64_t& height) const { return 128; }
+ virtual size_t get_block_weight(const uint64_t& height) const { return 128; }
virtual difficulty_type get_block_cumulative_difficulty(const uint64_t& height) const { return 10; }
virtual difficulty_type get_block_difficulty(const uint64_t& height) const { return 0; }
virtual uint64_t get_block_already_generated_coins(const uint64_t& height) const { return 10000000000; }
@@ -93,7 +93,6 @@ public:
virtual uint64_t get_num_outputs(const uint64_t& amount) const { return 1; }
virtual uint64_t get_indexing_base() const { return 0; }
virtual output_data_t get_output_key(const uint64_t& amount, const uint64_t& index) { return output_data_t(); }
- virtual output_data_t get_output_key(const uint64_t& global_index) const { return output_data_t(); }
virtual tx_out_index get_output_tx_and_index_from_global(const uint64_t& index) const { return tx_out_index(); }
virtual tx_out_index get_output_tx_and_index(const uint64_t& amount, const uint64_t& index) const { return tx_out_index(); }
virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices) const {}
@@ -131,7 +130,7 @@ public:
virtual bool for_all_txpool_txes(std::function<bool(const crypto::hash&, const txpool_tx_meta_t&, const cryptonote::blobdata*)>, bool include_blob = false, bool include_unrelayed_txes = false) const { return false; }
virtual void add_block( const block& blk
- , const size_t& block_size
+ , size_t block_weight
, const difficulty_type& cumulative_difficulty
, const uint64_t& coins_generated
, uint64_t num_rct_outs
diff --git a/tests/unit_tests/is_hdd.cpp b/tests/unit_tests/is_hdd.cpp
new file mode 100644
index 000000000..1be670e5e
--- /dev/null
+++ b/tests/unit_tests/is_hdd.cpp
@@ -0,0 +1,17 @@
+#include "common/util.h"
+#include <string>
+#include <gtest/gtest.h>
+
+#if defined(__GLIBC__)
+TEST(is_hdd, linux_os_root)
+{
+ std::string path = "/";
+ EXPECT_TRUE(tools::is_hdd(path.c_str()));
+}
+#else
+TEST(is_hdd, unknown_os)
+{
+ std::string path = "";
+ EXPECT_FALSE(tools::is_hdd(path.c_str()));
+}
+#endif
diff --git a/tests/unit_tests/json_serialization.cpp b/tests/unit_tests/json_serialization.cpp
new file mode 100644
index 000000000..234cb2c33
--- /dev/null
+++ b/tests/unit_tests/json_serialization.cpp
@@ -0,0 +1,217 @@
+
+#include <boost/optional/optional.hpp>
+#include <boost/range/adaptor/indexed.hpp>
+#include <gtest/gtest.h>
+#include <rapidjson/document.h>
+#include <vector>
+
+#include "crypto/hash.h"
+#include "cryptonote_basic/account.h"
+#include "cryptonote_basic/cryptonote_basic.h"
+#include "cryptonote_basic/cryptonote_format_utils.h"
+#include "cryptonote_core/cryptonote_tx_utils.h"
+#include "serialization/json_object.h"
+
+
+namespace
+{
+ cryptonote::transaction
+ make_miner_transaction(cryptonote::account_public_address const& to)
+ {
+ cryptonote::transaction tx{};
+ if (!cryptonote::construct_miner_tx(0, 0, 5000, 500, 500, to, tx))
+ throw std::runtime_error{"transaction construction error"};
+
+ crypto::hash id{0};
+ if (!cryptonote::get_transaction_hash(tx, id))
+ throw std::runtime_error{"could not get transaction hash"};
+
+ return tx;
+ }
+
+ cryptonote::transaction
+ make_transaction(
+ cryptonote::account_keys const& from,
+ std::vector<cryptonote::transaction> const& sources,
+ std::vector<cryptonote::account_public_address> const& destinations,
+ bool rct,
+ bool bulletproof)
+ {
+ std::uint64_t source_amount = 0;
+ std::vector<cryptonote::tx_source_entry> actual_sources;
+ for (auto const& source : sources)
+ {
+ std::vector<cryptonote::tx_extra_field> extra_fields;
+ if (!cryptonote::parse_tx_extra(source.extra, extra_fields))
+ throw std::runtime_error{"invalid transaction"};
+
+ cryptonote::tx_extra_pub_key key_field{};
+ if (!cryptonote::find_tx_extra_field_by_type(extra_fields, key_field))
+ throw std::runtime_error{"invalid transaction"};
+
+ for (auto const& input : boost::adaptors::index(source.vout))
+ {
+ source_amount += input.value().amount;
+ auto const& key = boost::get<cryptonote::txout_to_key>(input.value().target);
+
+ actual_sources.push_back(
+ {{}, 0, key_field.pub_key, {}, std::size_t(input.index()), input.value().amount, rct, rct::identity()}
+ );
+
+ for (unsigned ring = 0; ring < 10; ++ring)
+ actual_sources.back().push_output(input.index(), key.key, input.value().amount);
+ }
+ }
+
+ std::vector<cryptonote::tx_destination_entry> to;
+ for (auto const& destination : destinations)
+ to.push_back({(source_amount / destinations.size()), destination, false});
+
+ cryptonote::transaction tx{};
+
+ crypto::secret_key tx_key{};
+ std::vector<crypto::secret_key> extra_keys{};
+
+ std::unordered_map<crypto::public_key, cryptonote::subaddress_index> subaddresses;
+ subaddresses[from.m_account_address.m_spend_public_key] = {0,0};
+
+ if (!cryptonote::construct_tx_and_get_tx_key(from, subaddresses, actual_sources, to, boost::none, {}, tx, 0, tx_key, extra_keys, rct, bulletproof ? rct::RangeProofBulletproof : rct::RangeProofBorromean))
+ throw std::runtime_error{"transaction construction error"};
+
+ return tx;
+ }
+} // anonymous
+
+TEST(JsonSerialization, MinerTransaction)
+{
+ cryptonote::account_base acct;
+ acct.generate();
+ const auto miner_tx = make_miner_transaction(acct.get_keys().m_account_address);
+
+ crypto::hash tx_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(miner_tx, tx_hash));
+
+ rapidjson::Document doc;
+ cryptonote::json::toJsonValue(doc, miner_tx, doc);
+
+ cryptonote::transaction miner_tx_copy;
+ cryptonote::json::fromJsonValue(doc, miner_tx_copy);
+
+ crypto::hash tx_copy_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(miner_tx_copy, tx_copy_hash));
+ EXPECT_EQ(tx_hash, tx_copy_hash);
+
+ cryptonote::blobdata tx_bytes{};
+ cryptonote::blobdata tx_copy_bytes{};
+
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(miner_tx, tx_bytes));
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(miner_tx_copy, tx_copy_bytes));
+
+ EXPECT_EQ(tx_bytes, tx_copy_bytes);
+}
+
+TEST(JsonSerialization, RegularTransaction)
+{
+ cryptonote::account_base acct1;
+ acct1.generate();
+
+ cryptonote::account_base acct2;
+ acct2.generate();
+
+ const auto miner_tx = make_miner_transaction(acct1.get_keys().m_account_address);
+ const auto tx = make_transaction(
+ acct1.get_keys(), {miner_tx}, {acct2.get_keys().m_account_address}, false, false
+ );
+
+ crypto::hash tx_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(tx, tx_hash));
+
+ rapidjson::Document doc;
+ cryptonote::json::toJsonValue(doc, tx, doc);
+
+ cryptonote::transaction tx_copy;
+ cryptonote::json::fromJsonValue(doc, tx_copy);
+
+ crypto::hash tx_copy_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(tx_copy, tx_copy_hash));
+ EXPECT_EQ(tx_hash, tx_copy_hash);
+
+ cryptonote::blobdata tx_bytes{};
+ cryptonote::blobdata tx_copy_bytes{};
+
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(tx, tx_bytes));
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(tx_copy, tx_copy_bytes));
+
+ EXPECT_EQ(tx_bytes, tx_copy_bytes);
+}
+
+TEST(JsonSerialization, RingctTransaction)
+{
+ cryptonote::account_base acct1;
+ acct1.generate();
+
+ cryptonote::account_base acct2;
+ acct2.generate();
+
+ const auto miner_tx = make_miner_transaction(acct1.get_keys().m_account_address);
+ const auto tx = make_transaction(
+ acct1.get_keys(), {miner_tx}, {acct2.get_keys().m_account_address}, true, false
+ );
+
+ crypto::hash tx_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(tx, tx_hash));
+
+ rapidjson::Document doc;
+ cryptonote::json::toJsonValue(doc, tx, doc);
+
+ cryptonote::transaction tx_copy;
+ cryptonote::json::fromJsonValue(doc, tx_copy);
+
+ crypto::hash tx_copy_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(tx_copy, tx_copy_hash));
+ EXPECT_EQ(tx_hash, tx_copy_hash);
+
+ cryptonote::blobdata tx_bytes{};
+ cryptonote::blobdata tx_copy_bytes{};
+
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(tx, tx_bytes));
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(tx_copy, tx_copy_bytes));
+
+ EXPECT_EQ(tx_bytes, tx_copy_bytes);
+}
+
+TEST(JsonSerialization, BulletproofTransaction)
+{
+ cryptonote::account_base acct1;
+ acct1.generate();
+
+ cryptonote::account_base acct2;
+ acct2.generate();
+
+ const auto miner_tx = make_miner_transaction(acct1.get_keys().m_account_address);
+ const auto tx = make_transaction(
+ acct1.get_keys(), {miner_tx}, {acct2.get_keys().m_account_address}, true, true
+ );
+
+ crypto::hash tx_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(tx, tx_hash));
+
+ rapidjson::Document doc;
+ cryptonote::json::toJsonValue(doc, tx, doc);
+
+ cryptonote::transaction tx_copy;
+ cryptonote::json::fromJsonValue(doc, tx_copy);
+
+ crypto::hash tx_copy_hash{};
+ ASSERT_TRUE(cryptonote::get_transaction_hash(tx_copy, tx_copy_hash));
+ EXPECT_EQ(tx_hash, tx_copy_hash);
+
+ cryptonote::blobdata tx_bytes{};
+ cryptonote::blobdata tx_copy_bytes{};
+
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(tx, tx_bytes));
+ ASSERT_TRUE(cryptonote::t_serializable_object_to_blob(tx_copy, tx_copy_bytes));
+
+ EXPECT_EQ(tx_bytes, tx_copy_bytes);
+}
+
diff --git a/tests/unit_tests/keccak.cpp b/tests/unit_tests/keccak.cpp
new file mode 100644
index 000000000..4276b0e1d
--- /dev/null
+++ b/tests/unit_tests/keccak.cpp
@@ -0,0 +1,150 @@
+// 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"
+
+extern "C" {
+#include "crypto/keccak.h"
+}
+
+#define KECCAK_BLOCKLEN 136
+
+#define TEST_KECCAK(sz, chunks) \
+ std::string data; \
+ data.resize(sz); \
+ for (size_t i = 0; i < sz; ++i) \
+ data[i] = i * 17; \
+ uint8_t md0[32], md1[32]; \
+ keccak((const uint8_t*)data.data(), data.size(), md0, 32); \
+ KECCAK_CTX ctx; \
+ keccak_init(&ctx); \
+ size_t offset = 0; \
+ for (size_t i = 0; i < sizeof(chunks) / sizeof(chunks[0]); ++i) \
+ { \
+ ASSERT_TRUE(offset + chunks[i] <= data.size()); \
+ keccak_update(&ctx, (const uint8_t*)data.data() + offset, chunks[i]); \
+ offset += chunks[i]; \
+ } \
+ ASSERT_TRUE(offset == data.size()); \
+ keccak_finish(&ctx, md1); \
+ ASSERT_EQ(memcmp(md0, md1, 32), 0);
+
+TEST(keccak, )
+{
+}
+
+TEST(keccak, 0_and_0)
+{
+ static const size_t chunks[] = {0};
+ TEST_KECCAK(0, chunks);
+}
+
+TEST(keccak, 1_and_1)
+{
+ static const size_t chunks[] = {1};
+ TEST_KECCAK(1, chunks);
+}
+
+TEST(keccak, 1_and_0_1_0)
+{
+ static const size_t chunks[] = {0, 1, 0};
+ TEST_KECCAK(1, chunks);
+}
+
+TEST(keccak, 2_and_1_1)
+{
+ static const size_t chunks[] = {1, 1};
+ TEST_KECCAK(2, chunks);
+}
+
+TEST(keccak, 4_and_0_0_1_0_2_1_0)
+{
+ static const size_t chunks[] = {0, 0, 1, 0, 2, 1, 0};
+ TEST_KECCAK(4, chunks);
+}
+
+TEST(keccak, 15_and_1_14)
+{
+ static const size_t chunks[] = {1, 14};
+ TEST_KECCAK(15, chunks);
+}
+
+TEST(keccak, 135_and_134_1)
+{
+ static const size_t chunks[] = {134, 1};
+ TEST_KECCAK(135, chunks);
+}
+
+TEST(keccak, 135_and_135_0)
+{
+ static const size_t chunks[] = {135, 0};
+ TEST_KECCAK(135, chunks);
+}
+
+TEST(keccak, 135_and_0_135)
+{
+ static const size_t chunks[] = {0, 135};
+ TEST_KECCAK(135, chunks);
+}
+
+TEST(keccak, 136_and_135_1)
+{
+ static const size_t chunks[] = {135, 1};
+ TEST_KECCAK(136, chunks);
+}
+
+TEST(keccak, 136_and_136_0)
+{
+ static const size_t chunks[] = {136, 0};
+ TEST_KECCAK(136, chunks);
+}
+
+TEST(keccak, 136_and_0_136)
+{
+ static const size_t chunks[] = {0, 136};
+ TEST_KECCAK(136, chunks);
+}
+
+TEST(keccak, 136_and_136)
+{
+ static const size_t chunks[] = {136};
+ TEST_KECCAK(136, chunks);
+}
+
+TEST(keccak, 137_and_136_1)
+{
+ static const size_t chunks[] = {136, 1};
+ TEST_KECCAK(137, chunks);
+}
+
+TEST(keccak, 137_and_1_136)
+{
+ static const size_t chunks[] = {1, 136};
+ TEST_KECCAK(137, chunks);
+}
+
diff --git a/tests/unit_tests/mlocker.cpp b/tests/unit_tests/mlocker.cpp
new file mode 100644
index 000000000..480940374
--- /dev/null
+++ b/tests/unit_tests/mlocker.cpp
@@ -0,0 +1,194 @@
+// 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 "misc_log_ex.h"
+#include "mlocker.h"
+
+#if defined __GNUC__ && !defined _WIN32
+#define HAVE_MLOCK 1
+#endif
+
+#ifdef HAVE_MLOCK
+
+#define BASE(data) (char*)(((uintptr_t)(data.get() + page_size - 1)) / page_size * page_size)
+
+TEST(mlocker, distinct_1)
+{
+ const size_t page_size = epee::mlocker::get_page_size();
+ ASSERT_TRUE(page_size > 0);
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ std::unique_ptr<char[]> data{new char[8 * page_size]};
+ epee::mlocker *m0 = new epee::mlocker(BASE(data), 1);
+ epee::mlocker *m1 = new epee::mlocker(BASE(data) + 2 * page_size, 1);
+ epee::mlocker *m2 = new epee::mlocker(BASE(data) + 3 * page_size, 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 3);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 3);
+ delete m0;
+ delete m1;
+ delete m2;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+TEST(mlocker, distinct_full_page)
+{
+ const size_t page_size = epee::mlocker::get_page_size();
+ ASSERT_TRUE(page_size > 0);
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ std::unique_ptr<char[]> data{new char[8 * page_size]};
+ epee::mlocker *m0 = new epee::mlocker(BASE(data), page_size);
+ epee::mlocker *m1 = new epee::mlocker(BASE(data) + 2 * page_size, page_size);
+ epee::mlocker *m2 = new epee::mlocker(BASE(data) + 3 * page_size, page_size);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 3);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 3);
+ delete m0;
+ delete m1;
+ delete m2;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+TEST(mlocker, identical)
+{
+ const size_t page_size = epee::mlocker::get_page_size();
+ ASSERT_TRUE(page_size >= 32);
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ std::unique_ptr<char[]> data{new char[8 * page_size]};
+ epee::mlocker *m0 = new epee::mlocker(BASE(data) + page_size, 32);
+ epee::mlocker *m1 = new epee::mlocker(BASE(data) + page_size, 32);
+ epee::mlocker *m2 = new epee::mlocker(BASE(data) + page_size, 32);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 3);
+ delete m1;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 2);
+ delete m0;
+ delete m2;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+TEST(mlocker, overlapping_small)
+{
+ const size_t page_size = epee::mlocker::get_page_size();
+ ASSERT_TRUE(page_size >= 64);
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ std::unique_ptr<char[]> data{new char[8 * page_size]};
+ epee::mlocker *m0 = new epee::mlocker(BASE(data), 32);
+ epee::mlocker *m1 = new epee::mlocker(BASE(data) + 16, 32);
+ epee::mlocker *m2 = new epee::mlocker(BASE(data) + 8, 32);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 3);
+ delete m1;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 2);
+ delete m2;
+ delete m0;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+TEST(mlocker, multi_page)
+{
+ const size_t page_size = epee::mlocker::get_page_size();
+ ASSERT_TRUE(page_size > 0);
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ std::unique_ptr<char[]> data{new char[8 * page_size]};
+ epee::mlocker *m0 = new epee::mlocker(BASE(data) + page_size, page_size * 3);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 3);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 1);
+ epee::mlocker *m1 = new epee::mlocker(BASE(data) + page_size * 7, page_size);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 4);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 2);
+ delete m0;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 1);
+ delete m1;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+TEST(mlocker, cross_page)
+{
+ const size_t page_size = epee::mlocker::get_page_size();
+ ASSERT_TRUE(page_size > 32);
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ std::unique_ptr<char[]> data{new char[2 * page_size]};
+ epee::mlocker *m0 = new epee::mlocker(BASE(data) + page_size - 1, 2);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 2);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 1);
+ delete m0;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+TEST(mlocker, redundant)
+{
+ const size_t page_size = epee::mlocker::get_page_size();
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ std::unique_ptr<char[]> data{new char[2 * page_size]};
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+ epee::mlocker *m0 = new epee::mlocker(BASE(data), 32);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 1);
+ epee::mlocker *m1 = new epee::mlocker(BASE(data), 32);
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 2);
+ delete m1;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 1);
+ delete m0;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+TEST(mlocker, mlocked)
+{
+ const size_t base_pages = epee::mlocker::get_num_locked_pages();
+ const size_t base_objects = epee::mlocker::get_num_locked_objects();
+ {
+ struct Foo { uint64_t u; };
+ epee::mlocked<Foo> l;
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 1);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 1);
+ }
+ ASSERT_EQ(epee::mlocker::get_num_locked_pages(), base_pages + 0);
+ ASSERT_EQ(epee::mlocker::get_num_locked_objects(), base_objects + 0);
+}
+
+#endif
diff --git a/tests/unit_tests/mnemonics.cpp b/tests/unit_tests/mnemonics.cpp
index 8fa3192b9..0b74a6b94 100644
--- a/tests/unit_tests/mnemonics.cpp
+++ b/tests/unit_tests/mnemonics.cpp
@@ -27,6 +27,8 @@
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "gtest/gtest.h"
+#include "wipeable_string.h"
+#include "mnemonics/language_base.h"
#include "mnemonics/electrum-words.h"
#include "crypto/crypto.h"
#include <stdlib.h>
@@ -74,14 +76,16 @@ namespace
void test_language(const Language::Base &language)
{
const std::vector<std::string> &word_list = language.get_word_list();
- std::string seed = "", return_seed = "";
+ epee::wipeable_string w_seed = "", w_return_seed = "";
+ std::string seed, return_seed;
// Generate a random seed without checksum
crypto::secret_key randkey;
for (size_t ii = 0; ii < sizeof(randkey); ++ii)
{
randkey.data[ii] = rand();
}
- crypto::ElectrumWords::bytes_to_words(randkey, seed, language.get_language_name());
+ crypto::ElectrumWords::bytes_to_words(randkey, w_seed, language.get_language_name());
+ seed = std::string(w_seed.data(), w_seed.size());
// remove the checksum word
const char *space = strrchr(seed.c_str(), ' ');
ASSERT_TRUE(space != NULL);
@@ -103,7 +107,8 @@ namespace
ASSERT_STREQ(language.get_language_name().c_str(), language_name.c_str());
// Convert the secret key back to seed
- crypto::ElectrumWords::bytes_to_words(key, return_seed, language.get_language_name());
+ crypto::ElectrumWords::bytes_to_words(key, w_return_seed, language.get_language_name());
+ return_seed = std::string(w_return_seed.data(), w_return_seed.size());
ASSERT_EQ(true, res);
std::cout << "Returned seed:\n";
std::cout << return_seed << std::endl;
@@ -126,8 +131,9 @@ namespace
std::cout << "Detected language: " << language_name << std::endl;
ASSERT_STREQ(language.get_language_name().c_str(), language_name.c_str());
- return_seed = "";
- crypto::ElectrumWords::bytes_to_words(key, return_seed, language.get_language_name());
+ w_return_seed = "";
+ crypto::ElectrumWords::bytes_to_words(key, w_return_seed, language.get_language_name());
+ return_seed = std::string(w_return_seed.data(), w_return_seed.size());
ASSERT_EQ(true, res);
std::cout << "Returned seed:\n";
std::cout << return_seed << std::endl;
@@ -202,3 +208,17 @@ TEST(mnemonics, language_detection_with_bad_checksum)
ASSERT_EQ(true, res);
ASSERT_STREQ(language_name.c_str(), "Português");
}
+
+TEST(mnemonics, utf8prefix)
+{
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("foo"), 0) == "");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("foo"), 1) == "f");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("foo"), 2) == "fo");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("foo"), 3) == "foo");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("foo"), 4) == "foo");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("æon"), 0) == "");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("æon"), 1) == "æ");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("æon"), 2) == "æo");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("æon"), 3) == "æon");
+ ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("æon"), 4) == "æon");
+}
diff --git a/tests/unit_tests/multiexp.cpp b/tests/unit_tests/multiexp.cpp
new file mode 100644
index 000000000..d8d79a7a2
--- /dev/null
+++ b/tests/unit_tests/multiexp.cpp
@@ -0,0 +1,254 @@
+// 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 "crypto/crypto.h"
+#include "ringct/rctOps.h"
+#include "ringct/multiexp.h"
+
+static const rct::key TESTSCALAR = rct::skGen();
+static const rct::key TESTPOW2SCALAR = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+static const rct::key TESTSMALLSCALAR = {{5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+static const rct::key TESTPOINT = rct::scalarmultBase(rct::skGen());
+
+static rct::key basic(const std::vector<rct::MultiexpData> &data)
+{
+ ge_p3 res_p3 = ge_p3_identity;
+ for (const auto &d: data)
+ {
+ ge_cached cached;
+ ge_p3 p3;
+ ge_p1p1 p1;
+ ge_scalarmult_p3(&p3, d.scalar.bytes, &d.point);
+ ge_p3_to_cached(&cached, &p3);
+ ge_add(&p1, &res_p3, &cached);
+ ge_p1p1_to_p3(&res_p3, &p1);
+ }
+ rct::key res;
+ ge_p3_tobytes(res.bytes, &res_p3);
+ return res;
+}
+
+static ge_p3 get_p3(const rct::key &point)
+{
+ ge_p3 p3;
+ EXPECT_TRUE(ge_frombytes_vartime(&p3, point.bytes) == 0);
+ return p3;
+}
+
+TEST(multiexp, bos_coster_empty)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({rct::zero(), get_p3(rct::identity())});
+ ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
+}
+
+TEST(multiexp, straus_empty)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({rct::zero(), get_p3(rct::identity())});
+ ASSERT_TRUE(basic(data) == straus(data));
+}
+
+TEST(multiexp, pippenger_empty)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({rct::zero(), get_p3(rct::identity())});
+ ASSERT_TRUE(basic(data) == pippenger(data));
+}
+
+TEST(multiexp, bos_coster_zero_and_non_zero)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({rct::zero(), get_p3(TESTPOINT)});
+ data.push_back({TESTSCALAR, get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
+}
+
+TEST(multiexp, straus_zero_and_non_zero)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({rct::zero(), get_p3(TESTPOINT)});
+ data.push_back({TESTSCALAR, get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == straus(data));
+}
+
+TEST(multiexp, pippenger_zero_and_non_zero)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({rct::zero(), get_p3(TESTPOINT)});
+ data.push_back({TESTSCALAR, get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == pippenger(data));
+}
+
+TEST(multiexp, bos_coster_pow2_scalar)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({TESTPOW2SCALAR, get_p3(TESTPOINT)});
+ data.push_back({TESTSMALLSCALAR, get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
+}
+
+TEST(multiexp, straus_pow2_scalar)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({TESTPOW2SCALAR, get_p3(TESTPOINT)});
+ data.push_back({TESTSMALLSCALAR, get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == straus(data));
+}
+
+TEST(multiexp, pippenger_pow2_scalar)
+{
+ std::vector<rct::MultiexpData> data;
+ data.push_back({TESTPOW2SCALAR, get_p3(TESTPOINT)});
+ data.push_back({TESTSMALLSCALAR, get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == pippenger(data));
+}
+
+TEST(multiexp, bos_coster_only_zeroes)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 16; ++n)
+ data.push_back({rct::zero(), get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
+}
+
+TEST(multiexp, straus_only_zeroes)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 16; ++n)
+ data.push_back({rct::zero(), get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == straus(data));
+}
+
+TEST(multiexp, pippenger_only_zeroes)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 16; ++n)
+ data.push_back({rct::zero(), get_p3(TESTPOINT)});
+ ASSERT_TRUE(basic(data) == pippenger(data));
+}
+
+TEST(multiexp, bos_coster_only_identities)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 16; ++n)
+ data.push_back({TESTSCALAR, get_p3(rct::identity())});
+ ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
+}
+
+TEST(multiexp, straus_only_identities)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 16; ++n)
+ data.push_back({TESTSCALAR, get_p3(rct::identity())});
+ ASSERT_TRUE(basic(data) == straus(data));
+}
+
+TEST(multiexp, pippenger_only_identities)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 16; ++n)
+ data.push_back({TESTSCALAR, get_p3(rct::identity())});
+ ASSERT_TRUE(basic(data) == pippenger(data));
+}
+
+TEST(multiexp, bos_coster_random)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 32; ++n)
+ {
+ data.push_back({rct::skGen(), get_p3(rct::scalarmultBase(rct::skGen()))});
+ ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
+ }
+}
+
+TEST(multiexp, straus_random)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 32; ++n)
+ {
+ data.push_back({rct::skGen(), get_p3(rct::scalarmultBase(rct::skGen()))});
+ ASSERT_TRUE(basic(data) == straus(data));
+ }
+}
+
+TEST(multiexp, pippenger_random)
+{
+ std::vector<rct::MultiexpData> data;
+ for (int n = 0; n < 32; ++n)
+ {
+ data.push_back({rct::skGen(), get_p3(rct::scalarmultBase(rct::skGen()))});
+ ASSERT_TRUE(basic(data) == pippenger(data));
+ }
+}
+
+TEST(multiexp, straus_cached)
+{
+ static constexpr size_t N = 256;
+ std::vector<rct::MultiexpData> P(N);
+ for (size_t n = 0; n < N; ++n)
+ {
+ P[n].scalar = rct::zero();
+ ASSERT_TRUE(ge_frombytes_vartime(&P[n].point, rct::scalarmultBase(rct::skGen()).bytes) == 0);
+ }
+ std::shared_ptr<rct::straus_cached_data> cache = rct::straus_init_cache(P);
+ for (size_t n = 0; n < N/16; ++n)
+ {
+ std::vector<rct::MultiexpData> data;
+ size_t sz = 1 + crypto::rand<size_t>() % (N-1);
+ for (size_t s = 0; s < sz; ++s)
+ {
+ data.push_back({rct::skGen(), P[s].point});
+ }
+ ASSERT_TRUE(basic(data) == straus(data, cache));
+ }
+}
+
+TEST(multiexp, pippenger_cached)
+{
+ static constexpr size_t N = 256;
+ std::vector<rct::MultiexpData> P(N);
+ for (size_t n = 0; n < N; ++n)
+ {
+ P[n].scalar = rct::zero();
+ ASSERT_TRUE(ge_frombytes_vartime(&P[n].point, rct::scalarmultBase(rct::skGen()).bytes) == 0);
+ }
+ std::shared_ptr<rct::pippenger_cached_data> cache = rct::pippenger_init_cache(P);
+ for (size_t n = 0; n < N/16; ++n)
+ {
+ std::vector<rct::MultiexpData> data;
+ size_t sz = 1 + crypto::rand<size_t>() % (N-1);
+ for (size_t s = 0; s < sz; ++s)
+ {
+ data.push_back({rct::skGen(), P[s].point});
+ }
+ ASSERT_TRUE(basic(data) == pippenger(data, cache));
+ }
+}
diff --git a/tests/unit_tests/multisig.cpp b/tests/unit_tests/multisig.cpp
index 922299333..eb453b960 100644
--- a/tests/unit_tests/multisig.cpp
+++ b/tests/unit_tests/multisig.cpp
@@ -61,10 +61,13 @@ static void make_wallet(unsigned int idx, tools::wallet2 &wallet)
try
{
- wallet.init("");
+ wallet.init(false, "");
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));
+ wallet.decrypt_keys("");
+ ASSERT_TRUE(test_addresses[idx].spendkey == epee::string_tools::pod_to_hex(wallet.get_account().get_keys().m_spend_secret_key));
+ wallet.encrypt_keys("");
}
catch (const std::exception &e)
{
@@ -83,8 +86,12 @@ static void make_M_2_wallet(tools::wallet2 &wallet0, tools::wallet2 &wallet1, un
std::vector<crypto::secret_key> sk0(1), sk1(1);
std::vector<crypto::public_key> pk0(1), pk1(1);
+ wallet0.decrypt_keys("");
std::string mi0 = wallet0.get_multisig_info();
+ wallet0.encrypt_keys("");
+ wallet1.decrypt_keys("");
std::string mi1 = wallet1.get_multisig_info();
+ wallet1.encrypt_keys("");
ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi1, sk0[0], pk0[0]));
ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi0, sk1[0], pk1[0]));
@@ -118,9 +125,15 @@ static void make_M_3_wallet(tools::wallet2 &wallet0, tools::wallet2 &wallet1, to
std::vector<crypto::secret_key> sk0(2), sk1(2), sk2(2);
std::vector<crypto::public_key> pk0(2), pk1(2), pk2(2);
+ wallet0.decrypt_keys("");
std::string mi0 = wallet0.get_multisig_info();
+ wallet0.encrypt_keys("");
+ wallet1.decrypt_keys("");
std::string mi1 = wallet1.get_multisig_info();
+ wallet1.encrypt_keys("");
+ wallet2.decrypt_keys("");
std::string mi2 = wallet2.get_multisig_info();
+ wallet2.encrypt_keys("");
ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi1, sk0[0], pk0[0]));
ASSERT_TRUE(tools::wallet2::verify_multisig_info(mi2, sk0[1], pk0[1]));
diff --git a/tests/unit_tests/ringct.cpp b/tests/unit_tests/ringct.cpp
index 6e3958f8a..3877ef785 100644
--- a/tests/unit_tests/ringct.cpp
+++ b/tests/unit_tests/ringct.cpp
@@ -1085,3 +1085,34 @@ TEST(ringct, zeroCommmit)
const rct::key manual = rct::addKeys(a, b);
ASSERT_EQ(z, manual);
}
+
+TEST(ringct, H)
+{
+ ge_p3 p3;
+ ASSERT_EQ(ge_frombytes_vartime(&p3, rct::H.bytes), 0);
+ ASSERT_EQ(memcmp(&p3, &ge_p3_H, sizeof(ge_p3)), 0);
+}
+
+TEST(ringct, mul8)
+{
+ ASSERT_EQ(rct::scalarmult8(rct::identity()), rct::identity());
+ ASSERT_EQ(rct::scalarmult8(rct::H), rct::scalarmultKey(rct::H, rct::EIGHT));
+ ASSERT_EQ(rct::scalarmultKey(rct::scalarmultKey(rct::H, rct::INV_EIGHT), rct::EIGHT), rct::H);
+}
+
+TEST(ringct, aggregated)
+{
+ static const size_t N_PROOFS = 16;
+ std::vector<rctSig> s(N_PROOFS);
+ std::vector<const rctSig*> sp(N_PROOFS);
+
+ for (size_t n = 0; n < N_PROOFS; ++n)
+ {
+ static const uint64_t inputs[] = {1000, 1000};
+ static const uint64_t outputs[] = {500, 1500};
+ s[n] = make_sample_simple_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, 0);
+ sp[n] = &s[n];
+ }
+
+ ASSERT_TRUE(verRctSemanticsSimple(sp));
+}
diff --git a/tests/unit_tests/ringdb.cpp b/tests/unit_tests/ringdb.cpp
index d50d61b0f..9b842569a 100644
--- a/tests/unit_tests/ringdb.cpp
+++ b/tests/unit_tests/ringdb.cpp
@@ -39,25 +39,29 @@
#include "crypto/crypto.h"
#include "crypto/random.h"
#include "crypto/chacha.h"
+#include "ringct/rctOps.h"
+#include "cryptonote_basic/cryptonote_basic.h"
#include "wallet/ringdb.h"
static crypto::chacha_key generate_chacha_key()
{
- uint8_t key[CHACHA_KEY_SIZE];
- crypto::rand(CHACHA_KEY_SIZE, key);
crypto::chacha_key chacha_key;
- memcpy(&chacha_key, key, CHACHA_KEY_SIZE);
+ uint64_t password = crypto::rand<uint64_t>();
+ crypto::generate_chacha_key(std::string((const char*)&password, sizeof(password)), chacha_key, 1);
return chacha_key;
}
static crypto::key_image generate_key_image()
{
- return crypto::rand<crypto::key_image>();
+ crypto::key_image key_image;
+ cryptonote::keypair keypair = cryptonote::keypair::generate(hw::get_device("default"));
+ crypto::generate_key_image(keypair.pub, keypair.sec, key_image);
+ return key_image;
}
static crypto::public_key generate_output()
{
- return crypto::rand<crypto::public_key>();
+ return rct::rct2pk(rct::scalarmultBase(rct::skGen()));
}
@@ -76,13 +80,13 @@ public:
private:
std::string make_filename()
{
- boost::filesystem::path path = tools::get_default_data_dir();
- path /= "fake";
+ boost::filesystem::path path =
+ boost::filesystem::temp_directory_path();
#if defined(__MINGW32__) || defined(__MINGW__)
- filename = tempnam(path.string().c_str(), "ringdb-test-");
+ filename = tempnam(path.string().c_str(), "monero-ringdb-test-");
EXPECT_TRUE(filename != NULL);
#else
- path /= "ringdb-test-XXXXXX";
+ path /= "monero-ringdb-test-XXXXXX";
filename = strdup(path.string().c_str());
EXPECT_TRUE(mkdtemp(filename) != NULL);
#endif
diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index 5a2114027..2f7b5aac7 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -671,8 +671,7 @@ TEST(Serialization, serializes_ringct_types)
TEST(Serialization, portability_wallet)
{
const cryptonote::network_type nettype = cryptonote::TESTNET;
- const bool restricted = false;
- tools::wallet2 w(nettype, restricted);
+ tools::wallet2 w(nettype);
const boost::filesystem::path wallet_file = unit_test::data_dir / "wallet_9svHk1";
string password = "test";
bool r = false;
@@ -810,7 +809,7 @@ TEST(Serialization, portability_outputs)
if(ciphertext.size() < prefix_size)
return {};
crypto::chacha_key key;
- crypto::generate_chacha_key(&skey, sizeof(skey), key);
+ crypto::generate_chacha_key(&skey, sizeof(skey), key, 1);
const crypto::chacha_iv &iv = *(const crypto::chacha_iv*)&ciphertext[0];
std::string plaintext;
plaintext.resize(ciphertext.size() - prefix_size);
@@ -825,7 +824,7 @@ TEST(Serialization, portability_outputs)
return {};
}
crypto::chacha8(ciphertext.data() + sizeof(iv), ciphertext.size() - prefix_size, key, iv, &plaintext[0]);
- return std::move(plaintext);
+ return plaintext;
};
crypto::secret_key view_secret_key;
epee::string_tools::hex_to_pod("339673bb1187e2f73ba7841ab6841c5553f96e9f13f8fe6612e69318db4e9d0a", view_secret_key);
diff --git a/tests/unit_tests/wipeable_string.cpp b/tests/unit_tests/wipeable_string.cpp
new file mode 100644
index 000000000..5ea1c1729
--- /dev/null
+++ b/tests/unit_tests/wipeable_string.cpp
@@ -0,0 +1,204 @@
+// 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 <boost/optional/optional.hpp>
+#include <string.h>
+#include "gtest/gtest.h"
+
+#include "misc_log_ex.h"
+#include "wipeable_string.h"
+
+TEST(wipeable_string, ctor)
+{
+ epee::wipeable_string s0;
+ ASSERT_EQ(s0.size(), 0);
+
+ epee::wipeable_string s1(std::string("foo"));
+ ASSERT_EQ(s1.size(), 3);
+ ASSERT_TRUE(!memcmp(s1.data(), "foo", s1.size()));
+
+ epee::wipeable_string s2(std::string("bar"));
+ ASSERT_EQ(s2.size(), 3);
+ ASSERT_TRUE(!memcmp(s2.data(), "bar", s2.size()));
+
+ epee::wipeable_string s3(std::string("quux"));
+ ASSERT_EQ(s3.size(), 4);
+ ASSERT_TRUE(!memcmp(s3.data(), "quux", s3.size()));
+}
+
+TEST(wipeable_string, wipe)
+{
+ epee::wipeable_string s0(std::string("foo"));
+ ASSERT_EQ(s0.size(), 3);
+ s0.wipe();
+ ASSERT_EQ(s0.size(), 3);
+ ASSERT_TRUE(!memcmp(s0.data(), "\0\0\0", 3));
+}
+
+TEST(wipeable_string, clear)
+{
+ epee::wipeable_string s0(std::string("foo"));
+ ASSERT_EQ(s0.size(), 3);
+ s0.clear();
+ ASSERT_EQ(s0.size(), 0);
+}
+
+TEST(wipeable_string, push_back)
+{
+ epee::wipeable_string s0(std::string("fo"));
+ ASSERT_EQ(s0.size(), 2);
+ s0.push_back('o');
+ ASSERT_EQ(s0.size(), 3);
+ ASSERT_TRUE(!memcmp(s0.data(), "foo", s0.size()));
+}
+
+TEST(wipeable_string, append_char)
+{
+ epee::wipeable_string s0(std::string("fo"));
+ ASSERT_EQ(s0.size(), 2);
+ s0 += 'o';
+ ASSERT_EQ(s0.size(), 3);
+ ASSERT_TRUE(!memcmp(s0.data(), "foo", s0.size()));
+}
+
+TEST(wipeable_string, append_string)
+{
+ epee::wipeable_string s0(std::string("foo"));
+ ASSERT_EQ(s0.size(), 3);
+ s0 += "bar";
+ ASSERT_EQ(s0.size(), 6);
+ ASSERT_TRUE(!memcmp(s0.data(), "foobar", s0.size()));
+}
+
+TEST(wipeable_string, empty)
+{
+ epee::wipeable_string s0;
+ ASSERT_TRUE(s0.empty());
+ s0.push_back(' ');
+ ASSERT_FALSE(s0.empty());
+ ASSERT_EQ(s0.pop_back(), ' ');
+ ASSERT_TRUE(s0.empty());
+}
+
+TEST(wipeable_string, pop_back)
+{
+ epee::wipeable_string s = "test";
+ ASSERT_EQ(s.size(), 4);
+ ASSERT_EQ(s.pop_back(), 't');
+ ASSERT_EQ(s.size(), 3);
+ ASSERT_TRUE(!memcmp(s.data(), "tes", s.size()));
+}
+
+TEST(wipeable_string, equal)
+{
+ epee::wipeable_string s0 = "foo";
+ epee::wipeable_string s1 = "bar";
+ epee::wipeable_string s0_2 = "foo";
+ ASSERT_TRUE(s0 == s0);
+ ASSERT_TRUE(s0 == s0_2);
+ ASSERT_TRUE(s1 == s1);
+ ASSERT_FALSE(s1 == s0);
+ ASSERT_FALSE(s1 == s0_2);
+}
+
+TEST(wipeable_string, not_equal)
+{
+ epee::wipeable_string s0 = "foo";
+ epee::wipeable_string s1 = "bar";
+ epee::wipeable_string s0_2 = "foo";
+ ASSERT_FALSE(s0 != s0);
+ ASSERT_FALSE(s0 != s0_2);
+ ASSERT_FALSE(s1 != s1);
+ ASSERT_TRUE(s1 != s0);
+ ASSERT_TRUE(s1 != s0_2);
+}
+
+static epee::wipeable_string trimmed(const char *s)
+{
+ epee::wipeable_string str(s);
+ str.trim();
+ return str;
+}
+
+TEST(wipeable_string, trim)
+{
+ ASSERT_TRUE(trimmed("") == "");
+ ASSERT_TRUE(trimmed(" ") == "");
+ ASSERT_TRUE(trimmed(" ") == "");
+ ASSERT_TRUE(trimmed("a") == "a");
+ ASSERT_TRUE(trimmed(" a") == "a");
+ ASSERT_TRUE(trimmed(" a") == "a");
+ ASSERT_TRUE(trimmed("a ") == "a");
+ ASSERT_TRUE(trimmed("a ") == "a");
+ ASSERT_TRUE(trimmed(" a ") == "a");
+ ASSERT_TRUE(trimmed(" a ") == "a");
+ ASSERT_TRUE(trimmed(" ab ") == "ab");
+ ASSERT_TRUE(trimmed(" a b ") == "a b");
+ ASSERT_TRUE(trimmed(" a b ") == "a b");
+}
+
+static bool check_split(const char *s, const std::vector<epee::wipeable_string> &v)
+{
+ epee::wipeable_string str(s);
+ std::vector<epee::wipeable_string> fields;
+ str.split(fields);
+ return v == fields;
+}
+
+TEST(wipeable_string, split)
+{
+ ASSERT_TRUE(check_split("", {}));
+ ASSERT_TRUE(check_split("foo", {"foo"}));
+ ASSERT_TRUE(check_split(" foo ", {"foo"}));
+ ASSERT_TRUE(check_split("foo bar", {"foo", "bar"}));
+ ASSERT_TRUE(check_split("foo bar", {"foo", "bar"}));
+ ASSERT_TRUE(check_split("foo bar baz", {"foo", "bar", "baz"}));
+ ASSERT_TRUE(check_split(" foo bar baz ", {"foo", "bar", "baz"}));
+ ASSERT_TRUE(check_split(" foo bar baz", {"foo", "bar", "baz"}));
+ ASSERT_TRUE(check_split("foo bar baz ", {"foo", "bar", "baz"}));
+}
+
+TEST(wipeable_string, parse_hexstr)
+{
+ boost::optional<epee::wipeable_string> s;
+
+ ASSERT_EQ(boost::none, epee::wipeable_string("x").parse_hexstr());
+ ASSERT_EQ(boost::none, epee::wipeable_string("x0000000000000000").parse_hexstr());
+ ASSERT_EQ(boost::none, epee::wipeable_string("0000000000000000x").parse_hexstr());
+ ASSERT_EQ(boost::none, epee::wipeable_string("0").parse_hexstr());
+ ASSERT_EQ(boost::none, epee::wipeable_string("000").parse_hexstr());
+
+ ASSERT_TRUE((s = epee::wipeable_string("").parse_hexstr()));
+ ASSERT_EQ(*s, "");
+ ASSERT_TRUE((s = epee::wipeable_string("00").parse_hexstr()));
+ ASSERT_EQ(*s, epee::wipeable_string("", 1));
+ ASSERT_TRUE((s = epee::wipeable_string("41").parse_hexstr()));
+ ASSERT_EQ(*s, epee::wipeable_string("A"));
+ ASSERT_TRUE((s = epee::wipeable_string("414243").parse_hexstr()));
+ ASSERT_EQ(*s, epee::wipeable_string("ABC"));
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-12 05:35:06 +0000