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_utf16
16// : public codecvt<Elem, char, mbstate_t>
17// {
18// // unspecified
19// };
20
21// int length(stateT& state, const externT* from, const externT* from_end,
22// size_t max) const;
23
24#include <codecvt>
25#include <cassert>
26
27#include "test_macros.h"
28
29template <class CharT, std::size_t = sizeof(CharT)>
30struct TestHelper;
31
32template <class CharT>
33struct TestHelper<CharT, 2> {
34 static void test();
35};
36
37template <class CharT>
38struct TestHelper<CharT, 4> {
39 static void test();
40};
41
42template <class CharT>
43void TestHelper<CharT, 2>::test() {
44 {
45 typedef std::codecvt_utf16<char16_t> C;
46 C c;
47 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
48 std::mbstate_t m;
49 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
50 assert(r == 0);
51
52 n[0] = char(0x10);
53 n[1] = char(0x05);
54 r = c.length(state&: m, from: n, end: n + 2, max: 2);
55 assert(r == 2);
56
57 n[0] = char(0x04);
58 n[1] = char(0x53);
59 r = c.length(state&: m, from: n, end: n + 2, max: 2);
60 assert(r == 2);
61
62 n[0] = char(0x00);
63 n[1] = char(0x56);
64 r = c.length(state&: m, from: n, end: n + 2, max: 2);
65 assert(r == 2);
66 }
67 {
68 typedef std::codecvt_utf16<char16_t, 0x1000> C;
69 C c;
70 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
71 std::mbstate_t m;
72 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
73 assert(r == 0);
74
75 n[0] = char(0x10);
76 n[1] = char(0x05);
77 r = c.length(state&: m, from: n, end: n + 2, max: 2);
78 assert(r == 0);
79
80 n[0] = char(0x04);
81 n[1] = char(0x53);
82 r = c.length(state&: m, from: n, end: n + 2, max: 2);
83 assert(r == 2);
84
85 n[0] = char(0x00);
86 n[1] = char(0x56);
87 r = c.length(state&: m, from: n, end: n + 2, max: 2);
88 assert(r == 2);
89 }
90 {
91 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::consume_header> C;
92 C c;
93 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
94 std::mbstate_t m;
95 int r = c.length(state&: m, from: n, end: n + 6, max: 2);
96 assert(r == 2);
97
98 n[0] = char(0x10);
99 n[1] = char(0x05);
100 r = c.length(state&: m, from: n, end: n + 2, max: 2);
101 assert(r == 2);
102
103 n[0] = char(0x04);
104 n[1] = char(0x53);
105 r = c.length(state&: m, from: n, end: n + 2, max: 2);
106 assert(r == 2);
107
108 n[0] = char(0x00);
109 n[1] = char(0x56);
110 r = c.length(state&: m, from: n, end: n + 2, max: 2);
111 assert(r == 2);
112 }
113 {
114 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::little_endian> C;
115 C c;
116 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
117 std::mbstate_t m;
118 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
119 assert(r == 0);
120
121 n[1] = char(0x10);
122 n[0] = char(0x05);
123 r = c.length(state&: m, from: n, end: n + 2, max: 2);
124 assert(r == 2);
125
126 n[1] = char(0x04);
127 n[0] = char(0x53);
128 r = c.length(state&: m, from: n, end: n + 2, max: 2);
129 assert(r == 2);
130
131 n[1] = char(0x00);
132 n[0] = char(0x56);
133 r = c.length(state&: m, from: n, end: n + 2, max: 2);
134 assert(r == 2);
135 }
136 {
137 typedef std::codecvt_utf16<char16_t, 0x1000, std::little_endian> C;
138 C c;
139 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
140 std::mbstate_t m;
141 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
142 assert(r == 0);
143
144 n[1] = char(0x10);
145 n[0] = char(0x05);
146 r = c.length(state&: m, from: n, end: n + 2, max: 2);
147 assert(r == 0);
148
149 n[1] = char(0x04);
150 n[0] = char(0x53);
151 r = c.length(state&: m, from: n, end: n + 2, max: 2);
152 assert(r == 2);
153
154 n[1] = char(0x00);
155 n[0] = char(0x56);
156 r = c.length(state&: m, from: n, end: n + 2, max: 2);
157 assert(r == 2);
158 }
159 {
160 typedef std::codecvt_utf16<char16_t, 0x10ffff, std::codecvt_mode(std::consume_header | std::little_endian)> C;
161 C c;
162 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
163 std::mbstate_t m;
164 int r = c.length(state&: m, from: n, end: n + 6, max: 2);
165 assert(r == 2);
166
167 n[1] = char(0x10);
168 n[0] = char(0x05);
169 r = c.length(state&: m, from: n, end: n + 2, max: 2);
170 assert(r == 2);
171
172 n[1] = char(0x04);
173 n[0] = char(0x53);
174 r = c.length(state&: m, from: n, end: n + 2, max: 2);
175 assert(r == 2);
176
177 n[1] = char(0x00);
178 n[0] = char(0x56);
179 r = c.length(state&: m, from: n, end: n + 2, max: 2);
180 assert(r == 2);
181 }
182}
183
184template <class CharT>
185void TestHelper<CharT, 4>::test() {
186 {
187 typedef std::codecvt_utf16<char32_t> C;
188 C c;
189 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
190 std::mbstate_t m;
191 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
192 assert(r == 4);
193
194 n[0] = char(0x10);
195 n[1] = char(0x05);
196 r = c.length(state&: m, from: n, end: n + 2, max: 2);
197 assert(r == 2);
198
199 n[0] = char(0x04);
200 n[1] = char(0x53);
201 r = c.length(state&: m, from: n, end: n + 2, max: 2);
202 assert(r == 2);
203
204 n[0] = char(0x00);
205 n[1] = char(0x56);
206 r = c.length(state&: m, from: n, end: n + 2, max: 2);
207 assert(r == 2);
208 }
209 {
210 typedef std::codecvt_utf16<char32_t, 0x1000> C;
211 C c;
212 char n[4] = {char(0xD8), char(0xC0), char(0xDC), char(0x03)};
213 std::mbstate_t m;
214 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
215 assert(r == 0);
216
217 n[0] = char(0x10);
218 n[1] = char(0x05);
219 r = c.length(state&: m, from: n, end: n + 2, max: 2);
220 assert(r == 0);
221
222 n[0] = char(0x04);
223 n[1] = char(0x53);
224 r = c.length(state&: m, from: n, end: n + 2, max: 2);
225 assert(r == 2);
226
227 n[0] = char(0x00);
228 n[1] = char(0x56);
229 r = c.length(state&: m, from: n, end: n + 2, max: 2);
230 assert(r == 2);
231 }
232 {
233 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::consume_header> C;
234 C c;
235 char n[6] = {char(0xFE), char(0xFF), char(0xD8), char(0xC0), char(0xDC), char(0x03)};
236 std::mbstate_t m;
237 int r = c.length(state&: m, from: n, end: n + 6, max: 2);
238 assert(r == 6);
239
240 n[0] = char(0x10);
241 n[1] = char(0x05);
242 r = c.length(state&: m, from: n, end: n + 2, max: 2);
243 assert(r == 2);
244
245 n[0] = char(0x04);
246 n[1] = char(0x53);
247 r = c.length(state&: m, from: n, end: n + 2, max: 2);
248 assert(r == 2);
249
250 n[0] = char(0x00);
251 n[1] = char(0x56);
252 r = c.length(state&: m, from: n, end: n + 2, max: 2);
253 assert(r == 2);
254 }
255 {
256 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::little_endian> C;
257 C c;
258 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
259 std::mbstate_t m;
260 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
261 assert(r == 4);
262
263 n[1] = char(0x10);
264 n[0] = char(0x05);
265 r = c.length(state&: m, from: n, end: n + 2, max: 2);
266 assert(r == 2);
267
268 n[1] = char(0x04);
269 n[0] = char(0x53);
270 r = c.length(state&: m, from: n, end: n + 2, max: 2);
271 assert(r == 2);
272
273 n[1] = char(0x00);
274 n[0] = char(0x56);
275 r = c.length(state&: m, from: n, end: n + 2, max: 2);
276 assert(r == 2);
277 }
278 {
279 typedef std::codecvt_utf16<char32_t, 0x1000, std::little_endian> C;
280 C c;
281 char n[4] = {char(0xC0), char(0xD8), char(0x03), char(0xDC)};
282 std::mbstate_t m;
283 int r = c.length(state&: m, from: n, end: n + 4, max: 2);
284 assert(r == 0);
285
286 n[1] = char(0x10);
287 n[0] = char(0x05);
288 r = c.length(state&: m, from: n, end: n + 2, max: 2);
289 assert(r == 0);
290
291 n[1] = char(0x04);
292 n[0] = char(0x53);
293 r = c.length(state&: m, from: n, end: n + 2, max: 2);
294 assert(r == 2);
295
296 n[1] = char(0x00);
297 n[0] = char(0x56);
298 r = c.length(state&: m, from: n, end: n + 2, max: 2);
299 assert(r == 2);
300 }
301 {
302 typedef std::codecvt_utf16<char32_t, 0x10ffff, std::codecvt_mode(std::consume_header | std::little_endian)> C;
303 C c;
304 char n[6] = {char(0xFF), char(0xFE), char(0xC0), char(0xD8), char(0x03), char(0xDC)};
305 std::mbstate_t m;
306 int r = c.length(state&: m, from: n, end: n + 6, max: 2);
307 assert(r == 6);
308
309 n[1] = char(0x10);
310 n[0] = char(0x05);
311 r = c.length(state&: m, from: n, end: n + 2, max: 2);
312 assert(r == 2);
313
314 n[1] = char(0x04);
315 n[0] = char(0x53);
316 r = c.length(state&: m, from: n, end: n + 2, max: 2);
317 assert(r == 2);
318
319 n[1] = char(0x00);
320 n[0] = char(0x56);
321 r = c.length(state&: m, from: n, end: n + 2, max: 2);
322 assert(r == 2);
323 }
324}
325
326int main(int, char**) {
327 TestHelper<wchar_t>::test();
328 TestHelper<char16_t>::test();
329 TestHelper<char32_t>::test();
330 return 0;
331}
332

source code of libcxx/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp