libcxx/test/support/charconv_test_helpers.h

   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 #ifndef SUPPORT_CHARCONV_TEST_HELPERS_H
  10 #define SUPPORT_CHARCONV_TEST_HELPERS_H
  11
  12 #include <charconv>
  13 #include <cassert>
  14 #include <limits>
  15 #include <numeric>
  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++11
  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 && typename std::make_unsigned<T>::type(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 <= typename std::make_unsigned<X>::type((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         // Poison the buffer for testing whether a successful std::to_chars
 110         // doesn't modify data beyond r.ptr.
 111         std::iota(buf, buf + sizeof(buf), char(1));
 112         r = to_chars(buf, buf + sizeof(buf), v, args...);
 113         assert(r.ec == std::errc{});
 114         for (size_t i = r.ptr - buf; i < sizeof(buf); ++i)
 115             assert(buf[i] == static_cast<char>(i + 1));
 116         *r.ptr = '\0';
 117
 118         auto a = fromchars(buf, r.ptr, args...);
 119         assert(v == a);
 120
 121         auto ep = r.ptr - 1;
 122         r = to_chars(buf, ep, v, args...);
 123         assert(r.ptr == ep);
 124         assert(r.ec == std::errc::value_too_large);
 125     }
 126
 127 private:
 128     static long long fromchars(char const* p, char const* ep, int base, true_type)
 129     {
 130         char* last;
 131         auto r = strtoll(p, &last, base);
 132         assert(last == ep);
 133
 134         return r;
 135     }
 136
 137     static unsigned long long fromchars(char const* p, char const* ep, int base, false_type)
 138     {
 139         char* last;
 140         auto r = strtoull(p, &last, base);
 141         assert(last == ep);
 142
 143         return r;
 144     }
 145
 146     static auto fromchars(char const* p, char const* ep, int base = 10)
 147     -> decltype(fromchars(p, ep, base, std::is_signed<X>()))
 148     {
 149         return fromchars(p, ep, base, std::is_signed<X>());
 150     }
 151
 152     char buf[100];
 153 };
 154
 155 template <typename X>
 156 struct roundtrip_test_base
 157 {
 158     template <typename T, typename... Ts>
 159     void test(T v, Ts... args)
 160     {
 161         using std::from_chars;
 162         using std::to_chars;
 163         std::from_chars_result r2;
 164         std::to_chars_result r;
 165         X x = 0xc;
 166
 167         if (fits_in<X>(v))
 168         {
 169             r = to_chars(buf, buf + sizeof(buf), v, args...);
 170             assert(r.ec == std::errc{});
 171
 172             r2 = from_chars(buf, r.ptr, x, args...);
 173             assert(r2.ptr == r.ptr);
 174             assert(x == X(v));
 175         }
 176         else
 177         {
 178             r = to_chars(buf, buf + sizeof(buf), v, args...);
 179             assert(r.ec == std::errc{});
 180
 181             r2 = from_chars(buf, r.ptr, x, args...);
 182
 183 #ifdef TEST_COMPILER_MSVC
 184     #pragma warning(push)
 185     #pragma warning(disable: 4127) // conditional expression is constant
 186 #endif // TEST_COMPILER_MSVC
 187             if (std::is_signed<T>::value && v < 0 && std::is_unsigned<X>::value)
 188             {
 189                 assert(x == 0xc);
 190                 assert(r2.ptr == buf);
 191                 assert(r2.ec == std::errc::invalid_argument);
 192             }
 193             else
 194             {
 195                 assert(x == 0xc);
 196                 assert(r2.ptr == r.ptr);
 197                 assert(r2.ec == std::errc::result_out_of_range);
 198             }
 199 #ifdef TEST_COMPILER_MSVC
 200     #pragma warning(pop)
 201 #endif // TEST_COMPILER_MSVC
 202         }
 203     }
 204
 205 private:
 206     char buf[100];
 207 };
 208
 209 template <typename... T>
 210 struct type_list
 211 {
 212 };
 213
 214 template <typename L1, typename L2>
 215 struct type_concat;
 216
 217 template <typename... Xs, typename... Ys>
 218 struct type_concat<type_list<Xs...>, type_list<Ys...>>
 219 {
 220     using type = type_list<Xs..., Ys...>;
 221 };
 222
 223 template <typename L1, typename L2>
 224 using concat_t = typename type_concat<L1, L2>::type;
 225
 226 template <typename L1, typename L2>
 227 constexpr auto concat(L1, L2) -> concat_t<L1, L2>
 228 {
 229     return {};
 230 }
 231
 232 auto all_signed = type_list<char, signed char, short, int, long, long long>();
 233 auto all_unsigned = type_list<unsigned char, unsigned short, unsigned int,
 234                               unsigned long, unsigned long long>();
 235 auto integrals = concat(all_signed, all_unsigned);
 236
 237 template <template <typename> class Fn, typename... Ts>
 238 void
 239 run(type_list<Ts...>)
 240 {
 241     int ls[sizeof...(Ts)] = {(Fn<Ts>{}(), 0)...};
 242     (void)ls;
 243 }
 244
 245 #endif // SUPPORT_CHARCONV_TEST_HELPERS_H