tests/cxx/t-assign.cc

   1 /* Test mp*_class assignment operators.
   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   // operator=(const mpz_class &)
  37   {
  38     mpz_class a(123), b;
  39     b = a; ASSERT_ALWAYS(b == 123);
  40   }
  41
  42   // template <class T, class U> operator=(const __gmp_expr<T, U> &)
  43   // not tested here, see t-unary.cc, t-binary.cc
  44
  45   // operator=(signed char)
  46   {
  47     signed char a = -127;
  48     mpz_class b;
  49     b = a; ASSERT_ALWAYS(b == -127);
  50   }
  51
  52   // operator=(unsigned char)
  53   {
  54     unsigned char a = 255;
  55     mpz_class b;
  56     b = a; ASSERT_ALWAYS(b == 255);
  57   }
  58
  59   // either signed or unsigned char, machine dependent
  60   {
  61     mpz_class a;
  62     a = 'A'; ASSERT_ALWAYS(a == 65);
  63   }
  64   {
  65     mpz_class a;
  66     a = 'z'; ASSERT_ALWAYS(a == 122);
  67   }
  68
  69   // operator=(signed int)
  70   {
  71     signed int a = 0;
  72     mpz_class b;
  73     b = a; ASSERT_ALWAYS(b == 0);
  74   }
  75   {
  76     signed int a = -123;
  77     mpz_class b;
  78     b = a; ASSERT_ALWAYS(b == -123);
  79   }
  80   {
  81     signed int a = 32767;
  82     mpz_class b;
  83     b = a; ASSERT_ALWAYS(b == 32767);
  84   }
  85
  86   // operator=(unsigned int)
  87   {
  88     unsigned int a = 65535u;
  89     mpz_class b;
  90     b = a; ASSERT_ALWAYS(b == 65535u);
  91   }
  92
  93   // operator=(signed short int)
  94   {
  95     signed short int a = -12345;
  96     mpz_class b;
  97     b = a; ASSERT_ALWAYS(b == -12345);
  98   }
  99
 100   // operator=(unsigned short int)
 101   {
 102     unsigned short int a = 54321u;
 103     mpz_class b;
 104     b = a; ASSERT_ALWAYS(b == 54321u);
 105   }
 106
 107   // operator=(signed long int)
 108   {
 109     signed long int a = -1234567890L;
 110     mpz_class b;
 111     b = a; ASSERT_ALWAYS(b == -1234567890L);
 112   }
 113
 114   // operator=(unsigned long int)
 115   {
 116     unsigned long int a = 3456789012UL;
 117     mpz_class b;
 118     b = a; ASSERT_ALWAYS(b == 3456789012UL);
 119   }
 120
 121   // operator=(float)
 122   {
 123     float a = 123.0;
 124     mpz_class b;
 125     b = a; ASSERT_ALWAYS(b == 123);
 126   }
 127
 128   // operator=(double)
 129   {
 130     double a = 0.0;
 131     mpz_class b;
 132     b = a; ASSERT_ALWAYS(b == 0);
 133   }
 134   {
 135     double a = -12.375;
 136     mpz_class b;
 137     b = a; ASSERT_ALWAYS(b == -12);
 138   }
 139   {
 140     double a = 6.789e+3;
 141     mpz_class b;
 142     b = a; ASSERT_ALWAYS(b == 6789);
 143   }
 144   {
 145     double a = 9.375e-1;
 146     mpz_class b;
 147     b = a; ASSERT_ALWAYS(b == 0);
 148   }
 149
 150   // operator=(long double)
 151   // currently not implemented
 152
 153   // operator=(const char *)
 154   {
 155     const char *a = "1234567890";
 156     mpz_class b;
 157     b = a; ASSERT_ALWAYS(b == 1234567890L);
 158   }
 159
 160   // operator=(const std::string &)
 161   {
 162     string a("1234567890");
 163     mpz_class b;
 164     b = a; ASSERT_ALWAYS(b == 1234567890L);
 165   }
 166
 167   // operator=(const char *) with invalid
 168   {
 169     try {
 170       const char *a = "abc";
 171       mpz_class b;
 172       b = a;
 173       ASSERT_ALWAYS (0);  /* should not be reached */
 174     } catch (invalid_argument) {
 175     }
 176   }
 177
 178   // operator=(const std::string &) with invalid
 179   {
 180     try {
 181       string a("def");
 182       mpz_class b;
 183       b = a;
 184       ASSERT_ALWAYS (0);  /* should not be reached */
 185     } catch (invalid_argument) {
 186     }
 187   }
 188 }
 189
 190 void
 191 check_mpq (void)
 192 {
 193   // operator=(const mpq_class &)
 194   {
 195     mpq_class a(1, 2), b;
 196     b = a; ASSERT_ALWAYS(b == 0.5);
 197   }
 198
 199   // template <class T, class U> operator=(const __gmp_expr<T, U> &)
 200   // not tested here, see t-unary.cc, t-binary.cc
 201
 202   // operator=(signed char)
 203   {
 204     signed char a = -127;
 205     mpq_class b;
 206     b = a; ASSERT_ALWAYS(b == -127);
 207   }
 208
 209   // operator=(unsigned char)
 210   {
 211     unsigned char a = 255;
 212     mpq_class b;
 213     b = a; ASSERT_ALWAYS(b == 255);
 214   }
 215
 216   // either signed or unsigned char, machine dependent
 217   {
 218     mpq_class a;
 219     a = 'A'; ASSERT_ALWAYS(a == 65);
 220   }
 221   {
 222     mpq_class a;
 223     a = 'z'; ASSERT_ALWAYS(a == 122);
 224   }
 225
 226   // operator=(signed int)
 227   {
 228     signed int a = 0;
 229     mpq_class b;
 230     b = a; ASSERT_ALWAYS(b == 0);
 231   }
 232   {
 233     signed int a = -123;
 234     mpq_class b;
 235     b = a; ASSERT_ALWAYS(b == -123);
 236   }
 237   {
 238     signed int a = 32767;
 239     mpq_class b;
 240     b = a; ASSERT_ALWAYS(b == 32767);
 241   }
 242
 243   // operator=(unsigned int)
 244   {
 245     unsigned int a = 65535u;
 246     mpq_class b;
 247     b = a; ASSERT_ALWAYS(b == 65535u);
 248   }
 249
 250   // operator=(signed short int)
 251   {
 252     signed short int a = -12345;
 253     mpq_class b;
 254     b = a; ASSERT_ALWAYS(b == -12345);
 255   }
 256
 257   // operator=(unsigned short int)
 258   {
 259     unsigned short int a = 54321u;
 260     mpz_class b;
 261     b = a; ASSERT_ALWAYS(b == 54321u);
 262   }
 263
 264   // operator=(signed long int)
 265   {
 266     signed long int a = -1234567890L;
 267     mpq_class b;
 268     b = a; ASSERT_ALWAYS(b == -1234567890L);
 269   }
 270
 271   // operator=(unsigned long int)
 272   {
 273     unsigned long int a = 3456789012UL;
 274     mpq_class b;
 275     b = a; ASSERT_ALWAYS(b == 3456789012UL);
 276   }
 277
 278   // operator=(float)
 279   {
 280     float a = 123.0;
 281     mpq_class b;
 282     b = a; ASSERT_ALWAYS(b == 123);
 283   }
 284
 285   // operator=(double)
 286   {
 287     double a = 0.0;
 288     mpq_class b;
 289     b = a; ASSERT_ALWAYS(b == 0);
 290   }
 291   {
 292     double a = -12.375;
 293     mpq_class b;
 294     b = a; ASSERT_ALWAYS(b == -12.375);
 295   }
 296   {
 297     double a = 6.789e+3;
 298     mpq_class b;
 299     b = a; ASSERT_ALWAYS(b == 6789);
 300   }
 301   {
 302     double a = 9.375e-1;
 303     mpq_class b;
 304     b = a; ASSERT_ALWAYS(b == 0.9375);
 305   }
 306
 307   // operator=(long double)
 308   // currently not implemented
 309
 310   // operator=(const char *)
 311   {
 312     const char *a = "1234567890";
 313     mpq_class b;
 314     b = a; ASSERT_ALWAYS(b == 1234567890L);
 315   }
 316
 317   // operator=(const std::string &)
 318   {
 319     string a("1234567890");
 320     mpq_class b;
 321     b = a; ASSERT_ALWAYS(b == 1234567890L);
 322   }
 323
 324   // operator=(const char *) with invalid
 325   {
 326     try {
 327       const char *a = "abc";
 328       mpq_class b;
 329       b = a;
 330       ASSERT_ALWAYS (0);  /* should not be reached */
 331     } catch (invalid_argument) {
 332     }
 333   }
 334
 335   // operator=(const std::string &) with invalid
 336   {
 337     try {
 338       string a("def");
 339       mpq_class b;
 340       b = a;
 341       ASSERT_ALWAYS (0);  /* should not be reached */
 342     } catch (invalid_argument) {
 343     }
 344   }
 345 }
 346
 347 void
 348 check_mpf (void)
 349 {
 350   // operator=(const mpf_class &)
 351   {
 352     mpf_class a(123), b;
 353     b = a; ASSERT_ALWAYS(b == 123);
 354   }
 355
 356   // template <class T, class U> operator=(const __gmp_expr<T, U> &)
 357   // not tested here, see t-unary.cc, t-binary.cc
 358
 359   // operator=(signed char)
 360   {
 361     signed char a = -127;
 362     mpf_class b;
 363     b = a; ASSERT_ALWAYS(b == -127);
 364   }
 365
 366   // operator=(unsigned char)
 367   {
 368     unsigned char a = 255;
 369     mpf_class b;
 370     b = a; ASSERT_ALWAYS(b == 255);
 371   }
 372
 373   // either signed or unsigned char, machine dependent
 374   {
 375     mpf_class a;
 376     a = 'A'; ASSERT_ALWAYS(a == 65);
 377   }
 378   {
 379     mpf_class a;
 380     a = 'z'; ASSERT_ALWAYS(a == 122);
 381   }
 382
 383   // operator=(signed int)
 384   {
 385     signed int a = 0;
 386     mpf_class b;
 387     b = a; ASSERT_ALWAYS(b == 0);
 388   }
 389   {
 390     signed int a = -123;
 391     mpf_class b;
 392     b = a; ASSERT_ALWAYS(b == -123);
 393   }
 394   {
 395     signed int a = 32767;
 396     mpf_class b;
 397     b = a; ASSERT_ALWAYS(b == 32767);
 398   }
 399
 400   // operator=(unsigned int)
 401   {
 402     unsigned int a = 65535u;
 403     mpf_class b;
 404     b = a; ASSERT_ALWAYS(b == 65535u);
 405   }
 406
 407   // operator=(signed short int)
 408   {
 409     signed short int a = -12345;
 410     mpf_class b;
 411     b = a; ASSERT_ALWAYS(b == -12345);
 412   }
 413
 414   // operator=(unsigned short int)
 415   {
 416     unsigned short int a = 54321u;
 417     mpf_class b;
 418     b = a; ASSERT_ALWAYS(b == 54321u);
 419   }
 420
 421   // operator=(signed long int)
 422   {
 423     signed long int a = -1234567890L;
 424     mpf_class b;
 425     b = a; ASSERT_ALWAYS(b == -1234567890L);
 426   }
 427
 428   // operator=(unsigned long int)
 429   {
 430     unsigned long int a = 3456789012UL;
 431     mpf_class b;
 432     b = a; ASSERT_ALWAYS(b == 3456789012UL);
 433   }
 434
 435   // operator=(float)
 436   {
 437     float a = 123.0;
 438     mpf_class b;
 439     b = a; ASSERT_ALWAYS(b == 123);
 440   }
 441
 442   // operator=(double)
 443   {
 444     double a = 0.0;
 445     mpf_class b;
 446     b = a; ASSERT_ALWAYS(b == 0);
 447   }
 448   {
 449     double a = -12.375;
 450     mpf_class b;
 451     b = a; ASSERT_ALWAYS(b == -12.375);
 452   }
 453   {
 454     double a = 6.789e+3;
 455     mpf_class b;
 456     b = a; ASSERT_ALWAYS(b == 6789);
 457   }
 458   {
 459     double a = 9.375e-1;
 460     mpf_class b;
 461     b = a; ASSERT_ALWAYS(b == 0.9375);
 462   }
 463
 464   // operator=(long double)
 465   // currently not implemented
 466
 467   // operator=(const char *)
 468   {
 469     const char *a = "1234567890";
 470     mpf_class b;
 471     b = a; ASSERT_ALWAYS(b == 1234567890L);
 472   }
 473
 474   // operator=(const std::string &)
 475   {
 476     string a("1234567890");
 477     mpf_class b;
 478     b = a; ASSERT_ALWAYS(b == 1234567890L);
 479   }
 480
 481   // operator=(const char *) with invalid
 482   {
 483     try {
 484       const char *a = "abc";
 485       mpf_class b;
 486       b = a;
 487       ASSERT_ALWAYS (0);  /* should not be reached */
 488     } catch (invalid_argument) {
 489     }
 490   }
 491
 492   // operator=(const std::string &) with invalid
 493   {
 494     try {
 495       string a("def");
 496       mpf_class b;
 497       b = a;
 498       ASSERT_ALWAYS (0);  /* should not be reached */
 499     } catch (invalid_argument) {
 500     }
 501   }
 502 }
 503
 504
 505 int
 506 main (void)
 507 {
 508   tests_start();
 509
 510   check_mpz();
 511   check_mpq();
 512   check_mpf();
 513
 514   tests_end();
 515   return 0;
 516 }