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