standard_affine_point.test.cpp

Go to the documentation of this file.

#include <gtest/gtest.h>
 
#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
#include "barretenberg/vm2/common/standard_affine_point.hpp"
 
namespace bb::avm2 {
namespace {
 
using EmbeddedCurvePoint = StandardAffinePoint<grumpkin::g1::affine_element>;
using Fr = grumpkin::fr;
using Fq = grumpkin::fq;
 
TEST(StandardAffinePointTest, InfinityPreservesRawCoordinates)
{
    // When constructing an infinity point with non-zero coordinates,
    // x() and y() should return the raw coordinates
    Fq raw_x = 1;
    Fq raw_y = 2;
 
    EmbeddedCurvePoint point(raw_x, raw_y, /*is_infinity=*/true);
 
    EXPECT_TRUE(point.is_infinity());
    EXPECT_EQ(point.x(), raw_x);
    EXPECT_EQ(point.y(), raw_y);
}
 
TEST(StandardAffinePointTest, NormalPointCoordinates)
{
    // Normal (non-infinity) points should return their coordinates
    auto one = EmbeddedCurvePoint::one();
    EXPECT_FALSE(one.is_infinity());
    EXPECT_FALSE(one.x().is_zero());
    EXPECT_FALSE(one.y().is_zero());
}
 
TEST(StandardAffinePointTest, AdditionResultingInInfinityNormalized)
{
    // When addition produces infinity, result should have (0,0) coordinates
    auto p = EmbeddedCurvePoint::one();
    auto neg_p = -p;
 
    auto inf_result = p + neg_p;
 
    EXPECT_TRUE(inf_result.is_infinity());
    EXPECT_TRUE(inf_result.x().is_zero());
    EXPECT_TRUE(inf_result.y().is_zero());
}
 
TEST(StandardAffinePointTest, SubtractingInfinityNormalized)
{
    // Subtracting a point from itself should yield infinity with (0,0) coordinates
    auto p = EmbeddedCurvePoint::one();
    auto inf = EmbeddedCurvePoint::infinity();
 
    auto result = p + (-inf);
 
    EXPECT_EQ(result, p);
}
 
TEST(StandardAffinePointTest, ScalarMultiplicationResultingInInfinityNormalized)
{
    // When scalar multiplication produces infinity, result should have (0,0) coordinates
    auto p = EmbeddedCurvePoint::one();
    Fr zero_scalar = Fr::zero();
 
    auto inf_result = p * zero_scalar;
 
    EXPECT_TRUE(inf_result.is_infinity());
    EXPECT_TRUE(inf_result.x().is_zero());
    EXPECT_TRUE(inf_result.y().is_zero());
}
 
TEST(StandardAffinePointTest, StaticInfinityHasZeroCoordinates)
{
    // The static infinity() method should return (0,0,true)
    auto& inf = EmbeddedCurvePoint::infinity();
 
    EXPECT_TRUE(inf.is_infinity());
    EXPECT_TRUE(inf.x().is_zero());
    EXPECT_TRUE(inf.y().is_zero());
}
 
TEST(StandardAffinePointTest, NegatingInfinityPreservesRawCoordinates)
{
    // Negating an infinity point should preserve its raw coordinates
    Fq raw_x = 1;
    Fq raw_y = 2;
    EmbeddedCurvePoint inf(raw_x, raw_y, /*is_infinity=*/true);
 
    auto neg_inf = -inf;
 
    EXPECT_TRUE(neg_inf.is_infinity());
    EXPECT_EQ(neg_inf.x(), raw_x);
    EXPECT_EQ(neg_inf.y(), raw_y);
}
 
} // namespace
} // namespace bb::avm2