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;
 13use ark_std::str::FromStr;
 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        "14396564181574133132095017386052820535110852477085064878242263917028290117882",
 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        "1321267396236123309645330145349353750536542060403774171357889269349508194307",
 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        "7747776931431194635550680695131420638163057297019399136408144301550822179875",
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        "7301086967624450577859019086314322648061398679982346993011603220910508457334",
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        "15682093831225862156789646514039007320076873845630437896571987838976271280994",
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        "21380590862979124081952185245260157621176025366712756262647409092194433207997",
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_bn254_point() {
188    let a = Fq::from_str("168700").unwrap();
189
190    let d = Fq::from_str("168696").unwrap();
191    let y = Fq::from_str(
192        "19987327827845206670850937090314462639017692512983955920885166014935289314257",
193    )
194    .unwrap();
195    let x2 = Fq::from_str(
196        "2144239075372598103060889495211040948751593385312551803225522963913923559328",
197    )
198    .unwrap();
199
200    let computed_y2 = y.square();
201    let y2 = Fq::from_str(
202        "11134206686211572308995578277928848431421308813024790181507137950838333998633",
203    )
204    .unwrap();
205    assert_eq!(y2, computed_y2);
206
207    let computed_dy2 = d * &computed_y2;
208    let dy2 =
209        Fq::from_str("345576003677591687256955722467813448317229128849323754147891993737799010947")
210            .unwrap();
211    assert_eq!(dy2, computed_dy2);
212
213    let computed_divisor = computed_dy2 - a;
214    let divisor =
215        Fq::from_str("345576003677591687256955722467813448317229128849323754147891993737798842247")
216            .unwrap();
217    assert_eq!(divisor, computed_divisor);
218
219    let computed_x2 = (computed_y2 - &Fq::one()) / &computed_divisor;
220    assert_eq!(x2, computed_x2);
221
222    let x = Fq::from_str(
223        "4801447892755635304907919953550459075619191823587157449340656925102682829025",
224    )
225    .unwrap();
226    let computed_x = computed_x2.sqrt().unwrap();
227    assert_eq!(computed_x.square(), x2);
228    assert_eq!(x, computed_x);
229
230    fn add<'a>(curr: (Fq, Fq), other: &'a (Fq, Fq)) -> (Fq, Fq) {
231        let y1y2 = curr.1 * &other.1;
232        let x1x2 = curr.0 * &other.0;
233        let a = Fq::from_str("168700").unwrap();
234        let d = Fq::from_str("168696").unwrap();
235        let dx1x2y1y2 = d * &y1y2 * &x1x2;
236
237        let d1 = Fq::one() + &dx1x2y1y2;
238        let d2 = Fq::one() - &dx1x2y1y2;
239
240        let x1y2 = curr.0 * &other.1;
241        let y1x2 = curr.1 * &other.0;
242
243        let x = (x1y2 + &y1x2) / &d1;
244        let y = (y1y2 - a * &x1x2) / &d2;
245
246        (x, y)
247    }
248
249    let result = add((x, y), &(x, y));
250    let result = add(result, &result);
251    let result = add(result, &result);
252
253    let point_x =
254        Fq::from_str("380676173762867192861894055350059333852732198308367125138259398265363727587")
255            .unwrap();
256    let point_y = Fq::from_str(
257        "8435074244857818446059206728316702149733931432112984450960434710303841866985",
258    )
259    .unwrap();
260    assert_eq!((point_x, point_y), result);
261}
262
263#[test]
264fn test_fq_square_in_place() {
265    let mut f1 = Fq::from_str(
266        "6060110850233386730847324622937480088943976359504617699731744947670229990461",
267    )
268    .unwrap();
269    let f3 = Fq::from_str(
270        "17018926051730832095053393285350575966874590491719897015583930476179087429684",
271    )
272    .unwrap();
273    assert!(!f1.is_zero());
274    assert!(!f3.is_zero());
275    f1.square_in_place();
276    assert_eq!(f1, f3);
277}
278
279#[test]
280fn test_fq_sqrt() {
281    let f1 = Fq::from_str(
282        "5830207146824777307592559303161432403393380070279905260050870500920682305217",
283    )
284    .unwrap();
285    let f3 = Fq::from_str(
286        "2108183130040740552565127577293974960058698876185401671087892009247563211475",
287    )
288    .unwrap();
289    assert_eq!(f1.sqrt().unwrap(), f3);
290}
291
292#[test]
293fn test_fq_from_str() {
294    let f1_from_repr = Fq::from(BigInteger([
295        0xab8a2535947d1a77,
296        0x9ba74cbfda0bbcda,
297        0xe928b59724d60baf,
298        0x1cccaaeb9bb1680a,
299    ]));
300    let f1 = Fq::from_str(
301        "13026376210409056429264774981357153555336288129100724591327877625017068755575",
302    )
303    .unwrap();
304    let f2_from_repr = Fq::from(BigInteger([
305        0x97e9103775d2f35c,
306        0xbe6756b6c587544b,
307        0x6ee38c3afd88ef4b,
308        0x2bacd150f540c677,
309    ]));
310    let f2 = Fq::from_str(
311        "19754794831832707859764530223239420866832328728734160755396495950822165902172",
312    )
313    .unwrap();
314    assert_eq!(f1_from_repr, f1);
315    assert_eq!(f2_from_repr, f2);
316}
317
318#[test]
319fn test_fq_legendre() {
320    assert_eq!(QuadraticResidue, Fq::one().legendre());
321    assert_eq!(Zero, Fq::zero().legendre());
322
323    let e = BigInteger([
324        0x2e8de1a676c03be8,
325        0x73350d34fe25a560,
326        0x7ea085919029688e,
327        0x1d0868cb993cf28,
328    ]);
329    assert_eq!(QuadraticResidue, Fq::from(e).legendre());
330    let e = BigInteger([
331        0x891d8cc23c8d0706,
332        0xe91800e007db2698,
333        0xfff380321e9ac7a7,
334        0x2659e28bd17eab6,
335    ]);
336    assert_eq!(QuadraticNonResidue, Fq::from(e).legendre());
337}
338
339#[test]
340fn test_fq_bytes() {
341    let f1_from_repr = Fq::from(BigInteger([
342        0xab8a2535947d1a77,
343        0x9ba74cbfda0bbcda,
344        0xe928b59724d60baf,
345        0x1cccaaeb9bb1680a,
346    ]));
347
348    let mut f1_bytes = [0u8; 32];
349    f1_from_repr.write(f1_bytes.as_mut()).unwrap();
350
351    let f1 = Fq::read(f1_bytes.as_ref()).unwrap();
352    assert_eq!(f1_from_repr, f1);
353}
354
355#[test]
356fn test_fr_add() {
357    let f1 = Fr::from(BigInteger([
358        0xccfc9a195e0f5c46,
359        0xaed4874d13fb1285,
360        0x27368f86ca2848eb,
361        0x4f8adcfeb44fccc,
362    ]));
363    let f2 = Fr::from(BigInteger([
364        0x661ff05bf8570851,
365        0x1b171f4c59be97ef,
366        0x5d2ce7f9b4d701f3,
367        0x1e0e794623e0f68,
368    ]));
369    let f3 = Fr::from(BigInteger([
370        0xcba9f2991d453da6,
371        0x1eacb8e13498bc6a,
372        0x4d596ec9aecf1fd3,
373        0xcd0b95f15cd82f,
374    ]));
375    assert_eq!(f1 + &f2, f3);
376}
377
378#[test]
379fn test_fr_mul() {
380    let f1 = Fr::from(BigInteger([
381        0xc2964d2dd5fb980f,
382        0xbab64d599c57e496,
383        0x39cae13e7d1d4f78,
384        0x1aa995aa4de205c,
385    ]));
386    let f2 = Fr::from(BigInteger([
387        0xc256e720cd43533b,
388        0x3bfbadf6247e13bb,
389        0x94c3d63a53714f63,
390        0x10f8a7bf74efd57,
391    ]));
392    let f3 = Fr::from(BigInteger([
393        0x5eac88be41e0e1fd,
394        0x57aab36675b11e24,
395        0x835582d896b4d13f,
396        0x4808736e213036e,
397    ]));
398    assert_eq!(f1 * &f2, f3);
399}
400#[test]
401fn test_fr_bytes() {
402    let f1_from_repr = Fr::from(BigInteger([
403        0xc81265fb4130fe0c,
404        0xb308836c14e22279,
405        0x699e887f96bff372,
406        0x84ecc7e76c11ad,
407    ]));
408
409    let mut f1_bytes = [0u8; 32];
410    f1_from_repr.write(f1_bytes.as_mut()).unwrap();
411
412    let f1 = Fr::read(f1_bytes.as_ref()).unwrap();
413    assert_eq!(f1_from_repr, f1);
414}
415
416#[test]
417fn test_fr_from_str() {
418    let f100_from_repr = Fr::from(BigInteger([0x64, 0, 0, 0]));
419    let f100 = Fr::from_str("100").unwrap();
420    assert_eq!(f100_from_repr, f100);
421}