1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // XFAIL: libcpp-no-exceptions
11 // <complex>
12 
13 // template<class T>
14 //   complex<T>
15 //   operator/(const complex<T>& lhs, const complex<T>& rhs);
16 
17 #include <complex>
18 #include <cassert>
19 
20 #include "../cases.h"
21 
22 template <class T>
23 void
24 test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
25 {
26     assert(lhs / rhs == x);
27 }
28 
29 template <class T>
30 void
31 test()
32 {
33     std::complex<T> lhs(-4.0, 7.5);
34     std::complex<T> rhs(1.5, 2.5);
35     std::complex<T>   x(1.5, 2.5);
36     test(lhs, rhs, x);
37 }
38 
39 void test_edges()
40 {
41     const unsigned N = sizeof(x) / sizeof(x[0]);
42     for (unsigned i = 0; i < N; ++i)
43     {
44         for (unsigned j = 0; j < N; ++j)
45         {
46             std::complex<double> r = x[i] / x[j];
47             switch (classify(x[i]))
48             {
49             case zero:
50                 switch (classify(x[j]))
51                 {
52                 case zero:
53                     assert(classify(r) == NaN);
54                     break;
55                 case non_zero:
56                     assert(classify(r) == zero);
57                     break;
58                 case inf:
59                     assert(classify(r) == zero);
60                     break;
61                 case NaN:
62                     assert(classify(r) == NaN);
63                     break;
64                 case non_zero_nan:
65                     assert(classify(r) == NaN);
66                     break;
67                 }
68                 break;
69             case non_zero:
70                 switch (classify(x[j]))
71                 {
72                 case zero:
73                     assert(classify(r) == inf);
74                     break;
75                 case non_zero:
76                     assert(classify(r) == non_zero);
77                     break;
78                 case inf:
79                     assert(classify(r) == zero);
80                     break;
81                 case NaN:
82                     assert(classify(r) == NaN);
83                     break;
84                 case non_zero_nan:
85                     assert(classify(r) == NaN);
86                     break;
87                 }
88                 break;
89             case inf:
90                 switch (classify(x[j]))
91                 {
92                 case zero:
93                     assert(classify(r) == inf);
94                     break;
95                 case non_zero:
96                     assert(classify(r) == inf);
97                     break;
98                 case inf:
99                     assert(classify(r) == NaN);
100                     break;
101                 case NaN:
102                     assert(classify(r) == NaN);
103                     break;
104                 case non_zero_nan:
105                     assert(classify(r) == NaN);
106                     break;
107                 }
108                 break;
109             case NaN:
110                 switch (classify(x[j]))
111                 {
112                 case zero:
113                     assert(classify(r) == NaN);
114                     break;
115                 case non_zero:
116                     assert(classify(r) == NaN);
117                     break;
118                 case inf:
119                     assert(classify(r) == NaN);
120                     break;
121                 case NaN:
122                     assert(classify(r) == NaN);
123                     break;
124                 case non_zero_nan:
125                     assert(classify(r) == NaN);
126                     break;
127                 }
128                 break;
129             case non_zero_nan:
130                 switch (classify(x[j]))
131                 {
132                 case zero:
133                     assert(classify(r) == inf);
134                     break;
135                 case non_zero:
136                     assert(classify(r) == NaN);
137                     break;
138                 case inf:
139                     assert(classify(r) == NaN);
140                     break;
141                 case NaN:
142                     assert(classify(r) == NaN);
143                     break;
144                 case non_zero_nan:
145                     assert(classify(r) == NaN);
146                     break;
147                 }
148                 break;
149             }
150         }
151     }
152 }
153 
154 int main()
155 {
156     test<float>();
157     test<double>();
158     test<long double>();
159     test_edges();
160 }
161