field_conversion.test.cpp

Go to the documentation of this file.

#include "barretenberg/stdlib/primitives/field/field_conversion.hpp"
#include "barretenberg/circuit_checker/circuit_checker.hpp"
#include "barretenberg/common/zip_view.hpp"
#include "barretenberg/stdlib/primitives/test_utils.hpp"
#include <gtest/gtest.h>
 
using bb::stdlib::test_utils::check_circuit_and_gate_count;
 
namespace bb::stdlib::field_conversion_tests {
 
template <typename Builder> using fr = field_t<Builder>;
template <typename Builder> using fq = bigfield<Builder, bb::Bn254FqParams>;
template <typename Builder> using bn254_element = element<Builder, fq<Builder>, fr<Builder>, curve::BN254::Group>;
template <typename Builder> using grumpkin_element = cycle_group<Builder>;
 
template <typename Builder> class stdlib_field_conversion : public ::testing::Test {
  public:
    using Codec = StdlibCodec<field_t<Builder>>;
 
    template <typename T, typename CreateFn>
    void check_deserialization_gate_count(CreateFn create_native, uint32_t expected_gates, size_t num_elements = 1)
    {
        using NativeCodec = FrCodec;
        Builder builder;
 
        for (size_t i = 0; i < num_elements; ++i) {
            // Create native value and serialize
            auto native_value = create_native();
            auto native_fields = NativeCodec::serialize_to_fields(native_value);
 
            // Create witnesses from "proof data"
            std::vector<field_t<Builder>> witness_fields;
            for (const auto& f : native_fields) {
                witness_fields.push_back(field_t<Builder>::from_witness(&builder, f));
            }
 
            // Deserialize in circuit
            [[maybe_unused]] auto deserialized = Codec::template deserialize_from_fields<T>(witness_fields);
        }
 
        check_circuit_and_gate_count(builder, expected_gates);
    }
 
    // Serialize and deserialize
    template <typename T> void check_conversion(T in, bool valid_circuit = true)
    {
        size_t len = Codec::template calc_num_fields<T>();
        auto frs = Codec::serialize_to_fields(in);
        EXPECT_EQ(len, frs.size());
        auto out = Codec::template deserialize_from_fields<T>(frs);
 
        EXPECT_EQ(in.get_value(), out.get_value());
 
        auto ctx = in.get_context();
 
        EXPECT_EQ(CircuitChecker::check(*ctx), valid_circuit);
    }
 
    template <typename T> void check_conversion_iterable(T x)
    {
        size_t len = Codec::template calc_num_fields<T>();
        auto frs = Codec::template serialize_to_fields<T>(x);
        EXPECT_EQ(len, frs.size());
        auto y = Codec::template deserialize_from_fields<T>(frs);
        EXPECT_EQ(x.size(), y.size());
        for (auto [val1, val2] : zip_view(x, y)) {
            EXPECT_EQ(val1.get_value(), val2.get_value());
        }
    }
};
 
using BuilderTypes = testing::Types<UltraCircuitBuilder, MegaCircuitBuilder>;
 
TYPED_TEST_SUITE(stdlib_field_conversion, BuilderTypes);
 
TYPED_TEST(stdlib_field_conversion, FieldConversionFr)
{
    using Builder = TypeParam;
    Builder builder;
    bb::fr field_element_val(
        std::string("9a807b615c4d3e2fa0b1c2d3e4f56789fedcba9876543210abcdef0123456789")); // 256 bits
    fr<Builder> field_element(&builder, field_element_val);
    this->check_conversion(field_element);
 
    field_element_val = bb::fr::modulus_minus_two; // modulus - 2
    field_element = fr<Builder>(&builder, field_element_val);
    this->check_conversion(field_element);
 
    field_element_val = bb::fr(1);
    field_element = fr<Builder>(&builder, field_element_val);
    this->check_conversion(field_element);
}
 
TYPED_TEST(stdlib_field_conversion, FieldConversionGrumpkinFr)
{
    using Builder = TypeParam;
    Builder builder;
 
    // Constructing bigfield objects with bb::fq values
    bb::fq field_element_val(
        std::string("9a807b615c4d3e2fa0b1c2d3e4f56789fedcba9876543210abcdef0123456789")); // 256 bits
    this->check_conversion(fq<Builder>::from_witness(&builder, field_element_val));
}
 
TYPED_TEST(stdlib_field_conversion, ConvertShortChallenge)
{
    using Builder = TypeParam;
    using Codec = StdlibCodec<field_t<Builder>>;
    constexpr size_t SHORT_BITS = 2 * fq<Builder>::NUM_LIMB_BITS;
    const uint256_t raw(std::string("9a807b615c4d3e2fa0b1c2d3e4f56789fedcba9876543210abcdef0123456789"));
 
    Builder builder;
    const uint256_t val = raw.slice(0, SHORT_BITS);
    const auto chal = fr<Builder>::from_witness(&builder, bb::fr(val));
 
    EXPECT_EQ(uint256_t(Codec::template convert_short_challenge<fr<Builder>>(chal).get_value()), val);
    EXPECT_EQ(Codec::template convert_short_challenge<fq<Builder>>(chal).get_value(), uint512_t(val));
    EXPECT_TRUE(CircuitChecker::check(builder));
}
 
TYPED_TEST(stdlib_field_conversion, ConvertFullChallenge)
{
    using Builder = TypeParam;
    using Codec = StdlibCodec<field_t<Builder>>;
 
    Builder builder;
    const bb::fr val = bb::fr::random_element();
    const auto chal = fr<Builder>::from_witness(&builder, val);
 
    EXPECT_EQ(uint256_t(Codec::template convert_full_challenge<fr<Builder>>(chal).get_value()), uint256_t(val));
    EXPECT_EQ(Codec::template convert_full_challenge<fq<Builder>>(chal).get_value(), uint512_t(uint256_t(val)));
    EXPECT_TRUE(CircuitChecker::check(builder));
}
 
TYPED_TEST(stdlib_field_conversion, FieldConversionBN254AffineElement)
{
    using Builder = TypeParam;
    { // Serialize and deserialize the bn254 generator
        Builder builder;
 
        bn254_element<Builder> group_element =
            bn254_element<Builder>::from_witness(&builder, curve::BN254::AffineElement::one());
        this->check_conversion(group_element);
    }
    { // Serialize and deserialize a valid bn254 point
        Builder builder;
 
        curve::BN254::AffineElement group_element_val(1, bb::fq::modulus_minus_two);
        bn254_element<Builder> group_element = bn254_element<Builder>::from_witness(&builder, group_element_val);
        this->check_conversion(group_element);
    }
 
    { // Serialize and deserialize random Grumpkin points
        Builder builder;
        const size_t num_points = 50;
        const curve::BN254::AffineElement native_generator = curve::BN254::AffineElement::one();
 
        for (size_t i = 0; i < num_points; i++) {
            bb::fr random_scalar = bb::fr::random_element();
            bn254_element<Builder> group_element =
                bn254_element<Builder>::from_witness(&builder, native_generator * random_scalar);
            this->check_conversion(group_element);
        }
    }
    { // Serialize and deserialize the point at infinity (canonical (0,0) form)
        Builder builder;
 
        bn254_element<Builder> group_element =
            bn254_element<Builder>::from_witness(&builder, curve::BN254::AffineElement::infinity());
        this->check_conversion(group_element);
    }
 
    { // Serialize and deserialize "coordinates" that do not correspond to any point on the curve
        Builder builder;
 
        curve::BN254::AffineElement group_element_val(1, 4);
        bn254_element<Builder> group_element;
        if constexpr (IsAnyOf<Builder, UltraCircuitBuilder>) {
            EXPECT_THROW_WITH_MESSAGE(group_element = bn254_element<Builder>::from_witness(&builder, group_element_val),
                                      "");
        } else {
            group_element = bn254_element<Builder>::from_witness(&builder, group_element_val);
            this->check_conversion(group_element);
        }
    }
}
 
TYPED_TEST(stdlib_field_conversion, FieldConversionGrumpkinAffineElement)
{
    using Builder = TypeParam;
 
    { // Serialize and deserialize the Grumpkin generator
        Builder builder;
        grumpkin_element<Builder> group_element =
            grumpkin_element<Builder>::from_witness(&builder, curve::Grumpkin::AffineElement::one());
        this->check_conversion(group_element);
    }
    { // Serialize and deserialize random Grumpkin points
        Builder builder;
        const size_t num_points = 50;
        const curve::Grumpkin::AffineElement native_generator = curve::Grumpkin::AffineElement::one();
 
        for (size_t i = 0; i < num_points; i++) {
            bb::fq random_scalar = bb::fq::random_element();
            grumpkin_element<Builder> group_element =
                grumpkin_element<Builder>::from_witness(&builder, native_generator * random_scalar);
            this->check_conversion(group_element);
        }
    }
 
    { // Serialize and deserialize "coordinates" that do not correspond to any point on the curve
        BB_DISABLE_ASSERTS(); // Avoid on_curve assertion failure in cycle_group constructor
        Builder builder;
 
        curve::Grumpkin::AffineElement group_element_val(12, 100);
        grumpkin_element<Builder> group_element = grumpkin_element<Builder>::from_witness(&builder, group_element_val);
        this->check_conversion(group_element, /* valid circuit */ false);
    }
 
    { // Serialize and deserialize the point at infinity
        Builder builder;
 
        // from_witness handles infinity: coordinates are set to (0,0), and the 2-arg constructor
        // auto-detects infinity from x^2 + 5*y^2 == 0.
        grumpkin_element<Builder> group_element =
            grumpkin_element<Builder>::from_witness(&builder, curve::Grumpkin::AffineElement::infinity());
        this->check_conversion(group_element);
    }
}
 
TYPED_TEST(stdlib_field_conversion, DeserializePointAtInfinity)
{
    using Builder = TypeParam;
    using Codec = StdlibCodec<field_t<Builder>>;
    Builder builder;
    const fr<Builder> zero(fr<Builder>::from_witness_index(&builder, builder.zero_idx()));
 
    {
        std::vector<fr<Builder>> zeros(4, zero);
 
        bn254_element<Builder> point_at_infinity =
            Codec::template deserialize_from_fields<bn254_element<Builder>>(zeros);
 
        EXPECT_TRUE(point_at_infinity.get_value().is_point_at_infinity());
        EXPECT_TRUE(CircuitChecker::check(builder));
    }
    {
        std::vector<fr<Builder>> zeros(2, zero);
 
        grumpkin_element<Builder> point_at_infinity =
            Codec::template deserialize_from_fields<grumpkin_element<Builder>>(zeros);
 
        EXPECT_TRUE(point_at_infinity.get_value().is_point_at_infinity());
        EXPECT_TRUE(CircuitChecker::check(builder));
    }
}
 
TYPED_TEST(stdlib_field_conversion, FieldConversionArrayBn254Fr)
{
    using Builder = TypeParam;
    Builder builder;
 
    // Constructing std::array objects with fr<Builder> values
    std::array<fr<Builder>, 4> array_of_frs_4{
        fr<Builder>(&builder, 1), fr<Builder>(&builder, 2), fr<Builder>(&builder, 3), fr<Builder>(&builder, 4)
    };
    this->check_conversion_iterable(array_of_frs_4);
 
    std::array<fr<Builder>, 7> array_of_frs_7{ fr<Builder>(&builder, bb::fr::modulus_minus_two),
                                               fr<Builder>(&builder, bb::fr::modulus_minus_two - 123),
                                               fr<Builder>(&builder, 215215125),
                                               fr<Builder>(&builder, 102701750),
                                               fr<Builder>(&builder, 367032),
                                               fr<Builder>(&builder, 12985028),
                                               fr<Builder>(&builder, bb::fr::modulus_minus_two - 125015028) };
    this->check_conversion_iterable(array_of_frs_7);
}
 
TYPED_TEST(stdlib_field_conversion, FieldConversionArrayGrumpkinFr)
{
    using Builder = TypeParam;
    Builder builder;
 
    // Constructing std::array objects with fq<Builder> values
    std::array<fq<Builder>, 4> array_of_fqs_4{
        fq<Builder>::from_witness(
            &builder,
            static_cast<bb::fq>(std::string("9a807b615c4d3e2fa0b1c2d3e4f56789fedcba9876543210abcdef0123456789"))),
        fq<Builder>::from_witness(
            &builder,
            static_cast<bb::fq>(std::string("2bf1eaf87f7d27e8dc4056e9af975985bccc89077a21891d6c7b6ccce0631f95"))),
        fq<Builder>::from_witness(
            &builder,
            static_cast<bb::fq>(std::string("9a807b615c4d3e2fa0b1c2d3e4f56789fedcba9876543210abcdef0123456789"))),
        fq<Builder>::from_witness(
            &builder,
            static_cast<bb::fq>(std::string("018555a8eb50cf07f64b019ebaf3af3c925c93e631f3ecd455db07bbb52bbdd3"))),
    };
    this->check_conversion_iterable(array_of_fqs_4);
}
 
TYPED_TEST(stdlib_field_conversion, FieldConversionUnivariateBn254Fr)
{
    using Builder = TypeParam;
    Builder builder;
 
    // Constructing Univariate objects with fr<Builder> values
    Univariate<fr<Builder>, 4> univariate{
        { fr<Builder>(&builder, 1), fr<Builder>(&builder, 2), fr<Builder>(&builder, 3), fr<Builder>(&builder, 4) }
    };
    this->check_conversion_iterable(univariate);
}
 
TYPED_TEST(stdlib_field_conversion, FieldConversionUnivariateGrumpkinFr)
{
    using Builder = TypeParam;
    Builder builder;
 
    // Constructing std::array objects with fq<Builder> values
    Univariate<fq<Builder>, 4> univariate{
        { fq<Builder>::from_witness(
              &builder,
              static_cast<bb::fq>(std::string("9a807b615c4d3e2fa0b1c2d3e4f56789fedcba9876543210abcdef0123456789"))),
          fq<Builder>::from_witness(
              &builder,
              static_cast<bb::fq>(std::string("2bf1eaf87f7d27e8dc4056e9af975985bccc89077a21891d6c7b6ccce0631f95"))),
          fq<Builder>::from_witness(
              &builder,
              static_cast<bb::fq>(std::string("018555a8eb50cf07f64b019ebaf3af3c925c93e631f3ecd455db07bbb52bbdd3"))),
          fq<Builder>::from_witness(
              &builder,
              static_cast<bb::fq>(std::string("2bf1eaf87f7d27e8dc4056e9af975985bccc89077a21891d6c7b6ccce0631f95"))) }
    };
    this->check_conversion_iterable(univariate);
}
 
// ============================================================================
// Gate Count Tests for Deserialization Operations
// ============================================================================
 
TYPED_TEST(stdlib_field_conversion, GateCountScalarDeserialization)
{
    // Scalar deserialization adds no gates (just witness creation)
    this->template check_deserialization_gate_count<fr<TypeParam>>([] { return bb::fr::random_element(); }, 0);
}
 
TYPED_TEST(stdlib_field_conversion, GateCountBigfieldDeserialization)
{
    // Deserializing a single bigfield element is expensive due to creating new ranges for range constraints
    this->template check_deserialization_gate_count<fq<TypeParam>>([] { return bb::fq::random_element(); }, 3513);
}
 
TYPED_TEST(stdlib_field_conversion, GateCountMultipleBigfieldDeserialization)
{
    this->template check_deserialization_gate_count<fq<TypeParam>>([] { return bb::fq::random_element(); }, 3913, 10);
}
 
TYPED_TEST(stdlib_field_conversion, GateCountBN254PointDeserialization)
{
    using Builder = TypeParam;
    // Ultra: full bigfield construction + on-curve validation + assert_is_in_field for x and y
    // Mega: no in-circuit checks; range constraint and on_curve validation deferred to ECCVM and Translator
    constexpr uint32_t expected = std::is_same_v<Builder, bb::UltraCircuitBuilder> ? 3865 : 0;
    this->template check_deserialization_gate_count<bn254_element<Builder>>(
        [] { return curve::BN254::AffineElement::random_element(); }, expected);
}
 
TYPED_TEST(stdlib_field_conversion, GateCountMultipleBN254PointDeserialization)
{
    using Builder = TypeParam;
 
    constexpr uint32_t expected = std::is_same_v<Builder, bb::UltraCircuitBuilder> ? 5746 : 0;
    this->template check_deserialization_gate_count<bn254_element<Builder>>(
        [] { return curve::BN254::AffineElement::random_element(); }, expected, 10);
}
 
TYPED_TEST(stdlib_field_conversion, GateCountGrumpkinPointDeserialization)
{
    this->template check_deserialization_gate_count<grumpkin_element<TypeParam>>(
        [] { return curve::Grumpkin::AffineElement::random_element(); }, 10);
}
 
TYPED_TEST(stdlib_field_conversion, GateCountArrayDeserialization)
{
    constexpr size_t SIZE = 8;
    this->template check_deserialization_gate_count<std::array<fr<TypeParam>, SIZE>>(
        [] {
            std::array<bb::fr, SIZE> arr;
            for (size_t i = 0; i < SIZE; ++i) {
                arr[i] = bb::fr::random_element();
            }
            return arr;
        },
        0);
}
 
TYPED_TEST(stdlib_field_conversion, GateCountUnivariateDeserialization)
{
    constexpr size_t LENGTH = 8;
    this->template check_deserialization_gate_count<Univariate<fr<TypeParam>, LENGTH>>(
        [] {
            std::array<bb::fr, LENGTH> evals;
            for (size_t i = 0; i < LENGTH; ++i) {
                evals[i] = bb::fr::random_element();
            }
            return Univariate<bb::fr, LENGTH>(evals);
        },
        0);
}
 
TYPED_TEST(stdlib_field_conversion, BigfieldDeserializationFailsOnLimbOverflow)
{
    using Builder = TypeParam;
    using Codec = StdlibCodec<field_t<Builder>>;
 
    bb::fr low_limb = bb::fr(0);
    // 2^136 placed in high_limb position far exceeds the 2^118 bound for high limbs
    bb::fr high_limb = bb::fr(uint256_t(1) << (2 * fq<Builder>::NUM_LIMB_BITS));
 
    // Test 1: Native codec should reject via BB_ASSERT (asserts enabled)
    {
        std::vector<bb::fr> native_fields = { low_limb, high_limb };
        EXPECT_THROW(FrCodec::deserialize_from_fields<bb::fq>(native_fields), std::runtime_error);
    }
 
    // Test 2: Circuit codec should reject via circuit constraints (disable asserts to bypass bigfield constructor
    // checks)
    {
        BB_DISABLE_ASSERTS();
        Builder builder;
        std::vector<field_t<Builder>> circuit_fields = { field_t<Builder>::from_witness(&builder, low_limb),
                                                         field_t<Builder>::from_witness(&builder, high_limb) };
 
        // Deserialize as bigfield - this creates the bigfield from the two limbs
        [[maybe_unused]] auto bigfield_val = Codec::template deserialize_from_fields<fq<Builder>>(circuit_fields);
 
        // Circuit should fail validation
        EXPECT_FALSE(CircuitChecker::check(builder));
    }
}
 
// ============================================================================
// Codec Consistency Tests: Verify FrCodec and StdlibCodec behave identically
// ============================================================================
 
TYPED_TEST(stdlib_field_conversion, BothCodecsRejectPointAtInfinityAlias)
{
    using Builder = TypeParam;
    using Codec = StdlibCodec<field_t<Builder>>;
    using fq = bigfield<Builder, bb::Bn254FqParams>;
    using bn254_element = element<Builder, fq, field_t<Builder>, curve::BN254::Group>;
 
    constexpr uint64_t NUM_LIMB_BITS = 68;
    const uint256_t modulus = bb::fq::modulus;
 
    // Create alias coordinates: x = modulus, y = modulus
    const uint256_t x_lo = modulus & ((uint256_t(1) << (NUM_LIMB_BITS * 2)) - 1);
    const uint256_t x_hi = modulus >> (NUM_LIMB_BITS * 2);
 
    // Test 1: Native codec rejects via on_curve check
    {
        std::vector<bb::fr> native_fields = { bb::fr(x_lo), bb::fr(x_hi), bb::fr(x_lo), bb::fr(x_hi) };
        EXPECT_THROW(FrCodec::deserialize_from_fields<curve::BN254::AffineElement>(native_fields), std::runtime_error);
    }
 
    // Test 2: Circuit codec rejects (Ultra only - Mega delegates on-curve check to ECCVM)
    if constexpr (IsAnyOf<Builder, UltraCircuitBuilder>) {
        BB_DISABLE_ASSERTS();
        Builder builder;
        std::vector<field_t<Builder>> circuit_fields = { field_t<Builder>::from_witness(&builder, bb::fr(x_lo)),
                                                         field_t<Builder>::from_witness(&builder, bb::fr(x_hi)),
                                                         field_t<Builder>::from_witness(&builder, bb::fr(x_lo)),
                                                         field_t<Builder>::from_witness(&builder, bb::fr(x_hi)) };
        [[maybe_unused]] auto point = Codec::template deserialize_from_fields<bn254_element>(circuit_fields);
        EXPECT_FALSE(CircuitChecker::check(builder));
    }
}
 
TYPED_TEST(stdlib_field_conversion, BothCodecsAcceptCanonicalRejectAlias)
{
    using Builder = TypeParam;
    using Codec = StdlibCodec<field_t<Builder>>;
    using fq_ct = bigfield<Builder, bb::Bn254FqParams>;
 
    constexpr uint64_t NUM_LIMB_BITS = 68;
    constexpr uint64_t LOW_BITS = NUM_LIMB_BITS * 2; // 136
    const uint256_t LOW_MASK = (uint256_t(1) << LOW_BITS) - 1;
 
    auto split_to_limbs = [&](const uint256_t& value) -> std::pair<uint256_t, uint256_t> {
        return { value & LOW_MASK, value >> LOW_BITS };
    };
 
    // Test 1: q - 1 is accepted (max canonical value)
    {
        const uint256_t value = bb::fq::modulus - 1;
        const auto [low_limb, high_limb] = split_to_limbs(value);
 
        // Native codec: accepts
        std::vector<bb::fr> native_fields = { bb::fr(low_limb), bb::fr(high_limb) };
        auto native_result = FrCodec::deserialize_from_fields<bb::fq>(native_fields);
        EXPECT_EQ(uint256_t(native_result), value);
 
        // Circuit codec: accepts
        Builder builder;
        std::vector<field_t<Builder>> circuit_fields = { field_t<Builder>::from_witness(&builder, bb::fr(low_limb)),
                                                         field_t<Builder>::from_witness(&builder, bb::fr(high_limb)) };
        [[maybe_unused]] auto circuit_result = Codec::template deserialize_from_fields<fq_ct>(circuit_fields);
        EXPECT_TRUE(CircuitChecker::check(builder));
    }
 
    // Test 2: q is rejected (smallest alias)
    {
        const uint256_t value = bb::fq::modulus;
        const auto [low_limb, high_limb] = split_to_limbs(value);
 
        // Native codec: rejects
        std::vector<bb::fr> native_fields = { bb::fr(low_limb), bb::fr(high_limb) };
        EXPECT_THROW(FrCodec::deserialize_from_fields<bb::fq>(native_fields), std::runtime_error);
 
        // Circuit codec: rejects via assert_is_in_field
        {
            BB_DISABLE_ASSERTS();
            Builder builder;
            std::vector<field_t<Builder>> circuit_fields = { field_t<Builder>::from_witness(&builder, bb::fr(low_limb)),
                                                             field_t<Builder>::from_witness(&builder,
                                                                                            bb::fr(high_limb)) };
            [[maybe_unused]] auto circuit_result = Codec::template deserialize_from_fields<fq_ct>(circuit_fields);
            EXPECT_FALSE(CircuitChecker::check(builder));
        }
    }
 
    // Test 3: Large value between q and 2^254 is rejected
    {
        const uint256_t value = (uint256_t(1) << 254) - 1; // 2^254 - 1, well above modulus
        const auto [low_limb, high_limb] = split_to_limbs(value);
 
        // Verify this is indeed between modulus and 2^254
        EXPECT_GT(value, bb::fq::modulus);
        EXPECT_LT(value, uint256_t(1) << 254);
 
        // Native codec: rejects
        std::vector<bb::fr> native_fields = { bb::fr(low_limb), bb::fr(high_limb) };
        EXPECT_THROW(FrCodec::deserialize_from_fields<bb::fq>(native_fields), std::runtime_error);
 
        // Circuit codec: rejects via assert_is_in_field
        {
            BB_DISABLE_ASSERTS();
            Builder builder;
            std::vector<field_t<Builder>> circuit_fields = { field_t<Builder>::from_witness(&builder, bb::fr(low_limb)),
                                                             field_t<Builder>::from_witness(&builder,
                                                                                            bb::fr(high_limb)) };
            [[maybe_unused]] auto circuit_result = Codec::template deserialize_from_fields<fq_ct>(circuit_fields);
            EXPECT_FALSE(CircuitChecker::check(builder));
        }
    }
}
 
} // namespace bb::stdlib::field_conversion_tests