2016-07-20 21:39:32 -07:00
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <gmock/gmock.h>
|
|
|
|
|
|
|
|
#include "crypto/equihash.h"
|
|
|
|
|
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-07-27 00:15:49 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return false;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListGeneration;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListColliding;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == RoundEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == FinalSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == FinalColliding;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialGeneration;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSorting;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSubtreeEnd;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialIndexEnd;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.BasicSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
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-07-27 00:15:49 -07:00
|
|
|
ASSERT_NO_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return false;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListGeneration;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == ListColliding;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == RoundEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == FinalSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
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-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialGeneration;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSorting;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialSubtreeEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialIndexEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2016-07-27 00:15:49 -07:00
|
|
|
ASSERT_THROW(Eh48_5.OptimisedSolve(state, [](std::vector<eh_index> soln) {
|
|
|
|
return false;
|
|
|
|
}, [](EhSolverCancelCheck pos) {
|
2016-07-20 21:39:32 -07:00
|
|
|
return pos == PartialEnd;
|
|
|
|
}), EhSolverCancelledException);
|
|
|
|
}
|
|
|
|
}
|