]> git.siccegge.de Git - software/DIPE.git/blob - tests/testDIPE.cpp
benchmarks\~
[software/DIPE.git] / tests / testDIPE.cpp
1 #include <gtest/gtest.h>
2 #include <pbc/pbc.h>
3
4 #include "DIPE.h"
5
6 static dipe_param_t param;
7
8 TEST(DipeTest, DipeMasterKeygen) {
9 dipe_master_publickey_t pk;
10 dipe_master_secretkey_t sk;
11
12 dipe_master_keygen(param, 12, &pk, &sk);
13
14 dipe_free_master_secretkey(sk);
15 dipe_free_master_publickey(pk);
16 }
17
18 TEST(DipeTest, DipeKeygen) {
19 dipe_master_publickey_t pk;
20 dipe_master_secretkey_t msk;
21 dipe_secretkey_t sk;
22 element_t y[5];
23 for (size_t i = 0; i < 5; ++i) {
24 element_init_Zr(y[i], *dipe_get_pairing(param));
25 element_random(y[i]);
26 }
27
28 dipe_master_keygen(param, 5, &pk, &msk);
29 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
30
31 dipe_free_master_secretkey(msk);
32 dipe_free_master_publickey(pk);
33 dipe_free_secretkey(sk);
34
35 for (size_t i = 0; i < 5; ++i) {
36 element_clear(y[i]);
37 }
38 }
39
40 TEST(DipeTest, DipeDecapFail) {
41 dipe_ctxt_t ctxt;
42 dipe_master_publickey_t pk;
43 dipe_master_secretkey_t msk;
44 dipe_secretkey_t sk;
45
46 element_t y[5];
47 for (size_t i = 0; i < 5; ++i) {
48 element_init_Zr(y[i], *dipe_get_pairing(param));
49 element_random(y[i]);
50 }
51
52 dipe_master_keygen(param, 5, &pk, &msk);
53 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
54
55 element_t ptxt, ptxtp;
56 element_init_GT(ptxt, *dipe_get_pairing(param));
57 element_init_GT(ptxtp, *dipe_get_pairing(param));
58
59 element_random(ptxt);
60
61 dipe_encap(param, 1, &pk, 1, y, ptxt, &ctxt);
62 dipe_decap(param, 1, &sk, "1234567890abcdef", y, ctxt, ptxtp);
63
64 EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
65
66 for (size_t i = 0; i < 5; ++i) {
67 element_clear(y[i]);
68 }
69
70 element_clear(ptxt);
71 element_clear(ptxtp);
72
73 dipe_free_master_secretkey(msk);
74 dipe_free_master_publickey(pk);
75 dipe_free_secretkey(sk);
76 dipe_free_ctxt(ctxt);
77 }
78
79 TEST(DipeTest, DipeDecapTrivialSuccess) {
80 dipe_ctxt_t ctxt;
81 dipe_master_publickey_t pk;
82 dipe_master_secretkey_t msk;
83 dipe_secretkey_t sk;
84
85 element_t y[5];
86 for (size_t i = 0; i < 5; ++i) {
87 element_init_Zr(y[i], *dipe_get_pairing(param));
88 element_set0(y[i]);
89 }
90
91 dipe_master_keygen(param, 5, &pk, &msk);
92 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
93
94 element_t ptxt, ptxtp;
95 element_init_GT(ptxt, *dipe_get_pairing(param));
96 element_init_GT(ptxtp, *dipe_get_pairing(param));
97
98 element_random(ptxt);
99
100 dipe_encap(param, 1, &pk, 1, y, ptxt, &ctxt);
101 dipe_decap(param, 1, &sk, "1234567890abcdef", y, ctxt, ptxtp);
102
103 EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
104
105 for (size_t i = 0; i < 5; ++i) {
106 element_clear(y[i]);
107 }
108
109 element_clear(ptxt);
110 element_clear(ptxtp);
111
112 dipe_free_master_secretkey(msk);
113 dipe_free_master_publickey(pk);
114 dipe_free_secretkey(sk);
115 dipe_free_ctxt(ctxt);
116 }
117
118 TEST(DipeTest, DipeDecapSuccess) {
119 dipe_ctxt_t ctxt;
120 dipe_master_publickey_t pk;
121 dipe_master_secretkey_t msk;
122 dipe_secretkey_t sk;
123
124 element_t y[6];
125 element_t x[6];
126
127 for (size_t i = 0; i < 6; i+=2) {
128 element_init_Zr(y[i], *dipe_get_pairing(param));
129 element_init_Zr(x[i], *dipe_get_pairing(param));
130 element_init_Zr(y[i+1], *dipe_get_pairing(param));
131 element_init_Zr(x[i+1], *dipe_get_pairing(param));
132
133 element_set1(y[i]);
134 element_set1(x[i+1]);
135 element_random(y[i+1]);
136 element_neg(x[i], y[i+1]);
137 }
138
139 dipe_master_keygen(param, 6, &pk, &msk);
140 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
141
142 element_t ptxt, ptxtp;
143 element_init_GT(ptxt, *dipe_get_pairing(param));
144 element_init_GT(ptxtp, *dipe_get_pairing(param));
145
146 element_random(ptxt);
147
148 dipe_encap(param, 1, &pk, 1, x, ptxt, &ctxt);
149
150 dipe_decap(param, 1, &sk, "1234567890abcdef", y, ctxt, ptxtp);
151 EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
152
153 /* non-matching CID */
154 dipe_decap(param, 1, &sk, "fedcba0987654321", y, ctxt, ptxtp);
155 EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
156
157 /* inconsistent y value */
158 dipe_decap(param, 1, &sk, "1234567890abcdef", x, ctxt, ptxtp);
159 EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
160
161 for (size_t i = 0; i < 6; ++i) {
162 element_clear(y[i]);
163 element_clear(x[i]);
164 }
165
166 element_clear(ptxt);
167 element_clear(ptxtp);
168
169 dipe_free_master_secretkey(msk);
170 dipe_free_master_publickey(pk);
171 dipe_free_secretkey(sk);
172 dipe_free_ctxt(ctxt);
173 }
174
175 TEST(DipeTest, DipeDecryptSuccessSmall) {
176 char ctxt[672];
177 char ptxt[672];
178 size_t ptxt_len;
179 size_t overhead;
180 dipe_master_publickey_t pk;
181 dipe_master_secretkey_t msk;
182 dipe_secretkey_t sk;
183
184 element_t y[6];
185 element_t x[6];
186
187 for (size_t i = 0; i < 6; i+=2) {
188 element_init_Zr(y[i], *dipe_get_pairing(param));
189 element_init_Zr(x[i], *dipe_get_pairing(param));
190 element_init_Zr(y[i+1], *dipe_get_pairing(param));
191 element_init_Zr(x[i+1], *dipe_get_pairing(param));
192
193 element_set1(y[i]);
194 element_set1(x[i+1]);
195 element_random(y[i+1]);
196 element_neg(x[i], y[i+1]);
197 }
198
199 dipe_master_keygen(param, 6, &pk, &msk);
200 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
201 overhead = dipe_ciphertext_overhead(param, 6, 0);
202
203 for (size_t clen = overhead; clen < 672; ++clen) {
204 memset(ctxt, 0, 672);
205 memset(ptxt, 0, 672);
206 memcpy(ptxt, "test", 4);
207
208 dipe_encrypt(param, 1, &pk, 1, x, 4, ptxt, clen, ctxt);
209 ptxt_len = dipe_decrypt(param, 1, &sk, 0, "1234567890abcdef", y, clen, ctxt, ptxt);
210
211 if (clen >= overhead + 4) {
212 EXPECT_EQ(ptxt_len, 4);
213 EXPECT_STREQ(ptxt, "test");
214 }
215 else {
216 EXPECT_EQ(ptxt_len, 0);
217 }
218 }
219
220 for (size_t i = 0; i < 6; ++i) {
221 element_clear(y[i]);
222 element_clear(x[i]);
223 }
224
225 dipe_free_master_secretkey(msk);
226 dipe_free_master_publickey(pk);
227 dipe_free_secretkey(sk);
228 }
229
230 TEST(DipeTest, DipeDecryptSuccessTightSmall) {
231 size_t ptxt_len;
232 size_t overhead;
233 dipe_master_publickey_t pk;
234 dipe_master_secretkey_t msk;
235 dipe_secretkey_t sk;
236
237 element_t y[6];
238 element_t x[6];
239
240 for (size_t i = 0; i < 6; i+=2) {
241 element_init_Zr(y[i], *dipe_get_pairing(param));
242 element_init_Zr(x[i], *dipe_get_pairing(param));
243 element_init_Zr(y[i+1], *dipe_get_pairing(param));
244 element_init_Zr(x[i+1], *dipe_get_pairing(param));
245
246 element_set1(y[i]);
247 element_set1(x[i+1]);
248 element_random(y[i+1]);
249 element_neg(x[i], y[i+1]);
250 }
251
252 dipe_master_keygen(param, 6, &pk, &msk);
253 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
254 overhead = dipe_ciphertext_overhead(param, 6, 0);
255
256 char ctxt[overhead + 4];
257 char ptxt[overhead + 4];
258
259 for (size_t clen = overhead; clen <= overhead + 4; ++clen) {
260 memset(ctxt, 0, overhead + 4);
261 memset(ptxt, 0, overhead + 4);
262 memcpy(ptxt, "test", 4);
263
264 dipe_encrypt(param, 1, &pk, 1, x, 4, ptxt, clen, ctxt);
265 ptxt_len = dipe_decrypt(param, 1, &sk, 0, "1234567890abcdef", y, clen, ctxt, ptxt);
266
267 if (clen >= overhead + 4) {
268 EXPECT_EQ(ptxt_len, 4);
269 EXPECT_STREQ(ptxt, "test");
270 }
271 else {
272 EXPECT_EQ(ptxt_len, 0);
273 }
274 }
275
276 for (size_t i = 0; i < 6; ++i) {
277 element_clear(y[i]);
278 element_clear(x[i]);
279 }
280
281 dipe_free_master_secretkey(msk);
282 dipe_free_master_publickey(pk);
283 dipe_free_secretkey(sk);
284 }
285
286
287 TEST(DipeTest, DipeDecryptSuccessLargeBlocksize) {
288 char ctxt[672];
289 char ptxt[672];
290 size_t ptxt_len;
291 size_t overhead;
292 dipe_master_publickey_t pk;
293 dipe_master_secretkey_t msk;
294 dipe_secretkey_t sk;
295
296 element_t y[6];
297 element_t x[6];
298
299 for (size_t i = 0; i < 6; i+=2) {
300 element_init_Zr(y[i], *dipe_get_pairing(param));
301 element_init_Zr(x[i], *dipe_get_pairing(param));
302 element_init_Zr(y[i+1], *dipe_get_pairing(param));
303 element_init_Zr(x[i+1], *dipe_get_pairing(param));
304
305 element_set1(y[i]);
306 element_set1(x[i+1]);
307 element_random(y[i+1]);
308 element_neg(x[i], y[i+1]);
309 }
310
311 dipe_master_keygen(param, 6, &pk, &msk);
312 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
313 overhead = dipe_ciphertext_overhead(param, 6, 0);
314
315 for (size_t clen = overhead; clen <= 672; ++clen) {
316 memset(ctxt, 0, 672);
317 memset(ptxt, 0, 672);
318 memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb", 28);
319
320 dipe_encrypt(param, 1, &pk, 1, x, 28, ptxt, clen, ctxt);
321 ptxt_len = dipe_decrypt(param, 1, &sk, 0, "1234567890abcdef", y, clen, ctxt, ptxt);
322
323 if (clen >= overhead + 28) {
324 EXPECT_EQ(ptxt_len, 28);
325 EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb");
326 }
327 else {
328 EXPECT_EQ(ptxt_len, 0);
329 }
330 }
331
332 for (size_t i = 0; i < 6; ++i) {
333 element_clear(y[i]);
334 element_clear(x[i]);
335 }
336
337 dipe_free_master_secretkey(msk);
338 dipe_free_master_publickey(pk);
339 dipe_free_secretkey(sk);
340 }
341
342 TEST(DipeTest, DipeDecryptSuccessTightLargeBlocksize) {
343 size_t ptxt_len;
344 size_t overhead;
345 dipe_master_publickey_t pk;
346 dipe_master_secretkey_t msk;
347 dipe_secretkey_t sk;
348
349 element_t y[6];
350 element_t x[6];
351
352 for (size_t i = 0; i < 6; i+=2) {
353 element_init_Zr(y[i], *dipe_get_pairing(param));
354 element_init_Zr(x[i], *dipe_get_pairing(param));
355 element_init_Zr(y[i+1], *dipe_get_pairing(param));
356 element_init_Zr(x[i+1], *dipe_get_pairing(param));
357
358 element_set1(y[i]);
359 element_set1(x[i+1]);
360 element_random(y[i+1]);
361 element_neg(x[i], y[i+1]);
362 }
363
364 dipe_master_keygen(param, 6, &pk, &msk);
365 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
366 overhead = dipe_ciphertext_overhead(param, 6, 0);
367
368 char ctxt[overhead + 28];
369 char ptxt[overhead + 28];
370
371
372 for (size_t clen = overhead; clen <= overhead + 28; ++clen) {
373 memset(ctxt, 0, overhead + 28);
374 memset(ptxt, 0, overhead + 28);
375 memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb", 28);
376
377 dipe_encrypt(param, 1, &pk, 1, x, 28, ptxt, clen, ctxt);
378 ptxt_len = dipe_decrypt(param, 1, &sk, 0, "1234567890abcdef", y, clen, ctxt, ptxt);
379
380 if (clen >= overhead + 28) {
381 EXPECT_EQ(ptxt_len, 28);
382 EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb");
383 }
384 else {
385 EXPECT_EQ(ptxt_len, 0);
386 }
387 }
388
389 for (size_t i = 0; i < 6; ++i) {
390 element_clear(y[i]);
391 element_clear(x[i]);
392 }
393
394 dipe_free_master_secretkey(msk);
395 dipe_free_master_publickey(pk);
396 dipe_free_secretkey(sk);
397 }
398
399
400 TEST(DipeTest, DipeDecryptSuccessLargeNonBlocksize) {
401 char ctxt[672];
402 char ptxt[672];
403 size_t ptxt_len;
404 size_t overhead;
405 dipe_master_publickey_t pk;
406 dipe_master_secretkey_t msk;
407 dipe_secretkey_t sk;
408
409 element_t y[6];
410 element_t x[6];
411
412 for (size_t i = 0; i < 6; i+=2) {
413 element_init_Zr(y[i], *dipe_get_pairing(param));
414 element_init_Zr(x[i], *dipe_get_pairing(param));
415 element_init_Zr(y[i+1], *dipe_get_pairing(param));
416 element_init_Zr(x[i+1], *dipe_get_pairing(param));
417
418 element_set1(y[i]);
419 element_set1(x[i+1]);
420 element_random(y[i+1]);
421 element_neg(x[i], y[i+1]);
422 }
423
424 dipe_master_keygen(param, 6, &pk, &msk);
425 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
426 overhead = dipe_ciphertext_overhead(param, 6, 0);
427
428 for (size_t clen = overhead; clen <= 672; ++clen) {
429 memset(ctxt, 0, 672);
430 memset(ptxt, 0, 672);
431 memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
432
433 dipe_encrypt(param, 1, &pk, 1, x, 35, ptxt, clen, ctxt);
434 ptxt_len = dipe_decrypt(param, 1, &sk, 0, "1234567890abcdef", y, clen, ctxt, ptxt);
435
436 if (clen >= overhead + 35) {
437 EXPECT_EQ(ptxt_len, 35);
438 EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc");
439 }
440 else {
441 EXPECT_EQ(ptxt_len, 0);
442 }
443 }
444
445 for (size_t i = 0; i < 6; ++i) {
446 element_clear(y[i]);
447 element_clear(x[i]);
448 }
449
450 dipe_free_master_secretkey(msk);
451 dipe_free_master_publickey(pk);
452 dipe_free_secretkey(sk);
453 }
454
455 TEST(DipeTest, DipeDecryptSuccessTightLargeNonBlocksize) {
456 size_t ptxt_len;
457 size_t overhead;
458 dipe_master_publickey_t pk;
459 dipe_master_secretkey_t msk;
460 dipe_secretkey_t sk;
461
462 element_t y[6];
463 element_t x[6];
464
465 for (size_t i = 0; i < 6; i+=2) {
466 element_init_Zr(y[i], *dipe_get_pairing(param));
467 element_init_Zr(x[i], *dipe_get_pairing(param));
468 element_init_Zr(y[i+1], *dipe_get_pairing(param));
469 element_init_Zr(x[i+1], *dipe_get_pairing(param));
470
471 element_set1(y[i]);
472 element_set1(x[i+1]);
473 element_random(y[i+1]);
474 element_neg(x[i], y[i+1]);
475 }
476
477 dipe_master_keygen(param, 6, &pk, &msk);
478 dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
479 overhead = dipe_ciphertext_overhead(param, 6, 0);
480
481 char ctxt[overhead + 35];
482 char ptxt[overhead + 35];
483
484
485 for (size_t clen = overhead; clen <= overhead + 35; ++clen) {
486 memset(ctxt, 0, overhead + 35);
487 memset(ptxt, 0, overhead + 35);
488 memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
489
490 dipe_encrypt(param, 1, &pk, 1, x, 35, ptxt, clen, ctxt);
491 ptxt_len = dipe_decrypt(param, 1, &sk, 0, "1234567890abcdef", y, clen, ctxt, ptxt);
492
493 if (clen >= overhead + 35) {
494 EXPECT_EQ(ptxt_len, 35);
495 EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc");
496 }
497 else {
498 EXPECT_EQ(ptxt_len, 0);
499 }
500 }
501
502 for (size_t i = 0; i < 6; ++i) {
503 element_clear(y[i]);
504 element_clear(x[i]);
505 }
506
507 dipe_free_master_secretkey(msk);
508 dipe_free_master_publickey(pk);
509 dipe_free_secretkey(sk);
510 }
511
512 TEST(DipeTest, DipeDecryptSuccessMultiKey) {
513 size_t ptxt_len;
514 size_t overhead;
515 dipe_master_publickey_t pk[3];
516 dipe_master_secretkey_t msk[3];
517 dipe_secretkey_t sk[3];
518
519 element_t y[6];
520 element_t x[6];
521
522 for (size_t i = 0; i < 6; i+=2) {
523 element_init_Zr(y[i], *dipe_get_pairing(param));
524 element_init_Zr(x[i], *dipe_get_pairing(param));
525 element_init_Zr(y[i+1], *dipe_get_pairing(param));
526 element_init_Zr(x[i+1], *dipe_get_pairing(param));
527
528 element_set1(y[i]);
529 element_set1(x[i+1]);
530 element_random(y[i+1]);
531 element_neg(x[i], y[i+1]);
532 }
533
534 for (size_t i = 0; i < 3; ++i) {
535 dipe_master_keygen(param, 6, &pk[i], &msk[i]);
536 dipe_keygen(param, msk[i], "1234567890abcdef", y, &sk[i]);
537 }
538 overhead = dipe_ciphertext_overhead(param, 6, 0);
539
540 char ctxt[overhead + 35];
541 char ptxt[overhead + 35];
542
543
544 for (size_t clen = overhead; clen <= overhead + 35; ++clen) {
545 memset(ctxt, 0, overhead + 35);
546 memset(ptxt, 0, overhead + 35);
547 memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
548
549 dipe_encrypt(param, 3, pk, 3, x, 35, ptxt, clen, ctxt);
550 ptxt_len = dipe_decrypt(param, 3, sk, 0, "1234567890abcdef", y, clen, ctxt, ptxt);
551
552 if (clen >= overhead + 35) {
553 EXPECT_EQ(ptxt_len, 35);
554 EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc");
555 }
556 else {
557 EXPECT_EQ(ptxt_len, 0);
558 }
559 }
560
561 for (size_t i = 0; i < 6; ++i) {
562 element_clear(y[i]);
563 element_clear(x[i]);
564 }
565
566 for (size_t i = 0; i < 3; ++i) {
567 dipe_free_master_secretkey(msk[i]);
568 dipe_free_master_publickey(pk[i]);
569 dipe_free_secretkey(sk[i]);
570 }
571 }
572
573 TEST(DipeTest, DipeDecryptSuccessThreshold) {
574 size_t ptxt_len;
575 size_t overhead;
576 dipe_master_publickey_t pk[3];
577 dipe_master_secretkey_t msk[3];
578 dipe_secretkey_t sk[3];
579
580 element_t y[6];
581 element_t x[6];
582
583 for (size_t i = 0; i < 6; i+=2) {
584 element_init_Zr(y[i], *dipe_get_pairing(param));
585 element_init_Zr(x[i], *dipe_get_pairing(param));
586 element_init_Zr(y[i+1], *dipe_get_pairing(param));
587 element_init_Zr(x[i+1], *dipe_get_pairing(param));
588
589 element_set1(y[i]);
590 element_set1(x[i+1]);
591 element_random(y[i+1]);
592 element_neg(x[i], y[i+1]);
593 }
594
595 for (size_t i = 0; i < 3; ++i) {
596 dipe_master_keygen(param, 6, &pk[i], &msk[i]);
597 dipe_keygen(param, msk[i], "1234567890abcdef", y, &sk[i]);
598 }
599 overhead = dipe_ciphertext_overhead(param, 6, 2);
600
601 char ctxt[overhead + 35];
602 char ptxt[overhead + 35];
603
604
605 for (size_t clen = overhead+20; clen <= overhead + 35; ++clen) {
606 for (size_t kid = 0; kid < 3; ++kid) {
607 memset(ctxt, 0, overhead + 35);
608 memset(ptxt, 0, overhead + 35);
609 memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
610
611 dipe_encrypt(param, 3, pk, 1, x, 35, ptxt, clen, ctxt);
612 ptxt_len = dipe_decrypt(param, 1, &sk[kid], 2, "1234567890abcdef", y, clen, ctxt, ptxt);
613
614 if (clen >= overhead + 35) {
615 EXPECT_EQ(ptxt_len, 35);
616 EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc");
617 }
618 else {
619 EXPECT_EQ(ptxt_len, 0);
620 }
621 }
622 }
623
624 for (size_t i = 0; i < 6; ++i) {
625 element_clear(y[i]);
626 element_clear(x[i]);
627 }
628
629 for (size_t i = 0; i < 3; ++i) {
630 dipe_free_master_secretkey(msk[i]);
631 dipe_free_master_publickey(pk[i]);
632 dipe_free_secretkey(sk[i]);
633 }
634 }
635
636
637
638
639 int main(int argc, char **argv) {
640 ::testing::InitGoogleTest(&argc, argv);
641
642 dipe_init(fopen("../tests/a.param", "r"), &param);
643
644 int result = RUN_ALL_TESTS();
645 dipe_free_param(param);
646 return result;
647 }