1 // Copyright 2018 Google LLC.
2 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
3
4 #include "include/core/SkTypes.h"
5 #include "src/base/SkUTF.h"
6 #include "tests/Test.h"
7
8 #include <cstdint>
9 #include <cstddef>
10 #include <string>
11
DEF_TEST(SkUTF_UTF16,reporter)12 DEF_TEST(SkUTF_UTF16, reporter) {
13 // Test non-basic-multilingual-plane unicode.
14 static const SkUnichar gUni[] = {
15 0x10000, 0x18080, 0x20202, 0xFFFFF, 0x101234
16 };
17 for (SkUnichar uni : gUni) {
18 uint16_t buf[2];
19 size_t count = SkUTF::ToUTF16(uni, buf);
20 REPORTER_ASSERT(reporter, count == 2);
21 size_t count2 = SkUTF::CountUTF16(buf, sizeof(buf));
22 REPORTER_ASSERT(reporter, count2 == 1);
23 const uint16_t* ptr = buf;
24 SkUnichar c = SkUTF::NextUTF16(&ptr, buf + std::size(buf));
25 REPORTER_ASSERT(reporter, c == uni);
26 REPORTER_ASSERT(reporter, ptr - buf == 2);
27 }
28 }
29
DEF_TEST(SkUTF_UTF8,reporter)30 DEF_TEST(SkUTF_UTF8, reporter) {
31 static const struct {
32 const char* fUtf8;
33 SkUnichar fUni;
34 } gTest[] = {
35 { "a", 'a' },
36 { "\x7f", 0x7f },
37 { "\xC2\x80", 0x80 },
38 { "\xC3\x83", (3 << 6) | 3 },
39 { "\xDF\xBF", 0x7ff },
40 { "\xE0\xA0\x80", 0x800 },
41 { "\xE0\xB0\xB8", 0xC38 },
42 { "\xE3\x83\x83", (3 << 12) | (3 << 6) | 3 },
43 { "\xEF\xBF\xBF", 0xFFFF },
44 { "\xF0\x90\x80\x80", 0x10000 },
45 { "\xF3\x83\x83\x83", (3 << 18) | (3 << 12) | (3 << 6) | 3 }
46 };
47 for (auto test : gTest) {
48 const char* p = test.fUtf8;
49 const char* stop = p + strlen(p);
50 int n = SkUTF::CountUTF8(p, strlen(p));
51 SkUnichar u1 = SkUTF::NextUTF8(&p, stop);
52
53 REPORTER_ASSERT(reporter, n == 1);
54 REPORTER_ASSERT(reporter, u1 == test.fUni);
55 REPORTER_ASSERT(reporter, p - test.fUtf8 == (int)strlen(test.fUtf8));
56 }
57 }
58
59 #define ASCII_BYTE "X"
60 #define CONTINUATION_BYTE "\xA1"
61 #define LEADING_TWO_BYTE "\xC2"
62 #define LEADING_THREE_BYTE "\xE1"
63 #define LEADING_FOUR_BYTE "\xF0"
64 #define INVALID_BYTE "\xFC"
DEF_TEST(SkUTF_CountUTF8,r)65 DEF_TEST(SkUTF_CountUTF8, r) {
66 static const struct {
67 int expectedCount;
68 const char* utf8String;
69 } testCases[] = {
70 { 0, "" },
71 { 1, ASCII_BYTE },
72 { 2, ASCII_BYTE ASCII_BYTE },
73 { 1, LEADING_TWO_BYTE CONTINUATION_BYTE },
74 { 2, ASCII_BYTE LEADING_TWO_BYTE CONTINUATION_BYTE },
75 { 3, ASCII_BYTE ASCII_BYTE LEADING_TWO_BYTE CONTINUATION_BYTE },
76 { 1, LEADING_THREE_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
77 { 2, ASCII_BYTE LEADING_THREE_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
78 { 3, ASCII_BYTE ASCII_BYTE LEADING_THREE_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
79 { 1, LEADING_FOUR_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
80 { 2, ASCII_BYTE LEADING_FOUR_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
81 { 3, ASCII_BYTE ASCII_BYTE LEADING_FOUR_BYTE CONTINUATION_BYTE CONTINUATION_BYTE
82 CONTINUATION_BYTE },
83 { -1, INVALID_BYTE },
84 { -1, INVALID_BYTE CONTINUATION_BYTE },
85 { -1, INVALID_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
86 { -1, INVALID_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
87 { -1, LEADING_TWO_BYTE },
88 { -1, CONTINUATION_BYTE },
89 { -1, CONTINUATION_BYTE CONTINUATION_BYTE },
90 { -1, LEADING_THREE_BYTE CONTINUATION_BYTE },
91 { -1, CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
92 { -1, LEADING_FOUR_BYTE CONTINUATION_BYTE },
93 { -1, CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
94 };
95 for (auto testCase : testCases) {
96 const char* str = testCase.utf8String;
97 REPORTER_ASSERT(r, testCase.expectedCount == SkUTF::CountUTF8(str, strlen(str)));
98 }
99 }
100
DEF_TEST(SkUTF_NextUTF8_ToUTF8,r)101 DEF_TEST(SkUTF_NextUTF8_ToUTF8, r) {
102 struct {
103 SkUnichar expected;
104 const char* utf8String;
105 } testCases[] = {
106 { -1, INVALID_BYTE },
107 { -1, "" },
108 { 0x0058, ASCII_BYTE },
109 { 0x00A1, LEADING_TWO_BYTE CONTINUATION_BYTE },
110 { 0x1861, LEADING_THREE_BYTE CONTINUATION_BYTE CONTINUATION_BYTE },
111 { 0x010330, LEADING_FOUR_BYTE "\x90\x8C\xB0" },
112 };
113 for (auto testCase : testCases) {
114 const char* str = testCase.utf8String;
115 SkUnichar uni = SkUTF::NextUTF8(&str, str + strlen(str));
116 REPORTER_ASSERT(r, str == testCase.utf8String + strlen(testCase.utf8String));
117 REPORTER_ASSERT(r, uni == testCase.expected);
118 char buff[5] = {0, 0, 0, 0, 0};
119 size_t len = SkUTF::ToUTF8(uni, buff);
120 if (buff[len] != 0) {
121 ERRORF(r, "unexpected write");
122 continue;
123 }
124 if (uni == -1) {
125 REPORTER_ASSERT(r, len == 0);
126 continue;
127 }
128 if (len == 0) {
129 ERRORF(r, "unexpected failure.");
130 continue;
131 }
132 if (len > 4) {
133 ERRORF(r, "wrote too much");
134 continue;
135 }
136 str = testCase.utf8String;
137 REPORTER_ASSERT(r, len == strlen(buff));
138 REPORTER_ASSERT(r, len == strlen(str));
139 REPORTER_ASSERT(r, 0 == strcmp(str, buff));
140 }
141 }
142 #undef ASCII_BYTE
143 #undef CONTINUATION_BYTE
144 #undef LEADING_TWO_BYTE
145 #undef LEADING_THREE_BYTE
146 #undef LEADING_FOUR_BYTE
147 #undef INVALID_BYTE
148