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