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