1use ark_ff::{
  2    biginteger::{BigInt, BigInteger, BigInteger256},
  3    fields::{
  4        fp6_3over2::Fp6Parameters, FftField, FftParameters, Field, FpParameters, PrimeField,
  5        SquareRootField,
  6    },
  7    One, UniformRand, Zero,
  8};
  9use ark_serialize::{buffer_bit_byte_size, CanonicalSerialize};
 10use ark_std::{rand::Rng, test_rng};
 11use core::{
 12    cmp::Ordering,
 13    ops::{AddAssign, MulAssign, SubAssign},
 14};
 15
 16use crate::{Fq, Fq12, Fq2, Fq6, Fq6Parameters, FqParameters, Fr};
 17use ark_algebra_test_templates::{
 18    fields::*, generate_field_serialization_test, generate_field_test,
 19};
 20
 21generate_field_test!(bn254; fq2; fq6; fq12;);
 22generate_field_serialization_test!(bn254; fq2; fq6; fq12;);
 23
 24#[test]
 25fn test_fq_repr_from() {
 26    assert_eq!(BigInteger256::from(100u64), BigInt::new([100, 0, 0, 0]));
 27}
 28
 29#[test]
 30fn test_fq_repr_is_odd() {
 31    assert!(!BigInteger256::from(0).is_odd());
 32    assert!(BigInteger256::from(0).is_even());
 33    assert!(BigInteger256::from(1).is_odd());
 34    assert!(!BigInteger256::from(1).is_even());
 35    assert!(!BigInteger256::from(324834872).is_odd());
 36    assert!(BigInteger256::from(324834872).is_even());
 37    assert!(BigInteger256::from(324834873).is_odd());
 38    assert!(!BigInteger256::from(324834873).is_even());
 39}
 40
 41#[test]
 42fn test_fq_repr_is_zero() {
 43    assert!(BigInteger256::from(0u64).is_zero());
 44    assert!(!BigInteger256::from(1u64).is_zero());
 45    assert!(!BigInt::new([0, 0, 1, 0]).is_zero());
 46}
 47
 48#[test]
 49fn test_fq_repr_num_bits() {
 50    let mut a = BigInteger256::from(0);
 51    assert_eq!(0, a.num_bits());
 52    a = BigInteger256::from(1);
 53    for i in 1..257 {
 54        assert_eq!(i, a.num_bits());
 55        a.mul2();
 56    }
 57    assert_eq!(0, a.num_bits());
 58}
 59
 60#[test]
 61fn test_fq_num_bits() {
 62    assert_eq!(FqParameters::MODULUS_BITS, 254);
 63    assert_eq!(FqParameters::CAPACITY, 253);
 64}
 65
 66#[test]
 67fn test_fq_root_of_unity() {
 68    assert_eq!(FqParameters::TWO_ADICITY, 1);
 69    assert_eq!(
 70        Fq::multiplicative_generator().pow([
 71            0x9e10460b6c3e7ea3,
 72            0xcbc0b548b438e546,
 73            0xdc2822db40c0ac2e,
 74            0x183227397098d014,
 75        ]),
 76        Fq::two_adic_root_of_unity()
 77    );
 78    assert_eq!(
 79        Fq::two_adic_root_of_unity().pow([1 << FqParameters::TWO_ADICITY]),
 80        Fq::one()
 81    );
 82    assert!(Fq::multiplicative_generator().sqrt().is_none());
 83}
 84
 85#[test]
 86fn test_fq_ordering() {
 87    // BigInteger256's ordering is well-tested, but we still need to make sure the
 88    // Fq elements aren't being compared in Montgomery form.
 89    for i in 0..100 {
 90        assert!(Fq::from(BigInteger256::from(i + 1)) > Fq::from(BigInteger256::from(i)));
 91    }
 92}
 93
 94#[test]
 95fn test_fq_legendre() {
 96    use ark_ff::fields::LegendreSymbol::*;
 97
 98    assert_eq!(QuadraticResidue, Fq::one().legendre());
 99    assert_eq!(Zero, Fq::zero().legendre());
100    assert_eq!(
101        QuadraticResidue,
102        Fq::from(BigInteger256::from(4)).legendre()
103    );
104    assert_eq!(
105        QuadraticNonResidue,
106        Fq::from(BigInteger256::from(5)).legendre()
107    );
108}
109
110#[test]
111fn test_fq2_ordering() {
112    let mut a = Fq2::new(Fq::zero(), Fq::zero());
113    let mut b = a.clone();
114
115    assert!(a.cmp(&b) == Ordering::Equal);
116    b.c0.add_assign(&Fq::one());
117    assert!(a.cmp(&b) == Ordering::Less);
118    a.c0.add_assign(&Fq::one());
119    assert!(a.cmp(&b) == Ordering::Equal);
120    b.c1.add_assign(&Fq::one());
121    assert!(a.cmp(&b) == Ordering::Less);
122    a.c0.add_assign(&Fq::one());
123    assert!(a.cmp(&b) == Ordering::Less);
124    a.c1.add_assign(&Fq::one());
125    assert!(a.cmp(&b) == Ordering::Greater);
126    b.c0.add_assign(&Fq::one());
127    assert!(a.cmp(&b) == Ordering::Equal);
128}
129
130#[test]
131fn test_fq2_basics() {
132    assert_eq!(Fq2::new(Fq::zero(), Fq::zero(),), Fq2::zero());
133    assert_eq!(Fq2::new(Fq::one(), Fq::zero(),), Fq2::one());
134    assert!(Fq2::zero().is_zero());
135    assert!(!Fq2::one().is_zero());
136    assert!(!Fq2::new(Fq::zero(), Fq::one(),).is_zero());
137}
138
139#[test]
140fn test_fq2_legendre() {
141    use ark_ff::fields::LegendreSymbol::*;
142
143    assert_eq!(Zero, Fq2::zero().legendre());
144    // i^2 = -1
145    let mut m1 = -Fq2::one();
146    assert_eq!(QuadraticResidue, m1.legendre());
147    m1 = Fq6Parameters::mul_fp2_by_nonresidue(&m1);
148    assert_eq!(QuadraticNonResidue, m1.legendre());
149}
150
151#[test]
152fn test_fq6_mul_by_1() {
153    let mut rng = ark_std::test_rng();
154
155    for _ in 0..1000 {
156        let c1 = Fq2::rand(&mut rng);
157        let mut a = Fq6::rand(&mut rng);
158        let mut b = a;
159
160        a.mul_by_1(&c1);
161        b.mul_assign(&Fq6::new(Fq2::zero(), c1, Fq2::zero()));
162
163        assert_eq!(a, b);
164    }
165}
166
167#[test]
168fn test_fq6_mul_by_01() {
169    let mut rng = ark_std::test_rng();
170
171    for _ in 0..1000 {
172        let c0 = Fq2::rand(&mut rng);
173        let c1 = Fq2::rand(&mut rng);
174        let mut a = Fq6::rand(&mut rng);
175        let mut b = a;
176
177        a.mul_by_01(&c0, &c1);
178        b.mul_assign(&Fq6::new(c0, c1, Fq2::zero()));
179
180        assert_eq!(a, b);
181    }
182}
183
184#[test]
185fn test_fq12_mul_by_014() {
186    let mut rng = ark_std::test_rng();
187
188    for _ in 0..1000 {
189        let c0 = Fq2::rand(&mut rng);
190        let c1 = Fq2::rand(&mut rng);
191        let c5 = Fq2::rand(&mut rng);
192        let mut a = Fq12::rand(&mut rng);
193        let mut b = a;
194
195        a.mul_by_014(&c0, &c1, &c5);
196        b.mul_assign(&Fq12::new(
197            Fq6::new(c0, c1, Fq2::zero()),
198            Fq6::new(Fq2::zero(), c5, Fq2::zero()),
199        ));
200
201        assert_eq!(a, b);
202    }
203}
204
205#[test]
206fn test_fq12_mul_by_034() {
207    let mut rng = ark_std::test_rng();
208
209    for _ in 0..1000 {
210        let c0 = Fq2::rand(&mut rng);
211        let c3 = Fq2::rand(&mut rng);
212        let c4 = Fq2::rand(&mut rng);
213        let mut a = Fq12::rand(&mut rng);
214        let mut b = a;
215
216        a.mul_by_034(&c0, &c3, &c4);
217        b.mul_assign(&Fq12::new(
218            Fq6::new(c0, Fq2::zero(), Fq2::zero()),
219            Fq6::new(c3, c4, Fq2::zero()),
220        ));
221
222        assert_eq!(a, b);
223    }
224}