1 /*
2 * Copyright 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <ftl/cast.h>
18 #include <gtest/gtest.h>
19
20 #include <cfloat>
21 #include <cmath>
22 #include <limits>
23
24 namespace android::test {
25
26 using ftl::cast_safety;
27 using ftl::CastSafety;
28
29 template <typename T>
30 constexpr T min = std::numeric_limits<T>::lowest();
31
32 template <typename T>
33 constexpr T max = std::numeric_limits<T>::max();
34
35 template <typename T>
36 constexpr T inf = std::numeric_limits<T>::infinity();
37
38 template <typename T>
39 constexpr T NaN = std::numeric_limits<T>::quiet_NaN();
40
41 // Keep in sync with example usage in header file.
42
43 static_assert(cast_safety<uint8_t>(-1) == CastSafety::kUnderflow);
44 static_assert(cast_safety<int8_t>(128u) == CastSafety::kOverflow);
45
46 static_assert(cast_safety<uint32_t>(-.1f) == CastSafety::kUnderflow);
47 static_assert(cast_safety<int32_t>(static_cast<float>(INT32_MAX)) == CastSafety::kOverflow);
48
49 static_assert(cast_safety<float>(-DBL_MAX) == CastSafety::kUnderflow);
50
51 // Unsigned to unsigned.
52
53 static_assert(cast_safety<uint8_t>(0u) == CastSafety::kSafe);
54 static_assert(cast_safety<uint16_t>(max<uint8_t>) == CastSafety::kSafe);
55 static_assert(cast_safety<uint8_t>(static_cast<uint32_t>(max<uint8_t>)) == CastSafety::kSafe);
56
57 static_assert(cast_safety<uint32_t>(max<uint64_t>) == CastSafety::kOverflow);
58 static_assert(cast_safety<uint8_t>(static_cast<uint32_t>(max<uint8_t>) + 1) ==
59 CastSafety::kOverflow);
60
61 // Unsigned to signed.
62
63 static_assert(cast_safety<int16_t>(0u) == CastSafety::kSafe);
64 static_assert(cast_safety<int16_t>(max<uint8_t>) == CastSafety::kSafe);
65 static_assert(cast_safety<int16_t>(max<uint16_t>) == CastSafety::kOverflow);
66
67 static_assert(cast_safety<int64_t>(static_cast<uint64_t>(max<int64_t>) - 1) == CastSafety::kSafe);
68 static_assert(cast_safety<int64_t>(static_cast<uint64_t>(max<int64_t>)) == CastSafety::kSafe);
69 static_assert(cast_safety<int64_t>(static_cast<uint64_t>(max<int64_t>) + 1) ==
70 CastSafety::kOverflow);
71
72 // Signed to unsigned.
73
74 static_assert(cast_safety<uint16_t>(0) == CastSafety::kSafe);
75 static_assert(cast_safety<uint16_t>(max<int8_t>) == CastSafety::kSafe);
76 static_assert(cast_safety<uint16_t>(max<int16_t>) == CastSafety::kSafe);
77
78 static_assert(cast_safety<uint32_t>(-1) == CastSafety::kUnderflow);
79 static_assert(cast_safety<uint32_t>(max<int64_t>) == CastSafety::kOverflow);
80
81 static_assert(cast_safety<uint32_t>(static_cast<int64_t>(max<uint32_t>) - 1) == CastSafety::kSafe);
82 static_assert(cast_safety<uint32_t>(static_cast<int64_t>(max<uint32_t>)) == CastSafety::kSafe);
83 static_assert(cast_safety<uint32_t>(static_cast<int64_t>(max<uint32_t>) + 1) ==
84 CastSafety::kOverflow);
85
86 // Signed to signed.
87
88 static_assert(cast_safety<int8_t>(-129) == CastSafety::kUnderflow);
89 static_assert(cast_safety<int8_t>(-128) == CastSafety::kSafe);
90 static_assert(cast_safety<int8_t>(127) == CastSafety::kSafe);
91 static_assert(cast_safety<int8_t>(128) == CastSafety::kOverflow);
92
93 static_assert(cast_safety<int32_t>(static_cast<int64_t>(min<int32_t>)) == CastSafety::kSafe);
94 static_assert(cast_safety<int32_t>(static_cast<int64_t>(max<int32_t>)) == CastSafety::kSafe);
95
96 static_assert(cast_safety<int16_t>(min<int32_t>) == CastSafety::kUnderflow);
97 static_assert(cast_safety<int32_t>(max<int64_t>) == CastSafety::kOverflow);
98
99 // Float to float.
100
101 static_assert(cast_safety<double>(max<float>) == CastSafety::kSafe);
102 static_assert(cast_safety<double>(min<float>) == CastSafety::kSafe);
103
104 static_assert(cast_safety<float>(min<double>) == CastSafety::kUnderflow);
105 static_assert(cast_safety<float>(max<double>) == CastSafety::kOverflow);
106
TEST(CastSafety,FloatToFloat)107 TEST(CastSafety, FloatToFloat) {
108 EXPECT_EQ(cast_safety<float>(std::nexttoward(static_cast<double>(min<float>), min<double>)),
109 CastSafety::kUnderflow);
110 EXPECT_EQ(cast_safety<float>(std::nexttoward(static_cast<double>(max<float>), max<double>)),
111 CastSafety::kOverflow);
112 }
113
114 // Unsigned to float.
115
116 static_assert(cast_safety<float>(0u) == CastSafety::kSafe);
117 static_assert(cast_safety<float>(max<uint64_t>) == CastSafety::kSafe);
118
119 static_assert(cast_safety<double>(0u) == CastSafety::kSafe);
120 static_assert(cast_safety<double>(max<uint64_t>) == CastSafety::kSafe);
121
122 // Signed to float.
123
124 static_assert(cast_safety<float>(min<int64_t>) == CastSafety::kSafe);
125 static_assert(cast_safety<float>(max<int64_t>) == CastSafety::kSafe);
126
127 static_assert(cast_safety<double>(min<int64_t>) == CastSafety::kSafe);
128 static_assert(cast_safety<double>(max<int64_t>) == CastSafety::kSafe);
129
130 // Float to unsigned.
131
132 static_assert(cast_safety<uint32_t>(0.f) == CastSafety::kSafe);
133 static_assert(cast_safety<uint32_t>(min<float>) == CastSafety::kUnderflow);
134 static_assert(cast_safety<uint32_t>(max<float>) == CastSafety::kOverflow);
135 static_assert(cast_safety<uint32_t>(-.1f) == CastSafety::kUnderflow);
136
137 static_assert(cast_safety<uint16_t>(-inf<float>) == CastSafety::kUnderflow);
138 static_assert(cast_safety<uint32_t>(inf<float>) == CastSafety::kOverflow);
139 static_assert(cast_safety<uint64_t>(NaN<float>) == CastSafety::kOverflow);
140
141 static_assert(cast_safety<uint32_t>(static_cast<float>(max<int32_t>)) == CastSafety::kSafe);
142 static_assert(cast_safety<uint32_t>(static_cast<float>(max<uint32_t>)) == CastSafety::kOverflow);
143 static_assert(cast_safety<uint32_t>(static_cast<double>(max<int32_t>)) == CastSafety::kSafe);
144 static_assert(cast_safety<uint32_t>(static_cast<double>(max<uint32_t>)) == CastSafety::kSafe);
145
146 static_assert(cast_safety<uint64_t>(0.0) == CastSafety::kSafe);
147 static_assert(cast_safety<uint64_t>(min<double>) == CastSafety::kUnderflow);
148 static_assert(cast_safety<uint64_t>(max<double>) == CastSafety::kOverflow);
149 static_assert(cast_safety<uint64_t>(-.1) == CastSafety::kUnderflow);
150
151 static_assert(cast_safety<uint64_t>(static_cast<float>(max<int64_t>)) == CastSafety::kSafe);
152 static_assert(cast_safety<uint64_t>(static_cast<float>(max<uint64_t>)) == CastSafety::kOverflow);
153 static_assert(cast_safety<uint64_t>(static_cast<double>(max<int64_t>)) == CastSafety::kSafe);
154 static_assert(cast_safety<uint64_t>(static_cast<double>(max<uint64_t>)) == CastSafety::kOverflow);
155
156 // Float to signed.
157
158 static_assert(cast_safety<int32_t>(0.f) == CastSafety::kSafe);
159 static_assert(cast_safety<int32_t>(min<float>) == CastSafety::kUnderflow);
160 static_assert(cast_safety<int32_t>(max<float>) == CastSafety::kOverflow);
161
162 static_assert(cast_safety<int16_t>(-inf<double>) == CastSafety::kUnderflow);
163 static_assert(cast_safety<int32_t>(inf<double>) == CastSafety::kOverflow);
164 static_assert(cast_safety<int64_t>(NaN<double>) == CastSafety::kOverflow);
165
166 static_assert(cast_safety<int32_t>(static_cast<float>(min<int32_t>)) == CastSafety::kSafe);
167 static_assert(cast_safety<int32_t>(static_cast<float>(max<int32_t>)) == CastSafety::kOverflow);
168 static_assert(cast_safety<int32_t>(static_cast<double>(min<int32_t>)) == CastSafety::kSafe);
169 static_assert(cast_safety<int32_t>(static_cast<double>(max<int32_t>)) == CastSafety::kSafe);
170
171 static_assert(cast_safety<int64_t>(0.0) == CastSafety::kSafe);
172 static_assert(cast_safety<int64_t>(min<double>) == CastSafety::kUnderflow);
173 static_assert(cast_safety<int64_t>(max<double>) == CastSafety::kOverflow);
174
175 static_assert(cast_safety<int64_t>(static_cast<float>(min<int64_t>)) == CastSafety::kSafe);
176 static_assert(cast_safety<int64_t>(static_cast<float>(max<int64_t>)) == CastSafety::kOverflow);
177 static_assert(cast_safety<int64_t>(static_cast<double>(min<int64_t>)) == CastSafety::kSafe);
178 static_assert(cast_safety<int64_t>(static_cast<double>(max<int64_t>)) == CastSafety::kOverflow);
179
TEST(CastSafety,FloatToSigned)180 TEST(CastSafety, FloatToSigned) {
181 constexpr int32_t kMax = ftl::details::safe_limits<int32_t, float>::max();
182 static_assert(kMax == 2'147'483'520);
183 EXPECT_EQ(kMax, static_cast<int32_t>(std::nexttowardf(max<int32_t>, 0)));
184
185 EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(min<int32_t>, 0)), CastSafety::kSafe);
186 EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(max<int32_t>, 0)), CastSafety::kSafe);
187 EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(min<int64_t>, 0)), CastSafety::kSafe);
188 EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(max<int64_t>, 0)), CastSafety::kSafe);
189
190 EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(min<int32_t>, min<float>)),
191 CastSafety::kUnderflow);
192 EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(max<int32_t>, max<float>)),
193 CastSafety::kOverflow);
194 EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(min<int64_t>, min<double>)),
195 CastSafety::kUnderflow);
196 EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(max<int64_t>, max<double>)),
197 CastSafety::kOverflow);
198 }
199
200 } // namespace android::test
201