1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // UNSUPPORTED: c++03
10 // UNSUPPORTED: !stdlib=libc++ && c++11
11 // UNSUPPORTED: !stdlib=libc++ && c++14
12 
13 // <charconv>
14 
15 // to_chars_result to_chars(char* first, char* last, Integral value,
16 //                          int base = 10)
17 
18 #include <charconv>
19 #include "test_macros.h"
20 #include "charconv_test_helpers.h"
21 
22 #ifndef TEST_HAS_NO_INT128
23 __uint128_t make_u128(__uint128_t a, uint64_t b) {
24   a *= 1000000000000000000UL;
25   a *= 10;
26   return a + b;
27 }
28 
29 __uint128_t make_u128(__uint128_t a, uint64_t b, uint64_t c) {
30   a *= 10000000000000ULL;
31   a += b;
32   a *= 10000000000000ULL;
33   return a + c;
34 }
35 
36 __int128_t make_i128(__int128_t a, int64_t b) {
37   if (a < 0)
38     return -make_u128(-a, b);
39   return make_u128(a, b);
40 }
41 
42 __int128_t make_i128(__int128_t a, __int128_t b, int64_t c) {
43   if (a < 0)
44     return -make_u128(-a, b, c);
45   return make_u128(a, b, c);
46 }
47 #endif
48 
49 template <typename T>
50 struct test_basics : to_chars_test_base<T>
51 {
52     using to_chars_test_base<T>::test;
53     using to_chars_test_base<T>::test_value;
54 
55     void operator()()
56     {
57         test(0, "0");
58         test(42, "42");
59         test(32768, "32768");
60         test(0, "0", 10);
61         test(42, "42", 10);
62         test(32768, "32768", 10);
63         test(0xf, "f", 16);
64         test(0xdeadbeaf, "deadbeaf", 16);
65         test(0755, "755", 8);
66 
67         // Test each len till len of UINT64_MAX = 20 because to_chars algorithm
68         // makes branches based on decimal digits count in the value string
69         // representation.
70         // Test driver automatically skips values not fitting into source type.
71         test(1UL, "1");
72         test(12UL, "12");
73         test(123UL, "123");
74         test(1234UL, "1234");
75         test(12345UL, "12345");
76         test(123456UL, "123456");
77         test(1234567UL, "1234567");
78         test(12345678UL, "12345678");
79         test(123456789UL, "123456789");
80         test(1234567890UL, "1234567890");
81         test(12345678901UL, "12345678901");
82         test(123456789012UL, "123456789012");
83         test(1234567890123UL, "1234567890123");
84         test(12345678901234UL, "12345678901234");
85         test(123456789012345UL, "123456789012345");
86         test(1234567890123456UL, "1234567890123456");
87         test(12345678901234567UL, "12345678901234567");
88         test(123456789012345678UL, "123456789012345678");
89         test(1234567890123456789UL, "1234567890123456789");
90         test(12345678901234567890UL, "12345678901234567890");
91 #ifndef TEST_HAS_NO_INT128
92         test(make_u128(12UL, 3456789012345678901UL), "123456789012345678901");
93         test(make_u128(123UL, 4567890123456789012UL), "1234567890123456789012");
94         test(make_u128(1234UL, 5678901234567890123UL), "12345678901234567890123");
95         test(make_u128(12345UL, 6789012345678901234UL), "123456789012345678901234");
96         test(make_u128(123456UL, 7890123456789012345UL), "1234567890123456789012345");
97         test(make_u128(1234567UL, 8901234567890123456UL), "12345678901234567890123456");
98         test(make_u128(12345678UL, 9012345678901234567UL), "123456789012345678901234567");
99         test(make_u128(123456789UL, 123456789012345678UL), "1234567890123456789012345678");
100         test(make_u128(123UL, 4567890123456UL, 7890123456789UL), "12345678901234567890123456789");
101         test(make_u128(1234UL, 5678901234567UL, 8901234567890UL), "123456789012345678901234567890");
102         test(make_u128(12345UL, 6789012345678UL, 9012345678901UL), "1234567890123456789012345678901");
103         test(make_u128(123456UL, 7890123456789UL, 123456789012UL), "12345678901234567890123456789012");
104         test(make_u128(1234567UL, 8901234567890UL, 1234567890123UL), "123456789012345678901234567890123");
105         test(make_u128(12345678UL, 9012345678901UL, 2345678901234UL), "1234567890123456789012345678901234");
106         test(make_u128(123456789UL, 123456789012UL, 3456789012345UL), "12345678901234567890123456789012345");
107         test(make_u128(1234567890UL, 1234567890123UL, 4567890123456UL), "123456789012345678901234567890123456");
108         test(make_u128(12345678901UL, 2345678901234UL, 5678901234567UL), "1234567890123456789012345678901234567");
109         test(make_u128(123456789012UL, 3456789012345UL, 6789012345678UL), "12345678901234567890123456789012345678");
110         test(make_u128(1234567890123UL, 4567890123456UL, 7890123456789UL), "123456789012345678901234567890123456789");
111 #endif
112 
113         // Test special cases with zeros inside a value string representation,
114         // to_chars algorithm processes them in a special way and should not
115         // skip trailing zeros
116         // Test driver automatically skips values not fitting into source type.
117         test(0UL, "0");
118         test(10UL, "10");
119         test(100UL, "100");
120         test(1000UL, "1000");
121         test(10000UL, "10000");
122         test(100000UL, "100000");
123         test(1000000UL, "1000000");
124         test(10000000UL, "10000000");
125         test(100000000UL, "100000000");
126         test(1000000000UL, "1000000000");
127         test(10000000000UL, "10000000000");
128         test(100000000000UL, "100000000000");
129         test(1000000000000UL, "1000000000000");
130         test(10000000000000UL, "10000000000000");
131         test(100000000000000UL, "100000000000000");
132         test(1000000000000000UL, "1000000000000000");
133         test(10000000000000000UL, "10000000000000000");
134         test(100000000000000000UL, "100000000000000000");
135         test(1000000000000000000UL, "1000000000000000000");
136         test(10000000000000000000UL, "10000000000000000000");
137 #ifndef TEST_HAS_NO_INT128
138         test(make_u128(10UL, 0), "100000000000000000000");
139         test(make_u128(100UL, 0), "1000000000000000000000");
140         test(make_u128(1000UL, 0), "10000000000000000000000");
141         test(make_u128(10000UL, 0), "100000000000000000000000");
142         test(make_u128(100000UL, 0), "1000000000000000000000000");
143         test(make_u128(1000000UL, 0), "10000000000000000000000000");
144         test(make_u128(10000000UL, 0), "100000000000000000000000000");
145         test(make_u128(100000000UL, 0), "1000000000000000000000000000");
146         test(make_u128(100UL, 0, 0), "10000000000000000000000000000");
147         test(make_u128(1000UL, 0, 0), "100000000000000000000000000000");
148         test(make_u128(10000UL, 0, 0), "1000000000000000000000000000000");
149         test(make_u128(100000UL, 0, 0), "10000000000000000000000000000000");
150         test(make_u128(1000000UL, 0, 0), "100000000000000000000000000000000");
151         test(make_u128(10000000UL, 0, 0), "1000000000000000000000000000000000");
152         test(make_u128(100000000UL, 0, 0), "10000000000000000000000000000000000");
153         test(make_u128(1000000000UL, 0, 0), "100000000000000000000000000000000000");
154         test(make_u128(10000000000UL, 0, 0), "1000000000000000000000000000000000000");
155         test(make_u128(100000000000UL, 0, 0), "10000000000000000000000000000000000000");
156         test(make_u128(1000000000000UL, 0, 0), "100000000000000000000000000000000000000");
157 #endif
158 
159         for (int b = 2; b < 37; ++b)
160         {
161             using xl = std::numeric_limits<T>;
162 
163             test_value(1, b);
164             test_value(xl::lowest(), b);
165             test_value((xl::max)(), b);
166             test_value((xl::max)() / 2, b);
167         }
168     }
169 };
170 
171 template <typename T>
172 struct test_signed : to_chars_test_base<T>
173 {
174     using to_chars_test_base<T>::test;
175     using to_chars_test_base<T>::test_value;
176 
177     void operator()()
178     {
179         test(-1, "-1");
180         test(-12, "-12");
181         test(-1, "-1", 10);
182         test(-12, "-12", 10);
183         test(-21734634, "-21734634", 10);
184         test(-2647, "-101001010111", 2);
185         test(-0xcc1, "-cc1", 16);
186 
187         // Test each len till len of INT64_MAX = 19 because to_chars algorithm
188         // makes branches based on decimal digits count in the value string
189         // representation.
190         // Test driver automatically skips values not fitting into source type.
191         test(-1L, "-1");
192         test(-12L, "-12");
193         test(-123L, "-123");
194         test(-1234L, "-1234");
195         test(-12345L, "-12345");
196         test(-123456L, "-123456");
197         test(-1234567L, "-1234567");
198         test(-12345678L, "-12345678");
199         test(-123456789L, "-123456789");
200         test(-1234567890L, "-1234567890");
201         test(-12345678901L, "-12345678901");
202         test(-123456789012L, "-123456789012");
203         test(-1234567890123L, "-1234567890123");
204         test(-12345678901234L, "-12345678901234");
205         test(-123456789012345L, "-123456789012345");
206         test(-1234567890123456L, "-1234567890123456");
207         test(-12345678901234567L, "-12345678901234567");
208         test(-123456789012345678L, "-123456789012345678");
209         test(-1234567890123456789L, "-1234567890123456789");
210 #ifndef TEST_HAS_NO_INT128
211         test(make_i128(-1L, 2345678901234567890L), "-12345678901234567890");
212         test(make_i128(-12L, 3456789012345678901L), "-123456789012345678901");
213         test(make_i128(-123L, 4567890123456789012L), "-1234567890123456789012");
214         test(make_i128(-1234L, 5678901234567890123L), "-12345678901234567890123");
215         test(make_i128(-12345L, 6789012345678901234L), "-123456789012345678901234");
216         test(make_i128(-123456L, 7890123456789012345L), "-1234567890123456789012345");
217         test(make_i128(-1234567L, 8901234567890123456L), "-12345678901234567890123456");
218         test(make_i128(-12345678L, 9012345678901234567L), "-123456789012345678901234567");
219         test(make_i128(-123456789L, 123456789012345678L), "-1234567890123456789012345678");
220         test(make_i128(-1234567890L, 1234567890123456789L), "-12345678901234567890123456789");
221         test(make_i128(-123L, 4567890123456L, 7890123456789L), "-12345678901234567890123456789");
222         test(make_i128(-1234L, 5678901234567L, 8901234567890L), "-123456789012345678901234567890");
223         test(make_i128(-12345L, 6789012345678L, 9012345678901L), "-1234567890123456789012345678901");
224         test(make_i128(-123456L, 7890123456789L, 123456789012L), "-12345678901234567890123456789012");
225         test(make_i128(-1234567L, 8901234567890L, 1234567890123L), "-123456789012345678901234567890123");
226         test(make_i128(-12345678L, 9012345678901L, 2345678901234L), "-1234567890123456789012345678901234");
227         test(make_i128(-123456789L, 123456789012L, 3456789012345L), "-12345678901234567890123456789012345");
228         test(make_i128(-1234567890L, 1234567890123L, 4567890123456L), "-123456789012345678901234567890123456");
229         test(make_i128(-12345678901L, 2345678901234L, 5678901234567L), "-1234567890123456789012345678901234567");
230         test(make_i128(-123456789012L, 3456789012345L, 6789012345678L), "-12345678901234567890123456789012345678");
231         test(make_i128(-1234567890123L, 4567890123456L, 7890123456789L), "-123456789012345678901234567890123456789");
232 #endif
233 
234         // Test special cases with zeros inside a value string representation,
235         // to_chars algorithm processes them in a special way and should not
236         // skip trailing zeros
237         // Test driver automatically skips values not fitting into source type.
238         test(-10L, "-10");
239         test(-100L, "-100");
240         test(-1000L, "-1000");
241         test(-10000L, "-10000");
242         test(-100000L, "-100000");
243         test(-1000000L, "-1000000");
244         test(-10000000L, "-10000000");
245         test(-100000000L, "-100000000");
246         test(-1000000000L, "-1000000000");
247         test(-10000000000L, "-10000000000");
248         test(-100000000000L, "-100000000000");
249         test(-1000000000000L, "-1000000000000");
250         test(-10000000000000L, "-10000000000000");
251         test(-100000000000000L, "-100000000000000");
252         test(-1000000000000000L, "-1000000000000000");
253         test(-10000000000000000L, "-10000000000000000");
254         test(-100000000000000000L, "-100000000000000000");
255         test(-1000000000000000000L, "-1000000000000000000");
256 #ifndef TEST_HAS_NO_INT128
257         test(make_i128(-1L, 0L), "-10000000000000000000");
258         test(make_i128(-10L, 0L), "-100000000000000000000");
259         test(make_i128(-100L, 0L), "-1000000000000000000000");
260         test(make_i128(-1000L, 0L), "-10000000000000000000000");
261         test(make_i128(-10000L, 0L), "-100000000000000000000000");
262         test(make_i128(-100000L, 0L), "-1000000000000000000000000");
263         test(make_i128(-1000000L, 0L), "-10000000000000000000000000");
264         test(make_i128(-10000000L, 0L), "-100000000000000000000000000");
265         test(make_i128(-100000000L, 0L), "-1000000000000000000000000000");
266         test(make_i128(-1000000000L, 0L), "-10000000000000000000000000000");
267         test(make_i128(-100L, 0L, 0L), "-10000000000000000000000000000");
268         test(make_i128(-1000L, 0L, 0L), "-100000000000000000000000000000");
269         test(make_i128(-10000L, 0L, 0L), "-1000000000000000000000000000000");
270         test(make_i128(-100000L, 0L, 0L), "-10000000000000000000000000000000");
271         test(make_i128(-1000000L, 0L, 0L), "-100000000000000000000000000000000");
272         test(make_i128(-10000000L, 0L, 0L), "-1000000000000000000000000000000000");
273         test(make_i128(-100000000L, 0L, 0L), "-10000000000000000000000000000000000");
274         test(make_i128(-1000000000L, 0L, 0L), "-100000000000000000000000000000000000");
275         test(make_i128(-10000000000L, 0L, 0L), "-1000000000000000000000000000000000000");
276         test(make_i128(-100000000000L, 0L, 0L), "-10000000000000000000000000000000000000");
277         test(make_i128(-1000000000000L, 0L, 0L), "-100000000000000000000000000000000000000");
278 #endif
279 
280         for (int b = 2; b < 37; ++b)
281         {
282             using xl = std::numeric_limits<T>;
283 
284             test_value(0, b);
285             test_value(xl::lowest(), b);
286             test_value((xl::max)(), b);
287         }
288     }
289 };
290 
291 int main(int, char**)
292 {
293     run<test_basics>(integrals);
294     run<test_signed>(all_signed);
295 
296   return 0;
297 }
298