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 // <codecvt>
10
11 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX26_REMOVED_CODECVT
12
13 // template <class Elem, unsigned long Maxcode = 0x10ffff,
14 // codecvt_mode Mode = (codecvt_mode)0>
15 // class codecvt_utf8_utf16
16 // : public codecvt<Elem, char, mbstate_t>
17 // {
18 // // unspecified
19 // };
20
21 // result
22 // in(stateT& state,
23 // const externT* from, const externT* from_end, const externT*& from_next,
24 // internT* to, internT* to_end, internT*& to_next) const;
25
26 #include <codecvt>
27 #include <cassert>
28
29 #include "test_macros.h"
30
31 template <class CharT, std::size_t = sizeof(CharT)>
32 struct TestHelper;
33 template <class CharT>
34 struct TestHelper<CharT, 2> {
35 static void test();
36 };
37 template <class CharT>
38 struct TestHelper<CharT, 4> {
39 static void test();
40 };
41
42 template <class CharT>
test()43 void TestHelper<CharT, 2>::test() {
44 {
45 typedef std::codecvt_utf8_utf16<CharT, 0x1000> C;
46 C c;
47 CharT w[2] = {0};
48 char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
49 CharT* wp = nullptr;
50 std::mbstate_t m;
51 const char* np = nullptr;
52 std::codecvt_base::result r = c.in(m, n, n + 4, np, w, w + 2, wp);
53 assert(r == std::codecvt_base::error);
54 assert(wp == w);
55 assert(np == n);
56
57 n[0] = char(0xE1);
58 n[1] = char(0x80);
59 n[2] = char(0x85);
60 r = c.in(m, n, n + 3, np, w, w + 2, wp);
61 assert(r == std::codecvt_base::error);
62 assert(wp == w);
63 assert(np == n);
64
65 n[0] = char(0xD1);
66 n[1] = char(0x93);
67 r = c.in(m, n, n + 2, np, w, w + 2, wp);
68 assert(r == std::codecvt_base::ok);
69 assert(wp == w + 1);
70 assert(np == n + 2);
71 assert(w[0] == 0x0453);
72
73 n[0] = char(0x56);
74 r = c.in(m, n, n + 1, np, w, w + 2, wp);
75 assert(r == std::codecvt_base::ok);
76 assert(wp == w + 1);
77 assert(np == n + 1);
78 assert(w[0] == 0x0056);
79 }
80 {
81 typedef std::codecvt_utf8_utf16<CharT, 0x10ffff, std::consume_header> C;
82 C c;
83 CharT w[2] = {0};
84 char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1),
85 char(0x80), char(0x80), char(0x83)};
86 CharT* wp = nullptr;
87 std::mbstate_t m;
88 const char* np = nullptr;
89 std::codecvt_base::result r = c.in(m, n, n + 7, np, w, w + 2, wp);
90 assert(r == std::codecvt_base::ok);
91 assert(wp == w + 2);
92 assert(np == n + 7);
93 assert(w[0] == 0xD8C0);
94 assert(w[1] == 0xDC03);
95
96 n[0] = char(0xE1);
97 n[1] = char(0x80);
98 n[2] = char(0x85);
99 r = c.in(m, n, n + 3, np, w, w + 2, wp);
100 assert(r == std::codecvt_base::ok);
101 assert(wp == w + 1);
102 assert(np == n + 3);
103 assert(w[0] == 0x1005);
104
105 n[0] = char(0xD1);
106 n[1] = char(0x93);
107 r = c.in(m, n, n + 2, np, w, w + 2, wp);
108 assert(r == std::codecvt_base::ok);
109 assert(wp == w + 1);
110 assert(np == n + 2);
111 assert(w[0] == 0x0453);
112
113 n[0] = char(0x56);
114 r = c.in(m, n, n + 1, np, w, w + 2, wp);
115 assert(r == std::codecvt_base::ok);
116 assert(wp == w + 1);
117 assert(np == n + 1);
118 assert(w[0] == 0x0056);
119 }
120 }
121
122 template <class CharT>
test()123 void TestHelper<CharT, 4>::test() {
124 {
125 typedef std::codecvt_utf8_utf16<CharT> C;
126 C c;
127 CharT w[2] = {0};
128 char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
129 CharT* wp = nullptr;
130 std::mbstate_t m;
131 const char* np = nullptr;
132 std::codecvt_base::result r = c.in(m, n, n + 4, np, w, w + 2, wp);
133 assert(r == std::codecvt_base::ok);
134 assert(wp == w + 2);
135 assert(np == n + 4);
136 assert(w[0] == 0xD8C0);
137 assert(w[1] == 0xDC03);
138
139 n[0] = char(0xE1);
140 n[1] = char(0x80);
141 n[2] = char(0x85);
142 r = c.in(m, n, n + 3, np, w, w + 2, wp);
143 assert(r == std::codecvt_base::ok);
144 assert(wp == w + 1);
145 assert(np == n + 3);
146 assert(w[0] == 0x1005);
147
148 n[0] = char(0xD1);
149 n[1] = char(0x93);
150 r = c.in(m, n, n + 2, np, w, w + 2, wp);
151 assert(r == std::codecvt_base::ok);
152 assert(wp == w + 1);
153 assert(np == n + 2);
154 assert(w[0] == 0x0453);
155
156 n[0] = char(0x56);
157 r = c.in(m, n, n + 1, np, w, w + 2, wp);
158 assert(r == std::codecvt_base::ok);
159 assert(wp == w + 1);
160 assert(np == n + 1);
161 assert(w[0] == 0x0056);
162 }
163 {
164 typedef std::codecvt_utf8_utf16<CharT, 0x1000> C;
165 C c;
166 CharT w[2] = {0};
167 char n[4] = {char(0xF1), char(0x80), char(0x80), char(0x83)};
168 CharT* wp = nullptr;
169 std::mbstate_t m;
170 const char* np = nullptr;
171 std::codecvt_base::result r = c.in(m, n, n + 4, np, w, w + 2, wp);
172 assert(r == std::codecvt_base::error);
173 assert(wp == w);
174 assert(np == n);
175
176 n[0] = char(0xE1);
177 n[1] = char(0x80);
178 n[2] = char(0x85);
179 r = c.in(m, n, n + 3, np, w, w + 2, wp);
180 assert(r == std::codecvt_base::error);
181 assert(wp == w);
182 assert(np == n);
183
184 n[0] = char(0xD1);
185 n[1] = char(0x93);
186 r = c.in(m, n, n + 2, np, w, w + 2, wp);
187 assert(r == std::codecvt_base::ok);
188 assert(wp == w + 1);
189 assert(np == n + 2);
190 assert(w[0] == 0x0453);
191
192 n[0] = char(0x56);
193 r = c.in(m, n, n + 1, np, w, w + 2, wp);
194 assert(r == std::codecvt_base::ok);
195 assert(wp == w + 1);
196 assert(np == n + 1);
197 assert(w[0] == 0x0056);
198 }
199 {
200 typedef std::codecvt_utf8_utf16<CharT, 0x10ffff, std::consume_header> C;
201 C c;
202 CharT w[2] = {0};
203 char n[7] = {char(0xEF), char(0xBB), char(0xBF), char(0xF1),
204 char(0x80), char(0x80), char(0x83)};
205 CharT* wp = nullptr;
206 std::mbstate_t m;
207 const char* np = nullptr;
208 std::codecvt_base::result r = c.in(m, n, n + 7, np, w, w + 2, wp);
209 assert(r == std::codecvt_base::ok);
210 assert(wp == w + 2);
211 assert(np == n + 7);
212 assert(w[0] == 0xD8C0);
213 assert(w[1] == 0xDC03);
214
215 n[0] = char(0xE1);
216 n[1] = char(0x80);
217 n[2] = char(0x85);
218 r = c.in(m, n, n + 3, np, w, w + 2, wp);
219 assert(r == std::codecvt_base::ok);
220 assert(wp == w + 1);
221 assert(np == n + 3);
222 assert(w[0] == 0x1005);
223
224 n[0] = char(0xD1);
225 n[1] = char(0x93);
226 r = c.in(m, n, n + 2, np, w, w + 2, wp);
227 assert(r == std::codecvt_base::ok);
228 assert(wp == w + 1);
229 assert(np == n + 2);
230 assert(w[0] == 0x0453);
231
232 n[0] = char(0x56);
233 r = c.in(m, n, n + 1, np, w, w + 2, wp);
234 assert(r == std::codecvt_base::ok);
235 assert(wp == w + 1);
236 assert(np == n + 1);
237 assert(w[0] == 0x0056);
238 }
239 }
240
main(int,char **)241 int main(int, char**) {
242 #if !defined(_WIN32) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
243 TestHelper<wchar_t>::test();
244 #endif
245 TestHelper<char32_t>::test();
246 TestHelper<char16_t>::test();
247
248 return 0;
249 }
250