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