1use crate::{Fq, Fr};
  2use ark_ff::{
  3    biginteger::BigInteger256 as BigInteger,
  4    bytes::{FromBytes, ToBytes},
  5    fields::{Field, LegendreSymbol::*, SquareRootField},
  6    One, Zero,
  7};
  8use ark_std::test_rng;
  9
 10use ark_algebra_test_templates::fields::*;
 11
 12use core::str::FromStr;
 13use rand::Rng;
 14
 15#[test]
 16fn test_fr() {
 17    let mut rng = test_rng();
 18    let a: Fr = rng.gen();
 19    let b: Fr = rng.gen();
 20    field_test(a, b);
 21    primefield_test::<Fr>();
 22}
 23
 24#[test]
 25fn test_fq() {
 26    let mut rng = test_rng();
 27    let a: Fq = rng.gen();
 28    let b: Fq = rng.gen();
 29    field_test(a, b);
 30    primefield_test::<Fq>();
 31}
 32
 33#[test]
 34fn test_fq_add() {
 35    let f1 = Fq::from_str(
 36        "18386742314266644595564329008376577163854043021652781768352795308532764650733",
 37    )
 38    .unwrap();
 39    let f2 = Fq::from_str(
 40        "39786307610986038981023499868190793548353538256264351797285876981647142458383",
 41    )
 42    .unwrap();
 43    let f3 = Fq::from_str(
 44        "5737174750126493097140088368381404874517028777389495743035013590241325924603",
 45    )
 46    .unwrap();
 47    assert!(!f1.is_zero());
 48    assert!(!f2.is_zero());
 49    assert!(!f3.is_zero());
 50    assert_eq!(f1 + &f2, f3);
 51}
 52
 53#[test]
 54fn test_fq_add_one() {
 55    let f1 = Fq::from_str(
 56        "4946875394261337176810256604189376311946643975348516311606738923340201185904",
 57    )
 58    .unwrap();
 59    let f2 = Fq::from_str(
 60        "4946875394261337176810256604189376311946643975348516311606738923340201185905",
 61    )
 62    .unwrap();
 63    assert!(!f1.is_zero());
 64    assert!(!f2.is_zero());
 65    assert_eq!(f1 + &Fq::one(), f2);
 66}
 67
 68#[test]
 69fn test_fq_mul() {
 70    let f1 = Fq::from_str(
 71        "24703123148064348394273033316595937198355721297494556079070134653139656190956",
 72    )
 73    .unwrap();
 74    let f2 = Fq::from_str(
 75        "38196797080882758914424853878212529985425118523754343117256179679117054302131",
 76    )
 77    .unwrap();
 78    let f3 = Fq::from_str(
 79        "38057113854472161555556064369220825628027487067886761874351491955834635348140",
 80    )
 81    .unwrap();
 82    assert!(!f1.is_zero());
 83    assert!(!f2.is_zero());
 84    assert!(!f3.is_zero());
 85    assert_eq!(f1 * &f2, f3);
 86}
 87
 88#[test]
 89fn test_fq_triple_mul() {
 90    let f1 = Fq::from_str(
 91        "23834398828139479510988224171342199299644042568628082836691700490363123893905",
 92    )
 93    .unwrap();
 94    let f2 = Fq::from_str(
 95        "48343809612844640454129919255697536258606705076971130519928764925719046689317",
 96    )
 97    .unwrap();
 98    let f3 = Fq::from_str(
 99        "22704845471524346880579660022678666462201713488283356385810726260959369106033",
100    )
101    .unwrap();
102    let f4 = Fq::from_str(
103        "18897508522635316277030308074760673440128491438505204942623624791502972539393",
104    )
105    .unwrap();
106    assert!(!f1.is_zero());
107    assert!(!f2.is_zero());
108    assert!(!f3.is_zero());
109    assert_eq!(f1 * &f2 * &f3, f4);
110}
111
112#[test]
113fn test_fq_div() {
114    let f1 = Fq::from_str(
115        "31892744363926593013886463524057935370302352424137349660481695792871889573091",
116    )
117    .unwrap();
118    let f2 = Fq::from_str(
119        "47695868328933459965610498875668250916462767196500056002116961816137113470902",
120    )
121    .unwrap();
122    let f3 = Fq::from_str(
123        "29049672724678710659792141917402891276693777283079976086581207190825261000580",
124    )
125    .unwrap();
126    assert!(!f1.is_zero());
127    assert!(!f2.is_zero());
128    assert!(!f3.is_zero());
129    assert_eq!(f1 / &f2, f3);
130}
131
132#[test]
133fn test_fq_sub() {
134    let f1 = Fq::from_str(
135        "18695869713129401390241150743745601908470616448391638969502807001833388904079",
136    )
137    .unwrap();
138    let f2 = Fq::from_str(
139        "10105476028534616828778879109836101003805485072436929139123765141153277007373",
140    )
141    .unwrap();
142    let f3 = Fq::from_str(
143        "8590393684594784561462271633909500904665131375954709830379041860680111896706",
144    )
145    .unwrap();
146    assert!(!f1.is_zero());
147    assert!(!f2.is_zero());
148    assert!(!f3.is_zero());
149    assert_eq!(f1 - &f2, f3);
150}
151
152#[test]
153fn test_fq_double_in_place() {
154    let mut f1 = Fq::from_str(
155        "29729289787452206300641229002276778748586801323231253291984198106063944136114",
156    )
157    .unwrap();
158    let f3 = Fq::from_str(
159        "7022704399778222121834717496367591659483050145934868761364737512189307087715",
160    )
161    .unwrap();
162    assert!(!f1.is_zero());
163    assert!(!f3.is_zero());
164    f1.double_in_place();
165    assert_eq!(f1, f3);
166}
167
168#[test]
169fn test_fq_double_in_place_thrice() {
170    let mut f1 = Fq::from_str(
171        "32768907806651393940832831055386272949401004221411141755415956893066040832473",
172    )
173    .unwrap();
174    let f3 = Fq::from_str(
175        "52407761752706389608871686410346320244445823769178582752913020344774001921732",
176    )
177    .unwrap();
178    assert!(!f1.is_zero());
179    assert!(!f3.is_zero());
180    f1.double_in_place();
181    f1.double_in_place();
182    f1.double_in_place();
183    assert_eq!(f1, f3);
184}
185
186#[test]
187fn test_fq_generate_random_ed_on_bls12_381_point() {
188    let d = Fq::from_str(
189        "19257038036680949359750312669786877991949435402254120286184196891950884077233",
190    )
191    .unwrap();
192    let y = Fq::from_str(
193        "20269054604167148422407276086932743904275456233139568486008667107872965128512",
194    )
195    .unwrap();
196    let x2 = Fq::from_str(
197        "35041048504708632193693740149219726446678304552734087046982753200179718192840",
198    )
199    .unwrap();
200
201    let computed_y2 = y.square();
202    let y2 = Fq::from_str(
203        "22730681238307918419349440108285755984465605552827817317611903495170775437833",
204    )
205    .unwrap();
206    assert_eq!(y2, computed_y2);
207
208    let computed_dy2 = d * &computed_y2;
209    let dy2 = Fq::from_str(
210        "24720347560552809545835752815204882739669031262711919770503096707526812943411",
211    )
212    .unwrap();
213    assert_eq!(dy2, computed_dy2);
214
215    let computed_divisor = computed_dy2 + &Fq::one();
216    let divisor = Fq::from_str(
217        "24720347560552809545835752815204882739669031262711919770503096707526812943412",
218    )
219    .unwrap();
220    assert_eq!(divisor, computed_divisor);
221
222    let computed_x2 = (computed_y2 - &Fq::one()) / &computed_divisor;
223    assert_eq!(x2, computed_x2);
224
225    let x = Fq::from_str(
226        "15337652609730546173818014678723269532482775720866471265774032070871608223361",
227    )
228    .unwrap();
229    let computed_x = computed_x2.sqrt().unwrap();
230    assert_eq!(computed_x.square(), x2);
231    assert_eq!(x, computed_x);
232
233    fn add<'a>(curr: (Fq, Fq), other: &'a (Fq, Fq)) -> (Fq, Fq) {
234        let y1y2 = curr.1 * &other.1;
235        let x1x2 = curr.0 * &other.0;
236        let d = Fq::from_str(
237            "19257038036680949359750312669786877991949435402254120286184196891950884077233",
238        )
239        .unwrap();
240        let dx1x2y1y2 = d * &y1y2 * &x1x2;
241
242        let d1 = Fq::one() + &dx1x2y1y2;
243        let d2 = Fq::one() - &dx1x2y1y2;
244
245        let x1y2 = curr.0 * &other.1;
246        let y1x2 = curr.1 * &other.0;
247
248        let x = (x1y2 + &y1x2) / &d1;
249        let y = (y1y2 + &x1x2) / &d2;
250
251        (x, y)
252    }
253
254    let result = add((x, y), &(x, y));
255    let result = add(result, &result);
256    let result = add(result, &result);
257
258    let point_x = Fq::from_str(
259        "47259664076168047050113154262636619161204477920503059672059915868534495873964",
260    )
261    .unwrap();
262    let point_y = Fq::from_str(
263        "19016409245280491801573912449420132838852726543024859389273314249842195919690",
264    )
265    .unwrap();
266    assert_eq!((point_x, point_y), result);
267}
268
269#[test]
270fn test_fq_square_in_place() {
271    let mut f1 = Fq::from_str(
272        "34864651240005695523200639428464570946052769938774601449735727714436878540682",
273    )
274    .unwrap();
275    let f3 =
276        Fq::from_str("213133100629336594719108316042277780359104840987226496279264105585804377948")
277            .unwrap();
278    assert!(!f1.is_zero());
279    assert!(!f3.is_zero());
280    f1.square_in_place();
281    assert_eq!(f1, f3);
282}
283
284#[test]
285fn test_fq_sqrt() {
286    let f1 = Fq::from_str(
287        "10875927553327821418567659853801220899541454800710193788767706167237535308235",
288    )
289    .unwrap();
290    let f3 = Fq::from_str(
291        "10816221372957505053219354782681292880545918527618367765651802809826238616708",
292    )
293    .unwrap();
294    assert_eq!(f1.sqrt().unwrap(), f3);
295}
296
297#[test]
298fn test_fq_from_str() {
299    let f1_from_repr = Fq::from(BigInteger([
300        0xab8a2535947d1a77,
301        0x9ba74cbfda0bbcda,
302        0xe928b59724d60baf,
303        0x1cccaaeb9bb1680a,
304    ]));
305    let f1 = Fq::from_str(
306        "13026376210409056429264774981357153555336288129100724591327877625017068755575",
307    )
308    .unwrap();
309    let f2_from_repr = Fq::from(BigInteger([
310        0x97e9103775d2f35c,
311        0xbe6756b6c587544b,
312        0x6ee38c3afd88ef4b,
313        0x2bacd150f540c677,
314    ]));
315    let f2 = Fq::from_str(
316        "19754794831832707859764530223239420866832328728734160755396495950822165902172",
317    )
318    .unwrap();
319    assert_eq!(f1_from_repr, f1);
320    assert_eq!(f2_from_repr, f2);
321}
322
323#[test]
324fn test_fq_legendre() {
325    assert_eq!(QuadraticResidue, Fq::one().legendre());
326    assert_eq!(Zero, Fq::zero().legendre());
327
328    let e = BigInteger([
329        0x0dbc5349cd5664da,
330        0x8ac5b6296e3ae29d,
331        0x127cb819feceaa3b,
332        0x3a6b21fb03867191,
333    ]);
334    assert_eq!(QuadraticResidue, Fq::from(e).legendre());
335    let e = BigInteger([
336        0x96341aefd047c045,
337        0x9b5f4254500a4d65,
338        0x1ee08223b68ac240,
339        0x31d9cd545c0ec7c6,
340    ]);
341    assert_eq!(QuadraticNonResidue, Fq::from(e).legendre());
342}
343
344#[test]
345fn test_fq_bytes() {
346    let f1_from_repr = Fq::from(BigInteger([
347        0xab8a2535947d1a77,
348        0x9ba74cbfda0bbcda,
349        0xe928b59724d60baf,
350        0x1cccaaeb9bb1680a,
351    ]));
352
353    let mut f1_bytes = [0u8; 32];
354    f1_from_repr.write(f1_bytes.as_mut()).unwrap();
355
356    let f1 = Fq::read(f1_bytes.as_ref()).unwrap();
357    assert_eq!(f1_from_repr, f1);
358}
359
360#[test]
361fn test_fr_add() {
362    let f1 = Fr::from(BigInteger([
363        0xc81265fb4130fe0c,
364        0xb308836c14e22279,
365        0x699e887f96bff372,
366        0x84ecc7e76c11ad,
367    ]));
368    let f2 = Fr::from(BigInteger([
369        0x71875719b422efb8,
370        0x43658e68a93612,
371        0x9fa756be2011e833,
372        0xaa2b2cb08dac497,
373    ]));
374    let f3 = Fr::from(BigInteger([
375        0x3999bd14f553edc4,
376        0xb34be8fa7d8b588c,
377        0x945df3db6d1dba5,
378        0xb279f92f046d645,
379    ]));
380    assert_eq!(f1 + &f2, f3);
381}
382
383#[test]
384fn test_fr_mul() {
385    let f1 = Fr::from(BigInteger([
386        0xc81265fb4130fe0c,
387        0xb308836c14e22279,
388        0x699e887f96bff372,
389        0x84ecc7e76c11ad,
390    ]));
391    let f2 = Fr::from(BigInteger([
392        0x71875719b422efb8,
393        0x43658e68a93612,
394        0x9fa756be2011e833,
395        0xaa2b2cb08dac497,
396    ]));
397    let f3 = Fr::from(BigInteger([
398        0x6d6618ac6b4a8381,
399        0x5b9eb35d711ee1da,
400        0xce83310e6ac4105d,
401        0x98032e0f206320a,
402    ]));
403    assert_eq!(f1 * &f2, f3);
404}
405
406#[test]
407fn test_fr_bytes() {
408    let f1_from_repr = Fr::from(BigInteger([
409        0xc81265fb4130fe0c,
410        0xb308836c14e22279,
411        0x699e887f96bff372,
412        0x84ecc7e76c11ad,
413    ]));
414
415    let mut f1_bytes = [0u8; 32];
416    f1_from_repr.write(f1_bytes.as_mut()).unwrap();
417
418    let f1 = Fr::read(f1_bytes.as_ref()).unwrap();
419    assert_eq!(f1_from_repr, f1);
420}
421
422#[test]
423fn test_fr_from_str() {
424    let f100_from_repr = Fr::from(BigInteger([0x64, 0, 0, 0]));
425    let f100 = Fr::from_str("100").unwrap();
426    assert_eq!(f100_from_repr, f100);
427}