diff --git a/crypto3/libs/algebra/test/type_traits.cpp b/crypto3/libs/algebra/test/type_traits.cpp index 9d61fcb342..9295352e90 100644 --- a/crypto3/libs/algebra/test/type_traits.cpp +++ b/crypto3/libs/algebra/test/type_traits.cpp @@ -65,27 +65,27 @@ BOOST_AUTO_TEST_SUITE(type_traits_manual_tests) template void test_field_value_types() { - BOOST_ASSERT( has_type_field_type::value ); - BOOST_ASSERT( (has_function_is_zero::value) ); - BOOST_ASSERT( (has_function_inversed::value) ); - BOOST_ASSERT( (has_static_member_function_zero::value) ); - BOOST_ASSERT( (has_static_member_function_one::value) ); + BOOST_CHECK( has_type_field_type::value ); + BOOST_CHECK( (has_function_is_zero::value) ); + BOOST_CHECK( (has_function_inversed::value) ); + BOOST_CHECK( (has_static_member_function_zero::value) ); + BOOST_CHECK( (has_static_member_function_one::value) ); - BOOST_ASSERT( is_field_element::value ); + BOOST_CHECK( is_field_element::value ); } template void test_field_types() { - BOOST_ASSERT( has_type_value_type::value ); - BOOST_ASSERT( has_type_integral_type::value ); - BOOST_ASSERT( has_type_modular_type::value ); + BOOST_CHECK( has_type_value_type::value ); + BOOST_CHECK( has_type_integral_type::value ); + BOOST_CHECK( has_type_modular_type::value ); - BOOST_ASSERT( (has_static_member_data_value_bits::value) ); - BOOST_ASSERT( (has_static_member_data_modulus_bits::value) ); - BOOST_ASSERT( (has_static_member_data_arity::value) ); + BOOST_CHECK( (has_static_member_data_value_bits::value) ); + BOOST_CHECK( (has_static_member_data_modulus_bits::value) ); + BOOST_CHECK( (has_static_member_data_arity::value) ); - BOOST_ASSERT( is_field::value ); + BOOST_CHECK( is_field::value ); test_field_value_types(); @@ -96,10 +96,10 @@ void test_extended_field_types() { test_field_types(); - BOOST_ASSERT( has_type_extension_policy::value ); - BOOST_ASSERT( is_extended_field::value ); + BOOST_CHECK( has_type_extension_policy::value ); + BOOST_CHECK( is_extended_field::value ); - BOOST_ASSERT( is_extended_field_element::value ); + BOOST_CHECK( is_extended_field_element::value ); test_field_value_types(); } @@ -108,38 +108,38 @@ void test_extended_field_types() template void test_curve_group_types() { - BOOST_ASSERT( is_curve_group::value ); - BOOST_ASSERT( has_type_curve_type::value ); + BOOST_CHECK( is_curve_group::value ); + BOOST_CHECK( has_type_curve_type::value ); - BOOST_ASSERT( has_type_value_type::value ); + BOOST_CHECK( has_type_value_type::value ); using value_type = typename curve_group_type::value_type; - BOOST_ASSERT( has_type_field_type::value ); - BOOST_ASSERT( has_type_group_type::value ); + BOOST_CHECK( has_type_field_type::value ); + BOOST_CHECK( has_type_group_type::value ); - BOOST_ASSERT( (has_static_member_function_zero::value) ); - BOOST_ASSERT( (has_static_member_function_one::value) ); - BOOST_ASSERT( (has_function_is_zero::value) ); - BOOST_ASSERT( (has_function_is_well_formed::value) ); - BOOST_ASSERT( (has_function_double_inplace::value) ); + BOOST_CHECK( (has_static_member_function_zero::value) ); + BOOST_CHECK( (has_static_member_function_one::value) ); + BOOST_CHECK( (has_function_is_zero::value) ); + BOOST_CHECK( (has_function_is_well_formed::value) ); + BOOST_CHECK( (has_function_double_inplace::value) ); - BOOST_ASSERT( is_curve_element::value ); + BOOST_CHECK( is_curve_element::value ); } template void test_ordinary_curve_types() { - BOOST_ASSERT( has_type_base_field_type::value ); + BOOST_CHECK( has_type_base_field_type::value ); test_field_types(); - BOOST_ASSERT( has_type_scalar_field_type::value ); + BOOST_CHECK( has_type_scalar_field_type::value ); test_field_types(); - BOOST_ASSERT( has_type_g1_type::value ); + BOOST_CHECK( has_type_g1_type::value ); test_curve_group_types>(); - BOOST_ASSERT(is_curve::value); + BOOST_CHECK(is_curve::value); } template @@ -147,13 +147,13 @@ void test_pairing_friendly_curve_types() { test_ordinary_curve_types(); - BOOST_ASSERT( has_type_g2_type::value ); + BOOST_CHECK( has_type_g2_type::value ); test_curve_group_types>(); using g2_base_field = typename curve_type::template g2_type<>::params_type::field_type; test_extended_field_types(); - BOOST_ASSERT( has_type_gt_type::value ); + BOOST_CHECK( has_type_gt_type::value ); test_extended_field_types(); } @@ -221,118 +221,118 @@ BOOST_AUTO_TEST_CASE(ed25519_type_traits) { BOOST_AUTO_TEST_CASE(test_extended_fields_sqrt_trait) { - BOOST_ASSERT( FIELD_HAS_SQRT(curves::alt_bn128_254::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::alt_bn128_254::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::alt_bn128_254::template g1_type<>::field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::alt_bn128_254::template g2_type<>::field_type) ); - BOOST_ASSERT( !FIELD_HAS_SQRT(curves::alt_bn128_254::gt_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_381::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_381::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_381::template g1_type<>::field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_381::template g2_type<>::field_type) ); - BOOST_ASSERT( !FIELD_HAS_SQRT(curves::bls12_381::gt_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_377::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_377::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_377::template g1_type<>::field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::bls12_377::template g2_type<>::field_type) ); - BOOST_ASSERT( !FIELD_HAS_SQRT(curves::bls12_377::gt_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt4_298::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt4_298::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt4_298::template g1_type<>::field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt4_298::template g2_type<>::field_type) ); - BOOST_ASSERT( !FIELD_HAS_SQRT(curves::mnt4_298::gt_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt6_298::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt6_298::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt6_298::template g1_type<>::field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::mnt6_298::template g2_type<>::field_type) ); - BOOST_ASSERT( !FIELD_HAS_SQRT(curves::mnt6_298::gt_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::pallas::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::pallas::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::pallas::template g1_type<>::field_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::vesta::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::vesta::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::vesta::template g1_type<>::field_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::jubjub::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::jubjub::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::jubjub::template g1_type<>::field_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::babyjubjub::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::babyjubjub::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::babyjubjub::template g1_type<>::field_type) ); - - BOOST_ASSERT( FIELD_HAS_SQRT(curves::ed25519::base_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::ed25519::scalar_field_type) ); - BOOST_ASSERT( FIELD_HAS_SQRT(curves::ed25519::template g1_type<>::field_type) ); - - BOOST_ASSERT(FIELD_HAS_SQRT(fields::goldilocks)); - BOOST_ASSERT(FIELD_HAS_SQRT(fields::mersenne31)); - BOOST_ASSERT(FIELD_HAS_SQRT(fields::koalabear)); - BOOST_ASSERT(FIELD_HAS_SQRT(fields::babybear)); + BOOST_CHECK( FIELD_HAS_SQRT(curves::alt_bn128_254::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::alt_bn128_254::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::alt_bn128_254::template g1_type<>::field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::alt_bn128_254::template g2_type<>::field_type) ); + BOOST_CHECK( !FIELD_HAS_SQRT(curves::alt_bn128_254::gt_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_381::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_381::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_381::template g1_type<>::field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_381::template g2_type<>::field_type) ); + BOOST_CHECK( !FIELD_HAS_SQRT(curves::bls12_381::gt_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_377::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_377::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_377::template g1_type<>::field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::bls12_377::template g2_type<>::field_type) ); + BOOST_CHECK( !FIELD_HAS_SQRT(curves::bls12_377::gt_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt4_298::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt4_298::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt4_298::template g1_type<>::field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt4_298::template g2_type<>::field_type) ); + BOOST_CHECK( !FIELD_HAS_SQRT(curves::mnt4_298::gt_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt6_298::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt6_298::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt6_298::template g1_type<>::field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::mnt6_298::template g2_type<>::field_type) ); + BOOST_CHECK( !FIELD_HAS_SQRT(curves::mnt6_298::gt_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::pallas::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::pallas::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::pallas::template g1_type<>::field_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::vesta::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::vesta::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::vesta::template g1_type<>::field_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::jubjub::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::jubjub::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::jubjub::template g1_type<>::field_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::babyjubjub::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::babyjubjub::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::babyjubjub::template g1_type<>::field_type) ); + + BOOST_CHECK( FIELD_HAS_SQRT(curves::ed25519::base_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::ed25519::scalar_field_type) ); + BOOST_CHECK( FIELD_HAS_SQRT(curves::ed25519::template g1_type<>::field_type) ); + + BOOST_CHECK(FIELD_HAS_SQRT(fields::goldilocks)); + BOOST_CHECK(FIELD_HAS_SQRT(fields::mersenne31)); + BOOST_CHECK(FIELD_HAS_SQRT(fields::koalabear)); + BOOST_CHECK(FIELD_HAS_SQRT(fields::babybear)); } BOOST_AUTO_TEST_CASE(test_extended_fields_trait) { - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::field_type::value_type>::value ); - BOOST_ASSERT( is_extended_field_element::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::value ); - BOOST_ASSERT( !is_extended_field_element::field_type::value_type>::value ); - - BOOST_ASSERT(!is_extended_field_element::value); - BOOST_ASSERT(!is_extended_field_element::value); - BOOST_ASSERT(!is_extended_field_element::value); - BOOST_ASSERT(!is_extended_field_element::value); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::field_type::value_type>::value ); + BOOST_CHECK( is_extended_field_element::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::value ); + BOOST_CHECK( !is_extended_field_element::field_type::value_type>::value ); + + BOOST_CHECK(!is_extended_field_element::value); + BOOST_CHECK(!is_extended_field_element::value); + BOOST_CHECK(!is_extended_field_element::value); + BOOST_CHECK(!is_extended_field_element::value); } diff --git a/crypto3/libs/blueprint/test/algebra/fields/plonk/interpolation.cpp b/crypto3/libs/blueprint/test/algebra/fields/plonk/interpolation.cpp index bbcbd8ba18..753d501544 100644 --- a/crypto3/libs/blueprint/test/algebra/fields/plonk/interpolation.cpp +++ b/crypto3/libs/blueprint/test/algebra/fields/plonk/interpolation.cpp @@ -85,8 +85,8 @@ void test_linear_inter_coefs(const std::vector= y; break; case comparison_mode::FLAG: - BOOST_ASSERT_MSG(false, "FLAG mode is not supported, use comparison_flag component instead."); + BOOST_CHECK_MESSAGE(false, "FLAG mode is not supported, use comparison_flag component instead."); } std::array witnesses; diff --git a/crypto3/libs/blueprint/test/component_batch.cpp b/crypto3/libs/blueprint/test/component_batch.cpp index bc7a314f6d..33b3cbff50 100644 --- a/crypto3/libs/blueprint/test/component_batch.cpp +++ b/crypto3/libs/blueprint/test/component_batch.cpp @@ -146,7 +146,7 @@ BOOST_AUTO_TEST_CASE(component_batch_basic_test) { {var(0, 2, false, var::column_type::public_input), var(3, 0, false, var::column_type::witness)}, {var(4, 0, false, var::column_type::witness), var(0, 3, false, var::column_type::public_input)} }; - BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); + BOOST_CHECK(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); @@ -217,7 +217,7 @@ BOOST_AUTO_TEST_CASE(component_batch_continuation_test) { {var(1, 3, false, var::column_type::witness), var(5, 2, false, var::column_type::witness)} }; - BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); + BOOST_CHECK(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); @@ -304,7 +304,7 @@ BOOST_AUTO_TEST_CASE(component_batch_multibatch_test) { BOOST_CHECK_EQUAL(gate_2.constraints[i], expected_constraints_add[i]); } } - BOOST_ASSERT((gate_1.constraints[0] == expected_constraints_mul[0] && + BOOST_CHECK((gate_1.constraints[0] == expected_constraints_mul[0] && gate_2.constraints[0] == expected_constraints_add[0]) || (gate_1.constraints[0] == expected_constraints_add[0] && gate_2.constraints[0] == expected_constraints_mul[0])); @@ -338,7 +338,7 @@ BOOST_AUTO_TEST_CASE(component_batch_multibatch_test) { {var(4, 3, false, var::column_type::witness), var(2, 1, false, var::column_type::witness)} }; - BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); + BOOST_CHECK(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); @@ -392,12 +392,12 @@ BOOST_AUTO_TEST_CASE(component_batch_const_batch_test) { assignment_table.add_batch_constant_variable(2); } - BOOST_ASSERT(assignment_table.constant(0, 0) == 1444); - BOOST_ASSERT(assignment_table.constant(0, 1) == 1); - BOOST_ASSERT(assignment_table.constant(0, 2) == 1445); - BOOST_ASSERT(assignment_table.constant(0, 3) == 1446); - BOOST_ASSERT(assignment_table.constant(0, 4) == 2); - BOOST_ASSERT(assignment_table.rows_amount() == 5); + BOOST_CHECK(assignment_table.constant(0, 0) == 1444); + BOOST_CHECK(assignment_table.constant(0, 1) == 1); + BOOST_CHECK(assignment_table.constant(0, 2) == 1445); + BOOST_CHECK(assignment_table.constant(0, 3) == 1446); + BOOST_CHECK(assignment_table.constant(0, 4) == 2); + BOOST_CHECK(assignment_table.rows_amount() == 5); const std::vector expected_copy_constraints = { {var(0, 0, false, var::column_type::public_input), var(0, 0, false, var::column_type::witness)}, @@ -409,7 +409,7 @@ BOOST_AUTO_TEST_CASE(component_batch_const_batch_test) { {var(7, 3, false, var::column_type::witness), var(0, 4, false, var::column_type::constant)} }; - BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); + BOOST_CHECK(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); @@ -479,7 +479,7 @@ BOOST_AUTO_TEST_CASE(component_batch_params_test) { {var(9, 0, false, var::column_type::witness), var(12, 0, false, var::column_type::witness)} }; - BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); + BOOST_CHECK(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); @@ -504,15 +504,15 @@ BOOST_AUTO_TEST_CASE(component_batch_generate_circuit_variant_basic_test) { typename multiplication_type::input_type input_2 = {public_input_var_maker(), public_input_var_maker()}; auto res_1 = assignment_table.add_input_to_batch_circuit(input_1); auto res_2 = assignment_table.add_input_to_batch_circuit(input_2); - BOOST_ASSERT(var_value(assignment_table, res_1.output) == 0); - BOOST_ASSERT(var_value(assignment_table, res_2.output) == 0); + BOOST_CHECK(var_value(assignment_table, res_1.output) == 0); + BOOST_CHECK(var_value(assignment_table, res_2.output) == 0); res_1 = assignment_table.add_input_to_batch_assignment(input_1); - BOOST_ASSERT(var_value(assignment_table, res_1.output) == var_value(assignment_table, input_1.x) * var_value(assignment_table, input_1.y)); - BOOST_ASSERT(var_value(assignment_table, res_1.output) != 0); - BOOST_ASSERT(var_value(assignment_table, res_2.output) == 0); + BOOST_CHECK(var_value(assignment_table, res_1.output) == var_value(assignment_table, input_1.x) * var_value(assignment_table, input_1.y)); + BOOST_CHECK(var_value(assignment_table, res_1.output) != 0); + BOOST_CHECK(var_value(assignment_table, res_2.output) == 0); res_2 = assignment_table.add_input_to_batch_assignment(input_2); - BOOST_ASSERT(var_value(assignment_table, res_2.output) == var_value(assignment_table, input_2.x) * var_value(assignment_table, input_2.y)); - BOOST_ASSERT(var_value(assignment_table, res_2.output) != 0); + BOOST_CHECK(var_value(assignment_table, res_2.output) == var_value(assignment_table, input_2.x) * var_value(assignment_table, input_2.y)); + BOOST_CHECK(var_value(assignment_table, res_2.output) != 0); } BOOST_AUTO_TEST_SUITE_END() diff --git a/crypto3/libs/blueprint/test/detail/huang_lu.cpp b/crypto3/libs/blueprint/test/detail/huang_lu.cpp index 01bd74d9cc..f417283120 100644 --- a/crypto3/libs/blueprint/test/detail/huang_lu.cpp +++ b/crypto3/libs/blueprint/test/detail/huang_lu.cpp @@ -103,7 +103,7 @@ void test_against_exhaustive_search(std::list assignment = huang_lu(sizes, agent_amount); // Sanity check: all tasks are assigned for (std::size_t i = 0; i < sizes.size(); i++) { - BOOST_ASSERT(assignment.find(i) != assignment.end()); + BOOST_CHECK(assignment.find(i) != assignment.end()); } std::vector tasks(sizes.size(), 0); for (auto [key, size] : sizes) { @@ -123,8 +123,8 @@ void test_against_exhaustive_search(std::list constraints_2; constraints_2.emplace_back( var(0, -1, true, var::column_type::witness) * var(1, 3, true, var::column_type::witness) - var(2, 0, true, var::column_type::witness)); gate_id_type id_2(gate_type(0, constraints_2)); - BOOST_ASSERT(id != id_2); - BOOST_ASSERT(id < id_2 || id_2 < id); + BOOST_CHECK(id != id_2); + BOOST_CHECK(id < id_2 || id_2 < id); std::vector constraints_3; std::vector constraints_4; @@ -94,11 +94,11 @@ BOOST_AUTO_TEST_CASE(gate_id_sanity_tests) { var(0, 1, true, var::column_type::witness)); gate_id_type id_3(constraints_3); gate_id_type id_4(constraints_4); - BOOST_ASSERT(id_3 != id_4); + BOOST_CHECK(id_3 != id_4); value_type power_100 = values.get_power(100); value_type power_101 = values.get_power(101); - BOOST_ASSERT(power_100 != power_101); + BOOST_CHECK(power_100 != power_101); // gate_id should be unordered -- order of constraints inside the gate should not matter std::vector constraints_5; @@ -116,7 +116,7 @@ BOOST_AUTO_TEST_CASE(gate_id_sanity_tests) { gate_id_type id_5(constraints_5), id_6(constraints_6); - BOOST_ASSERT(id_5 == id_6); + BOOST_CHECK(id_5 == id_6); std::vector constraints_7; constraints_7.emplace_back(var(0, 0, true, var::column_type::witness)); @@ -124,7 +124,7 @@ BOOST_AUTO_TEST_CASE(gate_id_sanity_tests) { constraints_8.emplace_back(var(0, 0, true, var::column_type::constant)); gate_id_type id_7(constraints_7), id_8(constraints_8); - BOOST_ASSERT(id_7 != id_8); + BOOST_CHECK(id_7 != id_8); } BOOST_AUTO_TEST_CASE(lookup_gate_id_sanity_tests) { @@ -158,8 +158,8 @@ BOOST_AUTO_TEST_CASE(lookup_gate_id_sanity_tests) { gate_2(1, constraints_2); lookup_gate_id_type id_1 = lookup_gate_id_type(gate_1), id_2 = lookup_gate_id_type(gate_2); - BOOST_ASSERT(id_1 == id_2); - BOOST_ASSERT(!(id_1 < id_2) && !(id_2 < id_1)); + BOOST_CHECK(id_1 == id_2); + BOOST_CHECK(!(id_1 < id_2) && !(id_2 < id_1)); // Order of variables inside constraints should matter auto var_1 = var(0, -1, true, var::column_type::witness), var_2 = var(1, 3, true, var::column_type::witness); @@ -167,13 +167,13 @@ BOOST_AUTO_TEST_CASE(lookup_gate_id_sanity_tests) { constraint_4({0, {var_2, var_1}}); lookup_gate_id_type id_3(constraint_3), id_4(constraint_4); - BOOST_ASSERT(id_3 != id_4); + BOOST_CHECK(id_3 != id_4); // Table ids should matter lookup_constraint_type constraint_5({0, {var_1, var_2}}), constraint_6({1, {var_1, var_2}}); lookup_gate_id_type id_5(constraint_5), id_6(constraint_6); - BOOST_ASSERT(id_5 != id_6); + BOOST_CHECK(id_5 != id_6); } BOOST_AUTO_TEST_SUITE_END() diff --git a/crypto3/libs/blueprint/test/hashes/plonk/keccak_component.cpp b/crypto3/libs/blueprint/test/hashes/plonk/keccak_component.cpp index b92b3b8fe1..f719dccac8 100644 --- a/crypto3/libs/blueprint/test/hashes/plonk/keccak_component.cpp +++ b/crypto3/libs/blueprint/test/hashes/plonk/keccak_component.cpp @@ -87,7 +87,7 @@ void test_keccaks( auto result_check = [](AssignmentType &assignment, typename component_type::result_type &real_res) {}; if (!(WitnessesAmount == 15)) { - BOOST_ASSERT_MSG(false, "Please add support for WitnessesAmount that you passed here!"); + BOOST_CHECK_MESSAGE(false, "Please add support for WitnessesAmount that you passed here!"); } std::array witnesses; for (std::uint32_t i = 0; i < WitnessesAmount; i++) { diff --git a/crypto3/libs/blueprint/test/hashes/plonk/keccak_dynamic.cpp b/crypto3/libs/blueprint/test/hashes/plonk/keccak_dynamic.cpp index 055af595b4..c4cce623f4 100644 --- a/crypto3/libs/blueprint/test/hashes/plonk/keccak_dynamic.cpp +++ b/crypto3/libs/blueprint/test/hashes/plonk/keccak_dynamic.cpp @@ -89,7 +89,7 @@ void test_keccaks( auto result_check = [](AssignmentType &assignment, typename component_type::result_type &real_res) {}; if (!(WitnessesAmount == 15)) { - BOOST_ASSERT_MSG(false, "Please add support for WitnessesAmount that you passed here!"); + BOOST_CHECK_MESSAGE(false, "Please add support for WitnessesAmount that you passed here!"); } std::array witnesses; for (std::uint32_t i = 0; i < WitnessesAmount; i++) { diff --git a/crypto3/libs/blueprint/test/hashes/plonk/keccak_padding.cpp b/crypto3/libs/blueprint/test/hashes/plonk/keccak_padding.cpp index 61a6737732..4c4de0e5a1 100644 --- a/crypto3/libs/blueprint/test/hashes/plonk/keccak_padding.cpp +++ b/crypto3/libs/blueprint/test/hashes/plonk/keccak_padding.cpp @@ -135,7 +135,7 @@ auto test_keccak_padding_inner(std::vector witnesses; for (std::uint32_t i = 0; i < WitnessesAmount; i++) { diff --git a/crypto3/libs/blueprint/test/hashes/plonk/keccak_round.cpp b/crypto3/libs/blueprint/test/hashes/plonk/keccak_round.cpp index e6757a9849..1df73f5916 100644 --- a/crypto3/libs/blueprint/test/hashes/plonk/keccak_round.cpp +++ b/crypto3/libs/blueprint/test/hashes/plonk/keccak_round.cpp @@ -206,7 +206,7 @@ auto test_keccak_round_inner(std::array witnesses; for (std::uint32_t i = 0; i < WitnessesAmount; i++) { diff --git a/crypto3/libs/blueprint/test/hashes/plonk/keccak_static.cpp b/crypto3/libs/blueprint/test/hashes/plonk/keccak_static.cpp index b104349847..cfaed8b289 100644 --- a/crypto3/libs/blueprint/test/hashes/plonk/keccak_static.cpp +++ b/crypto3/libs/blueprint/test/hashes/plonk/keccak_static.cpp @@ -362,7 +362,7 @@ auto test_keccak_inner(std::vector mess }; if (!(WitnessesAmount == 15 || WitnessesAmount == 9)) { - BOOST_ASSERT_MSG(false, "Please add support for WitnessesAmount that you passed here!"); + BOOST_CHECK_MESSAGE(false, "Please add support for WitnessesAmount that you passed here!"); } std::array witnesses; for (std::uint32_t i = 0; i < WitnessesAmount; i++) { diff --git a/crypto3/libs/blueprint/test/manifest.cpp b/crypto3/libs/blueprint/test/manifest.cpp index b4e3350f4f..84f4a5042d 100644 --- a/crypto3/libs/blueprint/test/manifest.cpp +++ b/crypto3/libs/blueprint/test/manifest.cpp @@ -49,22 +49,22 @@ void test_manifest_range_intersect(std::int32_t start_1, std::int32_t end_1, std new_end = std::min(end_1, end_2); new_step = step_1; if (new_start >= new_end) { - BOOST_ASSERT(get_manifest_param_type(result) == manifest_param::type::UNSAT); + BOOST_CHECK(get_manifest_param_type(result) == manifest_param::type::UNSAT); } else if (new_start == new_end - 1) { - BOOST_ASSERT(get_manifest_param_type(result) == manifest_param::type::SINGLE_VALUE); + BOOST_CHECK(get_manifest_param_type(result) == manifest_param::type::SINGLE_VALUE); manifest_single_value_param* res = dynamic_cast(result.get()); - BOOST_ASSERT(res->value == std::size_t(new_start)); + BOOST_CHECK(res->value == std::size_t(new_start)); } else { - BOOST_ASSERT(get_manifest_param_type(result) == manifest_param::type::RANGE); + BOOST_CHECK(get_manifest_param_type(result) == manifest_param::type::RANGE); manifest_range_param* res = dynamic_cast(result.get()); - BOOST_ASSERT(res->start == new_start); - BOOST_ASSERT(res->finish == new_end); - BOOST_ASSERT(res->step == std::size_t(new_step)); + BOOST_CHECK(res->start == new_start); + BOOST_CHECK(res->finish == new_end); + BOOST_CHECK(res->step == std::size_t(new_step)); } } else { auto [gcd, m, n] = boost::integer::extended_euclidean(step_1, step_2); if (start_1 % gcd != start_2 % gcd) { - BOOST_ASSERT(get_manifest_param_type(result) == manifest_param::type::UNSAT); + BOOST_CHECK(get_manifest_param_type(result) == manifest_param::type::UNSAT); } else { new_step = step_1 * (step_2 / gcd); std::uint32_t result_modulo_new_step = @@ -73,17 +73,17 @@ void test_manifest_range_intersect(std::int32_t start_1, std::int32_t end_1, std new_start = new_start + (new_step + int(result_modulo_new_step - new_start) % new_step) % new_step; new_end = std::min(end_1, end_2); if (new_start >= new_end) { - BOOST_ASSERT(get_manifest_param_type(result) == manifest_param::type::UNSAT); + BOOST_CHECK(get_manifest_param_type(result) == manifest_param::type::UNSAT); } else if (new_start == new_end - 1) { - BOOST_ASSERT(get_manifest_param_type(result) == manifest_param::type::SINGLE_VALUE); + BOOST_CHECK(get_manifest_param_type(result) == manifest_param::type::SINGLE_VALUE); manifest_single_value_param* res = dynamic_cast(result.get()); - BOOST_ASSERT(res->value == std::size_t(new_start)); + BOOST_CHECK(res->value == std::size_t(new_start)); } else { - BOOST_ASSERT(get_manifest_param_type(result) == manifest_param::type::RANGE); + BOOST_CHECK(get_manifest_param_type(result) == manifest_param::type::RANGE); manifest_range_param* res = dynamic_cast(result.get()); - BOOST_ASSERT(res->start == new_start); - BOOST_ASSERT(res->finish == new_end); - BOOST_ASSERT(res->step == std::size_t(new_step)); + BOOST_CHECK(res->start == new_start); + BOOST_CHECK(res->finish == new_end); + BOOST_CHECK(res->step == std::size_t(new_step)); } } } @@ -107,31 +107,31 @@ void test_operator(std::shared_ptr param_1, std::shared_ptr)> &oper) { std::shared_ptr result = oper(param_1, param_2); std::shared_ptr result_2 = oper(param_2, param_1); - BOOST_ASSERT(get_manifest_param_type(result) == get_manifest_param_type(expected_result)); - BOOST_ASSERT(get_manifest_param_type(result_2) == get_manifest_param_type(expected_result)); + BOOST_CHECK(get_manifest_param_type(result) == get_manifest_param_type(expected_result)); + BOOST_CHECK(get_manifest_param_type(result_2) == get_manifest_param_type(expected_result)); auto type = get_manifest_param_type(expected_result); if (type == manifest_param::type::UNSAT) { return; } else if (type == manifest_param::type::SINGLE_VALUE) { auto value_1 = dynamic_cast(result.get())->value; auto value_2 = dynamic_cast(expected_result.get())->value; - BOOST_ASSERT(value_1 == value_2); + BOOST_CHECK(value_1 == value_2); auto value_3 = dynamic_cast(result_2.get())->value; - BOOST_ASSERT(value_3 == value_2); + BOOST_CHECK(value_3 == value_2); } else if (type == manifest_param::type::SET) { auto set_1 = dynamic_cast(result.get())->set; auto set_2 = dynamic_cast(expected_result.get())->set; - BOOST_ASSERT(set_1 == set_2); + BOOST_CHECK(set_1 == set_2); auto set_3 = dynamic_cast(result_2.get())->set; - BOOST_ASSERT(set_3 == set_2); + BOOST_CHECK(set_3 == set_2); } else if (type == manifest_param::type::RANGE) { auto range_1 = dynamic_cast(result.get()); auto range_2 = dynamic_cast(expected_result.get()); - BOOST_ASSERT(*range_1 == *range_2); + BOOST_CHECK(*range_1 == *range_2); auto range_3 = dynamic_cast(result_2.get()); - BOOST_ASSERT(*range_3 == *range_2); + BOOST_CHECK(*range_3 == *range_2); } else { - BOOST_ASSERT(false); + BOOST_CHECK(false); } } @@ -200,10 +200,10 @@ BOOST_AUTO_TEST_CASE(test_manifest_iteration) { manifest_single_value_param param(5); std::size_t i = 0; for (auto val : param) { - BOOST_ASSERT(val == 5); + BOOST_CHECK(val == 5); ++i; } - BOOST_ASSERT(i == 1); + BOOST_CHECK(i == 1); using manifest_set_param = manifest_set_param; std::set expected_set = {0, 1, 2, 3, 4, 5, 91, 11}; @@ -211,20 +211,20 @@ BOOST_AUTO_TEST_CASE(test_manifest_iteration) { std::size_t j = 0; for (auto val : param_set) { - BOOST_ASSERT(expected_set.find(val) != expected_set.end()); + BOOST_CHECK(expected_set.find(val) != expected_set.end()); ++j; } - BOOST_ASSERT(j == expected_set.size()); + BOOST_CHECK(j == expected_set.size()); using manifest_range_param = manifest_range_param; manifest_range_param param_range(1, 16, 2); std::set expected_range = {1, 3, 5, 7, 9, 11, 13, 15}; std::size_t k = 0; for (auto val : param_range) { - BOOST_ASSERT(expected_range.find(val) != expected_range.end()); + BOOST_CHECK(expected_range.find(val) != expected_range.end()); ++k; } - BOOST_ASSERT(k == expected_range.size()); + BOOST_CHECK(k == expected_range.size()); } template @@ -234,10 +234,10 @@ void test_table_operation(const std::map, TestTy auto [type_1, type_2] = test_case.first; auto expected_result = test_case.second; auto result = operation(type_1, type_2); - BOOST_ASSERT(result == expected_result); + BOOST_CHECK(result == expected_result); if constexpr (std::is_same_v) { auto second_result = operation(type_2, type_1); - BOOST_ASSERT(second_result == expected_result); + BOOST_CHECK(second_result == expected_result); } } } @@ -325,7 +325,7 @@ BOOST_AUTO_TEST_CASE(test_manifest_intersect) { plonk_component_manifest expected_res_1 = plonk_component_manifest( std::make_shared(3, 10, 3), manifest_constant_type::type::NONE); - BOOST_ASSERT(check_manifest_equality(manifest_res_1, expected_res_1)); + BOOST_CHECK(check_manifest_equality(manifest_res_1, expected_res_1)); plonk_component_manifest manifest_2( std::make_shared(3, 12, 3), @@ -334,7 +334,7 @@ BOOST_AUTO_TEST_CASE(test_manifest_intersect) { plonk_component_manifest expected_res_2 = plonk_component_manifest( std::make_shared(3, 10, 3), manifest_constant_type::type::NONE); - BOOST_ASSERT(check_manifest_equality(manifest_res_2, expected_res_2)); + BOOST_CHECK(check_manifest_equality(manifest_res_2, expected_res_2)); plonk_component_manifest manifest_3( std::make_shared(5), @@ -343,7 +343,7 @@ BOOST_AUTO_TEST_CASE(test_manifest_intersect) { plonk_component_manifest expected_res_3 = plonk_component_manifest( std::make_shared(5), manifest_constant_type::type::UNSAT); - BOOST_ASSERT(check_manifest_equality(manifest_res_3, expected_res_3)); + BOOST_CHECK(check_manifest_equality(manifest_res_3, expected_res_3)); compiler_manifest comp_manifest_2(20, true); plonk_component_manifest manifest_4( @@ -353,7 +353,7 @@ BOOST_AUTO_TEST_CASE(test_manifest_intersect) { plonk_component_manifest expected_res_4 = plonk_component_manifest( std::make_shared(std::set{1, 2, 3, 11}), manifest_constant_type::type::REQUIRED); - BOOST_ASSERT(check_manifest_equality(manifest_res_4, expected_res_4)); + BOOST_CHECK(check_manifest_equality(manifest_res_4, expected_res_4)); } BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file diff --git a/crypto3/libs/blueprint/test/mock/mocked_components.cpp b/crypto3/libs/blueprint/test/mock/mocked_components.cpp index 3493bb64d9..90321f9604 100644 --- a/crypto3/libs/blueprint/test/mock/mocked_components.cpp +++ b/crypto3/libs/blueprint/test/mock/mocked_components.cpp @@ -82,7 +82,7 @@ using namespace nil; auto result_check = [&expected_result](AssignmentType &assignment, \ typename component_type::result_type &real_res) { \ \ - BOOST_ASSERT(expected_result == var_value(assignment, real_res.a)); \ + BOOST_CHECK(expected_result == var_value(assignment, real_res.a)); \ }; \ \ component_type component_instance({0u, 1u, 2u}, {}, {}); \ @@ -127,8 +127,8 @@ TEST_SMALL_UNSIGNED_GEN(test_small_unsigned_rem, unsigned_remainder_component_sm auto result_check = [&expected_result_sign, &expected_result_mod](AssignmentType &assignment, \ typename component_type::result_type &real_res) { \ \ - BOOST_ASSERT(expected_result_sign == var_value(assignment, real_res.value[0])); \ - BOOST_ASSERT(expected_result_mod == var_value(assignment, real_res.value[1])); \ + BOOST_CHECK(expected_result_sign == var_value(assignment, real_res.value[0])); \ + BOOST_CHECK(expected_result_mod == var_value(assignment, real_res.value[1])); \ }; \ \ component_type component_instance({0u, 1u, 2u}, {}, {}); \ @@ -252,8 +252,8 @@ void test_small_signed_abs( auto result_check = [&expected_sign, &expected_mod](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(expected_sign == var_value(assignment, real_res.value[0])); - BOOST_ASSERT(expected_mod == var_value(assignment, real_res.value[1])); + BOOST_CHECK(expected_sign == var_value(assignment, real_res.value[0])); + BOOST_CHECK(expected_mod == var_value(assignment, real_res.value[1])); }; component_type component_instance({0, 1, 2}, {}, {}); @@ -311,9 +311,9 @@ void test_big_signed_abs( auto result_check = [&expected_sign, &expected_first, &expected_second](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(expected_sign == var_value(assignment, real_res.value[0])); - BOOST_ASSERT(expected_first == var_value(assignment, real_res.value[1])); - BOOST_ASSERT(expected_second == var_value(assignment, real_res.value[2])); + BOOST_CHECK(expected_sign == var_value(assignment, real_res.value[0])); + BOOST_CHECK(expected_first == var_value(assignment, real_res.value[1])); + BOOST_CHECK(expected_second == var_value(assignment, real_res.value[2])); }; component_type component_instance({0, 1, 2}, {}, {}); @@ -378,8 +378,8 @@ void test_big_signed_absolute() { auto result_check = [&expected_first, &expected_second](AssignmentType &assignment, \ typename component_type::result_type &real_res) { \ \ - BOOST_ASSERT(expected_first == var_value(assignment, real_res.value[0])); \ - BOOST_ASSERT(expected_second == var_value(assignment, real_res.value[1])); \ + BOOST_CHECK(expected_first == var_value(assignment, real_res.value[0])); \ + BOOST_CHECK(expected_second == var_value(assignment, real_res.value[1])); \ }; \ \ component_type component_instance({0, 1, 2}, {}, {}); \ @@ -417,7 +417,7 @@ void test_big_signed_absolute() { auto result_check = [&expected_result](AssignmentType &assignment, \ typename component_type::result_type &real_res) { \ \ - BOOST_ASSERT(expected_result == var_value(assignment, real_res.a)); \ + BOOST_CHECK(expected_result == var_value(assignment, real_res.a)); \ }; \ \ component_type component_instance({0, 1, 2}, {}, {}); \ @@ -472,9 +472,9 @@ TEST_BIG_UNSIGNED_BOOL_GEN(test_big_unsigned_greater_eq, unsinged_greater_equal_ auto result_check = [&expected_sign, &expected_first, &expected_second](AssignmentType &assignment, \ typename component_type::result_type &real_res) { \ \ - BOOST_ASSERT(expected_sign == var_value(assignment, real_res.value[0])); \ - BOOST_ASSERT(expected_first == var_value(assignment, real_res.value[1])); \ - BOOST_ASSERT(expected_second == var_value(assignment, real_res.value[2])); \ + BOOST_CHECK(expected_sign == var_value(assignment, real_res.value[0])); \ + BOOST_CHECK(expected_first == var_value(assignment, real_res.value[1])); \ + BOOST_CHECK(expected_second == var_value(assignment, real_res.value[2])); \ }; \ \ component_type component_instance({0, 1, 2}, {}, {}); \ @@ -522,7 +522,7 @@ TEST_BIG_SIGNED_GEN(test_big_signed_rem, signed_remainder_component_big) auto result_check = [&expected_result](AssignmentType &assignment, \ typename component_type::result_type &real_res) { \ \ - BOOST_ASSERT(expected_result == var_value(assignment, real_res.a)); \ + BOOST_CHECK(expected_result == var_value(assignment, real_res.a)); \ }; \ \ component_type component_instance({0, 1, 2}, {}, {}); \ diff --git a/crypto3/libs/blueprint/test/private_input.cpp b/crypto3/libs/blueprint/test/private_input.cpp index d9ee12859f..88101208d9 100644 --- a/crypto3/libs/blueprint/test/private_input.cpp +++ b/crypto3/libs/blueprint/test/private_input.cpp @@ -119,14 +119,14 @@ BOOST_AUTO_TEST_CASE(blueprint_plonk_private_input_copy_constraints) { public_2 = var(0, 1, false, var::column_type::public_input); bp.add_copy_constraint({private_1, private_2}); - BOOST_ASSERT(bp.copy_constraints().size() == 0); + BOOST_CHECK(bp.copy_constraints().size() == 0); bp.add_copy_constraint({private_1, public_1}); - BOOST_ASSERT(bp.copy_constraints().size() == 0); + BOOST_CHECK(bp.copy_constraints().size() == 0); bp.add_copy_constraint({public_2, private_2}); - BOOST_ASSERT(bp.copy_constraints().size() == 0); + BOOST_CHECK(bp.copy_constraints().size() == 0); bp.add_copy_constraint({public_1, public_2}); - BOOST_ASSERT(bp.copy_constraints().size() == 1); + BOOST_CHECK(bp.copy_constraints().size() == 1); } diff --git a/crypto3/libs/blueprint/test/test_plonk_component.cpp b/crypto3/libs/blueprint/test/test_plonk_component.cpp index 424ef9b784..45e005ec35 100644 --- a/crypto3/libs/blueprint/test/test_plonk_component.cpp +++ b/crypto3/libs/blueprint/test/test_plonk_component.cpp @@ -81,7 +81,7 @@ BOOST_AUTO_TEST_CASE(bare) { auto result_check = [&x, &pow](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(var_value(assignment, real_res.y) == x.pow(pow)); + BOOST_CHECK(var_value(assignment, real_res.y) == x.pow(pow)); }; std::array witnesses; @@ -109,7 +109,7 @@ BOOST_AUTO_TEST_CASE(print_to_file) { auto result_check = [&x, &pow](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(var_value(assignment, real_res.y) == x.pow(pow)); + BOOST_CHECK(var_value(assignment, real_res.y) == x.pow(pow)); }; std::array witnesses; @@ -136,7 +136,7 @@ BOOST_AUTO_TEST_CASE(print_to_file) { "./test_plonk_component0_table.tbl" ); - BOOST_ASSERT(check_placeholder_proof(bp, desc, assignments)); + BOOST_CHECK(check_placeholder_proof(bp, desc, assignments)); } BOOST_AUTO_TEST_CASE(verify_proof) { @@ -152,7 +152,7 @@ BOOST_AUTO_TEST_CASE(verify_proof) { auto result_check = [&x, &pow](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(var_value(assignment, real_res.y) == x.pow(pow)); + BOOST_CHECK(var_value(assignment, real_res.y) == x.pow(pow)); }; std::array witnesses; @@ -188,7 +188,7 @@ BOOST_AUTO_TEST_CASE(print_to_file_and_verify_proof) { auto result_check = [&x, &pow](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(var_value(assignment, real_res.y) == x.pow(pow)); + BOOST_CHECK(var_value(assignment, real_res.y) == x.pow(pow)); }; std::array witnesses; @@ -217,7 +217,7 @@ BOOST_AUTO_TEST_CASE(print_to_file_and_verify_proof) { "./test_plonk_component1_table.tbl" ); - BOOST_ASSERT(check_placeholder_proof(bp, desc, assignments)); + BOOST_CHECK(check_placeholder_proof(bp, desc, assignments)); } BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file diff --git a/crypto3/libs/blueprint/test/test_plonk_component.hpp b/crypto3/libs/blueprint/test/test_plonk_component.hpp index c1324e0c47..5e31342b4b 100644 --- a/crypto3/libs/blueprint/test/test_plonk_component.hpp +++ b/crypto3/libs/blueprint/test/test_plonk_component.hpp @@ -35,6 +35,8 @@ #include #include +#include + #include #include #include @@ -145,7 +147,7 @@ namespace nil { ifile.open(circuit_path, std::ios_base::binary | std::ios_base::in); if (!ifile.is_open()) { std::cerr << "Cannot find input file " << circuit_path << std::endl; - BOOST_ASSERT(false); + BOOST_CHECK(false); } std::vector v; ifile.seekg(0, std::ios_base::end); @@ -155,7 +157,7 @@ namespace nil { ifile.read(reinterpret_cast(v.data()), fsize); if (!ifile) { std::cerr << "Cannot parse input file " << circuit_path << std::endl; - BOOST_ASSERT(false); + BOOST_CHECK(false); } ifile.close(); @@ -174,7 +176,7 @@ namespace nil { iassignment.open(table_path, std::ios_base::binary | std::ios_base::in); if (!iassignment) { std::cerr << "Cannot open " << table_path << std::endl; - BOOST_ASSERT(false); + BOOST_CHECK(false); } std::vector v; iassignment.seekg(0, std::ios_base::end); @@ -184,7 +186,7 @@ namespace nil { iassignment.read(reinterpret_cast(v.data()), fsize); if (!iassignment) { std::cerr << "Cannot parse input file " << table_path << std::endl; - BOOST_ASSERT(false); + BOOST_CHECK(false); } iassignment.close(); nil::crypto3::marshalling::types::plonk_assignment_table marshalled_table_data; @@ -351,7 +353,7 @@ namespace nil { std::cout << bp.num_gates() + bp.num_lookup_gates() << " != " << component_type::get_gate_manifest(component_instance.witness_amount(), component_static_info_args...).get_gates_amount() << std::endl; } - BOOST_ASSERT_MSG(bp.num_gates() + bp.num_lookup_gates() == + BOOST_CHECK_MESSAGE(bp.num_gates() + bp.num_lookup_gates() == component_type::get_gate_manifest(component_instance.witness_amount(), component_static_info_args...).get_gates_amount(), "Component total gates amount does not match actual gates amount."); @@ -360,12 +362,12 @@ namespace nil { if (start_row + component_instance.rows_amount >= public_input.size()) { if ( assignment.rows_amount() - start_row != component_instance.rows_amount ) std::cout << assignment.rows_amount() << " != " << component_instance.rows_amount << std::endl; - BOOST_ASSERT_MSG(assignment.rows_amount() - start_row == component_instance.rows_amount, + BOOST_CHECK_MESSAGE(assignment.rows_amount() - start_row == component_instance.rows_amount, "Component rows amount does not match actual rows amount."); // Stretched components do not have a manifest, as they are dynamically generated. if constexpr (!blueprint::components::is_component_stretcher< BlueprintFieldType, ComponentType>::value) { - BOOST_ASSERT_MSG(assignment.rows_amount() - start_row == + BOOST_CHECK_MESSAGE(assignment.rows_amount() - start_row == component_type::get_rows_amount(component_instance.witness_amount(), component_static_info_args...), "Static component rows amount does not match actual rows amount."); @@ -405,7 +407,7 @@ namespace nil { // blueprint::detail::export_connectedness_zones( // zones, assignment, instance_input.all_vars(), start_row, rows_after_batching - start_row, std::cout); - BOOST_ASSERT_MSG(is_connected, + BOOST_CHECK_MESSAGE(is_connected, "Component disconnected! See comment above this assert for a way to output a visual representation of the connectedness graph."); } desc.usable_rows_amount = assignment.rows_amount(); @@ -472,8 +474,8 @@ namespace nil { // bp.export_circuit(std::cout); result_check(assignment, component_result); - BOOST_ASSERT(bp.num_gates() == 0); - BOOST_ASSERT(bp.num_lookup_gates() == 0); + BOOST_CHECK(bp.num_gates() == 0); + BOOST_CHECK(bp.num_lookup_gates() == 0); return std::make_tuple(desc, bp, assignment); } @@ -546,10 +548,10 @@ namespace nil { bp, desc, assignments ); if (expected_to_pass) { - BOOST_ASSERT(verifier_res); + BOOST_CHECK(verifier_res); } else { - BOOST_ASSERT(!verifier_res); + BOOST_CHECK(!verifier_res); } } } diff --git a/crypto3/libs/blueprint/test/utils/connectedness_check.cpp b/crypto3/libs/blueprint/test/utils/connectedness_check.cpp index f6e831ee7d..9ba0b80f69 100644 --- a/crypto3/libs/blueprint/test/utils/connectedness_check.cpp +++ b/crypto3/libs/blueprint/test/utils/connectedness_check.cpp @@ -77,42 +77,42 @@ BOOST_AUTO_TEST_CASE(connectedness_check_sanity_tests) { std::vector> reference_public_input = {public_input[0]}; std::vector output_variables = {var(4, start_row_index, false, var::column_type::witness)}; std::vector> reference_output_variables = {output_variables[0]}; - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::WEAK)); bp.add_copy_constraint({public_input[0], output_variables[0]}); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::WEAK)); public_input.push_back(var(0, 1, false, var::column_type::public_input)); reference_public_input = {public_input[0], public_input[1]}; - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::WEAK)); const std::size_t intermediate_var_index = 5; var intermediate_var = var(intermediate_var_index, start_row_index, false, var::column_type::witness); bp.add_copy_constraint({public_input[1], intermediate_var}); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::WEAK)); bp.add_copy_constraint({intermediate_var, output_variables[0]}); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::WEAK)); var another_intermediate_var = var(0, start_row_index + 2, false, var::column_type::constant); output_variables.push_back(another_intermediate_var); reference_output_variables = {output_variables[0], output_variables[1]}; - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, connectedness_check_type::type::STRONG)); std::size_t selector_idx = bp.add_gate({ @@ -121,45 +121,45 @@ BOOST_AUTO_TEST_CASE(connectedness_check_sanity_tests) { var(0, -1, true, var::column_type::witness), var(1, -1, true, var::column_type::witness), var(2, -1, true, var::column_type::witness)}); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, connectedness_check_type::type::WEAK)); assignment.enable_selector(selector_idx, start_row_index + 1); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 3, connectedness_check_type::type::WEAK)); var lookup_test_var = var(0, start_row_index + 3, false, var::column_type::constant); output_variables.push_back(lookup_test_var); reference_output_variables = {output_variables[0], output_variables[1], output_variables[2]}; - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::WEAK)); std::size_t lookup_selector_idx = bp.add_lookup_gate( {{0, {var(0, -1, true, var::column_type::constant)}}, {1, {var(0, 0, true, var::column_type::constant)}}}); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::WEAK)); assignment.enable_selector(lookup_selector_idx, start_row_index + 3); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::WEAK)); public_input.push_back(var(0, 2, false, var::column_type::public_input)); reference_public_input = {public_input[0], public_input[1], public_input[2]}; output_variables.push_back(var(0, 2, false, var::column_type::public_input)); reference_output_variables = {output_variables[0], output_variables[1], output_variables[2], output_variables[3]}; - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 4, connectedness_check_type::type::WEAK)); } @@ -187,26 +187,26 @@ BOOST_AUTO_TEST_CASE(connectedness_check_island_tests) { bp.add_gate({ var(4, 0, true, var::column_type::witness) * var(5, 0, true, var::column_type::witness)}); assignment.enable_selector(0, start_row_index); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::WEAK)); bp.add_gate({var(6, 0, true, var::column_type::witness)}); assignment.enable_selector(1, start_row_index); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 1, connectedness_check_type( connectedness_check_type::type::STRONG, connectedness_check_type::island_type::NONE))); bp.add_copy_constraint({intermediate_var, var(6, start_row_index, false, var::column_type::witness)}); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 2, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 2, connectedness_check_type::type::STRONG)); bp.add_lookup_gate({{0, {var(0, 1, true, var::column_type::constant)}}}); assignment.enable_selector(2, start_row_index); - BOOST_ASSERT(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 2, + BOOST_CHECK(!check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 2, connectedness_check_type::type::STRONG)); - BOOST_ASSERT(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 2, + BOOST_CHECK(check_connectedness(assignment, bp, reference_public_input, reference_output_variables, start_row_index, 2, connectedness_check_type( connectedness_check_type::type::STRONG, connectedness_check_type::island_type::NONE))); diff --git a/crypto3/libs/blueprint/test/verifiers/flexible/additions.cpp b/crypto3/libs/blueprint/test/verifiers/flexible/additions.cpp index 2e63a01c41..cc0a20dd8a 100644 --- a/crypto3/libs/blueprint/test/verifiers/flexible/additions.cpp +++ b/crypto3/libs/blueprint/test/verifiers/flexible/additions.cpp @@ -81,13 +81,13 @@ void test_flexible_addition( auto result_check = [&array](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(real_res.output.size() == ArraySize); + BOOST_CHECK(real_res.output.size() == ArraySize); for (std::size_t i = 0; i < ArraySize; i++) { if(var_value(assignment, real_res.output[i]) != (array[i].first + array[i].second)){ std::cout << "Block " << i << ": var = " << real_res.output[i] << " values = " << var_value(assignment, real_res.output[i]) << " != " << (array[i].first + array[i].second) << std::endl; } - BOOST_ASSERT(var_value(assignment, real_res.output[i]) == (array[i].first + array[i].second)); + BOOST_CHECK(var_value(assignment, real_res.output[i]) == (array[i].first + array[i].second)); } }; diff --git a/crypto3/libs/blueprint/test/verifiers/flexible/constant_pow.cpp b/crypto3/libs/blueprint/test/verifiers/flexible/constant_pow.cpp index 332ce22906..fbb96cc822 100644 --- a/crypto3/libs/blueprint/test/verifiers/flexible/constant_pow.cpp +++ b/crypto3/libs/blueprint/test/verifiers/flexible/constant_pow.cpp @@ -71,7 +71,7 @@ void test_flexible_constant_pow( auto result_check = [&x, &pow](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(var_value(assignment, real_res.y) == x.pow(pow)); + BOOST_CHECK(var_value(assignment, real_res.y) == x.pow(pow)); }; std::array witnesses; diff --git a/crypto3/libs/blueprint/test/verifiers/flexible/linear_check.cpp b/crypto3/libs/blueprint/test/verifiers/flexible/linear_check.cpp index 155a9a97b2..1412595830 100644 --- a/crypto3/libs/blueprint/test/verifiers/flexible/linear_check.cpp +++ b/crypto3/libs/blueprint/test/verifiers/flexible/linear_check.cpp @@ -108,7 +108,7 @@ void test_dfri_linear_check(const std::vector witnesses; diff --git a/crypto3/libs/blueprint/test/verifiers/flexible/multiplications.cpp b/crypto3/libs/blueprint/test/verifiers/flexible/multiplications.cpp index a90d2c47b9..6c93ca434c 100644 --- a/crypto3/libs/blueprint/test/verifiers/flexible/multiplications.cpp +++ b/crypto3/libs/blueprint/test/verifiers/flexible/multiplications.cpp @@ -81,13 +81,13 @@ void test_flexible_multiplication( auto result_check = [&array](AssignmentType &assignment, typename component_type::result_type &real_res) { - BOOST_ASSERT(real_res.output.size() == ArraySize); + BOOST_CHECK(real_res.output.size() == ArraySize); for (std::size_t i = 0; i < ArraySize; i++) { if(var_value(assignment, real_res.output[i]) != (array[i].first * array[i].second)){ std::cout << "Block " << i << ": var = " << real_res.output[i] << " values = " << var_value(assignment, real_res.output[i]) << " != " << (array[i].first * array[i].second) << std::endl; } - BOOST_ASSERT(var_value(assignment, real_res.output[i]) == (array[i].first * array[i].second)); + BOOST_CHECK(var_value(assignment, real_res.output[i]) == (array[i].first * array[i].second)); } }; diff --git a/crypto3/libs/blueprint/test/verifiers/flexible/negate.cpp b/crypto3/libs/blueprint/test/verifiers/flexible/negate.cpp index 322e2bd564..2e9f5f8e37 100644 --- a/crypto3/libs/blueprint/test/verifiers/flexible/negate.cpp +++ b/crypto3/libs/blueprint/test/verifiers/flexible/negate.cpp @@ -75,13 +75,13 @@ void test_flexible_negate(const std::vector static std::shared_ptr::preprocessed_data_type::common_data_type> load_common_data(std::string filename){ std::ifstream ifile; ifile.open(filename, std::ios_base::binary | std::ios_base::in); - BOOST_ASSERT(ifile.is_open()); + BOOST_CHECK(ifile.is_open()); std::vector v; ifile.seekg(0, std::ios_base::end); @@ -213,7 +213,7 @@ static std::shared_ptr(v.data()), fsize); - BOOST_ASSERT(ifile); + BOOST_CHECK(ifile); ifile.close(); using common_data_type = typename nil::crypto3::zk::snark::placeholder_public_preprocessor::preprocessed_data_type::common_data_type; @@ -315,7 +315,7 @@ gen_test_proof( ); std::cout <<"Proof verified" << std::endl; - BOOST_ASSERT(verification_result); + BOOST_CHECK(verification_result); return std::make_tuple(public_preprocessed_data.common_data, fri_params, proof); } @@ -352,7 +352,7 @@ void test_flexible_verifier( std::size_t value_vector_size = proof_ext.vector().size(); std::cout << "value vector size = " << value_vector_size << std::endl; std::cout << "var vector size = " << full_instance_input.vector().size() << std::endl; - BOOST_ASSERT(proof_ext.vector().size() == full_instance_input.vector().size()); + BOOST_CHECK(proof_ext.vector().size() == full_instance_input.vector().size()); std::vector public_input = proof_ext.vector(); typename component_type::input_type instance_input(full_instance_input); diff --git a/crypto3/libs/blueprint/test/zkevm_bbf/call_commit.cpp b/crypto3/libs/blueprint/test/zkevm_bbf/call_commit.cpp index b88adde7b0..d98ae324fd 100644 --- a/crypto3/libs/blueprint/test/zkevm_bbf/call_commit.cpp +++ b/crypto3/libs/blueprint/test/zkevm_bbf/call_commit.cpp @@ -75,7 +75,7 @@ class zkEVMCallCommitTestFixture: public CircuitTestFixture { bool result = test_bbf_component( "call_commit", {}, call_commit_assignment_input, max_rw, max_call_commits ); - BOOST_ASSERT(result == expected_result); + BOOST_CHECK(result == expected_result); } }; diff --git a/crypto3/libs/blueprint/test/zkevm_bbf/copy.cpp b/crypto3/libs/blueprint/test/zkevm_bbf/copy.cpp index b6ee72ddc8..506138d94e 100644 --- a/crypto3/libs/blueprint/test/zkevm_bbf/copy.cpp +++ b/crypto3/libs/blueprint/test/zkevm_bbf/copy.cpp @@ -84,7 +84,7 @@ class zkEVMCopyTestFixture: public CircuitTestFixture { bool result = test_bbf_component( "copy", {7}, copy_assignment_input, max_copy, max_rw, max_keccak_blocks, max_bytecode, max_call_commits ); - BOOST_ASSERT(result == expected_result); + BOOST_CHECK(result == expected_result); } }; diff --git a/crypto3/libs/blueprint/test/zkevm_bbf/hardhat.cpp b/crypto3/libs/blueprint/test/zkevm_bbf/hardhat.cpp index 042bf1f7e6..d58ac4defc 100644 --- a/crypto3/libs/blueprint/test/zkevm_bbf/hardhat.cpp +++ b/crypto3/libs/blueprint/test/zkevm_bbf/hardhat.cpp @@ -149,7 +149,7 @@ class zkEVMHardhatTestFixture: public CircuitTestFixture { max_exponentiations, max_bytecode ); - BOOST_ASSERT(result); + BOOST_CHECK(result); } const std::string exp_circuit = "exp"; @@ -161,7 +161,7 @@ class zkEVMHardhatTestFixture: public CircuitTestFixture { max_exp_rows, max_exponentiations ); - BOOST_ASSERT(result); + BOOST_CHECK(result); std::cout << std::endl; } @@ -175,7 +175,7 @@ class zkEVMHardhatTestFixture: public CircuitTestFixture { {7}, copy_assignment_input, max_copy, max_rw, max_keccak_blocks, max_bytecode, max_call_commits ); - BOOST_ASSERT(result); + BOOST_CHECK(result); std::cout << std::endl; } @@ -188,7 +188,7 @@ class zkEVMHardhatTestFixture: public CircuitTestFixture { keccak_circuit, {}, keccak_assignment_input,max_keccak_blocks ); - BOOST_ASSERT(result); + BOOST_CHECK(result); std::cout << std::endl; } @@ -201,7 +201,7 @@ class zkEVMHardhatTestFixture: public CircuitTestFixture { bytecode_circuit, {7}, bytecode_assignment_input, max_bytecode, max_keccak_blocks ); - BOOST_ASSERT(result); + BOOST_CHECK(result); std::cout << std::endl; } @@ -213,13 +213,13 @@ class zkEVMHardhatTestFixture: public CircuitTestFixture { result = test_bbf_component( rw_circuit, {}, rw_assignment_input, max_rw, max_mpt, max_call_commits); - BOOST_ASSERT(result); + BOOST_CHECK(result); // Max_rw, Max_mpt result = test_bbf_component( rw_circuit, {}, rw_small_field_assignment_input, max_rw, max_mpt, max_call_commits); - BOOST_ASSERT(result); + BOOST_CHECK(result); std::cout << std::endl; } @@ -232,7 +232,7 @@ class zkEVMHardhatTestFixture: public CircuitTestFixture { call_commit_circuit, {}, call_commit_assignment_input, max_rw, max_call_commits ); - BOOST_ASSERT(result); + BOOST_CHECK(result); std::cout << std::endl; } } diff --git a/crypto3/libs/blueprint/test/zkevm_bbf/rw.cpp b/crypto3/libs/blueprint/test/zkevm_bbf/rw.cpp index 39da88ff2f..4d4e569bd2 100644 --- a/crypto3/libs/blueprint/test/zkevm_bbf/rw.cpp +++ b/crypto3/libs/blueprint/test/zkevm_bbf/rw.cpp @@ -72,7 +72,7 @@ class zkEVMRWTestFixture: public CircuitTestFixture { bool result = test_bbf_component( "rw", {}, rw_assignment_input, max_rw_size, 0, max_call_commits ); - BOOST_ASSERT(result); // Max_rw, Max_mpt + BOOST_CHECK(result); // Max_rw, Max_mpt } }; diff --git a/crypto3/libs/hash/test/type_traits.cpp b/crypto3/libs/hash/test/type_traits.cpp index dd64dc70a4..131803c9ac 100644 --- a/crypto3/libs/hash/test/type_traits.cpp +++ b/crypto3/libs/hash/test/type_traits.cpp @@ -37,9 +37,9 @@ using namespace nil::crypto3::algebra; BOOST_AUTO_TEST_SUITE(hash_type_traits_manual_tests) BOOST_AUTO_TEST_CASE(test_hash_traits) { - BOOST_ASSERT(nil::crypto3::detail::has_digest_type>::value); - BOOST_ASSERT(nil::crypto3::detail::has_digest_bits>::value); - BOOST_ASSERT(nil::crypto3::detail::is_hash>::value); + BOOST_CHECK(nil::crypto3::detail::has_digest_type>::value); + BOOST_CHECK(nil::crypto3::detail::has_digest_bits>::value); + BOOST_CHECK(nil::crypto3::detail::is_hash>::value); } BOOST_AUTO_TEST_SUITE_END() diff --git a/crypto3/libs/zk/test/commitment/proof_of_work.cpp b/crypto3/libs/zk/test/commitment/proof_of_work.cpp index 9eeb73a1a3..6d33aa6315 100644 --- a/crypto3/libs/zk/test/commitment/proof_of_work.cpp +++ b/crypto3/libs/zk/test/commitment/proof_of_work.cpp @@ -56,18 +56,18 @@ BOOST_AUTO_TEST_SUITE(proof_of_work_test_suite) auto old_transcript_1 = transcript, old_transcript_2 = transcript; auto result = pow_type::generate(transcript, grinding_bits); - BOOST_ASSERT(pow_type::verify(old_transcript_1, result, grinding_bits)); + BOOST_CHECK(pow_type::verify(old_transcript_1, result, grinding_bits)); // manually reimplement verify to ensure that changes in implementation didn't break it old_transcript_2(result); auto chal = old_transcript_2.template challenge(); const integral_type expected_mask = integral_type( (1 << grinding_bits) - 1 ) << (field_type::modulus_bits - grinding_bits); - BOOST_ASSERT((integral_type(chal.to_integral()) & expected_mask) == 0); + BOOST_CHECK((integral_type(chal.to_integral()) & expected_mask) == 0); using hard_pow_type = nil::crypto3::zk::commitments::field_proof_of_work; // check that random stuff doesn't pass verify - BOOST_ASSERT(!hard_pow_type::verify(old_transcript_1, result, 9)); + BOOST_CHECK(!hard_pow_type::verify(old_transcript_1, result, 9)); } BOOST_AUTO_TEST_CASE(pow_basic_test) { @@ -82,17 +82,17 @@ BOOST_AUTO_TEST_SUITE(proof_of_work_test_suite) auto old_transcript_1 = transcript, old_transcript_2 = transcript; auto result = pow_type::generate(transcript, grinding_bits); - BOOST_ASSERT(pow_type::verify(old_transcript_1, result, grinding_bits)); + BOOST_CHECK(pow_type::verify(old_transcript_1, result, grinding_bits)); // manually reimplement verify to ensure that changes in implementation didn't break it auto bytes = pow_type::to_byte_array(result); old_transcript_2(bytes); auto chal = old_transcript_2.template int_challenge(); - BOOST_ASSERT( (chal & expected_mask) == 0); + BOOST_CHECK( (chal & expected_mask) == 0); // check that random stuff doesn't pass verify using hard_pow_type = nil::crypto3::zk::commitments::proof_of_work; - BOOST_ASSERT(!hard_pow_type::verify(old_transcript_1, result, grinding_bits)); + BOOST_CHECK(!hard_pow_type::verify(old_transcript_1, result, grinding_bits)); } BOOST_AUTO_TEST_SUITE_END() diff --git a/crypto3/libs/zk/test/systems/plonk/plonk_constraint.cpp b/crypto3/libs/zk/test/systems/plonk/plonk_constraint.cpp index 4826f08bb1..0b5f8ccf39 100644 --- a/crypto3/libs/zk/test/systems/plonk/plonk_constraint.cpp +++ b/crypto3/libs/zk/test/systems/plonk/plonk_constraint.cpp @@ -129,24 +129,24 @@ BOOST_AUTO_TEST_CASE(plonk_copy_constraint_constructor_test) { var w(0, 0, true); // copy_constraint_type copy_constraint(w0, w0); // Fails with assersion - copy_constraint_type cp0({w0, w0_1}); BOOST_ASSERT(cp0.first == w0 && cp0.second == w0_1); - copy_constraint_type cp1({w0_1, w0}); BOOST_ASSERT(cp1.first == w0 && cp1.second == w0_1); - copy_constraint_type cp2({w0, w1}); BOOST_ASSERT(cp2.first == w0 && cp2.second == w1); - copy_constraint_type cp3({w1, w0}); BOOST_ASSERT(cp3.first == w0 && cp3.second == w1); - copy_constraint_type cp4({w0_1, w1}); BOOST_ASSERT(cp4.first == w0_1 && cp4.second == w1); - copy_constraint_type cp5({w1, w0_1}); BOOST_ASSERT(cp5.first == w0_1 && cp5.second == w1); - copy_constraint_type cp6({w0, p0}); BOOST_ASSERT(cp6.first == w0 && cp6.second == p0); - copy_constraint_type cp7({p0, w0}); BOOST_ASSERT(cp7.first == w0 && cp7.second == p0); - copy_constraint_type cp8({w0, c0}); BOOST_ASSERT(cp8.first == w0 && cp8.second == c0); - copy_constraint_type cp9({c0, w0}); BOOST_ASSERT(cp9.first == w0 && cp9.second == c0); - copy_constraint_type cp10({w0, s0}); BOOST_ASSERT(cp10.first == w0 && cp10.second == s0); - copy_constraint_type cp11({s0, w0}); BOOST_ASSERT(cp11.first == w0 && cp11.second == s0); - copy_constraint_type cp12({p0, c0}); BOOST_ASSERT(cp12.first == p0 && cp12.second == c0); - copy_constraint_type cp13({c0, p0}); BOOST_ASSERT(cp13.first == p0 && cp13.second == c0); - copy_constraint_type cp14({p0, s0}); BOOST_ASSERT(cp14.first == p0 && cp14.second == s0); - copy_constraint_type cp15({s0, p0}); BOOST_ASSERT(cp15.first == p0 && cp15.second == s0); - copy_constraint_type cp16({c0, s0}); BOOST_ASSERT(cp16.first == c0 && cp16.second == s0); - copy_constraint_type cp17({s0, c0}); BOOST_ASSERT(cp17.first == c0 && cp17.second == s0); + copy_constraint_type cp0({w0, w0_1}); BOOST_CHECK(cp0.first == w0 && cp0.second == w0_1); + copy_constraint_type cp1({w0_1, w0}); BOOST_CHECK(cp1.first == w0 && cp1.second == w0_1); + copy_constraint_type cp2({w0, w1}); BOOST_CHECK(cp2.first == w0 && cp2.second == w1); + copy_constraint_type cp3({w1, w0}); BOOST_CHECK(cp3.first == w0 && cp3.second == w1); + copy_constraint_type cp4({w0_1, w1}); BOOST_CHECK(cp4.first == w0_1 && cp4.second == w1); + copy_constraint_type cp5({w1, w0_1}); BOOST_CHECK(cp5.first == w0_1 && cp5.second == w1); + copy_constraint_type cp6({w0, p0}); BOOST_CHECK(cp6.first == w0 && cp6.second == p0); + copy_constraint_type cp7({p0, w0}); BOOST_CHECK(cp7.first == w0 && cp7.second == p0); + copy_constraint_type cp8({w0, c0}); BOOST_CHECK(cp8.first == w0 && cp8.second == c0); + copy_constraint_type cp9({c0, w0}); BOOST_CHECK(cp9.first == w0 && cp9.second == c0); + copy_constraint_type cp10({w0, s0}); BOOST_CHECK(cp10.first == w0 && cp10.second == s0); + copy_constraint_type cp11({s0, w0}); BOOST_CHECK(cp11.first == w0 && cp11.second == s0); + copy_constraint_type cp12({p0, c0}); BOOST_CHECK(cp12.first == p0 && cp12.second == c0); + copy_constraint_type cp13({c0, p0}); BOOST_CHECK(cp13.first == p0 && cp13.second == c0); + copy_constraint_type cp14({p0, s0}); BOOST_CHECK(cp14.first == p0 && cp14.second == s0); + copy_constraint_type cp15({s0, p0}); BOOST_CHECK(cp15.first == p0 && cp15.second == s0); + copy_constraint_type cp16({c0, s0}); BOOST_CHECK(cp16.first == c0 && cp16.second == s0); + copy_constraint_type cp17({s0, c0}); BOOST_CHECK(cp17.first == c0 && cp17.second == s0); // copy_constraint_type cp18({w0, w}); // Fails with assertion } diff --git a/parallel-crypto3/libs/parallel-zk/test/commitment/proof_of_work.cpp b/parallel-crypto3/libs/parallel-zk/test/commitment/proof_of_work.cpp index 50bc876c3d..048239edec 100644 --- a/parallel-crypto3/libs/parallel-zk/test/commitment/proof_of_work.cpp +++ b/parallel-crypto3/libs/parallel-zk/test/commitment/proof_of_work.cpp @@ -56,18 +56,18 @@ BOOST_AUTO_TEST_SUITE(proof_of_knowledge_test_suite) auto old_transcript_1 = transcript, old_transcript_2 = transcript; auto result = pow_type::generate(transcript, grinding_bits); - BOOST_ASSERT(pow_type::verify(old_transcript_1, result, grinding_bits)); + BOOST_CHECK(pow_type::verify(old_transcript_1, result, grinding_bits)); // manually reimplement verify to ensure that changes in implementation didn't break it old_transcript_2(result); auto chal = old_transcript_2.template challenge(); const integral_type expected_mask = integral_type( (1 << grinding_bits) - 1 ) << (field_type::modulus_bits - grinding_bits); - BOOST_ASSERT((integral_type(chal.to_integral()) & expected_mask) == 0); + BOOST_CHECK((integral_type(chal.to_integral()) & expected_mask) == 0); using hard_pow_type = nil::crypto3::zk::commitments::field_proof_of_work; // check that random stuff doesn't pass verify - BOOST_ASSERT(!hard_pow_type::verify(old_transcript_1, result, 9)); + BOOST_CHECK(!hard_pow_type::verify(old_transcript_1, result, 9)); } BOOST_AUTO_TEST_CASE(pow_basic_test) { @@ -82,17 +82,17 @@ BOOST_AUTO_TEST_SUITE(proof_of_knowledge_test_suite) auto old_transcript_1 = transcript, old_transcript_2 = transcript; auto result = pow_type::generate(transcript, grinding_bits); - BOOST_ASSERT(pow_type::verify(old_transcript_1, result, grinding_bits)); + BOOST_CHECK(pow_type::verify(old_transcript_1, result, grinding_bits)); // manually reimplement verify to ensure that changes in implementation didn't break it auto bytes = pow_type::to_byte_array(result); old_transcript_2(bytes); auto chal = old_transcript_2.template int_challenge(); - BOOST_ASSERT( (chal & expected_mask) == 0); + BOOST_CHECK( (chal & expected_mask) == 0); // check that random stuff doesn't pass verify using hard_pow_type = nil::crypto3::zk::commitments::proof_of_work; - BOOST_ASSERT(!hard_pow_type::verify(old_transcript_1, result, grinding_bits)); + BOOST_CHECK(!hard_pow_type::verify(old_transcript_1, result, grinding_bits)); } BOOST_AUTO_TEST_SUITE_END() diff --git a/parallel-crypto3/libs/parallel-zk/test/math/expression_generator.hpp b/parallel-crypto3/libs/parallel-zk/test/math/expression_generator.hpp index 541f7f3f57..0b7a7de580 100644 --- a/parallel-crypto3/libs/parallel-zk/test/math/expression_generator.hpp +++ b/parallel-crypto3/libs/parallel-zk/test/math/expression_generator.hpp @@ -91,7 +91,7 @@ expression generate_random_constraint( linear_comb += engine(); return linear_comb; } else { - BOOST_ASSERT_MSG(false, "max_degree must be > 0"); + BOOST_CHECK_MESSAGE(false, "max_degree must be > 0"); } __builtin_unreachable(); } diff --git a/parallel-crypto3/libs/parallel-zk/test/systems/plonk/plonk_constraint.cpp b/parallel-crypto3/libs/parallel-zk/test/systems/plonk/plonk_constraint.cpp index 3daf16d766..b3deb8cb52 100644 --- a/parallel-crypto3/libs/parallel-zk/test/systems/plonk/plonk_constraint.cpp +++ b/parallel-crypto3/libs/parallel-zk/test/systems/plonk/plonk_constraint.cpp @@ -124,24 +124,24 @@ BOOST_AUTO_TEST_CASE(plonk_copy_constraint_constructor_test) { var w(0, 0, true); // copy_constraint_type copy_constraint(w0, w0); // Fails with assersion - copy_constraint_type cp0({w0, w0_1}); BOOST_ASSERT(cp0.first == w0 && cp0.second == w0_1); - copy_constraint_type cp1({w0_1, w0}); BOOST_ASSERT(cp1.first == w0 && cp1.second == w0_1); - copy_constraint_type cp2({w0, w1}); BOOST_ASSERT(cp2.first == w0 && cp2.second == w1); - copy_constraint_type cp3({w1, w0}); BOOST_ASSERT(cp3.first == w0 && cp3.second == w1); - copy_constraint_type cp4({w0_1, w1}); BOOST_ASSERT(cp4.first == w0_1 && cp4.second == w1); - copy_constraint_type cp5({w1, w0_1}); BOOST_ASSERT(cp5.first == w0_1 && cp5.second == w1); - copy_constraint_type cp6({w0, p0}); BOOST_ASSERT(cp6.first == w0 && cp6.second == p0); - copy_constraint_type cp7({p0, w0}); BOOST_ASSERT(cp7.first == w0 && cp7.second == p0); - copy_constraint_type cp8({w0, c0}); BOOST_ASSERT(cp8.first == w0 && cp8.second == c0); - copy_constraint_type cp9({c0, w0}); BOOST_ASSERT(cp9.first == w0 && cp9.second == c0); - copy_constraint_type cp10({w0, s0}); BOOST_ASSERT(cp10.first == w0 && cp10.second == s0); - copy_constraint_type cp11({s0, w0}); BOOST_ASSERT(cp11.first == w0 && cp11.second == s0); - copy_constraint_type cp12({p0, c0}); BOOST_ASSERT(cp12.first == p0 && cp12.second == c0); - copy_constraint_type cp13({c0, p0}); BOOST_ASSERT(cp13.first == p0 && cp13.second == c0); - copy_constraint_type cp14({p0, s0}); BOOST_ASSERT(cp14.first == p0 && cp14.second == s0); - copy_constraint_type cp15({s0, p0}); BOOST_ASSERT(cp15.first == p0 && cp15.second == s0); - copy_constraint_type cp16({c0, s0}); BOOST_ASSERT(cp16.first == c0 && cp16.second == s0); - copy_constraint_type cp17({s0, c0}); BOOST_ASSERT(cp17.first == c0 && cp17.second == s0); + copy_constraint_type cp0({w0, w0_1}); BOOST_CHECK(cp0.first == w0 && cp0.second == w0_1); + copy_constraint_type cp1({w0_1, w0}); BOOST_CHECK(cp1.first == w0 && cp1.second == w0_1); + copy_constraint_type cp2({w0, w1}); BOOST_CHECK(cp2.first == w0 && cp2.second == w1); + copy_constraint_type cp3({w1, w0}); BOOST_CHECK(cp3.first == w0 && cp3.second == w1); + copy_constraint_type cp4({w0_1, w1}); BOOST_CHECK(cp4.first == w0_1 && cp4.second == w1); + copy_constraint_type cp5({w1, w0_1}); BOOST_CHECK(cp5.first == w0_1 && cp5.second == w1); + copy_constraint_type cp6({w0, p0}); BOOST_CHECK(cp6.first == w0 && cp6.second == p0); + copy_constraint_type cp7({p0, w0}); BOOST_CHECK(cp7.first == w0 && cp7.second == p0); + copy_constraint_type cp8({w0, c0}); BOOST_CHECK(cp8.first == w0 && cp8.second == c0); + copy_constraint_type cp9({c0, w0}); BOOST_CHECK(cp9.first == w0 && cp9.second == c0); + copy_constraint_type cp10({w0, s0}); BOOST_CHECK(cp10.first == w0 && cp10.second == s0); + copy_constraint_type cp11({s0, w0}); BOOST_CHECK(cp11.first == w0 && cp11.second == s0); + copy_constraint_type cp12({p0, c0}); BOOST_CHECK(cp12.first == p0 && cp12.second == c0); + copy_constraint_type cp13({c0, p0}); BOOST_CHECK(cp13.first == p0 && cp13.second == c0); + copy_constraint_type cp14({p0, s0}); BOOST_CHECK(cp14.first == p0 && cp14.second == s0); + copy_constraint_type cp15({s0, p0}); BOOST_CHECK(cp15.first == p0 && cp15.second == s0); + copy_constraint_type cp16({c0, s0}); BOOST_CHECK(cp16.first == c0 && cp16.second == s0); + copy_constraint_type cp17({s0, c0}); BOOST_CHECK(cp17.first == c0 && cp17.second == s0); // copy_constraint_type cp18({w0, w}); // Fails with assertion }