1 //===- llvm/unittest/Support/ConvertUTFTest.cpp - ConvertUTF tests --------===//
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 #include "llvm/Support/ConvertUTF.h"
10 #include "llvm/ADT/ArrayRef.h"
11 #include "gtest/gtest.h"
12 #include <string>
13 #include <vector>
14 
15 using namespace llvm;
16 
17 TEST(ConvertUTFTest, ConvertUTF16LittleEndianToUTF8String) {
18   // Src is the look of disapproval.
19   static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c";
20   ArrayRef<char> Ref(Src, sizeof(Src) - 1);
21   std::string Result;
22   bool Success = convertUTF16ToUTF8String(Ref, Result);
23   EXPECT_TRUE(Success);
24   std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
25   EXPECT_EQ(Expected, Result);
26 }
27 
28 TEST(ConvertUTFTest, ConvertUTF16BigEndianToUTF8String) {
29   // Src is the look of disapproval.
30   static const char Src[] = "\xfe\xff\x0c\xa0\x00_\x0c\xa0";
31   ArrayRef<char> Ref(Src, sizeof(Src) - 1);
32   std::string Result;
33   bool Success = convertUTF16ToUTF8String(Ref, Result);
34   EXPECT_TRUE(Success);
35   std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
36   EXPECT_EQ(Expected, Result);
37 }
38 
39 TEST(ConvertUTFTest, ConvertUTF8ToUTF16String) {
40   // Src is the look of disapproval.
41   static const char Src[] = "\xe0\xb2\xa0_\xe0\xb2\xa0";
42   StringRef Ref(Src, sizeof(Src) - 1);
43   SmallVector<UTF16, 5> Result;
44   bool Success = convertUTF8ToUTF16String(Ref, Result);
45   EXPECT_TRUE(Success);
46   static const UTF16 Expected[] = {0x0CA0, 0x005f, 0x0CA0, 0};
47   ASSERT_EQ(3u, Result.size());
48   for (int I = 0, E = 3; I != E; ++I)
49     EXPECT_EQ(Expected[I], Result[I]);
50 }
51 
52 TEST(ConvertUTFTest, OddLengthInput) {
53   std::string Result;
54   bool Success = convertUTF16ToUTF8String(makeArrayRef("xxxxx", 5), Result);
55   EXPECT_FALSE(Success);
56 }
57 
58 TEST(ConvertUTFTest, Empty) {
59   std::string Result;
60   bool Success = convertUTF16ToUTF8String(llvm::ArrayRef<char>(None), Result);
61   EXPECT_TRUE(Success);
62   EXPECT_TRUE(Result.empty());
63 }
64 
65 TEST(ConvertUTFTest, HasUTF16BOM) {
66   bool HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xff\xfe", 2));
67   EXPECT_TRUE(HasBOM);
68   HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff", 2));
69   EXPECT_TRUE(HasBOM);
70   HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff ", 3));
71   EXPECT_TRUE(HasBOM); // Don't care about odd lengths.
72   HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff\x00asdf", 6));
73   EXPECT_TRUE(HasBOM);
74 
75   HasBOM = hasUTF16ByteOrderMark(None);
76   EXPECT_FALSE(HasBOM);
77   HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe", 1));
78   EXPECT_FALSE(HasBOM);
79 }
80 
81 TEST(ConvertUTFTest, UTF16WrappersForConvertUTF16ToUTF8String) {
82   // Src is the look of disapproval.
83   static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c";
84   ArrayRef<UTF16> SrcRef = makeArrayRef((const UTF16 *)Src, 4);
85   std::string Result;
86   bool Success = convertUTF16ToUTF8String(SrcRef, Result);
87   EXPECT_TRUE(Success);
88   std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
89   EXPECT_EQ(Expected, Result);
90 }
91 
92 TEST(ConvertUTFTest, ConvertUTF8toWide) {
93   // Src is the look of disapproval.
94   static const char Src[] = "\xe0\xb2\xa0_\xe0\xb2\xa0";
95   std::wstring Result;
96   bool Success = ConvertUTF8toWide((const char*)Src, Result);
97   EXPECT_TRUE(Success);
98   std::wstring Expected(L"\x0ca0_\x0ca0");
99   EXPECT_EQ(Expected, Result);
100   Result.clear();
101   Success = ConvertUTF8toWide(StringRef(Src, 7), Result);
102   EXPECT_TRUE(Success);
103   EXPECT_EQ(Expected, Result);
104 }
105 
106 TEST(ConvertUTFTest, convertWideToUTF8) {
107   // Src is the look of disapproval.
108   static const wchar_t Src[] = L"\x0ca0_\x0ca0";
109   std::string Result;
110   bool Success = convertWideToUTF8(Src, Result);
111   EXPECT_TRUE(Success);
112   std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
113   EXPECT_EQ(Expected, Result);
114 }
115 
116 struct ConvertUTFResultContainer {
117   ConversionResult ErrorCode;
118   std::vector<unsigned> UnicodeScalars;
119 
120   ConvertUTFResultContainer(ConversionResult ErrorCode)
121       : ErrorCode(ErrorCode) {}
122 
123   ConvertUTFResultContainer
124   withScalars(unsigned US0 = 0x110000, unsigned US1 = 0x110000,
125               unsigned US2 = 0x110000, unsigned US3 = 0x110000,
126               unsigned US4 = 0x110000, unsigned US5 = 0x110000,
127               unsigned US6 = 0x110000, unsigned US7 = 0x110000) {
128     ConvertUTFResultContainer Result(*this);
129     if (US0 != 0x110000)
130       Result.UnicodeScalars.push_back(US0);
131     if (US1 != 0x110000)
132       Result.UnicodeScalars.push_back(US1);
133     if (US2 != 0x110000)
134       Result.UnicodeScalars.push_back(US2);
135     if (US3 != 0x110000)
136       Result.UnicodeScalars.push_back(US3);
137     if (US4 != 0x110000)
138       Result.UnicodeScalars.push_back(US4);
139     if (US5 != 0x110000)
140       Result.UnicodeScalars.push_back(US5);
141     if (US6 != 0x110000)
142       Result.UnicodeScalars.push_back(US6);
143     if (US7 != 0x110000)
144       Result.UnicodeScalars.push_back(US7);
145     return Result;
146   }
147 };
148 
149 std::pair<ConversionResult, std::vector<unsigned>>
150 ConvertUTF8ToUnicodeScalarsLenient(StringRef S) {
151   const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(S.data());
152 
153   const UTF8 *SourceNext = SourceStart;
154   std::vector<UTF32> Decoded(S.size(), 0);
155   UTF32 *TargetStart = Decoded.data();
156 
157   auto ErrorCode =
158       ConvertUTF8toUTF32(&SourceNext, SourceStart + S.size(), &TargetStart,
159                          Decoded.data() + Decoded.size(), lenientConversion);
160 
161   Decoded.resize(TargetStart - Decoded.data());
162 
163   return std::make_pair(ErrorCode, Decoded);
164 }
165 
166 std::pair<ConversionResult, std::vector<unsigned>>
167 ConvertUTF8ToUnicodeScalarsPartialLenient(StringRef S) {
168   const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(S.data());
169 
170   const UTF8 *SourceNext = SourceStart;
171   std::vector<UTF32> Decoded(S.size(), 0);
172   UTF32 *TargetStart = Decoded.data();
173 
174   auto ErrorCode = ConvertUTF8toUTF32Partial(
175       &SourceNext, SourceStart + S.size(), &TargetStart,
176       Decoded.data() + Decoded.size(), lenientConversion);
177 
178   Decoded.resize(TargetStart - Decoded.data());
179 
180   return std::make_pair(ErrorCode, Decoded);
181 }
182 
183 ::testing::AssertionResult
184 CheckConvertUTF8ToUnicodeScalars(ConvertUTFResultContainer Expected,
185                                  StringRef S, bool Partial = false) {
186   ConversionResult ErrorCode;
187   std::vector<unsigned> Decoded;
188   if (!Partial)
189     std::tie(ErrorCode, Decoded) = ConvertUTF8ToUnicodeScalarsLenient(S);
190   else
191     std::tie(ErrorCode, Decoded) = ConvertUTF8ToUnicodeScalarsPartialLenient(S);
192 
193   if (Expected.ErrorCode != ErrorCode)
194     return ::testing::AssertionFailure() << "Expected error code "
195                                          << Expected.ErrorCode << ", actual "
196                                          << ErrorCode;
197 
198   if (Expected.UnicodeScalars != Decoded)
199     return ::testing::AssertionFailure()
200            << "Expected lenient decoded result:\n"
201            << ::testing::PrintToString(Expected.UnicodeScalars) << "\n"
202            << "Actual result:\n" << ::testing::PrintToString(Decoded);
203 
204   return ::testing::AssertionSuccess();
205 }
206 
207 TEST(ConvertUTFTest, UTF8ToUTF32Lenient) {
208 
209   //
210   // 1-byte sequences
211   //
212 
213   // U+0041 LATIN CAPITAL LETTER A
214   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
215       ConvertUTFResultContainer(conversionOK).withScalars(0x0041), "\x41"));
216 
217   //
218   // 2-byte sequences
219   //
220 
221   // U+0283 LATIN SMALL LETTER ESH
222   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
223       ConvertUTFResultContainer(conversionOK).withScalars(0x0283),
224       "\xca\x83"));
225 
226   // U+03BA GREEK SMALL LETTER KAPPA
227   // U+1F79 GREEK SMALL LETTER OMICRON WITH OXIA
228   // U+03C3 GREEK SMALL LETTER SIGMA
229   // U+03BC GREEK SMALL LETTER MU
230   // U+03B5 GREEK SMALL LETTER EPSILON
231   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
232       ConvertUTFResultContainer(conversionOK)
233           .withScalars(0x03ba, 0x1f79, 0x03c3, 0x03bc, 0x03b5),
234       "\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5"));
235 
236   //
237   // 3-byte sequences
238   //
239 
240   // U+4F8B CJK UNIFIED IDEOGRAPH-4F8B
241   // U+6587 CJK UNIFIED IDEOGRAPH-6587
242   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
243       ConvertUTFResultContainer(conversionOK).withScalars(0x4f8b, 0x6587),
244       "\xe4\xbe\x8b\xe6\x96\x87"));
245 
246   // U+D55C HANGUL SYLLABLE HAN
247   // U+AE00 HANGUL SYLLABLE GEUL
248   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
249       ConvertUTFResultContainer(conversionOK).withScalars(0xd55c, 0xae00),
250       "\xed\x95\x9c\xea\xb8\x80"));
251 
252   // U+1112 HANGUL CHOSEONG HIEUH
253   // U+1161 HANGUL JUNGSEONG A
254   // U+11AB HANGUL JONGSEONG NIEUN
255   // U+1100 HANGUL CHOSEONG KIYEOK
256   // U+1173 HANGUL JUNGSEONG EU
257   // U+11AF HANGUL JONGSEONG RIEUL
258   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
259       ConvertUTFResultContainer(conversionOK)
260           .withScalars(0x1112, 0x1161, 0x11ab, 0x1100, 0x1173, 0x11af),
261       "\xe1\x84\x92\xe1\x85\xa1\xe1\x86\xab\xe1\x84\x80\xe1\x85\xb3"
262       "\xe1\x86\xaf"));
263 
264   //
265   // 4-byte sequences
266   //
267 
268   // U+E0100 VARIATION SELECTOR-17
269   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
270       ConvertUTFResultContainer(conversionOK).withScalars(0x000E0100),
271       "\xf3\xa0\x84\x80"));
272 
273   //
274   // First possible sequence of a certain length
275   //
276 
277   // U+0000 NULL
278   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
279       ConvertUTFResultContainer(conversionOK).withScalars(0x0000),
280       StringRef("\x00", 1)));
281 
282   // U+0080 PADDING CHARACTER
283   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
284       ConvertUTFResultContainer(conversionOK).withScalars(0x0080),
285       "\xc2\x80"));
286 
287   // U+0800 SAMARITAN LETTER ALAF
288   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
289       ConvertUTFResultContainer(conversionOK).withScalars(0x0800),
290       "\xe0\xa0\x80"));
291 
292   // U+10000 LINEAR B SYLLABLE B008 A
293   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
294       ConvertUTFResultContainer(conversionOK).withScalars(0x10000),
295       "\xf0\x90\x80\x80"));
296 
297   // U+200000 (invalid)
298   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
299       ConvertUTFResultContainer(sourceIllegal)
300           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
301       "\xf8\x88\x80\x80\x80"));
302 
303   // U+4000000 (invalid)
304   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
305       ConvertUTFResultContainer(sourceIllegal)
306           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
307       "\xfc\x84\x80\x80\x80\x80"));
308 
309   //
310   // Last possible sequence of a certain length
311   //
312 
313   // U+007F DELETE
314   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
315       ConvertUTFResultContainer(conversionOK).withScalars(0x007f), "\x7f"));
316 
317   // U+07FF (unassigned)
318   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
319       ConvertUTFResultContainer(conversionOK).withScalars(0x07ff),
320       "\xdf\xbf"));
321 
322   // U+FFFF (noncharacter)
323   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
324       ConvertUTFResultContainer(conversionOK).withScalars(0xffff),
325       "\xef\xbf\xbf"));
326 
327   // U+1FFFFF (invalid)
328   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
329       ConvertUTFResultContainer(sourceIllegal)
330           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
331       "\xf7\xbf\xbf\xbf"));
332 
333   // U+3FFFFFF (invalid)
334   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
335       ConvertUTFResultContainer(sourceIllegal)
336           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
337       "\xfb\xbf\xbf\xbf\xbf"));
338 
339   // U+7FFFFFFF (invalid)
340   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
341       ConvertUTFResultContainer(sourceIllegal)
342           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
343       "\xfd\xbf\xbf\xbf\xbf\xbf"));
344 
345   //
346   // Other boundary conditions
347   //
348 
349   // U+D7FF (unassigned)
350   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
351       ConvertUTFResultContainer(conversionOK).withScalars(0xd7ff),
352       "\xed\x9f\xbf"));
353 
354   // U+E000 (private use)
355   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
356       ConvertUTFResultContainer(conversionOK).withScalars(0xe000),
357       "\xee\x80\x80"));
358 
359   // U+FFFD REPLACEMENT CHARACTER
360   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
361       ConvertUTFResultContainer(conversionOK).withScalars(0xfffd),
362       "\xef\xbf\xbd"));
363 
364   // U+10FFFF (noncharacter)
365   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
366       ConvertUTFResultContainer(conversionOK).withScalars(0x10ffff),
367       "\xf4\x8f\xbf\xbf"));
368 
369   // U+110000 (invalid)
370   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
371       ConvertUTFResultContainer(sourceIllegal)
372           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
373       "\xf4\x90\x80\x80"));
374 
375   //
376   // Unexpected continuation bytes
377   //
378 
379   // A sequence of unexpected continuation bytes that don't follow a first
380   // byte, every byte is a maximal subpart.
381 
382   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
383       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\x80"));
384   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
385       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xbf"));
386   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
387       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
388       "\x80\x80"));
389   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
390       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
391       "\x80\xbf"));
392   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
393       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
394       "\xbf\x80"));
395   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
396       ConvertUTFResultContainer(sourceIllegal)
397           .withScalars(0xfffd, 0xfffd, 0xfffd),
398       "\x80\xbf\x80"));
399   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
400       ConvertUTFResultContainer(sourceIllegal)
401           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
402       "\x80\xbf\x80\xbf"));
403   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
404       ConvertUTFResultContainer(sourceIllegal)
405           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
406       "\x80\xbf\x82\xbf\xaa"));
407   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
408       ConvertUTFResultContainer(sourceIllegal)
409           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
410       "\xaa\xb0\xbb\xbf\xaa\xa0"));
411   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
412       ConvertUTFResultContainer(sourceIllegal)
413           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
414       "\xaa\xb0\xbb\xbf\xaa\xa0\x8f"));
415 
416   // All continuation bytes (0x80--0xbf).
417   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
418       ConvertUTFResultContainer(sourceIllegal)
419           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
420                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
421           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
422                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
423           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
424                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
425           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
426                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
427           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
428                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
429           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
430                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
431           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
432                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
433           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
434                        0xfffd, 0xfffd, 0xfffd, 0xfffd),
435       "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
436       "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
437       "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
438       "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"));
439 
440   //
441   // Lonely start bytes
442   //
443 
444   // Start bytes of 2-byte sequences (0xc0--0xdf).
445   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
446       ConvertUTFResultContainer(sourceIllegal)
447           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
448                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
449           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
450                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
451           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
452                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
453           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
454                        0xfffd, 0xfffd, 0xfffd, 0xfffd),
455       "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
456       "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"));
457 
458   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
459       ConvertUTFResultContainer(sourceIllegal)
460           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
461                        0xfffd, 0x0020, 0xfffd, 0x0020)
462           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
463                        0xfffd, 0x0020, 0xfffd, 0x0020)
464           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
465                        0xfffd, 0x0020, 0xfffd, 0x0020)
466           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
467                        0xfffd, 0x0020, 0xfffd, 0x0020)
468           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
469                        0xfffd, 0x0020, 0xfffd, 0x0020)
470           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
471                        0xfffd, 0x0020, 0xfffd, 0x0020)
472           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
473                        0xfffd, 0x0020, 0xfffd, 0x0020)
474           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
475                        0xfffd, 0x0020, 0xfffd, 0x0020),
476       "\xc0\x20\xc1\x20\xc2\x20\xc3\x20\xc4\x20\xc5\x20\xc6\x20\xc7\x20"
477       "\xc8\x20\xc9\x20\xca\x20\xcb\x20\xcc\x20\xcd\x20\xce\x20\xcf\x20"
478       "\xd0\x20\xd1\x20\xd2\x20\xd3\x20\xd4\x20\xd5\x20\xd6\x20\xd7\x20"
479       "\xd8\x20\xd9\x20\xda\x20\xdb\x20\xdc\x20\xdd\x20\xde\x20\xdf\x20"));
480 
481   // Start bytes of 3-byte sequences (0xe0--0xef).
482   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
483       ConvertUTFResultContainer(sourceIllegal)
484           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
485                        0xfffd, 0xfffd, 0xfffd, 0xfffd)
486           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
487                        0xfffd, 0xfffd, 0xfffd, 0xfffd),
488       "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"));
489 
490   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
491       ConvertUTFResultContainer(sourceIllegal)
492           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
493                        0xfffd, 0x0020, 0xfffd, 0x0020)
494           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
495                        0xfffd, 0x0020, 0xfffd, 0x0020)
496           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
497                        0xfffd, 0x0020, 0xfffd, 0x0020)
498           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
499                        0xfffd, 0x0020, 0xfffd, 0x0020),
500       "\xe0\x20\xe1\x20\xe2\x20\xe3\x20\xe4\x20\xe5\x20\xe6\x20\xe7\x20"
501       "\xe8\x20\xe9\x20\xea\x20\xeb\x20\xec\x20\xed\x20\xee\x20\xef\x20"));
502 
503   // Start bytes of 4-byte sequences (0xf0--0xf7).
504   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
505       ConvertUTFResultContainer(sourceIllegal)
506           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
507                        0xfffd, 0xfffd, 0xfffd, 0xfffd),
508       "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7"));
509 
510   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
511       ConvertUTFResultContainer(sourceIllegal)
512           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
513                        0xfffd, 0x0020, 0xfffd, 0x0020)
514           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
515                        0xfffd, 0x0020, 0xfffd, 0x0020),
516       "\xf0\x20\xf1\x20\xf2\x20\xf3\x20\xf4\x20\xf5\x20\xf6\x20\xf7\x20"));
517 
518   // Start bytes of 5-byte sequences (0xf8--0xfb).
519   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
520       ConvertUTFResultContainer(sourceIllegal)
521           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
522       "\xf8\xf9\xfa\xfb"));
523 
524   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
525       ConvertUTFResultContainer(sourceIllegal)
526           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
527                        0xfffd, 0x0020, 0xfffd, 0x0020),
528       "\xf8\x20\xf9\x20\xfa\x20\xfb\x20"));
529 
530   // Start bytes of 6-byte sequences (0xfc--0xfd).
531   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
532       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
533       "\xfc\xfd"));
534 
535   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
536       ConvertUTFResultContainer(sourceIllegal)
537           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020),
538       "\xfc\x20\xfd\x20"));
539 
540   //
541   // Other bytes (0xc0--0xc1, 0xfe--0xff).
542   //
543 
544   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
545       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xc0"));
546   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
547       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xc1"));
548   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
549       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfe"));
550   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
551       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xff"));
552 
553   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
554       ConvertUTFResultContainer(sourceIllegal)
555           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
556       "\xc0\xc1\xfe\xff"));
557 
558   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
559       ConvertUTFResultContainer(sourceIllegal)
560           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
561       "\xfe\xfe\xff\xff"));
562 
563   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
564       ConvertUTFResultContainer(sourceIllegal)
565           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
566       "\xfe\x80\x80\x80\x80\x80"));
567 
568   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
569       ConvertUTFResultContainer(sourceIllegal)
570           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
571       "\xff\x80\x80\x80\x80\x80"));
572 
573   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
574       ConvertUTFResultContainer(sourceIllegal)
575           .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
576                        0xfffd, 0x0020, 0xfffd, 0x0020),
577       "\xc0\x20\xc1\x20\xfe\x20\xff\x20"));
578 
579   //
580   // Sequences with one continuation byte missing
581   //
582 
583   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
584       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xc2"));
585   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
586       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xdf"));
587   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
588       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
589       "\xe0\xa0"));
590   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
591       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
592       "\xe0\xbf"));
593   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
594       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
595       "\xe1\x80"));
596   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
597       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
598       "\xec\xbf"));
599   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
600       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
601       "\xed\x80"));
602   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
603       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
604       "\xed\x9f"));
605   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
606       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
607       "\xee\x80"));
608   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
609       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
610       "\xef\xbf"));
611   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
612       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
613       "\xf0\x90\x80"));
614   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
615       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
616       "\xf0\xbf\xbf"));
617   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
618       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
619       "\xf1\x80\x80"));
620   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
621       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
622       "\xf3\xbf\xbf"));
623   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
624       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
625       "\xf4\x80\x80"));
626   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
627       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
628       "\xf4\x8f\xbf"));
629 
630   // Overlong sequences with one trailing byte missing.
631   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
632       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
633       "\xc0"));
634   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
635       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
636       "\xc1"));
637   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
638       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
639       "\xe0\x80"));
640   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
641       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
642       "\xe0\x9f"));
643   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
644       ConvertUTFResultContainer(sourceIllegal)
645           .withScalars(0xfffd, 0xfffd, 0xfffd),
646       "\xf0\x80\x80"));
647   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
648       ConvertUTFResultContainer(sourceIllegal)
649           .withScalars(0xfffd, 0xfffd, 0xfffd),
650       "\xf0\x8f\x80"));
651   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
652       ConvertUTFResultContainer(sourceIllegal)
653           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
654       "\xf8\x80\x80\x80"));
655   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
656       ConvertUTFResultContainer(sourceIllegal)
657           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
658       "\xfc\x80\x80\x80\x80"));
659 
660   // Sequences that represent surrogates with one trailing byte missing.
661   // High surrogates
662   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
663       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
664       "\xed\xa0"));
665   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
666       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
667       "\xed\xac"));
668   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
669       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
670       "\xed\xaf"));
671   // Low surrogates
672   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
673       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
674       "\xed\xb0"));
675   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
676       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
677       "\xed\xb4"));
678   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
679       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
680       "\xed\xbf"));
681 
682   // Ill-formed 4-byte sequences.
683   // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
684   // U+1100xx (invalid)
685   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
686       ConvertUTFResultContainer(sourceIllegal)
687           .withScalars(0xfffd, 0xfffd, 0xfffd),
688       "\xf4\x90\x80"));
689   // U+13FBxx (invalid)
690   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
691       ConvertUTFResultContainer(sourceIllegal)
692           .withScalars(0xfffd, 0xfffd, 0xfffd),
693       "\xf4\xbf\xbf"));
694   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
695       ConvertUTFResultContainer(sourceIllegal)
696           .withScalars(0xfffd, 0xfffd, 0xfffd),
697       "\xf5\x80\x80"));
698   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
699       ConvertUTFResultContainer(sourceIllegal)
700           .withScalars(0xfffd, 0xfffd, 0xfffd),
701       "\xf6\x80\x80"));
702   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
703       ConvertUTFResultContainer(sourceIllegal)
704           .withScalars(0xfffd, 0xfffd, 0xfffd),
705       "\xf7\x80\x80"));
706   // U+1FFBxx (invalid)
707   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
708       ConvertUTFResultContainer(sourceIllegal)
709           .withScalars(0xfffd, 0xfffd, 0xfffd),
710       "\xf7\xbf\xbf"));
711 
712   // Ill-formed 5-byte sequences.
713   // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
714   // U+2000xx (invalid)
715   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
716       ConvertUTFResultContainer(sourceIllegal)
717           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
718       "\xf8\x88\x80\x80"));
719   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
720       ConvertUTFResultContainer(sourceIllegal)
721           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
722       "\xf8\xbf\xbf\xbf"));
723   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
724       ConvertUTFResultContainer(sourceIllegal)
725           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
726       "\xf9\x80\x80\x80"));
727   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
728       ConvertUTFResultContainer(sourceIllegal)
729           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
730       "\xfa\x80\x80\x80"));
731   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
732       ConvertUTFResultContainer(sourceIllegal)
733           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
734       "\xfb\x80\x80\x80"));
735   // U+3FFFFxx (invalid)
736   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
737       ConvertUTFResultContainer(sourceIllegal)
738           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
739       "\xfb\xbf\xbf\xbf"));
740 
741   // Ill-formed 6-byte sequences.
742   // 1111110u 10uuuuuu 10uzzzzz 10zzzyyyy 10yyyyxx 10xxxxxx
743   // U+40000xx (invalid)
744   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
745       ConvertUTFResultContainer(sourceIllegal)
746           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
747       "\xfc\x84\x80\x80\x80"));
748   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
749       ConvertUTFResultContainer(sourceIllegal)
750           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
751       "\xfc\xbf\xbf\xbf\xbf"));
752   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
753       ConvertUTFResultContainer(sourceIllegal)
754           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
755       "\xfd\x80\x80\x80\x80"));
756   // U+7FFFFFxx (invalid)
757   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
758       ConvertUTFResultContainer(sourceIllegal)
759           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
760       "\xfd\xbf\xbf\xbf\xbf"));
761 
762   //
763   // Sequences with two continuation bytes missing
764   //
765 
766   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
767       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
768       "\xf0\x90"));
769   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
770       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
771       "\xf0\xbf"));
772   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
773       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
774       "\xf1\x80"));
775   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
776       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
777       "\xf3\xbf"));
778   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
779       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
780       "\xf4\x80"));
781   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
782       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
783       "\xf4\x8f"));
784 
785   // Overlong sequences with two trailing byte missing.
786   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
787       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xe0"));
788   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
789       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
790       "\xf0\x80"));
791   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
792       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
793       "\xf0\x8f"));
794   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
795       ConvertUTFResultContainer(sourceIllegal)
796           .withScalars(0xfffd, 0xfffd, 0xfffd),
797       "\xf8\x80\x80"));
798   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
799       ConvertUTFResultContainer(sourceIllegal)
800           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
801       "\xfc\x80\x80\x80"));
802 
803   // Sequences that represent surrogates with two trailing bytes missing.
804   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
805       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xed"));
806 
807   // Ill-formed 4-byte sequences.
808   // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
809   // U+110yxx (invalid)
810   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
811       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
812       "\xf4\x90"));
813   // U+13Fyxx (invalid)
814   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
815       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
816       "\xf4\xbf"));
817   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
818       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
819       "\xf5\x80"));
820   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
821       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
822       "\xf6\x80"));
823   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
824       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
825       "\xf7\x80"));
826   // U+1FFyxx (invalid)
827   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
828       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
829       "\xf7\xbf"));
830 
831   // Ill-formed 5-byte sequences.
832   // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
833   // U+200yxx (invalid)
834   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
835       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
836       "\xf8\x88\x80"));
837   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
838       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
839       "\xf8\xbf\xbf"));
840   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
841       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
842       "\xf9\x80\x80"));
843   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
844       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
845       "\xfa\x80\x80"));
846   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
847       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
848       "\xfb\x80\x80"));
849   // U+3FFFyxx (invalid)
850   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
851       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
852       "\xfb\xbf\xbf"));
853 
854   // Ill-formed 6-byte sequences.
855   // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
856   // U+4000yxx (invalid)
857   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
858       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
859       "\xfc\x84\x80\x80"));
860   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
861       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
862       "\xfc\xbf\xbf\xbf"));
863   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
864       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
865       "\xfd\x80\x80\x80"));
866   // U+7FFFFyxx (invalid)
867   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
868       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
869       "\xfd\xbf\xbf\xbf"));
870 
871   //
872   // Sequences with three continuation bytes missing
873   //
874 
875   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
876       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf0"));
877   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
878       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf1"));
879   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
880       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf2"));
881   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
882       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf3"));
883   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
884       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf4"));
885 
886   // Broken overlong sequences.
887   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
888       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf0"));
889   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
890       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
891       "\xf8\x80"));
892   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
893       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
894       "\xfc\x80\x80"));
895 
896   // Ill-formed 4-byte sequences.
897   // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
898   // U+14yyxx (invalid)
899   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
900       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf5"));
901   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
902       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf6"));
903   // U+1Cyyxx (invalid)
904   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
905       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf7"));
906 
907   // Ill-formed 5-byte sequences.
908   // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
909   // U+20yyxx (invalid)
910   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
911       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
912       "\xf8\x88"));
913   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
914       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
915       "\xf8\xbf"));
916   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
917       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
918       "\xf9\x80"));
919   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
920       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
921       "\xfa\x80"));
922   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
923       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
924       "\xfb\x80"));
925   // U+3FCyyxx (invalid)
926   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
927       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
928       "\xfb\xbf"));
929 
930   // Ill-formed 6-byte sequences.
931   // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
932   // U+400yyxx (invalid)
933   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
934       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
935       "\xfc\x84\x80"));
936   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
937       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
938       "\xfc\xbf\xbf"));
939   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
940       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
941       "\xfd\x80\x80"));
942   // U+7FFCyyxx (invalid)
943   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
944       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
945       "\xfd\xbf\xbf"));
946 
947   //
948   // Sequences with four continuation bytes missing
949   //
950 
951   // Ill-formed 5-byte sequences.
952   // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
953   // U+uzyyxx (invalid)
954   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
955       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf8"));
956   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
957       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf9"));
958   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
959       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfa"));
960   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
961       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfb"));
962   // U+3zyyxx (invalid)
963   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
964       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfb"));
965 
966   // Broken overlong sequences.
967   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
968       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf8"));
969   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
970       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
971       "\xfc\x80"));
972 
973   // Ill-formed 6-byte sequences.
974   // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
975   // U+uzzyyxx (invalid)
976   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
977       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
978       "\xfc\x84"));
979   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
980       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
981       "\xfc\xbf"));
982   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
983       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
984       "\xfd\x80"));
985   // U+7Fzzyyxx (invalid)
986   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
987       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
988       "\xfd\xbf"));
989 
990   //
991   // Sequences with five continuation bytes missing
992   //
993 
994   // Ill-formed 6-byte sequences.
995   // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
996   // U+uzzyyxx (invalid)
997   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
998       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfc"));
999   // U+uuzzyyxx (invalid)
1000   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1001       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfd"));
1002 
1003   //
1004   // Consecutive sequences with trailing bytes missing
1005   //
1006 
1007   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1008       ConvertUTFResultContainer(sourceIllegal)
1009           .withScalars(0xfffd, /**/ 0xfffd, 0xfffd, /**/ 0xfffd, 0xfffd, 0xfffd)
1010           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd)
1011           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd)
1012           .withScalars(0xfffd, /**/ 0xfffd, /**/ 0xfffd, 0xfffd, 0xfffd)
1013           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd)
1014           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1015       "\xc0" "\xe0\x80" "\xf0\x80\x80"
1016       "\xf8\x80\x80\x80"
1017       "\xfc\x80\x80\x80\x80"
1018       "\xdf" "\xef\xbf" "\xf7\xbf\xbf"
1019       "\xfb\xbf\xbf\xbf"
1020       "\xfd\xbf\xbf\xbf\xbf"));
1021 
1022   //
1023   // Overlong UTF-8 sequences
1024   //
1025 
1026   // U+002F SOLIDUS
1027   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1028       ConvertUTFResultContainer(conversionOK).withScalars(0x002f), "\x2f"));
1029 
1030   // Overlong sequences of the above.
1031   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1032       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
1033       "\xc0\xaf"));
1034   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1035       ConvertUTFResultContainer(sourceIllegal)
1036           .withScalars(0xfffd, 0xfffd, 0xfffd),
1037       "\xe0\x80\xaf"));
1038   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1039       ConvertUTFResultContainer(sourceIllegal)
1040           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
1041       "\xf0\x80\x80\xaf"));
1042   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1043       ConvertUTFResultContainer(sourceIllegal)
1044           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1045       "\xf8\x80\x80\x80\xaf"));
1046   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1047       ConvertUTFResultContainer(sourceIllegal)
1048           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1049       "\xfc\x80\x80\x80\x80\xaf"));
1050 
1051   // U+0000 NULL
1052   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1053       ConvertUTFResultContainer(conversionOK).withScalars(0x0000),
1054       StringRef("\x00", 1)));
1055 
1056   // Overlong sequences of the above.
1057   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1058       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
1059       "\xc0\x80"));
1060   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1061       ConvertUTFResultContainer(sourceIllegal)
1062           .withScalars(0xfffd, 0xfffd, 0xfffd),
1063       "\xe0\x80\x80"));
1064   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1065       ConvertUTFResultContainer(sourceIllegal)
1066           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
1067       "\xf0\x80\x80\x80"));
1068   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1069       ConvertUTFResultContainer(sourceIllegal)
1070           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1071       "\xf8\x80\x80\x80\x80"));
1072   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1073       ConvertUTFResultContainer(sourceIllegal)
1074           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1075       "\xfc\x80\x80\x80\x80\x80"));
1076 
1077   // Other overlong sequences.
1078   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1079       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
1080       "\xc0\xbf"));
1081   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1082       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
1083       "\xc1\x80"));
1084   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1085       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
1086       "\xc1\xbf"));
1087   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1088       ConvertUTFResultContainer(sourceIllegal)
1089           .withScalars(0xfffd, 0xfffd, 0xfffd),
1090       "\xe0\x9f\xbf"));
1091   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1092       ConvertUTFResultContainer(sourceIllegal)
1093           .withScalars(0xfffd, 0xfffd, 0xfffd),
1094       "\xed\xa0\x80"));
1095   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1096       ConvertUTFResultContainer(sourceIllegal)
1097           .withScalars(0xfffd, 0xfffd, 0xfffd),
1098       "\xed\xbf\xbf"));
1099   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1100       ConvertUTFResultContainer(sourceIllegal)
1101           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
1102       "\xf0\x8f\x80\x80"));
1103   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1104       ConvertUTFResultContainer(sourceIllegal)
1105           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
1106       "\xf0\x8f\xbf\xbf"));
1107   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1108       ConvertUTFResultContainer(sourceIllegal)
1109           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1110       "\xf8\x87\xbf\xbf\xbf"));
1111   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1112       ConvertUTFResultContainer(sourceIllegal)
1113           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1114       "\xfc\x83\xbf\xbf\xbf\xbf"));
1115 
1116   //
1117   // Isolated surrogates
1118   //
1119 
1120   // Unicode 6.3.0:
1121   //
1122   //    D71.  High-surrogate code point: A Unicode code point in the range
1123   //    U+D800 to U+DBFF.
1124   //
1125   //    D73.  Low-surrogate code point: A Unicode code point in the range
1126   //    U+DC00 to U+DFFF.
1127 
1128   // Note: U+E0100 is <DB40 DD00> in UTF16.
1129 
1130   // High surrogates
1131 
1132   // U+D800
1133   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1134       ConvertUTFResultContainer(sourceIllegal)
1135           .withScalars(0xfffd, 0xfffd, 0xfffd),
1136       "\xed\xa0\x80"));
1137 
1138   // U+DB40
1139   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1140       ConvertUTFResultContainer(sourceIllegal)
1141           .withScalars(0xfffd, 0xfffd, 0xfffd),
1142       "\xed\xac\xa0"));
1143 
1144   // U+DBFF
1145   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1146       ConvertUTFResultContainer(sourceIllegal)
1147           .withScalars(0xfffd, 0xfffd, 0xfffd),
1148       "\xed\xaf\xbf"));
1149 
1150   // Low surrogates
1151 
1152   // U+DC00
1153   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1154       ConvertUTFResultContainer(sourceIllegal)
1155           .withScalars(0xfffd, 0xfffd, 0xfffd),
1156       "\xed\xb0\x80"));
1157 
1158   // U+DD00
1159   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1160       ConvertUTFResultContainer(sourceIllegal)
1161           .withScalars(0xfffd, 0xfffd, 0xfffd),
1162       "\xed\xb4\x80"));
1163 
1164   // U+DFFF
1165   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1166       ConvertUTFResultContainer(sourceIllegal)
1167           .withScalars(0xfffd, 0xfffd, 0xfffd),
1168       "\xed\xbf\xbf"));
1169 
1170   // Surrogate pairs
1171 
1172   // U+D800 U+DC00
1173   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1174       ConvertUTFResultContainer(sourceIllegal)
1175           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1176       "\xed\xa0\x80\xed\xb0\x80"));
1177 
1178   // U+D800 U+DD00
1179   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1180       ConvertUTFResultContainer(sourceIllegal)
1181           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1182       "\xed\xa0\x80\xed\xb4\x80"));
1183 
1184   // U+D800 U+DFFF
1185   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1186       ConvertUTFResultContainer(sourceIllegal)
1187           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1188       "\xed\xa0\x80\xed\xbf\xbf"));
1189 
1190   // U+DB40 U+DC00
1191   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1192       ConvertUTFResultContainer(sourceIllegal)
1193           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1194       "\xed\xac\xa0\xed\xb0\x80"));
1195 
1196   // U+DB40 U+DD00
1197   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1198       ConvertUTFResultContainer(sourceIllegal)
1199           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1200       "\xed\xac\xa0\xed\xb4\x80"));
1201 
1202   // U+DB40 U+DFFF
1203   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1204       ConvertUTFResultContainer(sourceIllegal)
1205           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1206       "\xed\xac\xa0\xed\xbf\xbf"));
1207 
1208   // U+DBFF U+DC00
1209   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1210       ConvertUTFResultContainer(sourceIllegal)
1211           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1212       "\xed\xaf\xbf\xed\xb0\x80"));
1213 
1214   // U+DBFF U+DD00
1215   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1216       ConvertUTFResultContainer(sourceIllegal)
1217           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1218       "\xed\xaf\xbf\xed\xb4\x80"));
1219 
1220   // U+DBFF U+DFFF
1221   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1222       ConvertUTFResultContainer(sourceIllegal)
1223           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
1224       "\xed\xaf\xbf\xed\xbf\xbf"));
1225 
1226   //
1227   // Noncharacters
1228   //
1229 
1230   // Unicode 6.3.0:
1231   //
1232   //    D14.  Noncharacter: A code point that is permanently reserved for
1233   //    internal use and that should never be interchanged. Noncharacters
1234   //    consist of the values U+nFFFE and U+nFFFF (where n is from 0 to 1016)
1235   //    and the values U+FDD0..U+FDEF.
1236 
1237   // U+FFFE
1238   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1239       ConvertUTFResultContainer(conversionOK).withScalars(0xfffe),
1240       "\xef\xbf\xbe"));
1241 
1242   // U+FFFF
1243   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1244       ConvertUTFResultContainer(conversionOK).withScalars(0xffff),
1245       "\xef\xbf\xbf"));
1246 
1247   // U+1FFFE
1248   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1249       ConvertUTFResultContainer(conversionOK).withScalars(0x1fffe),
1250       "\xf0\x9f\xbf\xbe"));
1251 
1252   // U+1FFFF
1253   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1254       ConvertUTFResultContainer(conversionOK).withScalars(0x1ffff),
1255       "\xf0\x9f\xbf\xbf"));
1256 
1257   // U+2FFFE
1258   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1259       ConvertUTFResultContainer(conversionOK).withScalars(0x2fffe),
1260       "\xf0\xaf\xbf\xbe"));
1261 
1262   // U+2FFFF
1263   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1264       ConvertUTFResultContainer(conversionOK).withScalars(0x2ffff),
1265       "\xf0\xaf\xbf\xbf"));
1266 
1267   // U+3FFFE
1268   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1269       ConvertUTFResultContainer(conversionOK).withScalars(0x3fffe),
1270       "\xf0\xbf\xbf\xbe"));
1271 
1272   // U+3FFFF
1273   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1274       ConvertUTFResultContainer(conversionOK).withScalars(0x3ffff),
1275       "\xf0\xbf\xbf\xbf"));
1276 
1277   // U+4FFFE
1278   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1279       ConvertUTFResultContainer(conversionOK).withScalars(0x4fffe),
1280       "\xf1\x8f\xbf\xbe"));
1281 
1282   // U+4FFFF
1283   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1284       ConvertUTFResultContainer(conversionOK).withScalars(0x4ffff),
1285       "\xf1\x8f\xbf\xbf"));
1286 
1287   // U+5FFFE
1288   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1289       ConvertUTFResultContainer(conversionOK).withScalars(0x5fffe),
1290       "\xf1\x9f\xbf\xbe"));
1291 
1292   // U+5FFFF
1293   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1294       ConvertUTFResultContainer(conversionOK).withScalars(0x5ffff),
1295       "\xf1\x9f\xbf\xbf"));
1296 
1297   // U+6FFFE
1298   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1299       ConvertUTFResultContainer(conversionOK).withScalars(0x6fffe),
1300       "\xf1\xaf\xbf\xbe"));
1301 
1302   // U+6FFFF
1303   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1304       ConvertUTFResultContainer(conversionOK).withScalars(0x6ffff),
1305       "\xf1\xaf\xbf\xbf"));
1306 
1307   // U+7FFFE
1308   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1309       ConvertUTFResultContainer(conversionOK).withScalars(0x7fffe),
1310       "\xf1\xbf\xbf\xbe"));
1311 
1312   // U+7FFFF
1313   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1314       ConvertUTFResultContainer(conversionOK).withScalars(0x7ffff),
1315       "\xf1\xbf\xbf\xbf"));
1316 
1317   // U+8FFFE
1318   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1319       ConvertUTFResultContainer(conversionOK).withScalars(0x8fffe),
1320       "\xf2\x8f\xbf\xbe"));
1321 
1322   // U+8FFFF
1323   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1324       ConvertUTFResultContainer(conversionOK).withScalars(0x8ffff),
1325       "\xf2\x8f\xbf\xbf"));
1326 
1327   // U+9FFFE
1328   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1329       ConvertUTFResultContainer(conversionOK).withScalars(0x9fffe),
1330       "\xf2\x9f\xbf\xbe"));
1331 
1332   // U+9FFFF
1333   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1334       ConvertUTFResultContainer(conversionOK).withScalars(0x9ffff),
1335       "\xf2\x9f\xbf\xbf"));
1336 
1337   // U+AFFFE
1338   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1339       ConvertUTFResultContainer(conversionOK).withScalars(0xafffe),
1340       "\xf2\xaf\xbf\xbe"));
1341 
1342   // U+AFFFF
1343   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1344       ConvertUTFResultContainer(conversionOK).withScalars(0xaffff),
1345       "\xf2\xaf\xbf\xbf"));
1346 
1347   // U+BFFFE
1348   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1349       ConvertUTFResultContainer(conversionOK).withScalars(0xbfffe),
1350       "\xf2\xbf\xbf\xbe"));
1351 
1352   // U+BFFFF
1353   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1354       ConvertUTFResultContainer(conversionOK).withScalars(0xbffff),
1355       "\xf2\xbf\xbf\xbf"));
1356 
1357   // U+CFFFE
1358   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1359       ConvertUTFResultContainer(conversionOK).withScalars(0xcfffe),
1360       "\xf3\x8f\xbf\xbe"));
1361 
1362   // U+CFFFF
1363   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1364       ConvertUTFResultContainer(conversionOK).withScalars(0xcfffF),
1365       "\xf3\x8f\xbf\xbf"));
1366 
1367   // U+DFFFE
1368   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1369       ConvertUTFResultContainer(conversionOK).withScalars(0xdfffe),
1370       "\xf3\x9f\xbf\xbe"));
1371 
1372   // U+DFFFF
1373   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1374       ConvertUTFResultContainer(conversionOK).withScalars(0xdffff),
1375       "\xf3\x9f\xbf\xbf"));
1376 
1377   // U+EFFFE
1378   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1379       ConvertUTFResultContainer(conversionOK).withScalars(0xefffe),
1380       "\xf3\xaf\xbf\xbe"));
1381 
1382   // U+EFFFF
1383   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1384       ConvertUTFResultContainer(conversionOK).withScalars(0xeffff),
1385       "\xf3\xaf\xbf\xbf"));
1386 
1387   // U+FFFFE
1388   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1389       ConvertUTFResultContainer(conversionOK).withScalars(0xffffe),
1390       "\xf3\xbf\xbf\xbe"));
1391 
1392   // U+FFFFF
1393   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1394       ConvertUTFResultContainer(conversionOK).withScalars(0xfffff),
1395       "\xf3\xbf\xbf\xbf"));
1396 
1397   // U+10FFFE
1398   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1399       ConvertUTFResultContainer(conversionOK).withScalars(0x10fffe),
1400       "\xf4\x8f\xbf\xbe"));
1401 
1402   // U+10FFFF
1403   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1404       ConvertUTFResultContainer(conversionOK).withScalars(0x10ffff),
1405       "\xf4\x8f\xbf\xbf"));
1406 
1407   // U+FDD0
1408   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1409       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd0),
1410       "\xef\xb7\x90"));
1411 
1412   // U+FDD1
1413   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1414       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd1),
1415       "\xef\xb7\x91"));
1416 
1417   // U+FDD2
1418   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1419       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd2),
1420       "\xef\xb7\x92"));
1421 
1422   // U+FDD3
1423   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1424       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd3),
1425       "\xef\xb7\x93"));
1426 
1427   // U+FDD4
1428   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1429       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd4),
1430       "\xef\xb7\x94"));
1431 
1432   // U+FDD5
1433   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1434       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd5),
1435       "\xef\xb7\x95"));
1436 
1437   // U+FDD6
1438   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1439       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd6),
1440       "\xef\xb7\x96"));
1441 
1442   // U+FDD7
1443   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1444       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd7),
1445       "\xef\xb7\x97"));
1446 
1447   // U+FDD8
1448   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1449       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd8),
1450       "\xef\xb7\x98"));
1451 
1452   // U+FDD9
1453   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1454       ConvertUTFResultContainer(conversionOK).withScalars(0xfdd9),
1455       "\xef\xb7\x99"));
1456 
1457   // U+FDDA
1458   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1459       ConvertUTFResultContainer(conversionOK).withScalars(0xfdda),
1460       "\xef\xb7\x9a"));
1461 
1462   // U+FDDB
1463   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1464       ConvertUTFResultContainer(conversionOK).withScalars(0xfddb),
1465       "\xef\xb7\x9b"));
1466 
1467   // U+FDDC
1468   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1469       ConvertUTFResultContainer(conversionOK).withScalars(0xfddc),
1470       "\xef\xb7\x9c"));
1471 
1472   // U+FDDD
1473   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1474       ConvertUTFResultContainer(conversionOK).withScalars(0xfddd),
1475       "\xef\xb7\x9d"));
1476 
1477   // U+FDDE
1478   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1479       ConvertUTFResultContainer(conversionOK).withScalars(0xfdde),
1480       "\xef\xb7\x9e"));
1481 
1482   // U+FDDF
1483   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1484       ConvertUTFResultContainer(conversionOK).withScalars(0xfddf),
1485       "\xef\xb7\x9f"));
1486 
1487   // U+FDE0
1488   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1489       ConvertUTFResultContainer(conversionOK).withScalars(0xfde0),
1490       "\xef\xb7\xa0"));
1491 
1492   // U+FDE1
1493   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1494       ConvertUTFResultContainer(conversionOK).withScalars(0xfde1),
1495       "\xef\xb7\xa1"));
1496 
1497   // U+FDE2
1498   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1499       ConvertUTFResultContainer(conversionOK).withScalars(0xfde2),
1500       "\xef\xb7\xa2"));
1501 
1502   // U+FDE3
1503   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1504       ConvertUTFResultContainer(conversionOK).withScalars(0xfde3),
1505       "\xef\xb7\xa3"));
1506 
1507   // U+FDE4
1508   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1509       ConvertUTFResultContainer(conversionOK).withScalars(0xfde4),
1510       "\xef\xb7\xa4"));
1511 
1512   // U+FDE5
1513   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1514       ConvertUTFResultContainer(conversionOK).withScalars(0xfde5),
1515       "\xef\xb7\xa5"));
1516 
1517   // U+FDE6
1518   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1519       ConvertUTFResultContainer(conversionOK).withScalars(0xfde6),
1520       "\xef\xb7\xa6"));
1521 
1522   // U+FDE7
1523   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1524       ConvertUTFResultContainer(conversionOK).withScalars(0xfde7),
1525       "\xef\xb7\xa7"));
1526 
1527   // U+FDE8
1528   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1529       ConvertUTFResultContainer(conversionOK).withScalars(0xfde8),
1530       "\xef\xb7\xa8"));
1531 
1532   // U+FDE9
1533   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1534       ConvertUTFResultContainer(conversionOK).withScalars(0xfde9),
1535       "\xef\xb7\xa9"));
1536 
1537   // U+FDEA
1538   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1539       ConvertUTFResultContainer(conversionOK).withScalars(0xfdea),
1540       "\xef\xb7\xaa"));
1541 
1542   // U+FDEB
1543   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1544       ConvertUTFResultContainer(conversionOK).withScalars(0xfdeb),
1545       "\xef\xb7\xab"));
1546 
1547   // U+FDEC
1548   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1549       ConvertUTFResultContainer(conversionOK).withScalars(0xfdec),
1550       "\xef\xb7\xac"));
1551 
1552   // U+FDED
1553   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1554       ConvertUTFResultContainer(conversionOK).withScalars(0xfded),
1555       "\xef\xb7\xad"));
1556 
1557   // U+FDEE
1558   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1559       ConvertUTFResultContainer(conversionOK).withScalars(0xfdee),
1560       "\xef\xb7\xae"));
1561 
1562   // U+FDEF
1563   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1564       ConvertUTFResultContainer(conversionOK).withScalars(0xfdef),
1565       "\xef\xb7\xaf"));
1566 
1567   // U+FDF0
1568   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1569       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf0),
1570       "\xef\xb7\xb0"));
1571 
1572   // U+FDF1
1573   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1574       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf1),
1575       "\xef\xb7\xb1"));
1576 
1577   // U+FDF2
1578   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1579       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf2),
1580       "\xef\xb7\xb2"));
1581 
1582   // U+FDF3
1583   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1584       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf3),
1585       "\xef\xb7\xb3"));
1586 
1587   // U+FDF4
1588   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1589       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf4),
1590       "\xef\xb7\xb4"));
1591 
1592   // U+FDF5
1593   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1594       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf5),
1595       "\xef\xb7\xb5"));
1596 
1597   // U+FDF6
1598   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1599       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf6),
1600       "\xef\xb7\xb6"));
1601 
1602   // U+FDF7
1603   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1604       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf7),
1605       "\xef\xb7\xb7"));
1606 
1607   // U+FDF8
1608   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1609       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf8),
1610       "\xef\xb7\xb8"));
1611 
1612   // U+FDF9
1613   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1614       ConvertUTFResultContainer(conversionOK).withScalars(0xfdf9),
1615       "\xef\xb7\xb9"));
1616 
1617   // U+FDFA
1618   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1619       ConvertUTFResultContainer(conversionOK).withScalars(0xfdfa),
1620       "\xef\xb7\xba"));
1621 
1622   // U+FDFB
1623   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1624       ConvertUTFResultContainer(conversionOK).withScalars(0xfdfb),
1625       "\xef\xb7\xbb"));
1626 
1627   // U+FDFC
1628   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1629       ConvertUTFResultContainer(conversionOK).withScalars(0xfdfc),
1630       "\xef\xb7\xbc"));
1631 
1632   // U+FDFD
1633   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1634       ConvertUTFResultContainer(conversionOK).withScalars(0xfdfd),
1635       "\xef\xb7\xbd"));
1636 
1637   // U+FDFE
1638   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1639       ConvertUTFResultContainer(conversionOK).withScalars(0xfdfe),
1640       "\xef\xb7\xbe"));
1641 
1642   // U+FDFF
1643   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1644       ConvertUTFResultContainer(conversionOK).withScalars(0xfdff),
1645       "\xef\xb7\xbf"));
1646 }
1647 
1648 TEST(ConvertUTFTest, UTF8ToUTF32PartialLenient) {
1649   // U+0041 LATIN CAPITAL LETTER A
1650   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1651       ConvertUTFResultContainer(conversionOK).withScalars(0x0041),
1652       "\x41", true));
1653 
1654   //
1655   // Sequences with one continuation byte missing
1656   //
1657 
1658   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1659       ConvertUTFResultContainer(sourceExhausted),
1660       "\xc2", true));
1661   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1662       ConvertUTFResultContainer(sourceExhausted),
1663       "\xdf", true));
1664   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1665       ConvertUTFResultContainer(sourceExhausted),
1666       "\xe0\xa0", true));
1667   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1668       ConvertUTFResultContainer(sourceExhausted),
1669       "\xe0\xbf", true));
1670   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1671       ConvertUTFResultContainer(sourceExhausted),
1672       "\xe1\x80", true));
1673   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1674       ConvertUTFResultContainer(sourceExhausted),
1675       "\xec\xbf", true));
1676   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1677       ConvertUTFResultContainer(sourceExhausted),
1678       "\xed\x80", true));
1679   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1680       ConvertUTFResultContainer(sourceExhausted),
1681       "\xed\x9f", true));
1682   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1683       ConvertUTFResultContainer(sourceExhausted),
1684       "\xee\x80", true));
1685   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1686       ConvertUTFResultContainer(sourceExhausted),
1687       "\xef\xbf", true));
1688   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1689       ConvertUTFResultContainer(sourceExhausted),
1690       "\xf0\x90\x80", true));
1691   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1692       ConvertUTFResultContainer(sourceExhausted),
1693       "\xf0\xbf\xbf", true));
1694   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1695       ConvertUTFResultContainer(sourceExhausted),
1696       "\xf1\x80\x80", true));
1697   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1698       ConvertUTFResultContainer(sourceExhausted),
1699       "\xf3\xbf\xbf", true));
1700   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1701       ConvertUTFResultContainer(sourceExhausted),
1702       "\xf4\x80\x80", true));
1703   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1704       ConvertUTFResultContainer(sourceExhausted),
1705       "\xf4\x8f\xbf", true));
1706 
1707   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
1708       ConvertUTFResultContainer(sourceExhausted).withScalars(0x0041),
1709       "\x41\xc2", true));
1710 }
1711 
1712