chiark / gitweb /
math/mpx-mul4-x86-sse2.S: Use `SHUF' instead of hardwired constants.
[catacomb] / math / group-test.c
1 /* -*-c-*-
2  *
3  * Testing group operations
4  *
5  * (c) 2004 Straylight/Edgeware
6  */
7
8 /*----- Licensing notice --------------------------------------------------*
9  *
10  * This file is part of Catacomb.
11  *
12  * Catacomb is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU Library General Public License as
14  * published by the Free Software Foundation; either version 2 of the
15  * License, or (at your option) any later version.
16  *
17  * Catacomb is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU Library General Public License for more details.
21  *
22  * You should have received a copy of the GNU Library General Public
23  * License along with Catacomb; if not, write to the Free
24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
25  * MA 02111-1307, USA.
26  */
27
28 /*----- Header files ------------------------------------------------------*/
29
30 #include <stdarg.h>
31
32 #include <mLib/testrig.h>
33
34 #include "group.h"
35 #include "fibrand.h"
36 #include "ec.h"
37 #include "ec-test.h"
38
39 /*----- Main code ---------------------------------------------------------*/
40
41 static group *getgroup(const char *p) {
42   group *g; qd_parse qd;
43   qd.p = p; qd.e = 0; g = group_parse(&qd);
44   if (g && !qd_eofp(&qd)) { G_DESTROYGROUP(g); g = 0; qd.e = "junk at eof"; }
45   if (!g) {
46     fprintf(stderr, "bad group string `%.*s|%s': %s\n",
47             (int)(qd.p - p), p, qd.p, qd.e);
48     exit(1);
49   }
50   return (g);
51 }
52
53 static ge *getge(group *g, const char *p) {
54   ge *x = G_CREATE(g);
55   if (group_readstring(g, x, p, 0)) {
56     fprintf(stderr, "bad group element `%s'\n", p);
57     exit(1);
58   }
59   return (x);
60 }
61
62 static void show(group *g, const char *p, ge *x) {
63   fprintf(stderr, "*** %s = ", p); group_writefile(g, x, stderr);
64   putc('\n', stderr);
65 }
66
67 static void showec(const char *p, ec *q) {
68   fprintf(stderr, "*** %s = ", p);
69   if (EC_ATINF(q)) fprintf(stderr, "inf\n");
70   else {
71     mp_writefile(q->x, stderr, 16); fputs(", ", stderr);
72     mp_writefile(q->x, stderr, 16); putchar('\n');
73   }
74 }
75
76 static void showmp(const char *p, mp *x, int r) {
77   fprintf(stderr, "*** %s = ", p); mp_writefile(x, stderr, r);
78   putc('\n', stderr);
79 }
80
81 static int EXECL_LIKE(0)
82   check(const char *op, const char *gd, group *g, ge *r, ge *c, ...)
83 {
84   va_list ap;
85
86   if (G_EQ(g, r, c)) return (1);
87   fprintf(stderr, "\n*** %s failed\n", op);
88   fprintf(stderr, "*** group: %s\n", gd);
89   va_start(ap, c);
90   for (;;) {
91     const char *p; ge *x;
92     p = va_arg(ap, const char *); if (!p) break;
93     x = va_arg(ap, ge *); show(g, p, x);
94   }
95   show(g, "expected", r);
96   show(g, "computed", c);
97   return (0);
98 }
99
100 /*----- Actual tests ------------------------------------------------------*/
101
102 static int vcheck(dstr *v)
103 {
104   group *g = getgroup(v[0].buf);
105   grand *gr = fibrand_create(0);
106   const char *e = G_CHECK(g, gr);
107   int ok = 1;
108   gr->ops->destroy(gr);
109   if (!e) e = "ok";
110   G_DESTROYGROUP(g);
111   if (strcmp(e, v[1].buf)) {
112     ok = 0;
113     fprintf(stderr, "*** check failed\n");
114     fprintf(stderr, "*** group: %s\n", v[0].buf);
115     fprintf(stderr, "*** expected: %s\n", v[1].buf);
116     fprintf(stderr, "*** returned: %s\n", e);
117   }
118   assert(mparena_count(MPARENA_GLOBAL) == 0);
119   return (ok);
120 }
121
122 static int vcheckelt(dstr *v)
123 {
124   group *g = getgroup(v[0].buf);
125   ge *x = getge(g, v[1].buf);
126   int ir = *(int *)v[2].buf;
127   int ic = group_check(g, x);
128   int ok = 1;
129   if (ir != ic) {
130     ok = 0;
131     fprintf(stderr, "*** check failed\n");
132     fprintf(stderr, "*** group: %s\n", v[0].buf);
133     show(g, "x", x);
134     fprintf(stderr, "*** expected %s\n", ir ? "failure" : "success");
135   }
136   G_DESTROY(g, x);
137   G_DESTROYGROUP(g);
138   assert(mparena_count(MPARENA_GLOBAL) == 0);
139   return (ok);
140 }
141
142 static int vmul(dstr *v)
143 {
144   group *g = getgroup(v[0].buf);
145   ge *x = getge(g, v[1].buf);
146   ge *y = getge(g, v[2].buf);
147   ge *r = getge(g, v[3].buf);
148   ge *c = G_CREATE(g);
149   int ok = 1;
150   G_MUL(g, c, x, y);
151   ok &= check("mul", v[0].buf, g, r, c, "x", x, "y", y, (char *)0);
152   G_DESTROY(g, x); G_DESTROY(g, y); G_DESTROY(g, r); G_DESTROY(g, c);
153   G_DESTROYGROUP(g);
154   assert(mparena_count(MPARENA_GLOBAL) == 0);
155   return (ok);
156 }
157
158 static int vsqr(dstr *v)
159 {
160   group *g = getgroup(v[0].buf);
161   ge *x = getge(g, v[1].buf);
162   ge *r = getge(g, v[2].buf);
163   ge *c = G_CREATE(g);
164   int ok = 1;
165   G_SQR(g, c, x);
166   ok &= check("sqr", v[0].buf, g, r, c, "x", x, (char *)0);
167   G_DESTROY(g, x); G_DESTROY(g, r); G_DESTROY(g, c);
168   G_DESTROYGROUP(g);
169   assert(mparena_count(MPARENA_GLOBAL) == 0);
170   return (ok);
171 }
172
173 static int vinv(dstr *v)
174 {
175   group *g = getgroup(v[0].buf);
176   ge *x = getge(g, v[1].buf);
177   ge *r = getge(g, v[2].buf);
178   ge *c = G_CREATE(g);
179   int ok = 1;
180   G_INV(g, c, x);
181   ok &= check("inv", v[0].buf, g, r, c, "x", x, (char *)0);
182   G_DESTROY(g, x); G_DESTROY(g, r); G_DESTROY(g, c);
183   G_DESTROYGROUP(g);
184   assert(mparena_count(MPARENA_GLOBAL) == 0);
185   return (ok);
186 }
187
188 static int vdiv(dstr *v)
189 {
190   group *g = getgroup(v[0].buf);
191   ge *x = getge(g, v[1].buf);
192   ge *y = getge(g, v[2].buf);
193   ge *r = getge(g, v[3].buf);
194   ge *c = G_CREATE(g);
195   int ok = 1;
196   G_DIV(g, c, x, y);
197   ok &= check("div", v[0].buf, g, r, c, "x", x, "y", y, (char *)0);
198   group_stddiv(g, c, x, y);
199   ok &= check("stddiv", v[0].buf, g, r, c, "x", x, "y", y, (char *)0);
200   G_DESTROY(g, x); G_DESTROY(g, y); G_DESTROY(g, r); G_DESTROY(g, c);
201   G_DESTROYGROUP(g);
202   assert(mparena_count(MPARENA_GLOBAL) == 0);
203   return (ok);
204 }
205
206 static int vexp(dstr *v)
207 {
208   group *g = getgroup(v[0].buf);
209   ge *x = getge(g, v[1].buf);
210   mp *n = *(mp **)v[2].buf;
211   ge *r = getge(g, v[3].buf);
212   ge *c = G_CREATE(g);
213   int ok = 1;
214   G_EXP(g, c, x, n);
215   if (!G_EQ(g, r, c)) {
216     ok = 0;
217     fprintf(stderr, "\n*** exp failed\n");
218     fprintf(stderr, "*** group: %s\n", v[0].buf);
219     show(g, "x", x); showmp("n", n, 10);
220     show(g, "expected", r); show(g, "computed", c);
221   }
222   group_stdexp(g, c, x, n);
223   if (!G_EQ(g, r, c)) {
224     ok = 0;
225     fprintf(stderr, "\n*** stdexp failed\n");
226     fprintf(stderr, "*** group: %s\n", v[0].buf);
227     show(g, "x", x); showmp("n", n, 10);
228     show(g, "expected", r); show(g, "computed", c);
229   }
230   G_DESTROY(g, x); MP_DROP(n); G_DESTROY(g, r); G_DESTROY(g, c);
231   G_DESTROYGROUP(g);
232   assert(mparena_count(MPARENA_GLOBAL) == 0);
233   return (ok);
234 }
235
236 static int vmexp(size_t n, dstr *v)
237 {
238   group *g = getgroup(v[0].buf);
239   ge *c, *r;
240   group_expfactor *f = xmalloc(n * sizeof(group_expfactor));
241   int ok = 1;
242   size_t i;
243   for (i = 0; i < n; i++) {
244     f[i].base = getge(g, v[1 + 2 * i].buf);
245     f[i].exp = *(mp **)v[2 + 2 * i].buf;
246   }
247   r = getge(g, v[1 + 2 * n].buf);
248   c = G_CREATE(g);
249   G_MEXP(g, c, f, n);
250   if (!G_EQ(g, r, c)) {
251     ok = 0;
252     fprintf(stderr, "\n*** mexp failed\n");
253     fprintf(stderr, "*** group: %s\n", v[0].buf);
254     for (i = 0; i < n; i++) {
255       show(g, "base", f[i].base);
256       showmp("exp", f[i].exp, 10);
257     }
258     show(g, "expected", r); show(g, "computed", c);
259   }
260   group_stdmexp(g, c, f, n);
261   if (!G_EQ(g, r, c)) {
262     ok = 0;
263     fprintf(stderr, "\n*** stdmexp failed\n");
264     fprintf(stderr, "*** group: %s\n", v[0].buf);
265     for (i = 0; i < n; i++) {
266       show(g, "base", f[i].base);
267       showmp("exp", f[i].exp, 10);
268     }
269     show(g, "expected", r); show(g, "computed", c);
270   }
271   for (i = 0; i < n; i++) { G_DESTROY(g, f[i].base); MP_DROP(f[i].exp); }
272   G_DESTROY(g, r); G_DESTROY(g, c);
273   G_DESTROYGROUP(g);
274   assert(mparena_count(MPARENA_GLOBAL) == 0);
275   return (ok);
276 }
277
278 static int vmexp1(dstr *v) { return vmexp(1, v); }
279 static int vmexp2(dstr *v) { return vmexp(2, v); }
280 static int vmexp3(dstr *v) { return vmexp(3, v); }
281 static int vmexp4(dstr *v) { return vmexp(4, v); }
282
283 static int vtoint(dstr *v)
284 {
285   group *g = getgroup(v[0].buf);
286   ge *x = getge(g, v[1].buf);
287   int ir = *(int *)v[2].buf;
288   mp *r = *(mp **)v[3].buf;
289   mp *c;
290   int ic;
291   int ok = 1;
292   c = G_TOINT(g, MP_NEW, x);
293   ic = c ? 0 : -1;
294   if (ir != ic || (!ic && !MP_EQ(r, c))) {
295     ok = 0;
296     fprintf(stderr, "\n*** toint failed\n");
297     fprintf(stderr, "*** group: %s\n", v[0].buf);
298     if (ir) fprintf(stderr, "*** expected failure\n");
299     else { show(g, "x", x); showmp("expected", r, 16);
300     showmp("computed", c, 16); }
301   }
302   G_DESTROY(g, x); mp_drop(r); mp_drop(c);
303   G_DESTROYGROUP(g);
304   assert(mparena_count(MPARENA_GLOBAL) == 0);
305   return (ok);
306 }
307
308 static int vfromint(dstr *v)
309 {
310   group *g = getgroup(v[0].buf);
311   mp *x = *(mp **)v[1].buf;
312   int ir = *(int *)v[2].buf;
313   ge *r = getge(g, v[3].buf);
314   int ic;
315   ge *c = G_CREATE(g);
316   int ok = 1;
317   ic = G_FROMINT(g, c, x);
318   if (ir != ic || (!ic && !G_EQ(g, r, c))) {
319     ok = 0;
320     fprintf(stderr, "\n*** fromint failed\n");
321     fprintf(stderr, "*** group: %s\n", v[0].buf);
322     showmp("x", x, 16); if (ir) fprintf(stderr, "*** should have failed\n");
323     else { show(g, "expected", r); show(g, "computed", c); }
324   }
325   MP_DROP(x); G_DESTROY(g, r); G_DESTROY(g, c);
326   G_DESTROYGROUP(g);
327   assert(mparena_count(MPARENA_GLOBAL) == 0);
328   return (ok);
329 }
330
331 static int vtoec(dstr *v)
332 {
333   group *g = getgroup(v[0].buf);
334   ge *x = getge(g, v[1].buf);
335   int ir = *(int *)v[2].buf;
336   ec *r = (ec *)v[3].buf;
337   int ic;
338   ec c = EC_INIT;
339   int ok = 1;
340   ic = G_TOEC(g, &c, x);
341   if (ir != ic || (!ic && !EC_EQ(r, &c))) {
342     ok = 0;
343     fprintf(stderr, "\n*** toec failed\n");
344     fprintf(stderr, "*** group: %s\n", v[0].buf);
345     show(g, "x", x);
346     if (ir) fprintf(stderr, "*** should have failed\n");
347     else { showec("expected", r); showec("computed", &c); }
348   }
349   G_DESTROY(g, x); EC_DESTROY(&c); EC_DESTROY(r);
350   G_DESTROYGROUP(g);
351   assert(mparena_count(MPARENA_GLOBAL) == 0);
352   return (ok);
353 }
354
355 static int vfromec(dstr *v)
356 {
357   group *g = getgroup(v[0].buf);
358   ec *p = (ec *)v[1].buf;
359   int ir = *(int *)v[2].buf;
360   ge *r = getge(g, v[3].buf);
361   int ic;
362   ge *c = G_CREATE(g);
363   int ok = 1;
364   ic = G_FROMEC(g, c, p);
365   if (ir != ic || (!ic && !G_EQ(g, r, c))) {
366     ok = 0;
367     fprintf(stderr, "\n*** fromec failed\n");
368     fprintf(stderr, "*** group: %s\n", v[0].buf);
369     showec("p", p); if (ir) fprintf(stderr, "*** should have failed\n");
370     else { show(g, "expected", r); show(g, "computed", c); }
371   }
372   EC_DESTROY(p); G_DESTROY(g, r); G_DESTROY(g, c);
373   G_DESTROYGROUP(g);
374   assert(mparena_count(MPARENA_GLOBAL) == 0);
375   return (ok);
376 }
377
378 static int vtobuf(dstr *v)
379 {
380   group *g = getgroup(v[0].buf);
381   ge *x = getge(g, v[1].buf);
382   int ir = *(int *)v[2].buf;
383   dstr c = DSTR_INIT;
384   int ic;
385   buf b;
386   int ok = 1;
387
388   dstr_ensure(&c, v[3].len);
389   buf_init(&b, c.buf, v[3].len);
390   ic = G_TOBUF(g, &b, x);
391   c.len = BLEN(&b);
392   if (ic != ir || (!ic && (c.len != v[3].len ||
393                            memcmp(c.buf, v[3].buf, c.len)))) {
394     ok = 0;
395     fprintf(stderr, "*** tobuf failed\n");
396     fprintf(stderr, "*** group: %s\n", v[0].buf);
397     show(g, "x", x);
398     if (ir) fprintf(stderr, "*** expected failure\n");
399     else {
400       fprintf(stderr, "*** expected: "); type_hex.dump(&v[3], stderr);
401       fprintf(stderr, "\n*** computed: "); type_hex.dump(&c, stderr);
402       fputc('\n', stderr);
403     }
404   }
405   G_DESTROY(g, x); dstr_destroy(&c);
406   G_DESTROYGROUP(g);
407   assert(mparena_count(MPARENA_GLOBAL) == 0);
408   return (ok);
409 }
410
411 static int vfrombuf(dstr *v)
412 {
413   group *g = getgroup(v[0].buf);
414   int ir = *(int *)v[2].buf;
415   ge *r = getge(g, v[3].buf);
416   int ic;
417   ge *c = G_CREATE(g);
418   buf b;
419   int ok = 1;
420
421   buf_init(&b, v[1].buf, v[1].len);
422   ic = G_FROMBUF(g, &b, c);
423   if ((ic < 0) != (ir < 0) || (ir >= 0 &&
424                                (ir != BLEN(&b) || !G_EQ(g, r, c)))) {
425     ok = 0;
426     fprintf(stderr, "*** frombuf failed\n");
427     fprintf(stderr, "*** group: %s\n", v[0].buf);
428     fprintf(stderr, "*** input string: "); type_hex.dump(&v[1], stderr);
429     fputc('\n', stderr);
430     if (ir < 0) fprintf(stderr, "*** expected failure\n");
431     else {
432       show(g, "expected", r); show(g, "computed", c);
433       fprintf(stderr, "*** expected used = %d\n", ir);
434       fprintf(stderr, "*** computed used = %lu\n", (unsigned long)BLEN(&b));
435     }
436   }
437   G_DESTROY(g, r); G_DESTROY(g, c);
438   G_DESTROYGROUP(g);
439   assert(mparena_count(MPARENA_GLOBAL) == 0);
440   return (ok);
441 }
442
443 static int vtoraw(dstr *v)
444 {
445   group *g = getgroup(v[0].buf);
446   ge *x = getge(g, v[1].buf);
447   int ir = *(int *)v[2].buf;
448   dstr c = DSTR_INIT;
449   int ic;
450   buf b;
451   int ok = 1;
452
453   dstr_ensure(&c, v[3].len);
454   buf_init(&b, c.buf, v[3].len);
455   ic = G_TORAW(g, &b, x);
456   c.len = BLEN(&b);
457   if (ic != ir || (!ic && (c.len != v[3].len ||
458                            memcmp(c.buf, v[3].buf, c.len)))) {
459     ok = 0;
460     fprintf(stderr, "*** toraw failed\n");
461     fprintf(stderr, "*** group: %s\n", v[0].buf);
462     show(g, "x", x);
463     if (ir) fprintf(stderr, "*** expected failure\n");
464     else {
465       fprintf(stderr, "*** expected: "); type_hex.dump(&v[3], stderr);
466       fprintf(stderr, "\n*** computed: "); type_hex.dump(&c, stderr);
467       fputc('\n', stderr);
468     }
469   }
470   G_DESTROY(g, x); dstr_destroy(&c);
471   G_DESTROYGROUP(g);
472   assert(mparena_count(MPARENA_GLOBAL) == 0);
473   return (ok);
474 }
475
476 static int vfromraw(dstr *v)
477 {
478   group *g = getgroup(v[0].buf);
479   int ir = *(int *)v[2].buf;
480   ge *r = getge(g, v[3].buf);
481   int ic;
482   ge *c = G_CREATE(g);
483   buf b;
484   int ok = 1;
485
486   buf_init(&b, v[1].buf, v[1].len);
487   ic = G_FROMRAW(g, &b, c);
488   if ((ic < 0) != (ir < 0) || (ir >= 0 &&
489                                (ir != BLEN(&b) || !G_EQ(g, r, c)))) {
490     ok = 0;
491     fprintf(stderr, "*** fromraw failed\n");
492     fprintf(stderr, "*** group: %s\n", v[0].buf);
493     fprintf(stderr, "*** input string: "); type_hex.dump(&v[1], stderr);
494     fputc('\n', stderr);
495     if (ir < 0) fprintf(stderr, "*** expected failure\n");
496     else {
497       show(g, "expected", r); show(g, "computed", c);
498       fprintf(stderr, "*** expected used = %d\n", ir);
499       fprintf(stderr, "*** computed used = %lu\n", (unsigned long)BLEN(&b));
500     }
501   }
502   G_DESTROY(g, r); G_DESTROY(g, c);
503   G_DESTROYGROUP(g);
504   assert(mparena_count(MPARENA_GLOBAL) == 0);
505   return (ok);
506 }
507
508 static const test_chunk tests[] = {
509   { "check",    vcheck,         { &type_string, &type_string } },
510   { "checkelt", vcheckelt,      { &type_string, &type_string, &type_int } },
511   { "mul",      vmul,           { &type_string, &type_string,
512                                   &type_string, &type_string } },
513   { "sqr",      vsqr,           { &type_string, &type_string,
514                                   &type_string } },
515   { "inv",      vinv,           { &type_string, &type_string,
516                                   &type_string } },
517   { "div",      vdiv,           { &type_string, &type_string,
518                                   &type_string, &type_string } },
519   { "exp",      vexp,           { &type_string, &type_string,
520                                   &type_mp, &type_string } },
521   { "mexp-1",   vmexp1,         { &type_string,
522                                   &type_string, &type_mp,
523                                   &type_string } },
524   { "mexp-2",   vmexp2,         { &type_string,
525                                   &type_string, &type_mp,
526                                   &type_string, &type_mp,
527                                   &type_string } },
528   { "mexp-3",   vmexp3,         { &type_string,
529                                   &type_string, &type_mp,
530                                   &type_string, &type_mp,
531                                   &type_string, &type_mp,
532                                   &type_string } },
533   { "mexp-4",   vmexp4,         { &type_string,
534                                   &type_string, &type_mp,
535                                   &type_string, &type_mp,
536                                   &type_string, &type_mp,
537                                   &type_string, &type_mp,
538                                   &type_string } },
539   { "toint",    vtoint,         { &type_string, &type_string,
540                                   &type_int, &type_mp } },
541   { "fromint",  vfromint,       { &type_string, &type_mp,
542                                   &type_int, &type_string } },
543   { "toec",     vtoec,          { &type_string, &type_string,
544                                   &type_int, &type_ec } },
545   { "fromec",   vfromec,        { &type_string, &type_ec,
546                                   &type_int, &type_string } },
547   { "tobuf",    vtobuf,         { &type_string, &type_string,
548                                   &type_int, &type_hex } },
549   { "frombuf",  vfrombuf,       { &type_string, &type_hex,
550                                   &type_int, &type_string } },
551   { "toraw",    vtoraw,         { &type_string, &type_string,
552                                   &type_int, &type_hex } },
553   { "fromraw",  vfromraw,       { &type_string, &type_hex,
554                                   &type_int, &type_string } },
555   { 0 }
556 };
557
558 int main(int argc, char *argv[])
559 {
560   sub_init();
561   test_run(argc, argv, tests, SRCDIR "/t/group");
562   return (0);
563 }
564
565 /*----- That's all, folks -------------------------------------------------*/