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