1/*
2 * Copyright (C) 2012-2017 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23 * THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "config.h"
27
28#include "WTFStringUtilities.h"
29#include <limits>
30#include <wtf/MathExtras.h>
31#include <wtf/text/CString.h>
32#include <wtf/text/WTFString.h>
33
34namespace TestWebKitAPI {
35
36TEST(WTF, StringCreationFromLiteral)
37{
38 String stringFromLiteralViaASCII("Explicit construction syntax"_s);
39 EXPECT_EQ(strlen("Explicit construction syntax"), stringFromLiteralViaASCII.length());
40 EXPECT_EQ("Explicit construction syntax", stringFromLiteralViaASCII);
41 EXPECT_TRUE(stringFromLiteralViaASCII.is8Bit());
42 EXPECT_EQ(String("Explicit construction syntax"), stringFromLiteralViaASCII);
43
44 String stringFromLiteral = "String Literal"_str;
45 EXPECT_EQ(strlen("String Literal"), stringFromLiteral.length());
46 EXPECT_EQ("String Literal", stringFromLiteral);
47 EXPECT_TRUE(stringFromLiteral.is8Bit());
48 EXPECT_EQ(String("String Literal"), stringFromLiteral);
49
50 String stringWithTemplate("Template Literal", String::ConstructFromLiteral);
51 EXPECT_EQ(strlen("Template Literal"), stringWithTemplate.length());
52 EXPECT_EQ("Template Literal", stringWithTemplate);
53 EXPECT_TRUE(stringWithTemplate.is8Bit());
54 EXPECT_EQ(String("Template Literal"), stringWithTemplate);
55}
56
57TEST(WTF, StringASCII)
58{
59 CString output;
60
61 // Null String.
62 output = String().ascii();
63 EXPECT_STREQ("", output.data());
64
65 // Empty String.
66 output = emptyString().ascii();
67 EXPECT_STREQ("", output.data());
68
69 // Regular String.
70 output = String("foobar"_s).ascii();
71 EXPECT_STREQ("foobar", output.data());
72}
73
74static inline const char* testStringNumberFixedPrecision(double number)
75{
76 static char testBuffer[100] = { };
77 std::strncpy(testBuffer, String::numberToStringFixedPrecision(number).utf8().data(), 99);
78 return testBuffer;
79}
80
81TEST(WTF, StringNumberFixedPrecision)
82{
83 using Limits = std::numeric_limits<double>;
84
85 EXPECT_STREQ("Infinity", testStringNumberFixedPrecision(Limits::infinity()));
86 EXPECT_STREQ("-Infinity", testStringNumberFixedPrecision(-Limits::infinity()));
87
88 EXPECT_STREQ("NaN", testStringNumberFixedPrecision(-Limits::quiet_NaN()));
89
90 EXPECT_STREQ("0", testStringNumberFixedPrecision(0));
91 EXPECT_STREQ("0", testStringNumberFixedPrecision(-0));
92
93 EXPECT_STREQ("2.22507e-308", testStringNumberFixedPrecision(Limits::min()));
94 EXPECT_STREQ("-1.79769e+308", testStringNumberFixedPrecision(Limits::lowest()));
95 EXPECT_STREQ("1.79769e+308", testStringNumberFixedPrecision(Limits::max()));
96
97 EXPECT_STREQ("3.14159", testStringNumberFixedPrecision(piDouble));
98 EXPECT_STREQ("3.14159", testStringNumberFixedPrecision(piFloat));
99 EXPECT_STREQ("1.5708", testStringNumberFixedPrecision(piOverTwoDouble));
100 EXPECT_STREQ("1.5708", testStringNumberFixedPrecision(piOverTwoFloat));
101 EXPECT_STREQ("0.785398", testStringNumberFixedPrecision(piOverFourDouble));
102 EXPECT_STREQ("0.785398", testStringNumberFixedPrecision(piOverFourFloat));
103
104 EXPECT_STREQ("2.71828", testStringNumberFixedPrecision(2.71828182845904523536028747135266249775724709369995));
105
106 EXPECT_STREQ("2.99792e+8", testStringNumberFixedPrecision(299792458));
107
108 EXPECT_STREQ("1.61803", testStringNumberFixedPrecision(1.6180339887498948482));
109
110 EXPECT_STREQ("1000", testStringNumberFixedPrecision(1e3));
111 EXPECT_STREQ("1e+10", testStringNumberFixedPrecision(1e10));
112 EXPECT_STREQ("1e+20", testStringNumberFixedPrecision(1e20));
113 EXPECT_STREQ("1e+21", testStringNumberFixedPrecision(1e21));
114 EXPECT_STREQ("1e+30", testStringNumberFixedPrecision(1e30));
115
116 EXPECT_STREQ("1100", testStringNumberFixedPrecision(1.1e3));
117 EXPECT_STREQ("1.1e+10", testStringNumberFixedPrecision(1.1e10));
118 EXPECT_STREQ("1.1e+20", testStringNumberFixedPrecision(1.1e20));
119 EXPECT_STREQ("1.1e+21", testStringNumberFixedPrecision(1.1e21));
120 EXPECT_STREQ("1.1e+30", testStringNumberFixedPrecision(1.1e30));
121}
122
123static inline const char* testStringNumberFixedWidth(double number)
124{
125 static char testBuffer[100] = { };
126 std::strncpy(testBuffer, String::numberToStringFixedWidth(number, 6).utf8().data(), 99);
127 return testBuffer;
128}
129
130TEST(WTF, StringNumberFixedWidth)
131{
132 using Limits = std::numeric_limits<double>;
133
134 EXPECT_STREQ("Infinity", testStringNumberFixedWidth(Limits::infinity()));
135 EXPECT_STREQ("-Infinity", testStringNumberFixedWidth(-Limits::infinity()));
136
137 EXPECT_STREQ("NaN", testStringNumberFixedWidth(-Limits::quiet_NaN()));
138
139 EXPECT_STREQ("0.000000", testStringNumberFixedWidth(0));
140 EXPECT_STREQ("0.000000", testStringNumberFixedWidth(-0));
141
142 EXPECT_STREQ("0.000000", testStringNumberFixedWidth(Limits::min()));
143 EXPECT_STREQ("", testStringNumberFixedWidth(Limits::lowest()));
144 EXPECT_STREQ("", testStringNumberFixedWidth(Limits::max()));
145
146 EXPECT_STREQ("3.141593", testStringNumberFixedWidth(piDouble));
147 EXPECT_STREQ("3.141593", testStringNumberFixedWidth(piFloat));
148 EXPECT_STREQ("1.570796", testStringNumberFixedWidth(piOverTwoDouble));
149 EXPECT_STREQ("1.570796", testStringNumberFixedWidth(piOverTwoFloat));
150 EXPECT_STREQ("0.785398", testStringNumberFixedWidth(piOverFourDouble));
151 EXPECT_STREQ("0.785398", testStringNumberFixedWidth(piOverFourFloat));
152
153 EXPECT_STREQ("2.718282", testStringNumberFixedWidth(2.71828182845904523536028747135266249775724709369995));
154
155 EXPECT_STREQ("299792458.000000", testStringNumberFixedWidth(299792458));
156
157 EXPECT_STREQ("1.618034", testStringNumberFixedWidth(1.6180339887498948482));
158
159 EXPECT_STREQ("1000.000000", testStringNumberFixedWidth(1e3));
160 EXPECT_STREQ("10000000000.000000", testStringNumberFixedWidth(1e10));
161 EXPECT_STREQ("100000000000000000000.000000", testStringNumberFixedWidth(1e20));
162 EXPECT_STREQ("", testStringNumberFixedWidth(1e21));
163
164 EXPECT_STREQ("1100.000000", testStringNumberFixedWidth(1.1e3));
165 EXPECT_STREQ("11000000000.000000", testStringNumberFixedWidth(1.1e10));
166 EXPECT_STREQ("110000000000000000000.000000", testStringNumberFixedWidth(1.1e20));
167 EXPECT_STREQ("", testStringNumberFixedWidth(1.1e21));
168}
169
170static inline const char* testStringNumber(double number)
171{
172 static char testBuffer[100] = { };
173 std::strncpy(testBuffer, String::number(number).utf8().data(), 99);
174 return testBuffer;
175}
176
177TEST(WTF, StringNumber)
178{
179 using Limits = std::numeric_limits<double>;
180
181 EXPECT_STREQ("Infinity", testStringNumber(Limits::infinity()));
182 EXPECT_STREQ("-Infinity", testStringNumber(-Limits::infinity()));
183
184 EXPECT_STREQ("NaN", testStringNumber(-Limits::quiet_NaN()));
185
186 EXPECT_STREQ("0", testStringNumber(0));
187 EXPECT_STREQ("0", testStringNumber(-0));
188
189 EXPECT_STREQ("2.2250738585072014e-308", testStringNumber(Limits::min()));
190 EXPECT_STREQ("-1.7976931348623157e+308", testStringNumber(Limits::lowest()));
191 EXPECT_STREQ("1.7976931348623157e+308", testStringNumber(Limits::max()));
192
193 EXPECT_STREQ("3.141592653589793", testStringNumber(piDouble));
194 EXPECT_STREQ("3.1415927410125732", testStringNumber(piFloat));
195 EXPECT_STREQ("1.5707963267948966", testStringNumber(piOverTwoDouble));
196 EXPECT_STREQ("1.5707963705062866", testStringNumber(piOverTwoFloat));
197 EXPECT_STREQ("0.7853981633974483", testStringNumber(piOverFourDouble));
198 EXPECT_STREQ("0.7853981852531433", testStringNumber(piOverFourFloat));
199
200 EXPECT_STREQ("2.718281828459045", testStringNumber(2.71828182845904523536028747135266249775724709369995));
201
202 EXPECT_STREQ("299792458", testStringNumber(299792458));
203
204 EXPECT_STREQ("1.618033988749895", testStringNumber(1.6180339887498948482));
205
206 EXPECT_STREQ("1000", testStringNumber(1e3));
207 EXPECT_STREQ("10000000000", testStringNumber(1e10));
208 EXPECT_STREQ("100000000000000000000", testStringNumber(1e20));
209 EXPECT_STREQ("1e+21", testStringNumber(1e21));
210 EXPECT_STREQ("1e+30", testStringNumber(1e30));
211
212 EXPECT_STREQ("1100", testStringNumber(1.1e3));
213 EXPECT_STREQ("11000000000", testStringNumber(1.1e10));
214 EXPECT_STREQ("110000000000000000000", testStringNumber(1.1e20));
215 EXPECT_STREQ("1.1e+21", testStringNumber(1.1e21));
216 EXPECT_STREQ("1.1e+30", testStringNumber(1.1e30));
217}
218
219TEST(WTF, StringReplaceWithLiteral)
220{
221 // Cases for 8Bit source.
222 String testString = "1224";
223 EXPECT_TRUE(testString.is8Bit());
224 testString.replaceWithLiteral('2', "");
225 EXPECT_STREQ("14", testString.utf8().data());
226
227 testString = "1224";
228 EXPECT_TRUE(testString.is8Bit());
229 testString.replaceWithLiteral('2', "3");
230 EXPECT_STREQ("1334", testString.utf8().data());
231
232 testString = "1224";
233 EXPECT_TRUE(testString.is8Bit());
234 testString.replaceWithLiteral('2', "555");
235 EXPECT_STREQ("15555554", testString.utf8().data());
236
237 testString = "1224";
238 EXPECT_TRUE(testString.is8Bit());
239 testString.replaceWithLiteral('3', "NotFound");
240 EXPECT_STREQ("1224", testString.utf8().data());
241
242 // Cases for 16Bit source.
243 testString = String::fromUTF8("résumé");
244 EXPECT_FALSE(testString.is8Bit());
245 testString.replaceWithLiteral(UChar(0x00E9 /*U+00E9 is 'é'*/), "e");
246 EXPECT_STREQ("resume", testString.utf8().data());
247
248 testString = String::fromUTF8("résumé");
249 EXPECT_FALSE(testString.is8Bit());
250 testString.replaceWithLiteral(UChar(0x00E9 /*U+00E9 is 'é'*/), "");
251 EXPECT_STREQ("rsum", testString.utf8().data());
252
253 testString = String::fromUTF8("résumé");
254 EXPECT_FALSE(testString.is8Bit());
255 testString.replaceWithLiteral('3', "NotFound");
256 EXPECT_STREQ("résumé", testString.utf8().data());
257}
258
259TEST(WTF, StringIsolatedCopy)
260{
261 String original = "1234";
262 auto copy = WTFMove(original).isolatedCopy();
263 EXPECT_FALSE(original.impl() == copy.impl());
264}
265
266TEST(WTF, StringToInt)
267{
268 bool ok = false;
269
270 EXPECT_EQ(0, String().toInt());
271 EXPECT_EQ(0, String().toInt(&ok));
272 EXPECT_FALSE(ok);
273
274 EXPECT_EQ(0, emptyString().toInt());
275 EXPECT_EQ(0, emptyString().toInt(&ok));
276 EXPECT_FALSE(ok);
277
278 EXPECT_EQ(0, String("0").toInt());
279 EXPECT_EQ(0, String("0").toInt(&ok));
280 EXPECT_TRUE(ok);
281
282 EXPECT_EQ(1, String("1").toInt());
283 EXPECT_EQ(1, String("1").toInt(&ok));
284 EXPECT_TRUE(ok);
285
286 EXPECT_EQ(2147483647, String("2147483647").toInt());
287 EXPECT_EQ(2147483647, String("2147483647").toInt(&ok));
288 EXPECT_TRUE(ok);
289
290 EXPECT_EQ(0, String("2147483648").toInt());
291 EXPECT_EQ(0, String("2147483648").toInt(&ok));
292 EXPECT_FALSE(ok);
293
294 EXPECT_EQ(-2147483648, String("-2147483648").toInt());
295 EXPECT_EQ(-2147483648, String("-2147483648").toInt(&ok));
296 EXPECT_TRUE(ok);
297
298 EXPECT_EQ(0, String("-2147483649").toInt());
299 EXPECT_EQ(0, String("-2147483649").toInt(&ok));
300 EXPECT_FALSE(ok);
301
302 // fail if we see leading junk
303 EXPECT_EQ(0, String("x1").toInt());
304 EXPECT_EQ(0, String("x1").toInt(&ok));
305 EXPECT_FALSE(ok);
306
307 // succeed if we see leading spaces
308 EXPECT_EQ(1, String(" 1").toInt());
309 EXPECT_EQ(1, String(" 1").toInt(&ok));
310 EXPECT_TRUE(ok);
311
312 // silently ignore trailing junk
313 EXPECT_EQ(1, String("1x").toInt());
314 EXPECT_EQ(1, String("1x").toInt(&ok));
315 EXPECT_TRUE(ok);
316}
317
318TEST(WTF, StringToDouble)
319{
320 bool ok = false;
321
322 EXPECT_EQ(0.0, String().toDouble());
323 EXPECT_EQ(0.0, String().toDouble(&ok));
324 EXPECT_FALSE(ok);
325
326 EXPECT_EQ(0.0, emptyString().toDouble());
327 EXPECT_EQ(0.0, emptyString().toDouble(&ok));
328 EXPECT_FALSE(ok);
329
330 EXPECT_EQ(0.0, String("0").toDouble());
331 EXPECT_EQ(0.0, String("0").toDouble(&ok));
332 EXPECT_TRUE(ok);
333
334 EXPECT_EQ(1.0, String("1").toDouble());
335 EXPECT_EQ(1.0, String("1").toDouble(&ok));
336 EXPECT_TRUE(ok);
337
338 // fail if we see leading junk
339 EXPECT_EQ(0.0, String("x1").toDouble());
340 EXPECT_EQ(0.0, String("x1").toDouble(&ok));
341 EXPECT_FALSE(ok);
342
343 // succeed if we see leading spaces
344 EXPECT_EQ(1.0, String(" 1").toDouble());
345 EXPECT_EQ(1.0, String(" 1").toDouble(&ok));
346 EXPECT_TRUE(ok);
347
348 // ignore trailing junk, but return false for "ok"
349 // FIXME: This is an inconsistency with toInt, which always guarantees
350 // it will return 0 if it's also going to return false for ok.
351 EXPECT_EQ(1.0, String("1x").toDouble());
352 EXPECT_EQ(1.0, String("1x").toDouble(&ok));
353 EXPECT_FALSE(ok);
354
355 // parse only numbers, not special values such as "infinity"
356 EXPECT_EQ(0.0, String("infinity").toDouble());
357 EXPECT_EQ(0.0, String("infinity").toDouble(&ok));
358 EXPECT_FALSE(ok);
359
360 // parse only numbers, not special values such as "nan"
361 EXPECT_EQ(0.0, String("nan").toDouble());
362 EXPECT_EQ(0.0, String("nan").toDouble(&ok));
363 EXPECT_FALSE(ok);
364}
365
366TEST(WTF, StringhasInfixStartingAt)
367{
368 EXPECT_TRUE(String("Test").is8Bit());
369 EXPECT_TRUE(String("Te").is8Bit());
370 EXPECT_TRUE(String("st").is8Bit());
371 EXPECT_TRUE(String("Test").hasInfixStartingAt(String("Te"), 0));
372 EXPECT_FALSE(String("Test").hasInfixStartingAt(String("Te"), 2));
373 EXPECT_TRUE(String("Test").hasInfixStartingAt(String("st"), 2));
374 EXPECT_FALSE(String("Test").hasInfixStartingAt(String("ST"), 2));
375
376 EXPECT_FALSE(String::fromUTF8("中国").is8Bit());
377 EXPECT_FALSE(String::fromUTF8("中").is8Bit());
378 EXPECT_FALSE(String::fromUTF8("国").is8Bit());
379 EXPECT_TRUE(String::fromUTF8("中国").hasInfixStartingAt(String::fromUTF8("中"), 0));
380 EXPECT_FALSE(String::fromUTF8("中国").hasInfixStartingAt(String::fromUTF8("中"), 1));
381 EXPECT_TRUE(String::fromUTF8("中国").hasInfixStartingAt(String::fromUTF8("国"), 1));
382
383 EXPECT_FALSE(String::fromUTF8("中国").hasInfixStartingAt(String("Te"), 0));
384 EXPECT_FALSE(String("Test").hasInfixStartingAt(String::fromUTF8("中"), 2));
385}
386
387TEST(WTF, StringExistingHash)
388{
389 String string1("Template Literal");
390 EXPECT_FALSE(string1.isNull());
391 EXPECT_FALSE(string1.impl()->hasHash());
392 string1.impl()->hash();
393 EXPECT_EQ(string1.existingHash(), string1.impl()->existingHash());
394 String string2;
395 EXPECT_EQ(string2.existingHash(), 0u);
396}
397
398TEST(WTF, StringUnicodeEqualUCharArray)
399{
400 String string1("abc");
401 EXPECT_FALSE(string1.isNull());
402 EXPECT_TRUE(string1.is8Bit());
403 UChar ab[] = { 'a', 'b' };
404 UChar abc[] = { 'a', 'b', 'c' };
405 UChar abcd[] = { 'a', 'b', 'c', 'd' };
406 UChar aBc[] = { 'a', 'B', 'c' };
407 EXPECT_FALSE(equal(string1, ab));
408 EXPECT_TRUE(equal(string1, abc));
409 EXPECT_FALSE(equal(string1, abcd));
410 EXPECT_FALSE(equal(string1, aBc));
411
412 String string2(abc, 3);
413 EXPECT_FALSE(equal(string2, ab));
414 EXPECT_TRUE(equal(string2, abc));
415 EXPECT_FALSE(equal(string2, abcd));
416 EXPECT_FALSE(equal(string2, aBc));
417}
418
419TEST(WTF, StringRightBasic)
420{
421 auto reference = String::fromUTF8("Cappuccino");
422 EXPECT_EQ(String::fromUTF8(""), reference.right(0));
423 EXPECT_EQ(String::fromUTF8("o"), reference.right(1));
424 EXPECT_EQ(String::fromUTF8("no"), reference.right(2));
425 EXPECT_EQ(String::fromUTF8("ino"), reference.right(3));
426 EXPECT_EQ(String::fromUTF8("cino"), reference.right(4));
427 EXPECT_EQ(String::fromUTF8("ccino"), reference.right(5));
428 EXPECT_EQ(String::fromUTF8("uccino"), reference.right(6));
429 EXPECT_EQ(String::fromUTF8("puccino"), reference.right(7));
430 EXPECT_EQ(String::fromUTF8("ppuccino"), reference.right(8));
431 EXPECT_EQ(String::fromUTF8("appuccino"), reference.right(9));
432 EXPECT_EQ(String::fromUTF8("Cappuccino"), reference.right(10));
433}
434
435TEST(WTF, StringLeftBasic)
436{
437 auto reference = String::fromUTF8("Cappuccino");
438 EXPECT_EQ(String::fromUTF8(""), reference.left(0));
439 EXPECT_EQ(String::fromUTF8("C"), reference.left(1));
440 EXPECT_EQ(String::fromUTF8("Ca"), reference.left(2));
441 EXPECT_EQ(String::fromUTF8("Cap"), reference.left(3));
442 EXPECT_EQ(String::fromUTF8("Capp"), reference.left(4));
443 EXPECT_EQ(String::fromUTF8("Cappu"), reference.left(5));
444 EXPECT_EQ(String::fromUTF8("Cappuc"), reference.left(6));
445 EXPECT_EQ(String::fromUTF8("Cappucc"), reference.left(7));
446 EXPECT_EQ(String::fromUTF8("Cappucci"), reference.left(8));
447 EXPECT_EQ(String::fromUTF8("Cappuccin"), reference.left(9));
448 EXPECT_EQ(String::fromUTF8("Cappuccino"), reference.left(10));
449}
450
451TEST(WTF, StringReverseFindBasic)
452{
453 auto reference = String::fromUTF8("Cappuccino");
454 EXPECT_EQ(reference.reverseFind('o'), 9U);
455 EXPECT_EQ(reference.reverseFind('n'), 8U);
456 EXPECT_EQ(reference.reverseFind('c'), 6U);
457 EXPECT_EQ(reference.reverseFind('p'), 3U);
458 EXPECT_EQ(reference.reverseFind('k'), notFound);
459
460 EXPECT_EQ(reference.reverseFind('o', 8), notFound);
461 EXPECT_EQ(reference.reverseFind('c', 8), 6U);
462 EXPECT_EQ(reference.reverseFind('c', 6), 6U);
463 EXPECT_EQ(reference.reverseFind('c', 5), 5U);
464 EXPECT_EQ(reference.reverseFind('c', 4), notFound);
465}
466
467TEST(WTF, StringSplitWithConsecutiveSeparators)
468{
469 String string { " This is a sentence. " };
470
471 Vector<String> actual = string.split(' ');
472 Vector<String> expected { "This", "is", "a", "sentence." };
473 ASSERT_EQ(expected.size(), actual.size());
474 for (auto i = 0u; i < actual.size(); ++i)
475 EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i;
476
477 actual = string.splitAllowingEmptyEntries(' ');
478 expected = { "", "This", "", "", "", "", "is", "", "a", "", "", "", "", "", "", "sentence.", "" };
479 ASSERT_EQ(expected.size(), actual.size());
480 for (auto i = 0u; i < actual.size(); ++i)
481 EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i;
482}
483
484} // namespace TestWebKitAPI
485