1 /* Test mp*_class assignment operators.
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 std::string;
30 using std::invalid_argument;
31
32
33 void
check_mpz(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 // swap(mpz_class &)
190 {
191 mpz_class a(123);
192 mpz_class b(456);
193 a.swap(b);
194 a.swap(a);
195 ASSERT_ALWAYS(a == 456);
196 ASSERT_ALWAYS(b == 123);
197 }
198
199 // swap(mpz_class &, mpz_class &)
200 {
201 mpz_class a(123);
202 mpz_class b(456);
203 ::swap(a, b);
204 ::swap(a, a);
205 ASSERT_ALWAYS(a == 456);
206 ASSERT_ALWAYS(b == 123);
207 }
208 {
209 using std::swap;
210 mpz_class a(123);
211 mpz_class b(456);
212 swap(a, b);
213 swap(a, a);
214 ASSERT_ALWAYS(a == 456);
215 ASSERT_ALWAYS(b == 123);
216 }
217 }
218
219 void
check_mpq(void)220 check_mpq (void)
221 {
222 // operator=(const mpq_class &)
223 {
224 mpq_class a(1, 2), b;
225 b = a; ASSERT_ALWAYS(b == 0.5);
226 }
227
228 // template <class T, class U> operator=(const __gmp_expr<T, U> &)
229 // not tested here, see t-unary.cc, t-binary.cc
230
231 // operator=(signed char)
232 {
233 signed char a = -127;
234 mpq_class b;
235 b = a; ASSERT_ALWAYS(b == -127);
236 }
237
238 // operator=(unsigned char)
239 {
240 unsigned char a = 255;
241 mpq_class b;
242 b = a; ASSERT_ALWAYS(b == 255);
243 }
244
245 // either signed or unsigned char, machine dependent
246 {
247 mpq_class a;
248 a = 'A'; ASSERT_ALWAYS(a == 65);
249 }
250 {
251 mpq_class a;
252 a = 'z'; ASSERT_ALWAYS(a == 122);
253 }
254
255 // operator=(signed int)
256 {
257 signed int a = 0;
258 mpq_class b;
259 b = a; ASSERT_ALWAYS(b == 0);
260 }
261 {
262 signed int a = -123;
263 mpq_class b;
264 b = a; ASSERT_ALWAYS(b == -123);
265 }
266 {
267 signed int a = 32767;
268 mpq_class b;
269 b = a; ASSERT_ALWAYS(b == 32767);
270 }
271
272 // operator=(unsigned int)
273 {
274 unsigned int a = 65535u;
275 mpq_class b;
276 b = a; ASSERT_ALWAYS(b == 65535u);
277 }
278
279 // operator=(signed short int)
280 {
281 signed short int a = -12345;
282 mpq_class b;
283 b = a; ASSERT_ALWAYS(b == -12345);
284 }
285
286 // operator=(unsigned short int)
287 {
288 unsigned short int a = 54321u;
289 mpq_class b;
290 b = a; ASSERT_ALWAYS(b == 54321u);
291 }
292
293 // operator=(signed long int)
294 {
295 signed long int a = -1234567890L;
296 mpq_class b;
297 b = a; ASSERT_ALWAYS(b == -1234567890L);
298 }
299
300 // operator=(unsigned long int)
301 {
302 unsigned long int a = 3456789012UL;
303 mpq_class b;
304 b = a; ASSERT_ALWAYS(b == 3456789012UL);
305 }
306
307 // operator=(float)
308 {
309 float a = 123.0;
310 mpq_class b;
311 b = a; ASSERT_ALWAYS(b == 123);
312 }
313
314 // operator=(double)
315 {
316 double a = 0.0;
317 mpq_class b;
318 b = a; ASSERT_ALWAYS(b == 0);
319 }
320 {
321 double a = -12.375;
322 mpq_class b;
323 b = a; ASSERT_ALWAYS(b == -12.375);
324 }
325 {
326 double a = 6.789e+3;
327 mpq_class b;
328 b = a; ASSERT_ALWAYS(b == 6789);
329 }
330 {
331 double a = 9.375e-1;
332 mpq_class b;
333 b = a; ASSERT_ALWAYS(b == 0.9375);
334 }
335
336 // operator=(long double)
337 // currently not implemented
338
339 // operator=(const char *)
340 {
341 const char *a = "1234567890";
342 mpq_class b;
343 b = a; ASSERT_ALWAYS(b == 1234567890L);
344 }
345
346 // operator=(const std::string &)
347 {
348 string a("1234567890");
349 mpq_class b;
350 b = a; ASSERT_ALWAYS(b == 1234567890L);
351 }
352
353 // operator=(const char *) with invalid
354 {
355 try {
356 const char *a = "abc";
357 mpq_class b;
358 b = a;
359 ASSERT_ALWAYS (0); /* should not be reached */
360 } catch (invalid_argument&) {
361 }
362 }
363
364 // operator=(const std::string &) with invalid
365 {
366 try {
367 string a("def");
368 mpq_class b;
369 b = a;
370 ASSERT_ALWAYS (0); /* should not be reached */
371 } catch (invalid_argument&) {
372 }
373 }
374
375 // swap(mpq_class &)
376 {
377 mpq_class a(3, 2);
378 mpq_class b(-1, 4);
379 a.swap(b);
380 a.swap(a);
381 ASSERT_ALWAYS(a == -.25);
382 ASSERT_ALWAYS(b == 1.5);
383 }
384
385 // swap(mpq_class &, mpq_class &)
386 {
387 mpq_class a(3, 2);
388 mpq_class b(-1, 4);
389 ::swap(a, b);
390 ::swap(a, a);
391 ASSERT_ALWAYS(a == -.25);
392 ASSERT_ALWAYS(b == 1.5);
393 }
394 {
395 using std::swap;
396 mpq_class a(3, 2);
397 mpq_class b(-1, 4);
398 swap(a, b);
399 swap(a, a);
400 ASSERT_ALWAYS(a == -.25);
401 ASSERT_ALWAYS(b == 1.5);
402 }
403 }
404
405 void
check_mpf(void)406 check_mpf (void)
407 {
408 // operator=(const mpf_class &)
409 {
410 mpf_class a(123), b;
411 b = a; ASSERT_ALWAYS(b == 123);
412 }
413
414 // template <class T, class U> operator=(const __gmp_expr<T, U> &)
415 // not tested here, see t-unary.cc, t-binary.cc
416
417 // operator=(signed char)
418 {
419 signed char a = -127;
420 mpf_class b;
421 b = a; ASSERT_ALWAYS(b == -127);
422 }
423
424 // operator=(unsigned char)
425 {
426 unsigned char a = 255;
427 mpf_class b;
428 b = a; ASSERT_ALWAYS(b == 255);
429 }
430
431 // either signed or unsigned char, machine dependent
432 {
433 mpf_class a;
434 a = 'A'; ASSERT_ALWAYS(a == 65);
435 }
436 {
437 mpf_class a;
438 a = 'z'; ASSERT_ALWAYS(a == 122);
439 }
440
441 // operator=(signed int)
442 {
443 signed int a = 0;
444 mpf_class b;
445 b = a; ASSERT_ALWAYS(b == 0);
446 }
447 {
448 signed int a = -123;
449 mpf_class b;
450 b = a; ASSERT_ALWAYS(b == -123);
451 }
452 {
453 signed int a = 32767;
454 mpf_class b;
455 b = a; ASSERT_ALWAYS(b == 32767);
456 }
457
458 // operator=(unsigned int)
459 {
460 unsigned int a = 65535u;
461 mpf_class b;
462 b = a; ASSERT_ALWAYS(b == 65535u);
463 }
464
465 // operator=(signed short int)
466 {
467 signed short int a = -12345;
468 mpf_class b;
469 b = a; ASSERT_ALWAYS(b == -12345);
470 }
471
472 // operator=(unsigned short int)
473 {
474 unsigned short int a = 54321u;
475 mpf_class b;
476 b = a; ASSERT_ALWAYS(b == 54321u);
477 }
478
479 // operator=(signed long int)
480 {
481 signed long int a = -1234567890L;
482 mpf_class b;
483 b = a; ASSERT_ALWAYS(b == -1234567890L);
484 }
485
486 // operator=(unsigned long int)
487 {
488 unsigned long int a = 3456789012UL;
489 mpf_class b;
490 b = a; ASSERT_ALWAYS(b == 3456789012UL);
491 }
492
493 // operator=(float)
494 {
495 float a = 123.0;
496 mpf_class b;
497 b = a; ASSERT_ALWAYS(b == 123);
498 }
499
500 // operator=(double)
501 {
502 double a = 0.0;
503 mpf_class b;
504 b = a; ASSERT_ALWAYS(b == 0);
505 }
506 {
507 double a = -12.375;
508 mpf_class b;
509 b = a; ASSERT_ALWAYS(b == -12.375);
510 }
511 {
512 double a = 6.789e+3;
513 mpf_class b;
514 b = a; ASSERT_ALWAYS(b == 6789);
515 }
516 {
517 double a = 9.375e-1;
518 mpf_class b;
519 b = a; ASSERT_ALWAYS(b == 0.9375);
520 }
521
522 // operator=(long double)
523 // currently not implemented
524
525 // operator=(const char *)
526 {
527 const char *a = "1234567890";
528 mpf_class b;
529 b = a; ASSERT_ALWAYS(b == 1234567890L);
530 }
531
532 // operator=(const std::string &)
533 {
534 string a("1234567890");
535 mpf_class b;
536 b = a; ASSERT_ALWAYS(b == 1234567890L);
537 }
538
539 // operator=(const char *) with invalid
540 {
541 try {
542 const char *a = "abc";
543 mpf_class b;
544 b = a;
545 ASSERT_ALWAYS (0); /* should not be reached */
546 } catch (invalid_argument&) {
547 }
548 }
549
550 // operator=(const std::string &) with invalid
551 {
552 try {
553 string a("def");
554 mpf_class b;
555 b = a;
556 ASSERT_ALWAYS (0); /* should not be reached */
557 } catch (invalid_argument&) {
558 }
559 }
560
561 // swap(mpf_class &)
562 {
563 mpf_class a(123);
564 mpf_class b(456);
565 a.swap(b);
566 a.swap(a);
567 ASSERT_ALWAYS(a == 456);
568 ASSERT_ALWAYS(b == 123);
569 }
570
571 // swap(mpf_class &, mpf_class &)
572 {
573 mpf_class a(123);
574 mpf_class b(456);
575 ::swap(a, b);
576 ::swap(a, a);
577 ASSERT_ALWAYS(a == 456);
578 ASSERT_ALWAYS(b == 123);
579 }
580 {
581 using std::swap;
582 mpf_class a(123);
583 mpf_class b(456);
584 swap(a, b);
585 swap(a, a);
586 ASSERT_ALWAYS(a == 456);
587 ASSERT_ALWAYS(b == 123);
588 }
589 }
590
591
592 int
main(void)593 main (void)
594 {
595 tests_start();
596
597 check_mpz();
598 check_mpq();
599 check_mpf();
600
601 tests_end();
602 return 0;
603 }
604