1 /*
2 * Copyright (C) 2011 Google Inc. All rights reserved.
3 * Copyright (C) 2013 Apple Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met:
8 *
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * * Redistributions in binary form must reproduce the above
12 * copyright notice, this list of conditions and the following disclaimer
13 * in the documentation and/or other materials provided with the
14 * distribution.
15 * * Neither the name of Google Inc. nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "config.h"
33
34 #include "wtf/Assertions.h"
35 #include "wtf/text/CString.h"
36 #include "wtf/text/StringBuilder.h"
37 #include "wtf/text/WTFString.h"
38 #include "wtf/unicode/CharacterNames.h"
39 #include <gtest/gtest.h>
40
41 namespace WTF {
42
operator <<(std::ostream & os,const String & string)43 static std::ostream& operator<<(std::ostream& os, const String& string)
44 {
45 return os << string.utf8().data();
46 }
47
48 }
49
50 namespace {
51
expectBuilderContent(const String & expected,const StringBuilder & builder)52 static void expectBuilderContent(const String& expected, const StringBuilder& builder)
53 {
54 // Not using builder.toString() because it changes internal state of builder.
55 if (builder.is8Bit())
56 EXPECT_EQ(expected, String(builder.characters8(), builder.length()));
57 else
58 EXPECT_EQ(expected, String(builder.characters16(), builder.length()));
59 }
60
expectEmpty(const StringBuilder & builder)61 void expectEmpty(const StringBuilder& builder)
62 {
63 EXPECT_EQ(0U, builder.length());
64 EXPECT_TRUE(builder.isEmpty());
65 EXPECT_EQ(0, builder.characters8());
66 }
67
TEST(StringBuilderTest,DefaultConstructor)68 TEST(StringBuilderTest, DefaultConstructor)
69 {
70 StringBuilder builder;
71 expectEmpty(builder);
72 }
73
TEST(StringBuilderTest,Append)74 TEST(StringBuilderTest, Append)
75 {
76 StringBuilder builder;
77 builder.append(String("0123456789"));
78 expectBuilderContent("0123456789", builder);
79 builder.append("abcd");
80 expectBuilderContent("0123456789abcd", builder);
81 builder.append("efgh", 3);
82 expectBuilderContent("0123456789abcdefg", builder);
83 builder.append("");
84 expectBuilderContent("0123456789abcdefg", builder);
85 builder.append('#');
86 expectBuilderContent("0123456789abcdefg#", builder);
87
88 builder.toString(); // Test after reifyString().
89 StringBuilder builder1;
90 builder.append("", 0);
91 expectBuilderContent("0123456789abcdefg#", builder);
92 builder1.append(builder.characters8(), builder.length());
93 builder1.append("XYZ");
94 builder.append(builder1.characters8(), builder1.length());
95 expectBuilderContent("0123456789abcdefg#0123456789abcdefg#XYZ", builder);
96
97 StringBuilder builder2;
98 builder2.reserveCapacity(100);
99 builder2.append("xyz");
100 const LChar* characters = builder2.characters8();
101 builder2.append("0123456789");
102 ASSERT_EQ(characters, builder2.characters8());
103
104 // Test appending UChar32 characters to StringBuilder.
105 StringBuilder builderForUChar32Append;
106 UChar32 frakturAChar = 0x1D504;
107 builderForUChar32Append.append(frakturAChar); // The fraktur A is not in the BMP, so it's two UTF-16 code units long.
108 ASSERT_EQ(2U, builderForUChar32Append.length());
109 builderForUChar32Append.append(static_cast<UChar32>('A'));
110 ASSERT_EQ(3U, builderForUChar32Append.length());
111 const UChar resultArray[] = { U16_LEAD(frakturAChar), U16_TRAIL(frakturAChar), 'A' };
112 expectBuilderContent(String(resultArray, WTF_ARRAY_LENGTH(resultArray)), builderForUChar32Append);
113 }
114
TEST(StringBuilderTest,ToString)115 TEST(StringBuilderTest, ToString)
116 {
117 StringBuilder builder;
118 builder.append("0123456789");
119 String string = builder.toString();
120 ASSERT_EQ(String("0123456789"), string);
121 ASSERT_EQ(string.impl(), builder.toString().impl());
122
123 // Changing the StringBuilder should not affect the original result of toString().
124 builder.append("abcdefghijklmnopqrstuvwxyz");
125 ASSERT_EQ(String("0123456789"), string);
126
127 // Changing the StringBuilder should not affect the original result of toString() in case the capacity is not changed.
128 builder.reserveCapacity(200);
129 string = builder.toString();
130 ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string);
131 builder.append("ABC");
132 ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string);
133
134 // Changing the original result of toString() should not affect the content of the StringBuilder.
135 String string1 = builder.toString();
136 ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1);
137 string1.append("DEF");
138 ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), builder.toString());
139 ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABCDEF"), string1);
140
141 // Resizing the StringBuilder should not affect the original result of toString().
142 string1 = builder.toString();
143 builder.resize(10);
144 builder.append("###");
145 ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1);
146 }
147
TEST(StringBuilderTest,Clear)148 TEST(StringBuilderTest, Clear)
149 {
150 StringBuilder builder;
151 builder.append("0123456789");
152 builder.clear();
153 expectEmpty(builder);
154 }
155
TEST(StringBuilderTest,Array)156 TEST(StringBuilderTest, Array)
157 {
158 StringBuilder builder;
159 builder.append("0123456789");
160 EXPECT_EQ('0', static_cast<char>(builder[0]));
161 EXPECT_EQ('9', static_cast<char>(builder[9]));
162 builder.toString(); // Test after reifyString().
163 EXPECT_EQ('0', static_cast<char>(builder[0]));
164 EXPECT_EQ('9', static_cast<char>(builder[9]));
165 }
166
TEST(StringBuilderTest,Resize)167 TEST(StringBuilderTest, Resize)
168 {
169 StringBuilder builder;
170 builder.append("0123456789");
171 builder.resize(10);
172 EXPECT_EQ(10U, builder.length());
173 expectBuilderContent("0123456789", builder);
174 builder.resize(8);
175 EXPECT_EQ(8U, builder.length());
176 expectBuilderContent("01234567", builder);
177
178 builder.toString();
179 builder.resize(7);
180 EXPECT_EQ(7U, builder.length());
181 expectBuilderContent("0123456", builder);
182 builder.resize(0);
183 expectEmpty(builder);
184 }
185
TEST(StringBuilderTest,Equal)186 TEST(StringBuilderTest, Equal)
187 {
188 StringBuilder builder1;
189 StringBuilder builder2;
190 ASSERT_TRUE(builder1 == builder2);
191 ASSERT_TRUE(equal(builder1, static_cast<LChar*>(0), 0));
192 ASSERT_TRUE(builder1 == String());
193 ASSERT_TRUE(String() == builder1);
194 ASSERT_TRUE(builder1 != String("abc"));
195
196 builder1.append("123");
197 builder1.reserveCapacity(32);
198 builder2.append("123");
199 builder1.reserveCapacity(64);
200 ASSERT_TRUE(builder1 == builder2);
201 ASSERT_TRUE(builder1 == String("123"));
202 ASSERT_TRUE(String("123") == builder1);
203
204 builder2.append("456");
205 ASSERT_TRUE(builder1 != builder2);
206 ASSERT_TRUE(builder2 != builder1);
207 ASSERT_TRUE(String("123") != builder2);
208 ASSERT_TRUE(builder2 != String("123"));
209 builder2.toString(); // Test after reifyString().
210 ASSERT_TRUE(builder1 != builder2);
211
212 builder2.resize(3);
213 ASSERT_TRUE(builder1 == builder2);
214
215 builder1.toString(); // Test after reifyString().
216 ASSERT_TRUE(builder1 == builder2);
217 }
218
TEST(StringBuilderTest,CanShrink)219 TEST(StringBuilderTest, CanShrink)
220 {
221 StringBuilder builder;
222 builder.reserveCapacity(256);
223 ASSERT_TRUE(builder.canShrink());
224 for (int i = 0; i < 256; i++)
225 builder.append('x');
226 ASSERT_EQ(builder.length(), builder.capacity());
227 ASSERT_FALSE(builder.canShrink());
228 }
229
TEST(StringBuilderTest,ToAtomicString)230 TEST(StringBuilderTest, ToAtomicString)
231 {
232 StringBuilder builder;
233 builder.append("123");
234 AtomicString atomicString = builder.toAtomicString();
235 ASSERT_EQ(String("123"), atomicString);
236
237 builder.reserveCapacity(256);
238 ASSERT_TRUE(builder.canShrink());
239 for (int i = builder.length(); i < 128; i++)
240 builder.append('x');
241 AtomicString atomicString1 = builder.toAtomicString();
242 ASSERT_EQ(128u, atomicString1.length());
243 ASSERT_EQ('x', atomicString1[127]);
244
245 // Later change of builder should not affect the atomic string.
246 for (int i = builder.length(); i < 256; i++)
247 builder.append('x');
248 ASSERT_EQ(128u, atomicString1.length());
249
250 ASSERT_FALSE(builder.canShrink());
251 String string = builder.toString();
252 AtomicString atomicString2 = builder.toAtomicString();
253 // They should share the same StringImpl.
254 ASSERT_EQ(atomicString2.impl(), string.impl());
255 }
256
TEST(StringBuilderTest,ToAtomicStringOnEmpty)257 TEST(StringBuilderTest, ToAtomicStringOnEmpty)
258 {
259 { // Default constructed.
260 StringBuilder builder;
261 AtomicString atomicString = builder.toAtomicString();
262 ASSERT_EQ(emptyAtom, atomicString);
263 }
264 { // With capacity.
265 StringBuilder builder;
266 builder.reserveCapacity(64);
267 AtomicString atomicString = builder.toAtomicString();
268 ASSERT_EQ(emptyAtom, atomicString);
269 }
270 { // AtomicString constructed from a null string.
271 StringBuilder builder;
272 builder.append(String());
273 AtomicString atomicString = builder.toAtomicString();
274 ASSERT_EQ(emptyAtom, atomicString);
275 }
276 { // AtomicString constructed from an empty string.
277 StringBuilder builder;
278 builder.append(emptyString());
279 AtomicString atomicString = builder.toAtomicString();
280 ASSERT_EQ(emptyAtom, atomicString);
281 }
282 { // AtomicString constructed from an empty StringBuilder.
283 StringBuilder builder;
284 StringBuilder emptyBuilder;
285 builder.append(emptyBuilder);
286 AtomicString atomicString = builder.toAtomicString();
287 ASSERT_EQ(emptyAtom, atomicString);
288 }
289 { // AtomicString constructed from an empty char* string.
290 StringBuilder builder;
291 builder.append("", 0);
292 AtomicString atomicString = builder.toAtomicString();
293 ASSERT_EQ(emptyAtom, atomicString);
294 }
295 { // Cleared StringBuilder.
296 StringBuilder builder;
297 builder.appendLiteral("WebKit");
298 builder.clear();
299 AtomicString atomicString = builder.toAtomicString();
300 ASSERT_EQ(emptyAtom, atomicString);
301 }
302 }
303
TEST(StringBuilderTest,Substring)304 TEST(StringBuilderTest, Substring)
305 {
306 { // Default constructed.
307 StringBuilder builder;
308 String substring = builder.substring(0, 10);
309 ASSERT_EQ(emptyString(), substring);
310 }
311 { // With capacity.
312 StringBuilder builder;
313 builder.reserveCapacity(64);
314 builder.append("abc");
315 String substring = builder.substring(2, 10);
316 ASSERT_EQ(String("c"), substring);
317 }
318 }
319
TEST(StringBuilderTest,AppendNumberDoubleUChar)320 TEST(StringBuilderTest, AppendNumberDoubleUChar)
321 {
322 const double someNumber = 1.2345;
323 StringBuilder reference;
324 reference.append(replacementCharacter); // Make it UTF-16.
325 reference.append(String::number(someNumber));
326 StringBuilder test;
327 test.append(replacementCharacter);
328 test.appendNumber(someNumber);
329 ASSERT_EQ(reference, test);
330 }
331
332 } // namespace
333