tests/cxx/t-constr.cc

   1 /* Test mp*_class constructors.
   2
   3 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
   4
   5 This file is part of the GNU MP Library.
   6
   7 The GNU MP Library is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU Lesser General Public License as published by
   9 the Free Software Foundation; either version 3 of the License, or (at your
  10 option) any later version.
  11
  12 The GNU MP Library is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  15 License for more details.
  16
  17 You should have received a copy of the GNU Lesser General Public License
  18 along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  19
  20 #include "config.h"
  21
  22 #include <iostream>
  23 #include <string>
  24
  25 #include "gmp.h"
  26 #include "gmpxx.h"
  27 #include "gmp-impl.h"
  28 #include "tests.h"
  29
  30 using namespace std;
  31
  32
  33 void
  34 check_mpz (void)
  35 {
  36   // mpz_class()
  37   {
  38     mpz_class a; ASSERT_ALWAYS(a == 0);
  39   }
  40
  41   // mpz_class(const mpz_class &)
  42   // see below
  43
  44   // template <class T, class U> mpz_class(const __gmp_expr<T, U> &)
  45   // not tested here, see t-unary.cc, t-binary.cc
  46
  47   // mpz_class(signed char)
  48   {
  49     signed char a = -127;
  50     mpz_class b(a); ASSERT_ALWAYS(b == -127);
  51   }
  52
  53   // mpz_class(unsigned char)
  54   {
  55     unsigned char a = 255;
  56     mpz_class b(a); ASSERT_ALWAYS(b == 255);
  57   }
  58
  59   // either signed or unsigned char, machine dependent
  60   {
  61     mpz_class a('A'); ASSERT_ALWAYS(a == 65);
  62   }
  63   {
  64     mpz_class a('z'); ASSERT_ALWAYS(a == 122);
  65   }
  66
  67   // mpz_class(signed int)
  68   {
  69     signed int a = 0;
  70     mpz_class b(a); ASSERT_ALWAYS(b == 0);
  71   }
  72   {
  73     signed int a = -123;
  74     mpz_class b(a); ASSERT_ALWAYS(b == -123);
  75   }
  76   {
  77     signed int a = 4567;
  78     mpz_class b(a); ASSERT_ALWAYS(b == 4567);
  79   }
  80
  81   // mpz_class(unsigned int)
  82   {
  83     unsigned int a = 890;
  84     mpz_class b(a); ASSERT_ALWAYS(b == 890);
  85   }
  86
  87   // mpz_class(signed short int)
  88   {
  89     signed short int a = -12345;
  90     mpz_class b(a); ASSERT_ALWAYS(b == -12345);
  91   }
  92
  93   // mpz_class(unsigned short int)
  94   {
  95     unsigned short int a = 54321u;
  96     mpz_class b(a); ASSERT_ALWAYS(b == 54321u);
  97   }
  98
  99   // mpz_class(signed long int)
 100   {
 101     signed long int a = -1234567890L;
 102     mpz_class b(a); ASSERT_ALWAYS(b == -1234567890L);
 103   }
 104
 105   // mpz_class(unsigned long int)
 106   {
 107     unsigned long int a = 1UL << 30;
 108     mpz_class b(a); ASSERT_ALWAYS(b == 1073741824L);
 109   }
 110
 111   // mpz_class(float)
 112   {
 113     float a = 123.45;
 114     mpz_class b(a); ASSERT_ALWAYS(b == 123);
 115   }
 116
 117   // mpz_class(double)
 118   {
 119     double a = 3.141592653589793238;
 120     mpz_class b(a); ASSERT_ALWAYS(b == 3);
 121   }
 122
 123   // mpz_class(long double)
 124   // currently not implemented
 125
 126   // mpz_class(const char *)
 127   {
 128     const char *a = "1234567890";
 129     mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
 130   }
 131
 132   // mpz_class(const char *, int)
 133   {
 134     const char *a = "FFFF";
 135     int base = 16;
 136     mpz_class b(a, base); ASSERT_ALWAYS(b == 65535u);
 137   }
 138
 139   // mpz_class(const std::string &)
 140   {
 141     string a("1234567890");
 142     mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
 143   }
 144
 145   // mpz_class(const std::string &, int)
 146   {
 147     string a("7777");
 148     int base = 8;
 149     mpz_class b(a, base); ASSERT_ALWAYS(b == 4095);
 150   }
 151
 152   // mpz_class(const char *) with invalid
 153   {
 154     try {
 155       const char *a = "ABC";
 156       mpz_class b(a);
 157       ASSERT_ALWAYS (0);  /* should not be reached */
 158     } catch (invalid_argument) {
 159     }
 160   }
 161
 162   // mpz_class(const char *, int) with invalid
 163   {
 164     try {
 165       const char *a = "GHI";
 166       int base = 16;
 167       mpz_class b(a, base);
 168       ASSERT_ALWAYS (0);  /* should not be reached */
 169     } catch (invalid_argument) {
 170     }
 171   }
 172
 173   // mpz_class(const std::string &) with invalid
 174   {
 175     try {
 176       string a("abc");
 177       mpz_class b(a);
 178       ASSERT_ALWAYS (0);  /* should not be reached */
 179     } catch (invalid_argument) {
 180     }
 181   }
 182
 183   // mpz_class(const std::string &, int) with invalid
 184   {
 185     try {
 186       string a("ZZZ");
 187       int base = 8;
 188       mpz_class b(a, base);
 189       ASSERT_ALWAYS (0);  /* should not be reached */
 190     } catch (invalid_argument) {
 191     }
 192   }
 193
 194   // mpz_class(mpz_srcptr)
 195   {
 196     mpz_t a;
 197     mpz_init_set_ui(a, 100);
 198     mpz_class b(a); ASSERT_ALWAYS(b == 100);
 199     mpz_clear(a);
 200   }
 201
 202   // mpz_class(const mpz_class &)
 203   {
 204     mpz_class a(12345); // tested above, assume it works
 205     mpz_class b(a); ASSERT_ALWAYS(b == 12345);
 206   }
 207
 208   // no constructor for bool, but it gets casted to int
 209   {
 210     bool a = true;
 211     mpz_class b(a); ASSERT_ALWAYS(b == 1);
 212   }
 213   {
 214     bool a = false;
 215     mpz_class b(a); ASSERT_ALWAYS(b == 0);
 216   }
 217 }
 218
 219 void
 220 check_mpq (void)
 221 {
 222   // mpq_class()
 223   {
 224     mpq_class a; ASSERT_ALWAYS(a == 0);
 225   }
 226
 227   // mpq_class(const mpq_class &)
 228   // see below
 229
 230   // template <class T, class U> mpq_class(const __gmp_expr<T, U> &)
 231   // not tested here, see t-unary.cc, t-binary.cc
 232
 233   // mpq_class(signed char)
 234   {
 235     signed char a = -127;
 236     mpq_class b(a); ASSERT_ALWAYS(b == -127);
 237   }
 238
 239   // mpq_class(unsigned char)
 240   {
 241     unsigned char a = 255;
 242     mpq_class b(a); ASSERT_ALWAYS(b == 255);
 243   }
 244
 245   // either signed or unsigned char, machine dependent
 246   {
 247     mpq_class a('A'); ASSERT_ALWAYS(a == 65);
 248   }
 249   {
 250     mpq_class a('z'); ASSERT_ALWAYS(a == 122);
 251   }
 252
 253   // mpq_class(signed int)
 254   {
 255     signed int a = 0;
 256     mpq_class b(a); ASSERT_ALWAYS(b == 0);
 257   }
 258   {
 259     signed int a = -123;
 260     mpq_class b(a); ASSERT_ALWAYS(b == -123);
 261   }
 262   {
 263     signed int a = 4567;
 264     mpq_class b(a); ASSERT_ALWAYS(b == 4567);
 265   }
 266
 267   // mpq_class(unsigned int)
 268   {
 269     unsigned int a = 890;
 270     mpq_class b(a); ASSERT_ALWAYS(b == 890);
 271   }
 272
 273   // mpq_class(signed short int)
 274   {
 275     signed short int a = -12345;
 276     mpq_class b(a); ASSERT_ALWAYS(b == -12345);
 277   }
 278
 279   // mpq_class(unsigned short int)
 280   {
 281     unsigned short int a = 54321u;
 282     mpq_class b(a); ASSERT_ALWAYS(b == 54321u);
 283   }
 284
 285   // mpq_class(signed long int)
 286   {
 287     signed long int a = -1234567890L;
 288     mpq_class b(a); ASSERT_ALWAYS(b == -1234567890L);
 289   }
 290
 291   // mpq_class(unsigned long int)
 292   {
 293     unsigned long int a = 1UL << 30;
 294     mpq_class b(a); ASSERT_ALWAYS(b == 1073741824L);
 295   }
 296
 297   // mpq_class(float)
 298   {
 299     float a = 0.625;
 300     mpq_class b(a); ASSERT_ALWAYS(b == 0.625);
 301   }
 302
 303   // mpq_class(double)
 304   {
 305     double a = 1.25;
 306     mpq_class b(a); ASSERT_ALWAYS(b == 1.25);
 307   }
 308
 309   // mpq_class(long double)
 310   // currently not implemented
 311
 312   // mpq_class(const char *)
 313   {
 314     const char *a = "1234567890";
 315     mpq_class b(a); ASSERT_ALWAYS(b == 1234567890L);
 316   }
 317
 318   // mpq_class(const char *, int)
 319   {
 320     const char *a = "FFFF";
 321     int base = 16;
 322     mpq_class b(a, base); ASSERT_ALWAYS(b == 65535u);
 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
 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
 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 }