Function TestEquihashSolvers

src/test/equihash_tests.cpp:48–85

}

void TestEquihashSolvers(unsigned int n, unsigned int k, const std::string &I, const arith_uint256 &nonce, const std::set<std::vector<uint32_t>> &solns) {
    size_t cBitLen { n/(k+1) };
    blake2b_state state;
    EhInitialiseState(n, k, state, false);
    uint256 V = ArithToUint256(nonce);
    BOOST_TEST_MESSAGE("Running solver: n = " << n << ", k = " << k << ", I = " << I << ", V = " << V.GetHex());
    blake2b_update(&state, (unsigned char*)&I[0], I.size());
    blake2b_update(&state, V.begin(), V.size());

    // First test the basic solver
    std::set<std::vector<uint32_t>> ret;
    std::function<bool(std::vector<unsigned char>)> validBlock =
            [&ret, cBitLen](std::vector<unsigned char> soln) {
        ret.insert(GetIndicesFromMinimal(soln, cBitLen));
        return false;
    };
    EhBasicSolveUncancellable(n, k, state, validBlock);
    BOOST_TEST_MESSAGE("[Basic] Number of solutions: " << ret.size());
    std::stringstream strm;
    PrintSolutions(strm, ret);
    BOOST_TEST_MESSAGE(strm.str());
    BOOST_CHECK(ret == solns);

    // The optimised solver should have the exact same result
    std::set<std::vector<uint32_t>> retOpt;
    std::function<bool(std::vector<unsigned char>)> validBlockOpt =
            [&retOpt, cBitLen](std::vector<unsigned char> soln) {
        retOpt.insert(GetIndicesFromMinimal(soln, cBitLen));
        return false;
    };
    EhOptimisedSolveUncancellable(n, k, state, validBlockOpt);
    BOOST_TEST_MESSAGE("[Optimised] Number of solutions: " << retOpt.size());
    strm.str("");
    PrintSolutions(strm, retOpt);
    BOOST_TEST_MESSAGE(strm.str());
    BOOST_CHECK(retOpt == solns);
    BOOST_CHECK(retOpt == ret);
}

void TestEquihashValidator(unsigned int n, unsigned int k, const std::string &I, const arith_uint256 &nonce, std::vector<uint32_t> soln, bool expected) {
    size_t cBitLen { n/(k+1) };