diff --git a/src/snark/src/algebra/curves/tests/test_bilinearity.cpp b/src/snark/src/algebra/curves/tests/test_bilinearity.cpp index 295745281..529bec337 100644 --- a/src/snark/src/algebra/curves/tests/test_bilinearity.cpp +++ b/src/snark/src/algebra/curves/tests/test_bilinearity.cpp @@ -13,6 +13,8 @@ #include "algebra/curves/mnt/mnt4/mnt4_pp.hpp" #include "algebra/curves/mnt/mnt6/mnt6_pp.hpp" +#include + using namespace libsnark; template @@ -46,11 +48,11 @@ void pairing_test() ans1.print(); ans2.print(); ans3.print(); - assert(ans1 == ans2); - assert(ans2 == ans3); + EXPECT_EQ(ans1, ans2); + EXPECT_EQ(ans2, ans3); - assert(ans1 != GT_one); - assert((ans1^Fr::field_char()) == GT_one); + EXPECT_NE(ans1, GT_one); + EXPECT_EQ((ans1^Fr::field_char()), GT_one); printf("\n\n"); } @@ -70,7 +72,7 @@ void double_miller_loop_test() const Fqk ans_1 = ppT::miller_loop(prec_P1, prec_Q1); const Fqk ans_2 = ppT::miller_loop(prec_P2, prec_Q2); const Fqk ans_12 = ppT::double_miller_loop(prec_P1, prec_Q1, prec_P2, prec_Q2); - assert(ans_1 * ans_2 == ans_12); + EXPECT_EQ(ans_1 * ans_2, ans_12); } template @@ -99,15 +101,15 @@ void affine_pairing_test() ans1.print(); ans2.print(); ans3.print(); - assert(ans1 == ans2); - assert(ans2 == ans3); + EXPECT_EQ(ans1, ans2); + EXPECT_EQ(ans2, ans3); - assert(ans1 != GT_one); - assert((ans1^Fr::field_char()) == GT_one); + EXPECT_NE(ans1, GT_one); + EXPECT_EQ((ans1^Fr::field_char()), GT_one); printf("\n\n"); } -int main(void) +TEST(algebra, bilinearity) { start_profiling(); edwards_pp::init_public_params(); diff --git a/src/snark/src/algebra/curves/tests/test_groups.cpp b/src/snark/src/algebra/curves/tests/test_groups.cpp index 725e490d7..087ee3d52 100644 --- a/src/snark/src/algebra/curves/tests/test_groups.cpp +++ b/src/snark/src/algebra/curves/tests/test_groups.cpp @@ -14,6 +14,8 @@ #include "algebra/curves/alt_bn128/alt_bn128_pp.hpp" #include +#include + using namespace libsnark; template @@ -25,31 +27,31 @@ void test_mixed_add() el = GroupT::zero(); el.to_special(); result = base.mixed_add(el); - assert(result == base + el); + EXPECT_EQ(result, base + el); base = GroupT::zero(); el = GroupT::random_element(); el.to_special(); result = base.mixed_add(el); - assert(result == base + el); + EXPECT_EQ(result, base + el); base = GroupT::random_element(); el = GroupT::zero(); el.to_special(); result = base.mixed_add(el); - assert(result == base + el); + EXPECT_EQ(result, base + el); base = GroupT::random_element(); el = GroupT::random_element(); el.to_special(); result = base.mixed_add(el); - assert(result == base + el); + EXPECT_EQ(result, base + el); base = GroupT::random_element(); el = base; el.to_special(); result = base.mixed_add(el); - assert(result == base.dbl()); + EXPECT_EQ(result, base.dbl()); } template @@ -60,53 +62,53 @@ void test_group() bigint<1> randsum = bigint<1>("121160274"); GroupT zero = GroupT::zero(); - assert(zero == zero); + EXPECT_EQ(zero, zero); GroupT one = GroupT::one(); - assert(one == one); + EXPECT_EQ(one, one); GroupT two = bigint<1>(2l) * GroupT::one(); - assert(two == two); + EXPECT_EQ(two, two); GroupT five = bigint<1>(5l) * GroupT::one(); GroupT three = bigint<1>(3l) * GroupT::one(); GroupT four = bigint<1>(4l) * GroupT::one(); - assert(two+five == three+four); + EXPECT_EQ(two+five, three+four); GroupT a = GroupT::random_element(); GroupT b = GroupT::random_element(); - assert(one != zero); - assert(a != zero); - assert(a != one); + EXPECT_NE(one, zero); + EXPECT_NE(a, zero); + EXPECT_NE(a, one); - assert(b != zero); - assert(b != one); + EXPECT_NE(b, zero); + EXPECT_NE(b, one); - assert(a.dbl() == a + a); - assert(b.dbl() == b + b); - assert(one.add(two) == three); - assert(two.add(one) == three); - assert(a + b == b + a); - assert(a - a == zero); - assert(a - b == a + (-b)); - assert(a - b == (-b) + a); + EXPECT_EQ(a.dbl(), a + a); + EXPECT_EQ(b.dbl(), b + b); + EXPECT_EQ(one.add(two), three); + EXPECT_EQ(two.add(one), three); + EXPECT_EQ(a + b, b + a); + EXPECT_EQ(a - a, zero); + EXPECT_EQ(a - b, a + (-b)); + EXPECT_EQ(a - b, (-b) + a); // handle special cases - assert(zero + (-a) == -a); - assert(zero - a == -a); - assert(a - zero == a); - assert(a + zero == a); - assert(zero + a == a); + EXPECT_EQ(zero + (-a), -a); + EXPECT_EQ(zero - a, -a); + EXPECT_EQ(a - zero, a); + EXPECT_EQ(a + zero, a); + EXPECT_EQ(zero + a, a); - assert((a + b).dbl() == (a + b) + (b + a)); - assert(bigint<1>("2") * (a + b) == (a + b) + (b + a)); + EXPECT_EQ((a + b).dbl(), (a + b) + (b + a)); + EXPECT_EQ(bigint<1>("2") * (a + b), (a + b) + (b + a)); - assert((rand1 * a) + (rand2 * a) == (randsum * a)); + EXPECT_EQ((rand1 * a) + (rand2 * a), (randsum * a)); - assert(GroupT::order() * a == zero); - assert(GroupT::order() * one == zero); - assert((GroupT::order() * a) - a != zero); - assert((GroupT::order() * one) - one != zero); + EXPECT_EQ(GroupT::order() * a, zero); + EXPECT_EQ(GroupT::order() * one, zero); + EXPECT_NE((GroupT::order() * a) - a, zero); + EXPECT_NE((GroupT::order() * one) - one, zero); test_mixed_add(); } @@ -115,7 +117,7 @@ template void test_mul_by_q() { GroupT a = GroupT::random_element(); - assert((GroupT::base_field_char()*a) == a.mul_by_q()); + EXPECT_EQ((GroupT::base_field_char()*a), a.mul_by_q()); } template @@ -129,13 +131,13 @@ void test_output() ss << g; GroupT gg; ss >> gg; - assert(g == gg); + EXPECT_EQ(g, gg); /* use a random point in next iteration */ g = GroupT::random_element(); } } -int main(void) +TEST(algebra, groups) { edwards_pp::init_public_params(); test_group >(); diff --git a/src/snark/src/algebra/fields/tests/test_bigint.cpp b/src/snark/src/algebra/fields/tests/test_bigint.cpp index b66aae0a3..d2da59e73 100644 --- a/src/snark/src/algebra/fields/tests/test_bigint.cpp +++ b/src/snark/src/algebra/fields/tests/test_bigint.cpp @@ -7,9 +7,11 @@ #include "algebra/fields/bigint.hpp" +#include + using namespace libsnark; -void test_bigint() +TEST(algebra, bigint) { static_assert(ULONG_MAX == 0xFFFFFFFFFFFFFFFFul, "unsigned long not 64-bit"); static_assert(GMP_NUMB_BITS == 64, "GMP limb not 64-bit"); @@ -24,84 +26,72 @@ void test_bigint() bigint<1> b1 = bigint<1>(b1_decimal); bigint<2> b2 = bigint<2>(b2_decimal); - assert(b0.as_ulong() == 0ul); - assert(b0.is_zero()); - assert(b1.as_ulong() == 76749407ul); - assert(!(b1.is_zero())); - assert(b2.as_ulong() == 15747124762497195938ul); - assert(!(b2.is_zero())); - assert(b0 != b1); - assert(!(b0 == b1)); + EXPECT_EQ(b0.as_ulong(), 0ul); + EXPECT_TRUE(b0.is_zero()); + EXPECT_EQ(b1.as_ulong(), 76749407ul); + EXPECT_FALSE(b1.is_zero()); + EXPECT_EQ(b2.as_ulong(), 15747124762497195938ul); + EXPECT_FALSE(b2.is_zero()); + EXPECT_NE(b0, b1); + EXPECT_FALSE(b0 == b1); - assert(b2.max_bits() == 128); - assert(b2.num_bits() == 99); + EXPECT_EQ(b2.max_bits(), 128); + EXPECT_EQ(b2.num_bits(), 99); for (size_t i = 0; i < 128; i++) { - assert(b2.test_bit(i) == (b2_binary[127-i] == '1')); + EXPECT_EQ(b2.test_bit(i), (b2_binary[127-i] == '1')); } bigint<3> b3 = b2 * b1; - assert(b3 == bigint<3>(b3_decimal)); - assert(!(b3.is_zero())); + EXPECT_EQ(b3, bigint<3>(b3_decimal)); + EXPECT_FALSE(b3.is_zero()); bigint<3> b3a { b3 }; - assert(b3a == bigint<3>(b3_decimal)); - assert(b3a == b3); - assert(!(b3a.is_zero())); + EXPECT_EQ(b3a, bigint<3>(b3_decimal)); + EXPECT_EQ(b3a, b3); + EXPECT_FALSE(b3a.is_zero()); mpz_t m3; mpz_init(m3); b3.to_mpz(m3); bigint<3> b3b { m3 }; - assert(b3b == b3); + EXPECT_EQ(b3b, b3); bigint<2> quotient; bigint<2> remainder; bigint<3>::div_qr(quotient, remainder, b3, b2); - assert(quotient.num_bits() < GMP_NUMB_BITS); - assert(quotient.as_ulong() == b1.as_ulong()); + EXPECT_LT(quotient.num_bits(), GMP_NUMB_BITS); + EXPECT_EQ(quotient.as_ulong(), b1.as_ulong()); bigint<1> b1inc = bigint<1>("76749408"); bigint<1> b1a = quotient.shorten(b1inc, "test"); - assert(b1a == b1); - assert(remainder.is_zero()); + EXPECT_EQ(b1a, b1); + EXPECT_TRUE(remainder.is_zero()); remainder.limit(b2, "test"); - try { - (void)(quotient.shorten(b1, "test")); - assert(false); - } catch (std::domain_error) {} - try { - remainder.limit(remainder, "test"); - assert(false); - } catch (std::domain_error) {} + EXPECT_THROW((void)(quotient.shorten(b1, "test")), std::domain_error); + EXPECT_THROW(remainder.limit(remainder, "test"), std::domain_error); bigint<1> br = bigint<1>("42"); b3 += br; - assert(b3 != b3a); - assert(b3 > b3a); - assert(!(b3a > b3)); + EXPECT_NE(b3, b3a); + EXPECT_GT(b3, b3a); + EXPECT_FALSE(b3a > b3); bigint<3>::div_qr(quotient, remainder, b3, b2); - assert(quotient.num_bits() < GMP_NUMB_BITS); - assert(quotient.as_ulong() == b1.as_ulong()); - assert(remainder.num_bits() < GMP_NUMB_BITS); - assert(remainder.as_ulong() == 42); + EXPECT_LT(quotient.num_bits(), GMP_NUMB_BITS); + EXPECT_EQ(quotient.as_ulong(), b1.as_ulong()); + EXPECT_LT(remainder.num_bits(), GMP_NUMB_BITS); + EXPECT_EQ(remainder.as_ulong(), 42); b3a.clear(); - assert(b3a.is_zero()); - assert(b3a.num_bits() == 0); - assert(!(b3.is_zero())); + EXPECT_TRUE(b3a.is_zero()); + EXPECT_EQ(b3a.num_bits(), 0); + EXPECT_FALSE(b3.is_zero()); bigint<4> bx = bigint<4>().randomize(); bigint<4> by = bigint<4>().randomize(); - assert(!(bx == by)); + EXPECT_FALSE(bx == by); // TODO: test serialization } -int main(void) -{ - test_bigint(); - return 0; -} - diff --git a/src/snark/src/algebra/fields/tests/test_fields.cpp b/src/snark/src/algebra/fields/tests/test_fields.cpp index a05f601e6..f4fc3319a 100644 --- a/src/snark/src/algebra/fields/tests/test_fields.cpp +++ b/src/snark/src/algebra/fields/tests/test_fields.cpp @@ -15,6 +15,8 @@ #include "algebra/fields/fp6_3over2.hpp" #include "algebra/fields/fp12_2over3over2.hpp" +#include + using namespace libsnark; template @@ -29,25 +31,25 @@ void test_field() FieldT a = FieldT::random_element(); FieldT a_ser; a_ser = reserialize(a); - assert(a_ser == a); + EXPECT_EQ(a_ser, a); FieldT b = FieldT::random_element(); FieldT c = FieldT::random_element(); FieldT d = FieldT::random_element(); - assert(a != zero); - assert(a != one); + EXPECT_NE(a, zero); + EXPECT_NE(a, one); - assert(a * a == a.squared()); - assert((a + b).squared() == a.squared() + a*b + b*a + b.squared()); - assert((a + b)*(c + d) == a*c + a*d + b*c + b*d); - assert(a - b == a + (-b)); - assert(a - b == (-b) + a); + EXPECT_EQ(a * a, a.squared()); + EXPECT_EQ((a + b).squared(), a.squared() + a*b + b*a + b.squared()); + EXPECT_EQ((a + b)*(c + d), a*c + a*d + b*c + b*d); + EXPECT_EQ(a - b, a + (-b)); + EXPECT_EQ(a - b, (-b) + a); - assert((a ^ rand1) * (a ^ rand2) == (a^randsum)); + EXPECT_EQ((a ^ rand1) * (a ^ rand2), (a^randsum)); - assert(a * a.inverse() == one); - assert((a + b) * c.inverse() == a * c.inverse() + (b.inverse() * c).inverse()); + EXPECT_EQ(a * a.inverse(), one); + EXPECT_EQ((a + b) * c.inverse(), a * c.inverse() + (b.inverse() * c).inverse()); } @@ -58,7 +60,7 @@ void test_sqrt() { FieldT a = FieldT::random_element(); FieldT asq = a.squared(); - assert(asq.sqrt() == a || asq.sqrt() == -a); + EXPECT_TRUE(asq.sqrt() == a || asq.sqrt() == -a); } } @@ -66,21 +68,21 @@ template void test_two_squarings() { FieldT a = FieldT::random_element(); - assert(a.squared() == a * a); - assert(a.squared() == a.squared_complex()); - assert(a.squared() == a.squared_karatsuba()); + EXPECT_EQ(a.squared(), a * a); + EXPECT_EQ(a.squared(), a.squared_complex()); + EXPECT_EQ(a.squared(), a.squared_karatsuba()); } template void test_Frobenius() { FieldT a = FieldT::random_element(); - assert(a.Frobenius_map(0) == a); + EXPECT_EQ(a.Frobenius_map(0), a); FieldT a_q = a ^ FieldT::base_field_char(); for (size_t power = 1; power < 10; ++power) { const FieldT a_qi = a.Frobenius_map(power); - assert(a_qi == a_q); + EXPECT_EQ(a_qi, a_q); a_q = a_q ^ FieldT::base_field_char(); } @@ -89,10 +91,10 @@ void test_Frobenius() template void test_unitary_inverse() { - assert(FieldT::extension_degree() % 2 == 0); + EXPECT_EQ(FieldT::extension_degree() % 2, 0); FieldT a = FieldT::random_element(); FieldT aqcubed_minus1 = a.Frobenius_map(FieldT::extension_degree()/2) * a.inverse(); - assert(aqcubed_minus1.inverse() == aqcubed_minus1.unitary_inverse()); + EXPECT_EQ(aqcubed_minus1.inverse(), aqcubed_minus1.unitary_inverse()); } template @@ -102,36 +104,36 @@ template<> void test_cyclotomic_squaring >() { typedef Fqk FieldT; - assert(FieldT::extension_degree() % 2 == 0); + EXPECT_EQ(FieldT::extension_degree() % 2, 0); FieldT a = FieldT::random_element(); FieldT a_unitary = a.Frobenius_map(FieldT::extension_degree()/2) * a.inverse(); // beta = a^((q^(k/2)-1)*(q+1)) FieldT beta = a_unitary.Frobenius_map(1) * a_unitary; - assert(beta.cyclotomic_squared() == beta.squared()); + EXPECT_EQ(beta.cyclotomic_squared(), beta.squared()); } template<> void test_cyclotomic_squaring >() { typedef Fqk FieldT; - assert(FieldT::extension_degree() % 2 == 0); + EXPECT_EQ(FieldT::extension_degree() % 2, 0); FieldT a = FieldT::random_element(); FieldT a_unitary = a.Frobenius_map(FieldT::extension_degree()/2) * a.inverse(); // beta = a^(q^(k/2)-1) FieldT beta = a_unitary; - assert(beta.cyclotomic_squared() == beta.squared()); + EXPECT_EQ(beta.cyclotomic_squared(), beta.squared()); } template<> void test_cyclotomic_squaring >() { typedef Fqk FieldT; - assert(FieldT::extension_degree() % 2 == 0); + EXPECT_EQ(FieldT::extension_degree() % 2, 0); FieldT a = FieldT::random_element(); FieldT a_unitary = a.Frobenius_map(FieldT::extension_degree()/2) * a.inverse(); // beta = a^((q^(k/2)-1)*(q+1)) FieldT beta = a_unitary.Frobenius_map(1) * a_unitary; - assert(beta.cyclotomic_squared() == beta.squared()); + EXPECT_EQ(beta.cyclotomic_squared(), beta.squared()); } template @@ -197,16 +199,16 @@ void test_Fp4_tom_cook() c2 = - (FieldT(5)*(FieldT(4).inverse()))* v0 + (FieldT(2)*(FieldT(3).inverse()))*(v1 + v2) - FieldT(24).inverse()*(v3 + v4) + FieldT(4)*v6 + beta*v6; c3 = FieldT(12).inverse() * (FieldT(5)*v0 - FieldT(7)*v1) - FieldT(24).inverse()*(v2 - FieldT(7)*v3 + v4 + v5) + FieldT(15)*v6; - assert(res == correct_res); + EXPECT_EQ(res, correct_res); // {v0, v3, v4, v5} const FieldT u = (FieldT::one() - beta).inverse(); - assert(v0 == u * c0 + beta * u * c2 - beta * u * FieldT(2).inverse() * v1 - beta * u * FieldT(2).inverse() * v2 + beta * v6); - assert(v3 == - FieldT(15) * u * c0 - FieldT(30) * u * c1 - FieldT(3) * (FieldT(4) + beta) * u * c2 - FieldT(6) * (FieldT(4) + beta) * u * c3 + (FieldT(24) - FieldT(3) * beta * FieldT(2).inverse()) * u * v1 + (-FieldT(8) + beta * FieldT(2).inverse()) * u * v2 + EXPECT_EQ(v0, u * c0 + beta * u * c2 - beta * u * FieldT(2).inverse() * v1 - beta * u * FieldT(2).inverse() * v2 + beta * v6); + EXPECT_EQ(v3, - FieldT(15) * u * c0 - FieldT(30) * u * c1 - FieldT(3) * (FieldT(4) + beta) * u * c2 - FieldT(6) * (FieldT(4) + beta) * u * c3 + (FieldT(24) - FieldT(3) * beta * FieldT(2).inverse()) * u * v1 + (-FieldT(8) + beta * FieldT(2).inverse()) * u * v2 - FieldT(3) * (-FieldT(16) + beta) * v6); - assert(v4 == - FieldT(15) * u * c0 + FieldT(30) * u * c1 - FieldT(3) * (FieldT(4) + beta) * u * c2 + FieldT(6) * (FieldT(4) + beta) * u * c3 + (FieldT(24) - FieldT(3) * beta * FieldT(2).inverse()) * u * v2 + (-FieldT(8) + beta * FieldT(2).inverse()) * u * v1 + EXPECT_EQ(v4, - FieldT(15) * u * c0 + FieldT(30) * u * c1 - FieldT(3) * (FieldT(4) + beta) * u * c2 + FieldT(6) * (FieldT(4) + beta) * u * c3 + (FieldT(24) - FieldT(3) * beta * FieldT(2).inverse()) * u * v2 + (-FieldT(8) + beta * FieldT(2).inverse()) * u * v1 - FieldT(3) * (-FieldT(16) + beta) * v6); - assert(v5 == - FieldT(80) * u * c0 - FieldT(240) * u * c1 - FieldT(8) * (FieldT(9) + beta) * u * c2 - FieldT(24) * (FieldT(9) + beta) * u * c3 - FieldT(2) * (-FieldT(81) + beta) * u * v1 + (-FieldT(81) + beta) * u * v2 + EXPECT_EQ(v5, - FieldT(80) * u * c0 - FieldT(240) * u * c1 - FieldT(8) * (FieldT(9) + beta) * u * c2 - FieldT(24) * (FieldT(9) + beta) * u * c3 - FieldT(2) * (-FieldT(81) + beta) * u * v1 + (-FieldT(81) + beta) * u * v2 - FieldT(8) * (-FieldT(81) + beta) * v6); // c0 + beta c2 - (beta v1)/2 - (beta v2)/ 2 - (-1 + beta) beta v6, @@ -216,7 +218,7 @@ void test_Fp4_tom_cook() } } -int main(void) +TEST(algebra, fields) { edwards_pp::init_public_params(); test_all_fields(); diff --git a/src/snark/src/gadgetlib1/gadgets/hashes/sha256/tests/test_sha256_gadget.cpp b/src/snark/src/gadgetlib1/gadgets/hashes/sha256/tests/test_sha256_gadget.cpp index 471928f6a..0bfaf3a12 100644 --- a/src/snark/src/gadgetlib1/gadgets/hashes/sha256/tests/test_sha256_gadget.cpp +++ b/src/snark/src/gadgetlib1/gadgets/hashes/sha256/tests/test_sha256_gadget.cpp @@ -10,6 +10,8 @@ #include "common/profiling.hpp" #include "gadgetlib1/gadgets/hashes/sha256/sha256_gadget.hpp" +#include + using namespace libsnark; template @@ -35,10 +37,10 @@ void test_two_to_one() f.generate_r1cs_witness(); output.generate_r1cs_witness(hash_bv); - assert(pb.is_satisfied()); + EXPECT_TRUE(pb.is_satisfied()); } -int main(void) +TEST(gadgetlib1, sha256) { start_profiling(); default_ec_pp::init_public_params(); diff --git a/src/snark/src/gadgetlib1/gadgets/merkle_tree/tests/test_merkle_tree_gadgets.cpp b/src/snark/src/gadgetlib1/gadgets/merkle_tree/tests/test_merkle_tree_gadgets.cpp index 8d52c579b..955a05440 100644 --- a/src/snark/src/gadgetlib1/gadgets/merkle_tree/tests/test_merkle_tree_gadgets.cpp +++ b/src/snark/src/gadgetlib1/gadgets/merkle_tree/tests/test_merkle_tree_gadgets.cpp @@ -15,6 +15,8 @@ #include "gadgetlib1/gadgets/merkle_tree/merkle_tree_check_update_gadget.hpp" #include "gadgetlib1/gadgets/hashes/sha256/sha256_gadget.hpp" +#include + using namespace libsnark; template @@ -28,7 +30,7 @@ void test_all_merkle_tree_gadgets() test_merkle_tree_check_update_gadget >(); } -int main(void) +TEST(gadgetlib1, merkle_tree) { start_profiling(); diff --git a/src/snark/src/relations/arithmetic_programs/qap/tests/test_qap.cpp b/src/snark/src/relations/arithmetic_programs/qap/tests/test_qap.cpp index d8aaddaa7..d77662926 100644 --- a/src/snark/src/relations/arithmetic_programs/qap/tests/test_qap.cpp +++ b/src/snark/src/relations/arithmetic_programs/qap/tests/test_qap.cpp @@ -17,6 +17,8 @@ #include "reductions/r1cs_to_qap/r1cs_to_qap.hpp" #include "relations/constraint_satisfaction_problems/r1cs/examples/r1cs_examples.hpp" +#include + using namespace libsnark; template @@ -28,7 +30,7 @@ void test_qap(const size_t qap_degree, const size_t num_inputs, const bool binar See the transformation from R1CS to QAP for why this is the case. So we need that qap_degree >= num_inputs + 1. */ - assert(num_inputs + 1 <= qap_degree); + ASSERT_LE(num_inputs + 1, qap_degree); enter_block("Call to test_qap"); const size_t num_constraints = qap_degree - num_inputs - 1; @@ -51,7 +53,7 @@ void test_qap(const size_t qap_degree, const size_t num_inputs, const bool binar leave_block("Generate constraint system and assignment"); enter_block("Check satisfiability of constraint system"); - assert(example.constraint_system.is_satisfied(example.primary_input, example.auxiliary_input)); + EXPECT_TRUE(example.constraint_system.is_satisfied(example.primary_input, example.auxiliary_input)); leave_block("Check satisfiability of constraint system"); const FieldT t = FieldT::random_element(), @@ -72,17 +74,17 @@ void test_qap(const size_t qap_degree, const size_t num_inputs, const bool binar leave_block("Compute QAP witness"); enter_block("Check satisfiability of QAP instance 1"); - assert(qap_inst_1.is_satisfied(qap_wit)); + EXPECT_TRUE(qap_inst_1.is_satisfied(qap_wit)); leave_block("Check satisfiability of QAP instance 1"); enter_block("Check satisfiability of QAP instance 2"); - assert(qap_inst_2.is_satisfied(qap_wit)); + EXPECT_TRUE(qap_inst_2.is_satisfied(qap_wit)); leave_block("Check satisfiability of QAP instance 2"); leave_block("Call to test_qap"); } -int main() +TEST(relations, qap) { start_profiling(); diff --git a/src/snark/src/zk_proof_systems/ppzksnark/r1cs_ppzksnark/tests/test_r1cs_ppzksnark.cpp b/src/snark/src/zk_proof_systems/ppzksnark/r1cs_ppzksnark/tests/test_r1cs_ppzksnark.cpp index 6f8b575f2..36b573549 100644 --- a/src/snark/src/zk_proof_systems/ppzksnark/r1cs_ppzksnark/tests/test_r1cs_ppzksnark.cpp +++ b/src/snark/src/zk_proof_systems/ppzksnark/r1cs_ppzksnark/tests/test_r1cs_ppzksnark.cpp @@ -17,6 +17,8 @@ #include "relations/constraint_satisfaction_problems/r1cs/examples/r1cs_examples.hpp" #include "zk_proof_systems/ppzksnark/r1cs_ppzksnark/examples/run_r1cs_ppzksnark.hpp" +#include + using namespace libsnark; template @@ -28,12 +30,12 @@ void test_r1cs_ppzksnark(size_t num_constraints, const bool test_serialization = true; r1cs_example > example = generate_r1cs_example_with_binary_input >(num_constraints, input_size); const bool bit = run_r1cs_ppzksnark(example, test_serialization); - assert(bit); + EXPECT_TRUE(bit); print_header("(leave) Test R1CS ppzkSNARK"); } -int main() +TEST(zk_proof_systems, r1cs_ppzksnark) { default_r1cs_ppzksnark_pp::init_public_params(); start_profiling();