1 /* Test mp*_class constructors.
2
3 Copyright 2001-2003 Free Software Foundation, Inc.
4
5 This file is part of the GNU MP Library test suite.
6
7 The GNU MP Library test suite is free software; you can redistribute it
8 and/or modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 3 of the License,
10 or (at your option) any later version.
11
12 The GNU MP Library test suite is distributed in the hope that it will be
13 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15 Public License for more details.
16
17 You should have received a copy of the GNU General Public License along with
18 the GNU MP Library test suite. If not, see https://www.gnu.org/licenses/. */
19
20 #include "config.h"
21
22 #include <iostream>
23 #include <string>
24
25 #include "gmpxx.h"
26 #include "gmp-impl.h"
27 #include "tests.h"
28
29 using namespace std;
30
31
32 void
check_mpz(void)33 check_mpz (void)
34 {
35 // mpz_class()
36 {
37 mpz_class a; ASSERT_ALWAYS(a == 0);
38 }
39
40 // mpz_class(const mpz_class &)
41 // see below
42
43 // template <class T, class U> mpz_class(const __gmp_expr<T, U> &)
44 // not tested here, see t-unary.cc, t-binary.cc
45
46 // mpz_class(signed char)
47 {
48 signed char a = -127;
49 mpz_class b(a); ASSERT_ALWAYS(b == -127);
50 }
51
52 // mpz_class(unsigned char)
53 {
54 unsigned char a = 255;
55 mpz_class b(a); ASSERT_ALWAYS(b == 255);
56 }
57
58 // either signed or unsigned char, machine dependent
59 {
60 mpz_class a('A'); ASSERT_ALWAYS(a == 65);
61 }
62 {
63 mpz_class a('z'); ASSERT_ALWAYS(a == 122);
64 }
65
66 // mpz_class(signed int)
67 {
68 signed int a = 0;
69 mpz_class b(a); ASSERT_ALWAYS(b == 0);
70 }
71 {
72 signed int a = -123;
73 mpz_class b(a); ASSERT_ALWAYS(b == -123);
74 }
75 {
76 signed int a = 4567;
77 mpz_class b(a); ASSERT_ALWAYS(b == 4567);
78 }
79
80 // mpz_class(unsigned int)
81 {
82 unsigned int a = 890;
83 mpz_class b(a); ASSERT_ALWAYS(b == 890);
84 }
85
86 // mpz_class(signed short int)
87 {
88 signed short int a = -12345;
89 mpz_class b(a); ASSERT_ALWAYS(b == -12345);
90 }
91
92 // mpz_class(unsigned short int)
93 {
94 unsigned short int a = 54321u;
95 mpz_class b(a); ASSERT_ALWAYS(b == 54321u);
96 }
97
98 // mpz_class(signed long int)
99 {
100 signed long int a = -1234567890L;
101 mpz_class b(a); ASSERT_ALWAYS(b == -1234567890L);
102 }
103
104 // mpz_class(unsigned long int)
105 {
106 unsigned long int a = 1UL << 30;
107 mpz_class b(a); ASSERT_ALWAYS(b == 1073741824L);
108 }
109
110 // mpz_class(float)
111 {
112 float a = 123.45;
113 mpz_class b(a); ASSERT_ALWAYS(b == 123);
114 }
115
116 // mpz_class(double)
117 {
118 double a = 3.141592653589793238;
119 mpz_class b(a); ASSERT_ALWAYS(b == 3);
120 }
121
122 // mpz_class(long double)
123 // currently not implemented
124
125 // mpz_class(const char *)
126 {
127 const char *a = "1234567890";
128 mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
129 }
130
131 // mpz_class(const char *, int)
132 {
133 const char *a = "FFFF";
134 int base = 16;
135 mpz_class b(a, base); ASSERT_ALWAYS(b == 65535u);
136 }
137
138 // mpz_class(const std::string &)
139 {
140 string a("1234567890");
141 mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
142 }
143
144 // mpz_class(const std::string &, int)
145 {
146 string a("7777");
147 int base = 8;
148 mpz_class b(a, base); ASSERT_ALWAYS(b == 4095);
149 }
150
151 // mpz_class(const char *) with invalid
152 {
153 try {
154 const char *a = "ABC";
155 mpz_class b(a);
156 ASSERT_ALWAYS (0); /* should not be reached */
157 } catch (invalid_argument&) {
158 }
159 }
160
161 // mpz_class(const char *, int) with invalid
162 {
163 try {
164 const char *a = "GHI";
165 int base = 16;
166 mpz_class b(a, base);
167 ASSERT_ALWAYS (0); /* should not be reached */
168 } catch (invalid_argument&) {
169 }
170 }
171
172 // mpz_class(const std::string &) with invalid
173 {
174 try {
175 string a("abc");
176 mpz_class b(a);
177 ASSERT_ALWAYS (0); /* should not be reached */
178 } catch (invalid_argument&) {
179 }
180 }
181
182 // mpz_class(const std::string &, int) with invalid
183 {
184 try {
185 string a("ZZZ");
186 int base = 8;
187 mpz_class b(a, base);
188 ASSERT_ALWAYS (0); /* should not be reached */
189 } catch (invalid_argument&) {
190 }
191 }
192
193 // mpz_class(mpz_srcptr)
194 {
195 mpz_t a;
196 mpz_init_set_ui(a, 100);
197 mpz_class b(a); ASSERT_ALWAYS(b == 100);
198 mpz_clear(a);
199 }
200
201 // mpz_class(const mpz_class &)
202 {
203 mpz_class a(12345); // tested above, assume it works
204 mpz_class b(a); ASSERT_ALWAYS(b == 12345);
205 }
206
207 // no constructor for bool, but it gets casted to int
208 {
209 bool a = true;
210 mpz_class b(a); ASSERT_ALWAYS(b == 1);
211 }
212 {
213 bool a = false;
214 mpz_class b(a); ASSERT_ALWAYS(b == 0);
215 }
216 }
217
218 void
check_mpq(void)219 check_mpq (void)
220 {
221 // mpq_class()
222 {
223 mpq_class a; ASSERT_ALWAYS(a == 0);
224 }
225
226 // mpq_class(const mpq_class &)
227 // see below
228
229 // template <class T, class U> mpq_class(const __gmp_expr<T, U> &)
230 // not tested here, see t-unary.cc, t-binary.cc
231
232 // mpq_class(signed char)
233 {
234 signed char a = -127;
235 mpq_class b(a); ASSERT_ALWAYS(b == -127);
236 }
237
238 // mpq_class(unsigned char)
239 {
240 unsigned char a = 255;
241 mpq_class b(a); ASSERT_ALWAYS(b == 255);
242 }
243
244 // either signed or unsigned char, machine dependent
245 {
246 mpq_class a('A'); ASSERT_ALWAYS(a == 65);
247 }
248 {
249 mpq_class a('z'); ASSERT_ALWAYS(a == 122);
250 }
251
252 // mpq_class(signed int)
253 {
254 signed int a = 0;
255 mpq_class b(a); ASSERT_ALWAYS(b == 0);
256 }
257 {
258 signed int a = -123;
259 mpq_class b(a); ASSERT_ALWAYS(b == -123);
260 }
261 {
262 signed int a = 4567;
263 mpq_class b(a); ASSERT_ALWAYS(b == 4567);
264 }
265
266 // mpq_class(unsigned int)
267 {
268 unsigned int a = 890;
269 mpq_class b(a); ASSERT_ALWAYS(b == 890);
270 }
271
272 // mpq_class(signed short int)
273 {
274 signed short int a = -12345;
275 mpq_class b(a); ASSERT_ALWAYS(b == -12345);
276 }
277
278 // mpq_class(unsigned short int)
279 {
280 unsigned short int a = 54321u;
281 mpq_class b(a); ASSERT_ALWAYS(b == 54321u);
282 }
283
284 // mpq_class(signed long int)
285 {
286 signed long int a = -1234567890L;
287 mpq_class b(a); ASSERT_ALWAYS(b == -1234567890L);
288 }
289
290 // mpq_class(unsigned long int)
291 {
292 unsigned long int a = 1UL << 30;
293 mpq_class b(a); ASSERT_ALWAYS(b == 1073741824L);
294 }
295
296 // mpq_class(float)
297 {
298 float a = 0.625;
299 mpq_class b(a); ASSERT_ALWAYS(b == 0.625);
300 }
301
302 // mpq_class(double)
303 {
304 double a = 1.25;
305 mpq_class b(a); ASSERT_ALWAYS(b == 1.25);
306 }
307
308 // mpq_class(long double)
309 // currently not implemented
310
311 // mpq_class(const char *)
312 {
313 const char *a = "1234567890";
314 mpq_class b(a); ASSERT_ALWAYS(b == 1234567890L);
315 }
316
317 // mpq_class(const char *, int)
318 {
319 const char *a = "FFFF";
320 int base = 16;
321 mpq_class b(a, base); ASSERT_ALWAYS(b == 65535u);
322 mpq_class c(0, 1); ASSERT_ALWAYS(c == 0);
323 }
324
325 // mpq_class(const std::string &)
326 {
327 string a("1234567890");
328 mpq_class b(a); ASSERT_ALWAYS(b == 1234567890L);
329 }
330
331 // mpq_class(const std::string &, int)
332 {
333 string a("7777");
334 int base = 8;
335 mpq_class b(a, base); ASSERT_ALWAYS(b == 4095);
336 }
337
338 // mpq_class(const char *) with invalid
339 {
340 try {
341 const char *a = "abc";
342 mpq_class b(a);
343 ASSERT_ALWAYS (0); /* should not be reached */
344 } catch (invalid_argument&) {
345 }
346 }
347
348 // mpq_class(const char *, int) with invalid
349 {
350 try {
351 const char *a = "ZZZ";
352 int base = 16;
353 mpq_class b (a, base);
354 ASSERT_ALWAYS (0); /* should not be reached */
355 } catch (invalid_argument&) {
356 }
357 }
358
359 // mpq_class(const std::string &) with invalid
360 {
361 try {
362 string a("abc");
363 mpq_class b(a);
364 ASSERT_ALWAYS (0); /* should not be reached */
365 } catch (invalid_argument&) {
366 }
367 }
368
369 // mpq_class(const std::string &, int) with invalid
370 {
371 try {
372 string a("ZZZ");
373 int base = 8;
374 mpq_class b (a, base);
375 ASSERT_ALWAYS (0); /* should not be reached */
376 } catch (invalid_argument&) {
377 }
378 }
379
380 // mpq_class(mpq_srcptr)
381 {
382 mpq_t a;
383 mpq_init(a);
384 mpq_set_ui(a, 100, 1);
385 mpq_class b(a); ASSERT_ALWAYS(b == 100);
386 mpq_clear(a);
387 }
388
389 // mpq_class(const mpz_class &, const mpz_class &)
390 {
391 mpz_class a(123), b(4); // tested above, assume it works
392 mpq_class c(a, b); ASSERT_ALWAYS(c == 30.75);
393 }
394 {
395 mpz_class a(-1), b(2); // tested above, assume it works
396 mpq_class c(a, b); ASSERT_ALWAYS(c == -0.5);
397 }
398 {
399 mpz_class a(5), b(4); // tested above, assume it works
400 mpq_class c(a, b); ASSERT_ALWAYS(c == 1.25);
401 }
402
403 // mpq_class(const mpz_class &)
404 {
405 mpq_class a(12345); // tested above, assume it works
406 mpq_class b(a); ASSERT_ALWAYS(b == 12345);
407 }
408
409 // no constructor for bool, but it gets casted to int
410 {
411 bool a = true;
412 mpq_class b(a); ASSERT_ALWAYS(b == 1);
413 }
414 {
415 bool a = false;
416 mpq_class b(a); ASSERT_ALWAYS(b == 0);
417 }
418 }
419
420 void
check_mpf(void)421 check_mpf (void)
422 {
423 // mpf_class()
424 {
425 mpf_class a; ASSERT_ALWAYS(a == 0);
426 }
427
428 // mpf_class(const mpf_class &)
429 // mpf_class(const mpf_class &, unsigned long int)
430 // see below
431
432 // template <class T, class U> mpf_class(const __gmp_expr<T, U> &)
433 // template <class T, class U> mpf_class(const __gmp_expr<T, U> &,
434 // unsigned long int)
435 // not tested here, see t-unary.cc, t-binary.cc
436
437 // mpf_class(signed char)
438 {
439 signed char a = -127;
440 mpf_class b(a); ASSERT_ALWAYS(b == -127);
441 }
442
443 // mpf_class(signed char, unsigned long int)
444 {
445 signed char a = -1;
446 int prec = 64;
447 mpf_class b(a, prec); ASSERT_ALWAYS(b == -1);
448 }
449
450 // mpf_class(unsigned char)
451 {
452 unsigned char a = 255;
453 mpf_class b(a); ASSERT_ALWAYS(b == 255);
454 }
455
456 // mpf_class(unsigned char, unsigned long int)
457 {
458 unsigned char a = 128;
459 int prec = 128;
460 mpf_class b(a, prec); ASSERT_ALWAYS(b == 128);
461 }
462
463 // either signed or unsigned char, machine dependent
464 {
465 mpf_class a('A'); ASSERT_ALWAYS(a == 65);
466 }
467 {
468 int prec = 256;
469 mpf_class a('z', prec); ASSERT_ALWAYS(a == 122);
470 }
471
472 // mpf_class(signed int)
473 {
474 signed int a = 0;
475 mpf_class b(a); ASSERT_ALWAYS(b == 0);
476 }
477 {
478 signed int a = -123;
479 mpf_class b(a); ASSERT_ALWAYS(b == -123);
480 }
481 {
482 signed int a = 4567;
483 mpf_class b(a); ASSERT_ALWAYS(b == 4567);
484 }
485
486 // mpf_class(signed int, unsigned long int)
487 {
488 signed int a = -123;
489 int prec = 64;
490 mpf_class b(a, prec); ASSERT_ALWAYS(b == -123);
491 }
492
493 // mpf_class(unsigned int)
494 {
495 unsigned int a = 890;
496 mpf_class b(a); ASSERT_ALWAYS(b == 890);
497 }
498
499 // mpf_class(unsigned int, unsigned long int)
500 {
501 unsigned int a = 890;
502 int prec = 128;
503 mpf_class b(a, prec); ASSERT_ALWAYS(b == 890);
504 }
505
506 // mpf_class(signed short int)
507 {
508 signed short int a = -12345;
509 mpf_class b(a); ASSERT_ALWAYS(b == -12345);
510 }
511
512 // mpf_class(signed short int, unsigned long int)
513 {
514 signed short int a = 6789;
515 int prec = 256;
516 mpf_class b(a, prec); ASSERT_ALWAYS(b == 6789);
517 }
518
519 // mpf_class(unsigned short int)
520 {
521 unsigned short int a = 54321u;
522 mpf_class b(a); ASSERT_ALWAYS(b == 54321u);
523 }
524
525 // mpf_class(unsigned short int, unsigned long int)
526 {
527 unsigned short int a = 54321u;
528 int prec = 64;
529 mpf_class b(a, prec); ASSERT_ALWAYS(b == 54321u);
530 }
531
532 // mpf_class(signed long int)
533 {
534 signed long int a = -1234567890L;
535 mpf_class b(a); ASSERT_ALWAYS(b == -1234567890L);
536 }
537
538 // mpf_class(signed long int, unsigned long int)
539 {
540 signed long int a = -1234567890L;
541 int prec = 128;
542 mpf_class b(a, prec); ASSERT_ALWAYS(b == -1234567890L);
543 }
544
545 // mpf_class(unsigned long int)
546 {
547 unsigned long int a = 3456789012UL;
548 mpf_class b(a); ASSERT_ALWAYS(b == 3456789012UL);
549 }
550
551 // mpf_class(unsigned long int, unsigned long int)
552 {
553 unsigned long int a = 3456789012UL;
554 int prec = 256;
555 mpf_class b(a, prec); ASSERT_ALWAYS(b == 3456789012UL);
556 }
557
558 // mpf_class(float)
559 {
560 float a = 1234.5;
561 mpf_class b(a); ASSERT_ALWAYS(b == 1234.5);
562 }
563
564 // mpf_class(float, unsigned long int)
565 {
566 float a = 1234.5;
567 int prec = 64;
568 mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234.5);
569 }
570
571 // mpf_class(double)
572 {
573 double a = 12345.0;
574 mpf_class b(a); ASSERT_ALWAYS(b == 12345);
575 }
576 {
577 double a = 1.2345e+4;
578 mpf_class b(a); ASSERT_ALWAYS(b == 12345);
579 }
580 {
581 double a = 312.5e-2;
582 mpf_class b(a); ASSERT_ALWAYS(b == 3.125);
583 }
584
585 // mpf_class(double, unsigned long int)
586 {
587 double a = 5.4321e+4;
588 int prec = 128;
589 mpf_class b(a, prec); ASSERT_ALWAYS(b == 54321L);
590 }
591
592 // mpf_class(long double)
593 // mpf_class(long double, unsigned long int)
594 // currently not implemented
595
596 // mpf_class(const char *)
597 {
598 const char *a = "1234567890";
599 mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
600 }
601
602 // mpf_class(const char *, unsigned long int, int = 0)
603 {
604 const char *a = "1234567890";
605 int prec = 256;
606 mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
607 }
608 {
609 const char *a = "777777";
610 int prec = 64, base = 8;
611 mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 262143L);
612 }
613
614 // mpf_class(const std::string &)
615 {
616 string a("1234567890");
617 mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
618 }
619
620 // mpf_class(const std::string &, unsigned long int, int = 0)
621 {
622 string a("1234567890");
623 int prec = 128;
624 mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
625 }
626 {
627 string a("FFFF");
628 int prec = 256, base = 16;
629 mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 65535u);
630 }
631
632 // mpf_class(const char *) with invalid
633 {
634 try {
635 const char *a = "abc";
636 mpf_class b(a);
637 ASSERT_ALWAYS (0); /* should not be reached */
638 } catch (invalid_argument&) {
639 }
640 }
641
642 // mpf_class(const char *, unsigned long int, int = 0) with invalid
643 {
644 try {
645 const char *a = "def";
646 int prec = 256;
647 mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
648 ASSERT_ALWAYS (0); /* should not be reached */
649 } catch (invalid_argument&) {
650 }
651 }
652 {
653 try {
654 const char *a = "ghi";
655 int prec = 64, base = 8;
656 mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 262143L);
657 ASSERT_ALWAYS (0); /* should not be reached */
658 } catch (invalid_argument&) {
659 }
660 }
661
662 // mpf_class(const std::string &) with invalid
663 {
664 try {
665 string a("abc");
666 mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
667 ASSERT_ALWAYS (0); /* should not be reached */
668 } catch (invalid_argument&) {
669 }
670 }
671
672 // mpf_class(const std::string &, unsigned long int, int = 0) with invalid
673 {
674 try {
675 string a("def");
676 int prec = 128;
677 mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
678 ASSERT_ALWAYS (0); /* should not be reached */
679 } catch (invalid_argument&) {
680 }
681 }
682 {
683 try {
684 string a("ghi");
685 int prec = 256, base = 16;
686 mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 65535u);
687 ASSERT_ALWAYS (0); /* should not be reached */
688 } catch (invalid_argument&) {
689 }
690 }
691
692 // mpf_class(mpf_srcptr)
693 {
694 mpf_t a;
695 mpf_init_set_ui(a, 100);
696 mpf_class b(a); ASSERT_ALWAYS(b == 100);
697 mpf_clear(a);
698 }
699
700 // mpf_class(mpf_srcptr, unsigned long int)
701 {
702 mpf_t a;
703 int prec = 64;
704 mpf_init_set_ui(a, 100);
705 mpf_class b(a, prec); ASSERT_ALWAYS(b == 100);
706 mpf_clear(a);
707 }
708
709 // mpf_class(const mpf_class &)
710 {
711 mpf_class a(12345); // tested above, assume it works
712 mpf_class b(a); ASSERT_ALWAYS(b == 12345);
713 }
714
715 // mpf_class(const mpf_class &, unsigned long int)
716 {
717 mpf_class a(12345); // tested above, assume it works
718 int prec = 64;
719 mpf_class b(a, prec); ASSERT_ALWAYS(b == 12345);
720 }
721
722 // no constructors for bool, but it gets casted to int
723 {
724 bool a = true;
725 mpf_class b(a); ASSERT_ALWAYS(b == 1);
726 }
727 {
728 bool a = false;
729 mpf_class b(a); ASSERT_ALWAYS(b == 0);
730 }
731 {
732 bool a = true;
733 int prec = 128;
734 mpf_class b(a, prec); ASSERT_ALWAYS(b == 1);
735 }
736 {
737 bool a = false;
738 int prec = 256;
739 mpf_class b(a, prec); ASSERT_ALWAYS(b == 0);
740 }
741 }
742
743
744 int
main(void)745 main (void)
746 {
747 tests_start();
748
749 check_mpz();
750 check_mpq();
751 check_mpf();
752
753 tests_end();
754 return 0;
755 }
756