1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "tests/Test.h"
9
10 #include "include/core/SkString.h"
11 #include "src/core/SkStringUtils.h"
12
13 #include <stdio.h>
14 #include <thread>
15
DEF_TEST(String,reporter)16 DEF_TEST(String, reporter) {
17 SkString a;
18 SkString b((size_t)0);
19 SkString c("");
20 SkString d(nullptr, 0);
21
22 REPORTER_ASSERT(reporter, a.isEmpty());
23 REPORTER_ASSERT(reporter, a == b && a == c && a == d);
24
25 a.set("hello");
26 b.set("hellox", 5);
27 c.set(a);
28 d.resize(5);
29 memcpy(d.writable_str(), "helloz", 5);
30
31 REPORTER_ASSERT(reporter, !a.isEmpty());
32 REPORTER_ASSERT(reporter, a.size() == 5);
33 REPORTER_ASSERT(reporter, a == b && a == c && a == d);
34 REPORTER_ASSERT(reporter, a.equals("hello", 5));
35 REPORTER_ASSERT(reporter, a.equals("hello"));
36 REPORTER_ASSERT(reporter, !a.equals("help"));
37
38 REPORTER_ASSERT(reporter, a.startsWith("hell"));
39 REPORTER_ASSERT(reporter, a.startsWith('h'));
40 REPORTER_ASSERT(reporter, !a.startsWith( "ell"));
41 REPORTER_ASSERT(reporter, !a.startsWith( 'e'));
42 REPORTER_ASSERT(reporter, a.startsWith(""));
43 REPORTER_ASSERT(reporter, a.endsWith("llo"));
44 REPORTER_ASSERT(reporter, a.endsWith('o'));
45 REPORTER_ASSERT(reporter, !a.endsWith("ll" ));
46 REPORTER_ASSERT(reporter, !a.endsWith('l'));
47 REPORTER_ASSERT(reporter, a.endsWith(""));
48 REPORTER_ASSERT(reporter, a.contains("he"));
49 REPORTER_ASSERT(reporter, a.contains("ll"));
50 REPORTER_ASSERT(reporter, a.contains("lo"));
51 REPORTER_ASSERT(reporter, a.contains("hello"));
52 REPORTER_ASSERT(reporter, !a.contains("hellohello"));
53 REPORTER_ASSERT(reporter, a.contains(""));
54 REPORTER_ASSERT(reporter, a.contains('e'));
55 REPORTER_ASSERT(reporter, !a.contains('z'));
56
57 SkString e(a);
58 SkString f("hello");
59 SkString g("helloz", 5);
60
61 REPORTER_ASSERT(reporter, a == e && a == f && a == g);
62
63 b.set("world");
64 c = b;
65 REPORTER_ASSERT(reporter, a != b && a != c && b == c);
66
67 a.append(" world");
68 e.append("worldz", 5);
69 e.insert(5, " ");
70 f.set("world");
71 f.prepend("hello ");
72 REPORTER_ASSERT(reporter, a.equals("hello world") && a == e && a == f);
73
74 a.reset();
75 b.resize(0);
76 REPORTER_ASSERT(reporter, a.isEmpty() && b.isEmpty() && a == b);
77
78 a.set("a");
79 a.set("ab");
80 a.set("abc");
81 a.set("abcd");
82
83 a.set("");
84 a.appendS32(0x7FFFFFFFL);
85 REPORTER_ASSERT(reporter, a.equals("2147483647"));
86 a.set("");
87 a.appendS32(0x80000001L);
88 REPORTER_ASSERT(reporter, a.equals("-2147483647"));
89 a.set("");
90 a.appendS32(0x80000000L);
91 REPORTER_ASSERT(reporter, a.equals("-2147483648"));
92
93 a.set("");
94 a.appendU32(0x7FFFFFFFUL);
95 REPORTER_ASSERT(reporter, a.equals("2147483647"));
96 a.set("");
97 a.appendU32(0x80000001UL);
98 REPORTER_ASSERT(reporter, a.equals("2147483649"));
99 a.set("");
100 a.appendU32(0xFFFFFFFFUL);
101 REPORTER_ASSERT(reporter, a.equals("4294967295"));
102
103 a.set("");
104 a.appendS64(0x7FFFFFFFFFFFFFFFLL, 0);
105 REPORTER_ASSERT(reporter, a.equals("9223372036854775807"));
106 a.set("");
107 a.appendS64(0x8000000000000001LL, 0);
108 REPORTER_ASSERT(reporter, a.equals("-9223372036854775807"));
109 a.set("");
110 a.appendS64(0x8000000000000000LL, 0);
111 REPORTER_ASSERT(reporter, a.equals("-9223372036854775808"));
112 a.set("");
113 a.appendS64(0x0000000001000000LL, 15);
114 REPORTER_ASSERT(reporter, a.equals("000000016777216"));
115 a.set("");
116 a.appendS64(0xFFFFFFFFFF000000LL, 15);
117 REPORTER_ASSERT(reporter, a.equals("-000000016777216"));
118
119 a.set("");
120 a.appendU64(0x7FFFFFFFFFFFFFFFULL, 0);
121 REPORTER_ASSERT(reporter, a.equals("9223372036854775807"));
122 a.set("");
123 a.appendU64(0x8000000000000001ULL, 0);
124 REPORTER_ASSERT(reporter, a.equals("9223372036854775809"));
125 a.set("");
126 a.appendU64(0xFFFFFFFFFFFFFFFFULL, 0);
127 REPORTER_ASSERT(reporter, a.equals("18446744073709551615"));
128 a.set("");
129 a.appendU64(0x0000000001000000ULL, 15);
130 REPORTER_ASSERT(reporter, a.equals("000000016777216"));
131
132 a.printf("%i", 0);
133 REPORTER_ASSERT(reporter, a.equals("0"));
134 a.printf("%g", 3.14);
135 REPORTER_ASSERT(reporter, a.equals("3.14"));
136 a.printf("hello %s", "skia");
137 REPORTER_ASSERT(reporter, a.equals("hello skia"));
138
139 static const struct {
140 SkScalar fValue;
141 const char* fString;
142 } gRec[] = {
143 { 0, "0" },
144 { SK_Scalar1, "1" },
145 { -SK_Scalar1, "-1" },
146 { SK_Scalar1/2, "0.5" },
147 #if defined(SK_BUILD_FOR_WIN) && (_MSC_VER < 1900)
148 { 3.4028234e38f, "3.4028235e+038" },
149 { -3.4028234e38f, "-3.4028235e+038" },
150 #else
151 { 3.4028234e38f, "3.4028235e+38" },
152 { -3.4028234e38f, "-3.4028235e+38" },
153 #endif
154 };
155 for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
156 a.reset();
157 a.appendScalar(gRec[i].fValue);
158 REPORTER_ASSERT(reporter, a.size() <= SkStrAppendScalar_MaxSize);
159 if (!a.equals(gRec[i].fString)) {
160 ERRORF(reporter, "received <%s> expected <%s>\n", a.c_str(), gRec[i].fString);
161 }
162 }
163
164 REPORTER_ASSERT(reporter, SkStringPrintf("%i", 0).equals("0"));
165
166 // 2000 is larger than the static buffer size inside SkString.cpp
167 a = SkStringPrintf("%2000s", " ");
168 REPORTER_ASSERT(reporter, a.size() == 2000);
169 for (size_t i = 0; i < a.size(); ++i) {
170 if (a[i] != ' ') {
171 ERRORF(reporter, "SkStringPrintf fail: a[%d] = '%c'", i, a[i]);
172 break;
173 }
174 }
175 a.reset();
176 a.printf("%2000s", " ");
177 REPORTER_ASSERT(reporter, a.size() == 2000);
178 for (size_t i = 0; i < a.size(); ++i) {
179 if (a[i] != ' ') {
180 ERRORF(reporter, "SkString::printf fail: a[%d] = '%c'", i, a[i]);
181 break;
182 }
183 }
184 a.appendf("%2000s", " ");
185 REPORTER_ASSERT(reporter, a.size() == 4000);
186 for (size_t i = 0; i < a.size(); ++i) {
187 if (a[i] != ' ') {
188 ERRORF(reporter, "SkString::appendf fail: a[%d] = '%c'", i, a[i]);
189 break;
190 }
191 }
192 }
193
DEF_TEST(String_SkStrSplit,r)194 DEF_TEST(String_SkStrSplit, r) {
195 SkTArray<SkString> results;
196
197 SkStrSplit("a-_b_c-dee--f-_-_-g-", "-_", &results);
198 REPORTER_ASSERT(r, results.count() == 6);
199 REPORTER_ASSERT(r, results[0].equals("a"));
200 REPORTER_ASSERT(r, results[1].equals("b"));
201 REPORTER_ASSERT(r, results[2].equals("c"));
202 REPORTER_ASSERT(r, results[3].equals("dee"));
203 REPORTER_ASSERT(r, results[4].equals("f"));
204 REPORTER_ASSERT(r, results[5].equals("g"));
205
206 results.reset();
207 SkStrSplit("\n", "\n", &results);
208 REPORTER_ASSERT(r, results.count() == 0);
209
210 results.reset();
211 SkStrSplit("", "\n", &results);
212 REPORTER_ASSERT(r, results.count() == 0);
213
214 results.reset();
215 SkStrSplit("a", "\n", &results);
216 REPORTER_ASSERT(r, results.count() == 1);
217 REPORTER_ASSERT(r, results[0].equals("a"));
218 }
DEF_TEST(String_SkStrSplit_All,r)219 DEF_TEST(String_SkStrSplit_All, r) {
220 SkTArray<SkString> results;
221 SkStrSplit("a-_b_c-dee--f-_-_-g-", "-_", kStrict_SkStrSplitMode, &results);
222 REPORTER_ASSERT(r, results.count() == 13);
223 REPORTER_ASSERT(r, results[0].equals("a"));
224 REPORTER_ASSERT(r, results[1].equals(""));
225 REPORTER_ASSERT(r, results[2].equals("b"));
226 REPORTER_ASSERT(r, results[3].equals("c"));
227 REPORTER_ASSERT(r, results[4].equals("dee"));
228 REPORTER_ASSERT(r, results[5].equals(""));
229 REPORTER_ASSERT(r, results[6].equals("f"));
230 REPORTER_ASSERT(r, results[7].equals(""));
231 REPORTER_ASSERT(r, results[8].equals(""));
232 REPORTER_ASSERT(r, results[9].equals(""));
233 REPORTER_ASSERT(r, results[10].equals(""));
234 REPORTER_ASSERT(r, results[11].equals("g"));
235 REPORTER_ASSERT(r, results[12].equals(""));
236
237 results.reset();
238 SkStrSplit("\n", "\n", kStrict_SkStrSplitMode, &results);
239 REPORTER_ASSERT(r, results.count() == 2);
240 REPORTER_ASSERT(r, results[0].equals(""));
241 REPORTER_ASSERT(r, results[1].equals(""));
242
243 results.reset();
244 SkStrSplit("", "\n", kStrict_SkStrSplitMode, &results);
245 REPORTER_ASSERT(r, results.count() == 0);
246
247 results.reset();
248 SkStrSplit("a", "\n", kStrict_SkStrSplitMode, &results);
249 REPORTER_ASSERT(r, results.count() == 1);
250 REPORTER_ASSERT(r, results[0].equals("a"));
251
252 results.reset();
253 SkStrSplit(",,", ",", kStrict_SkStrSplitMode, &results);
254 REPORTER_ASSERT(r, results.count() == 3);
255 REPORTER_ASSERT(r, results[0].equals(""));
256 REPORTER_ASSERT(r, results[1].equals(""));
257 REPORTER_ASSERT(r, results[2].equals(""));
258
259 results.reset();
260 SkStrSplit(",a,b,", ",", kStrict_SkStrSplitMode, &results);
261 REPORTER_ASSERT(r, results.count() == 4);
262 REPORTER_ASSERT(r, results[0].equals(""));
263 REPORTER_ASSERT(r, results[1].equals("a"));
264 REPORTER_ASSERT(r, results[2].equals("b"));
265 REPORTER_ASSERT(r, results[3].equals(""));
266 }
267
268 // https://bugs.chromium.org/p/skia/issues/detail?id=7107
DEF_TEST(String_Threaded,r)269 DEF_TEST(String_Threaded, r) {
270 SkString str("foo");
271
272 std::thread threads[5];
273 for (auto& thread : threads) {
274 thread = std::thread([&] {
275 SkString copy = str;
276 (void)copy.equals("test");
277 });
278 }
279 for (auto& thread : threads) {
280 thread.join();
281 }
282 }
283
284 // Ensure that the string allocate doesn't internally overflow any calculations, and accidentally
285 // let us create a string with a requested length longer than we can manage.
DEF_TEST(String_huge,r)286 DEF_TEST(String_huge, r) {
287 // start testing slightly below max 32
288 size_t size = UINT32_MAX - 16;
289 // See where we crash, and manually check that its at the right point.
290 //
291 // To test, change the false to true
292 while (false) {
293 // On a 64bit build, this should crash when size == 1 << 32, since we can't store
294 // that length in the string's header (which has a u32 slot for the length).
295 //
296 // On a 32bit build, this should crash the first time around, since we can't allocate
297 // anywhere near this amount.
298 //
299 SkString str(size);
300 size += 1;
301 }
302 }
303
DEF_TEST(String_fromUTF16,r)304 DEF_TEST(String_fromUTF16, r) {
305 // test data produced with `iconv`.
306 const uint16_t test1[] = {
307 0xD835, 0xDCD0, 0xD835, 0xDCD1, 0xD835, 0xDCD2, 0xD835, 0xDCD3, 0xD835, 0xDCD4, 0x0020,
308 0xD835, 0xDCD5, 0xD835, 0xDCD6, 0xD835, 0xDCD7, 0xD835, 0xDCD8, 0xD835, 0xDCD9
309 };
310 REPORTER_ASSERT(r, SkStringFromUTF16(test1, SK_ARRAY_COUNT(test1)).equals("���������� ����������"));
311
312 const uint16_t test2[] = {
313 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0020, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A,
314 };
315 REPORTER_ASSERT(r, SkStringFromUTF16(test2, SK_ARRAY_COUNT(test2)).equals("ABCDE FGHIJ"));
316
317 const uint16_t test3[] = {
318 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x0020, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA,
319 };
320 REPORTER_ASSERT(r, SkStringFromUTF16(test3, SK_ARRAY_COUNT(test3)).equals("αβγδε ζηθικ"));
321 }
322
323