2016-07-20 21:39:32 -07:00
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <gmock/gmock.h>
|
|
|
|
|
|
|
|
#include "crypto/equihash.h"
|
2016-08-13 06:14:09 -07:00
|
|
|
#include "uint256.h"
|
2016-07-20 21:39:32 -07:00
|
|
|
|
2016-08-13 06:58:08 -07:00
|
|
|
void TestExpandAndCompress(const std::string &scope, size_t bit_len, size_t byte_pad,
|
2016-08-12 21:45:53 -07:00
|
|
|
std::vector<unsigned char> compact,
|
|
|
|
std::vector<unsigned char> expanded)
|
|
|
|
{
|
|
|
|
SCOPED_TRACE(scope);
|
|
|
|
|
|
|
|
std::vector<unsigned char> out(expanded.size());
|
2016-08-13 06:58:08 -07:00
|
|
|
ExpandArray(compact.data(), compact.size(),
|
|
|
|
out.data(), out.size(), bit_len, byte_pad);
|
2016-08-12 21:45:53 -07:00
|
|
|
EXPECT_EQ(expanded, out);
|
|
|
|
|
|
|
|
out.resize(compact.size());
|
2016-08-13 06:58:08 -07:00
|
|
|
CompressArray(expanded.data(), expanded.size(),
|
|
|
|
out.data(), out.size(), bit_len, byte_pad);
|
2016-08-12 21:45:53 -07:00
|
|
|
EXPECT_EQ(compact, out);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(equihash_tests, expand_and_contract_arrays) {
|
2016-08-13 06:58:08 -07:00
|
|
|
TestExpandAndCompress("8 11-bit chunks, all-ones", 11, 0,
|
2016-08-12 21:45:53 -07:00
|
|
|
ParseHex("ffffffffffffffffffffff"),
|
|
|
|
ParseHex("07ff07ff07ff07ff07ff07ff07ff07ff"));
|
2016-08-13 06:58:08 -07:00
|
|
|
TestExpandAndCompress("8 21-bit chunks, alternating 1s and 0s", 21, 0,
|
2016-08-12 21:45:53 -07:00
|
|
|
ParseHex("aaaaad55556aaaab55555aaaaad55556aaaab55555"),
|
|
|
|
ParseHex("155555155555155555155555155555155555155555155555"));
|
2016-08-13 06:58:08 -07:00
|
|
|
TestExpandAndCompress("16 14-bit chunks, alternating 11s and 00s", 14, 0,
|
2016-08-12 21:45:53 -07:00
|
|
|
ParseHex("cccf333cccf333cccf333cccf333cccf333cccf333cccf333cccf333"),
|
|
|
|
ParseHex("3333333333333333333333333333333333333333333333333333333333333333"));
|
2016-08-13 06:58:08 -07:00
|
|
|
|
|
|
|
TestExpandAndCompress("8 11-bit chunks, all-ones, 2-byte padding", 11, 2,
|
|
|
|
ParseHex("ffffffffffffffffffffff"),
|
|
|
|
ParseHex("000007ff000007ff000007ff000007ff000007ff000007ff000007ff000007ff"));
|
2016-08-12 21:45:53 -07:00
|
|
|
}
|
|
|
|
|
2016-08-05 20:23:47 -07:00
|
|
|
TEST(equihash_tests, is_probably_duplicate) {
|
|
|
|
std::shared_ptr<eh_trunc> p1 (new eh_trunc[4] {0, 1, 2, 3});
|
|
|
|
std::shared_ptr<eh_trunc> p2 (new eh_trunc[4] {0, 1, 1, 3});
|
|
|
|
std::shared_ptr<eh_trunc> p3 (new eh_trunc[4] {3, 1, 1, 3});
|
|
|
|
|
|
|
|
ASSERT_FALSE(IsProbablyDuplicate<4>(p1, 4));
|
|
|
|
ASSERT_FALSE(IsProbablyDuplicate<4>(p2, 4));
|
|
|
|
ASSERT_TRUE(IsProbablyDuplicate<4>(p3, 4));
|
|
|
|
}
|
|
|
|
|
2016-07-20 21:39:32 -07:00
|
|
|
TEST(equihash_tests, check_basic_solver_cancelled) {
|
|
|
|
Equihash<48,5> Eh48_5;
|
|
|
|
crypto_generichash_blake2b_state state;
|
|
|
|
Eh48_5.InitialiseState(state);
|
2016-08-13 06:14:09 -07:00
|
|
|
uint256 V = uint256S("0x00");
|
|
|
|
crypto_generichash_blake2b_update(&state, V.begin(), V.size());
|
2016-07-20 21:39:32 -07:00
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return false;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListGeneration;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListColliding;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == RoundEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == FinalSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == FinalColliding;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialGeneration;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSorting;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSubtreeEnd;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialIndexEnd;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialEnd;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(equihash_tests, check_optimised_solver_cancelled) {
|
|
|
|
Equihash<48,5> Eh48_5;
|
|
|
|
crypto_generichash_blake2b_state state;
|
|
|
|
Eh48_5.InitialiseState(state);
|
2016-08-13 06:14:09 -07:00
|
|
|
uint256 V = uint256S("0x00");
|
|
|
|
crypto_generichash_blake2b_update(&state, V.begin(), V.size());
|
2016-07-20 21:39:32 -07:00
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return false;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListGeneration;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListColliding;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == RoundEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == FinalSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-22 04:54:14 -07:00
|
|
|
return pos == FinalColliding;
|
2016-07-20 21:39:32 -07:00
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialGeneration;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSubtreeEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialIndexEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-08-13 20:04:13 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<unsigned char> soln) {
|
2016-07-27 00:15:49 -07:00
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
}
|