1/* Test mp*_class constructors.
2
3Copyright 2001-2003 Free Software Foundation, Inc.
4
5This file is part of the GNU MP Library test suite.
6
7The GNU MP Library test suite is free software; you can redistribute it
8and/or modify it under the terms of the GNU General Public License as
9published by the Free Software Foundation; either version 3 of the License,
10or (at your option) any later version.
11
12The GNU MP Library test suite is distributed in the hope that it will be
13useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
15Public License for more details.
16
17You should have received a copy of the GNU General Public License along with
18the 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
29using namespace std;
30
31
32void
33check_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
218void
219check_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
420void
421check_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
744int
745main (void)
746{
747  tests_start();
748
749  check_mpz();
750  check_mpq();
751  check_mpf();
752
753  tests_end();
754  return 0;
755}
756