charconv_test_helpers.h (5765B)
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 #ifndef SUPPORT_CHARCONV_TEST_HELPERS_H 11 #define SUPPORT_CHARCONV_TEST_HELPERS_H 12 13 #include <charconv> 14 #include <cassert> 15 #include <limits> 16 #include <string.h> 17 #include <stdlib.h> 18 19 #include "test_macros.h" 20 21 #if TEST_STD_VER <= 11 22 #error This file requires C++14 23 #endif 24 25 using std::false_type; 26 using std::true_type; 27 28 template <typename To, typename From> 29 constexpr auto 30 is_non_narrowing(From a) -> decltype(To{a}, true_type()) 31 { 32 return {}; 33 } 34 35 template <typename To> 36 constexpr auto 37 is_non_narrowing(...) -> false_type 38 { 39 return {}; 40 } 41 42 template <typename X, typename T> 43 constexpr bool 44 _fits_in(T, true_type /* non-narrowing*/, ...) 45 { 46 return true; 47 } 48 49 template <typename X, typename T, typename xl = std::numeric_limits<X>> 50 constexpr bool 51 _fits_in(T v, false_type, true_type /* T signed*/, true_type /* X signed */) 52 { 53 return xl::lowest() <= v && v <= (xl::max)(); 54 } 55 56 template <typename X, typename T, typename xl = std::numeric_limits<X>> 57 constexpr bool 58 _fits_in(T v, false_type, true_type /* T signed */, false_type /* X unsigned*/) 59 { 60 return 0 <= v && std::make_unsigned_t<T>(v) <= (xl::max)(); 61 } 62 63 template <typename X, typename T, typename xl = std::numeric_limits<X>> 64 constexpr bool 65 _fits_in(T v, false_type, false_type /* T unsigned */, ...) 66 { 67 return v <= std::make_unsigned_t<X>((xl::max)()); 68 } 69 70 template <typename X, typename T> 71 constexpr bool 72 fits_in(T v) 73 { 74 return _fits_in<X>(v, is_non_narrowing<X>(v), std::is_signed<T>(), 75 std::is_signed<X>()); 76 } 77 78 template <typename X> 79 struct to_chars_test_base 80 { 81 template <typename T, size_t N, typename... Ts> 82 void test(T v, char const (&expect)[N], Ts... args) 83 { 84 using std::to_chars; 85 std::to_chars_result r; 86 87 constexpr size_t len = N - 1; 88 static_assert(len > 0, "expected output won't be empty"); 89 90 if (!fits_in<X>(v)) 91 return; 92 93 r = to_chars(buf, buf + len - 1, X(v), args...); 94 assert(r.ptr == buf + len - 1); 95 assert(r.ec == std::errc::value_too_large); 96 97 r = to_chars(buf, buf + sizeof(buf), X(v), args...); 98 assert(r.ptr == buf + len); 99 assert(r.ec == std::errc{}); 100 assert(memcmp(buf, expect, len) == 0); 101 } 102 103 template <typename... Ts> 104 void test_value(X v, Ts... args) 105 { 106 using std::to_chars; 107 std::to_chars_result r; 108 109 r = to_chars(buf, buf + sizeof(buf), v, args...); 110 assert(r.ec == std::errc{}); 111 *r.ptr = '\0'; 112 113 auto a = fromchars(buf, r.ptr, args...); 114 assert(v == a); 115 116 auto ep = r.ptr - 1; 117 r = to_chars(buf, ep, v, args...); 118 assert(r.ptr == ep); 119 assert(r.ec == std::errc::value_too_large); 120 } 121 122 private: 123 static auto fromchars(char const* p, char const* ep, int base, true_type) 124 { 125 char* last; 126 auto r = strtoll(p, &last, base); 127 assert(last == ep); 128 129 return r; 130 } 131 132 static auto fromchars(char const* p, char const* ep, int base, false_type) 133 { 134 char* last; 135 auto r = strtoull(p, &last, base); 136 assert(last == ep); 137 138 return r; 139 } 140 141 static auto fromchars(char const* p, char const* ep, int base = 10) 142 { 143 return fromchars(p, ep, base, std::is_signed<X>()); 144 } 145 146 char buf[100]; 147 }; 148 149 template <typename X> 150 struct roundtrip_test_base 151 { 152 template <typename T, typename... Ts> 153 void test(T v, Ts... args) 154 { 155 using std::from_chars; 156 using std::to_chars; 157 std::from_chars_result r2; 158 std::to_chars_result r; 159 X x = 0xc; 160 161 if (fits_in<X>(v)) 162 { 163 r = to_chars(buf, buf + sizeof(buf), v, args...); 164 assert(r.ec == std::errc{}); 165 166 r2 = from_chars(buf, r.ptr, x, args...); 167 assert(r2.ptr == r.ptr); 168 assert(x == X(v)); 169 } 170 else 171 { 172 r = to_chars(buf, buf + sizeof(buf), v, args...); 173 assert(r.ec == std::errc{}); 174 175 r2 = from_chars(buf, r.ptr, x, args...); 176 177 if (std::is_signed<T>::value && v < 0 && std::is_unsigned<X>::value) 178 { 179 assert(x == 0xc); 180 assert(r2.ptr == buf); 181 assert(r2.ec == std::errc::invalid_argument); 182 } 183 else 184 { 185 assert(x == 0xc); 186 assert(r2.ptr == r.ptr); 187 assert(r2.ec == std::errc::result_out_of_range); 188 } 189 } 190 } 191 192 private: 193 char buf[100]; 194 }; 195 196 template <typename... T> 197 struct type_list 198 { 199 }; 200 201 template <typename L1, typename L2> 202 struct type_concat; 203 204 template <typename... Xs, typename... Ys> 205 struct type_concat<type_list<Xs...>, type_list<Ys...>> 206 { 207 using type = type_list<Xs..., Ys...>; 208 }; 209 210 template <typename L1, typename L2> 211 using concat_t = typename type_concat<L1, L2>::type; 212 213 template <typename L1, typename L2> 214 constexpr auto concat(L1, L2) -> concat_t<L1, L2> 215 { 216 return {}; 217 } 218 219 auto all_signed = type_list<char, signed char, short, int, long, long long>(); 220 auto all_unsigned = type_list<unsigned char, unsigned short, unsigned int, 221 unsigned long, unsigned long long>(); 222 auto integrals = concat(all_signed, all_unsigned); 223 224 template <template <typename> class Fn, typename... Ts> 225 void 226 run(type_list<Ts...>) 227 { 228 int ls[sizeof...(Ts)] = {(Fn<Ts>{}(), 0)...}; 229 (void)ls; 230 } 231 232 #endif // SUPPORT_CHARCONV_TEST_HELPERS_H