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