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 // <string>
10 
11 // wstring to_wstring(int val);
12 // wstring to_wstring(unsigned val);
13 // wstring to_wstring(long val);
14 // wstring to_wstring(unsigned long val);
15 // wstring to_wstring(long long val);
16 // wstring to_wstring(unsigned long long val);
17 // wstring to_wstring(float val);
18 // wstring to_wstring(double val);
19 // wstring to_wstring(long double val);
20 
21 #include <string>
22 #include <cassert>
23 #include <limits>
24 
25 #include "parse_integer.h"
26 #include "test_macros.h"
27 
28 template <class T>
29 void
test_signed()30 test_signed()
31 {
32     {
33         std::wstring s = std::to_wstring(T(0));
34         assert(s.size() == 1);
35         assert(s[s.size()] == 0);
36         assert(s == L"0");
37     }
38     {
39         std::wstring s = std::to_wstring(T(12345));
40         assert(s.size() == 5);
41         assert(s[s.size()] == 0);
42         assert(s == L"12345");
43     }
44     {
45         std::wstring s = std::to_wstring(T(-12345));
46         assert(s.size() == 6);
47         assert(s[s.size()] == 0);
48         assert(s == L"-12345");
49     }
50     {
51         std::wstring s = std::to_wstring(std::numeric_limits<T>::max());
52         assert(s.size() == std::numeric_limits<T>::digits10 + 1);
53         T t = parse_integer<T>(s);
54         assert(t == std::numeric_limits<T>::max());
55     }
56     {
57         std::wstring s = std::to_wstring(std::numeric_limits<T>::min());
58         T t = parse_integer<T>(s);
59         assert(t == std::numeric_limits<T>::min());
60     }
61 }
62 
63 template <class T>
64 void
test_unsigned()65 test_unsigned()
66 {
67     {
68         std::wstring s = std::to_wstring(T(0));
69         assert(s.size() == 1);
70         assert(s[s.size()] == 0);
71         assert(s == L"0");
72     }
73     {
74         std::wstring s = std::to_wstring(T(12345));
75         assert(s.size() == 5);
76         assert(s[s.size()] == 0);
77         assert(s == L"12345");
78     }
79     {
80         std::wstring s = std::to_wstring(std::numeric_limits<T>::max());
81         assert(s.size() == std::numeric_limits<T>::digits10 + 1);
82         T t = parse_integer<T>(s);
83         assert(t == std::numeric_limits<T>::max());
84     }
85 }
86 
87 template <class T>
88 void
test_float()89 test_float()
90 {
91     {
92         std::wstring s = std::to_wstring(T(0));
93         assert(s.size() == 8);
94         assert(s[s.size()] == 0);
95         assert(s == L"0.000000");
96     }
97     {
98         std::wstring s = std::to_wstring(T(12345));
99         assert(s.size() == 12);
100         assert(s[s.size()] == 0);
101         assert(s == L"12345.000000");
102     }
103     {
104         std::wstring s = std::to_wstring(T(-12345));
105         assert(s.size() == 13);
106         assert(s[s.size()] == 0);
107         assert(s == L"-12345.000000");
108     }
109 }
110 
main(int,char **)111 int main(int, char**)
112 {
113     test_signed<int>();
114     test_signed<long>();
115     test_signed<long long>();
116     test_unsigned<unsigned>();
117     test_unsigned<unsigned long>();
118     test_unsigned<unsigned long long>();
119     test_float<float>();
120     test_float<double>();
121     test_float<long double>();
122 
123   return 0;
124 }
125