← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Tools/TestWebKitAPI/Tests/WTF/StringBuilder.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Tools/TestWebKitAPI/Tests/WTF/StringBuilder.cpp
 
1
/*
 
2
 * Copyright (C) 2011 Google 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 are
 
6
 * met:
 
7
 *
 
8
 *     * Redistributions of source code must retain the above copyright
 
9
 * notice, this list of conditions and the following disclaimer.
 
10
 *     * Redistributions in binary form must reproduce the above
 
11
 * copyright notice, this list of conditions and the following disclaimer
 
12
 * in the documentation and/or other materials provided with the
 
13
 * distribution.
 
14
 *     * Neither the name of Google Inc. nor the names of its
 
15
 * contributors may be used to endorse or promote products derived from
 
16
 * this software without specific prior written permission.
 
17
 *
 
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
19
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
20
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
21
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
22
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
23
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
24
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
25
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
26
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
27
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
28
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
29
 */
 
30
 
 
31
#include "config.h"
 
32
#include "WTFStringUtilities.h"
 
33
 
 
34
namespace TestWebKitAPI {
 
35
 
 
36
void expectBuilderContent(const char* expected, const StringBuilder& builder)
 
37
{
 
38
    // Not using builder.toString() or builder.toStringPreserveCapacity() because they all
 
39
    // change internal state of builder.
 
40
    EXPECT_EQ(String(expected), String(builder.characters(), builder.length()));
 
41
}
 
42
 
 
43
void expectEmpty(const StringBuilder& builder)
 
44
{
 
45
    EXPECT_EQ(0U, builder.length());
 
46
    EXPECT_TRUE(builder.isEmpty());
 
47
    EXPECT_EQ(0, builder.characters());
 
48
}
 
49
 
 
50
TEST(StringBuilderTest, DefaultConstructor)
 
51
{
 
52
    StringBuilder builder;
 
53
    expectEmpty(builder);
 
54
}
 
55
 
 
56
TEST(StringBuilderTest, Append)
 
57
{
 
58
    StringBuilder builder;
 
59
    builder.append(String("0123456789"));
 
60
    expectBuilderContent("0123456789", builder);
 
61
    builder.append("abcd");
 
62
    expectBuilderContent("0123456789abcd", builder);
 
63
    builder.append("efgh", 3);
 
64
    expectBuilderContent("0123456789abcdefg", builder);
 
65
    builder.append("");
 
66
    expectBuilderContent("0123456789abcdefg", builder);
 
67
    builder.append('#');
 
68
    expectBuilderContent("0123456789abcdefg#", builder);
 
69
 
 
70
    builder.toString(); // Test after reifyString().
 
71
    StringBuilder builder1;
 
72
    builder.append("", 0);
 
73
    expectBuilderContent("0123456789abcdefg#", builder);
 
74
    builder1.append(builder.characters(), builder.length());
 
75
    builder1.append("XYZ");
 
76
    builder.append(builder1.characters(), builder1.length());
 
77
    expectBuilderContent("0123456789abcdefg#0123456789abcdefg#XYZ", builder);
 
78
 
 
79
    StringBuilder builder2;
 
80
    builder2.reserveCapacity(100);
 
81
    builder2.append("xyz");
 
82
    const UChar* characters = builder2.characters();
 
83
    builder2.append("0123456789");
 
84
    ASSERT_EQ(characters, builder2.characters());
 
85
    builder2.toStringPreserveCapacity(); // Test after reifyString with buffer preserved.
 
86
    builder2.append("abcd");
 
87
    ASSERT_EQ(characters, builder2.characters());
 
88
}
 
89
 
 
90
TEST(StringBuilderTest, ToString)
 
91
{
 
92
    StringBuilder builder;
 
93
    builder.append("0123456789");
 
94
    String string = builder.toString();
 
95
    ASSERT_EQ(String("0123456789"), string);
 
96
    ASSERT_EQ(string.impl(), builder.toString().impl());
 
97
 
 
98
    // Changing the StringBuilder should not affect the original result of toString().
 
99
    builder.append("abcdefghijklmnopqrstuvwxyz");
 
100
    ASSERT_EQ(String("0123456789"), string);
 
101
 
 
102
    // Changing the StringBuilder should not affect the original result of toString() in case the capacity is not changed.
 
103
    builder.reserveCapacity(200);
 
104
    string = builder.toString();
 
105
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string);
 
106
    builder.append("ABC");
 
107
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string);
 
108
 
 
109
    // Changing the original result of toString() should not affect the content of the StringBuilder.
 
110
    String string1 = builder.toString();
 
111
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1);
 
112
    string1.append("DEF");
 
113
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), builder.toString());
 
114
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABCDEF"), string1);
 
115
 
 
116
    // Resizing the StringBuilder should not affect the original result of toString().
 
117
    string1 = builder.toString();
 
118
    builder.resize(10);
 
119
    builder.append("###");
 
120
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1);
 
121
}
 
122
 
 
123
TEST(StringBuilderTest, ToStringPreserveCapacity)
 
124
{
 
125
    StringBuilder builder;
 
126
    builder.append("0123456789");
 
127
    unsigned capacity = builder.capacity();
 
128
    String string = builder.toStringPreserveCapacity();
 
129
    ASSERT_EQ(capacity, builder.capacity());
 
130
    ASSERT_EQ(String("0123456789"), string);
 
131
    ASSERT_EQ(string.impl(), builder.toStringPreserveCapacity().impl());
 
132
    ASSERT_EQ(string.characters(), builder.characters());
 
133
 
 
134
    // Changing the StringBuilder should not affect the original result of toStringPreserveCapacity().
 
135
    builder.append("abcdefghijklmnopqrstuvwxyz");
 
136
    ASSERT_EQ(String("0123456789"), string);
 
137
 
 
138
    // Changing the StringBuilder should not affect the original result of toStringPreserveCapacity() in case the capacity is not changed.
 
139
    builder.reserveCapacity(200);
 
140
    capacity = builder.capacity();
 
141
    string = builder.toStringPreserveCapacity();
 
142
    ASSERT_EQ(capacity, builder.capacity());
 
143
    ASSERT_EQ(string.characters(), builder.characters());
 
144
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string);
 
145
    builder.append("ABC");
 
146
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string);
 
147
 
 
148
    // Changing the original result of toStringPreserveCapacity() should not affect the content of the StringBuilder.
 
149
    capacity = builder.capacity();
 
150
    String string1 = builder.toStringPreserveCapacity();
 
151
    ASSERT_EQ(capacity, builder.capacity());
 
152
    ASSERT_EQ(string1.characters(), builder.characters());
 
153
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1);
 
154
    string1.append("DEF");
 
155
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), builder.toStringPreserveCapacity());
 
156
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABCDEF"), string1);
 
157
 
 
158
    // Resizing the StringBuilder should not affect the original result of toStringPreserveCapacity().
 
159
    capacity = builder.capacity();
 
160
    string1 = builder.toStringPreserveCapacity();
 
161
    ASSERT_EQ(capacity, builder.capacity());
 
162
    ASSERT_EQ(string.characters(), builder.characters());
 
163
    builder.resize(10);
 
164
    builder.append("###");
 
165
    ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1);
 
166
}
 
167
 
 
168
TEST(StringBuilderTest, Clear)
 
169
{
 
170
    StringBuilder builder;
 
171
    builder.append("0123456789");
 
172
    builder.clear();
 
173
    expectEmpty(builder);
 
174
}
 
175
 
 
176
TEST(StringBuilderTest, Array)
 
177
{
 
178
    StringBuilder builder;
 
179
    builder.append("0123456789");
 
180
    EXPECT_EQ('0', static_cast<char>(builder[0]));
 
181
    EXPECT_EQ('9', static_cast<char>(builder[9]));
 
182
    builder.toString(); // Test after reifyString().
 
183
    EXPECT_EQ('0', static_cast<char>(builder[0]));
 
184
    EXPECT_EQ('9', static_cast<char>(builder[9]));
 
185
}
 
186
 
 
187
TEST(StringBuilderTest, Resize)
 
188
{
 
189
    StringBuilder builder;
 
190
    builder.append("0123456789");
 
191
    builder.resize(10);
 
192
    EXPECT_EQ(10U, builder.length());
 
193
    expectBuilderContent("0123456789", builder);
 
194
    builder.resize(8);
 
195
    EXPECT_EQ(8U, builder.length());
 
196
    expectBuilderContent("01234567", builder);
 
197
 
 
198
    builder.toString();
 
199
    builder.resize(7);
 
200
    EXPECT_EQ(7U, builder.length());
 
201
    expectBuilderContent("0123456", builder);
 
202
    builder.resize(0);
 
203
    expectEmpty(builder);
 
204
}
 
205
 
 
206
TEST(StringBuilderTest, Equal)
 
207
{
 
208
    StringBuilder builder1;
 
209
    StringBuilder builder2;
 
210
    ASSERT_TRUE(builder1 == builder2);
 
211
    ASSERT_TRUE(equal(builder1, static_cast<LChar*>(0), 0));
 
212
    ASSERT_TRUE(builder1 == String());
 
213
    ASSERT_TRUE(String() == builder1);
 
214
    ASSERT_TRUE(builder1 != String("abc"));
 
215
 
 
216
    builder1.append("123");
 
217
    builder1.reserveCapacity(32);
 
218
    builder2.append("123");
 
219
    builder1.reserveCapacity(64);
 
220
    ASSERT_TRUE(builder1 == builder2);
 
221
    ASSERT_TRUE(builder1 == String("123"));
 
222
    ASSERT_TRUE(String("123") == builder1);
 
223
 
 
224
    builder2.append("456");
 
225
    ASSERT_TRUE(builder1 != builder2);
 
226
    ASSERT_TRUE(builder2 != builder1);
 
227
    ASSERT_TRUE(String("123") != builder2);
 
228
    ASSERT_TRUE(builder2 != String("123"));
 
229
    builder2.toString(); // Test after reifyString().
 
230
    ASSERT_TRUE(builder1 != builder2);
 
231
 
 
232
    builder2.resize(3);
 
233
    ASSERT_TRUE(builder1 == builder2);
 
234
 
 
235
    builder1.toString(); // Test after reifyString().
 
236
    ASSERT_TRUE(builder1 == builder2);
 
237
}
 
238
 
 
239
TEST(StringBuilderTest, CanShrink)
 
240
{
 
241
    StringBuilder builder;
 
242
    builder.reserveCapacity(256);
 
243
    ASSERT_TRUE(builder.canShrink());
 
244
    for (int i = 0; i < 256; i++)
 
245
        builder.append('x');
 
246
    ASSERT_EQ(builder.length(), builder.capacity());
 
247
    ASSERT_FALSE(builder.canShrink());
 
248
}
 
249
 
 
250
TEST(StringBuilderTest, ToAtomicString)
 
251
{
 
252
    StringBuilder builder;
 
253
    builder.append("123");
 
254
    AtomicString atomicString = builder.toAtomicString();
 
255
    ASSERT_EQ(String("123"), atomicString);
 
256
 
 
257
    builder.reserveCapacity(256);
 
258
    ASSERT_TRUE(builder.canShrink());
 
259
    for (int i = builder.length(); i < 128; i++)
 
260
        builder.append('x');
 
261
    AtomicString atomicString1 = builder.toAtomicString();
 
262
    ASSERT_EQ(128u, atomicString1.length());
 
263
    ASSERT_EQ('x', atomicString1[127]);
 
264
 
 
265
    // Later change of builder should not affect the atomic string.
 
266
    for (int i = builder.length(); i < 256; i++)
 
267
        builder.append('x');
 
268
    ASSERT_EQ(128u, atomicString1.length());
 
269
 
 
270
    ASSERT_FALSE(builder.canShrink());
 
271
    String string = builder.toString();
 
272
    AtomicString atomicString2 = builder.toAtomicString();
 
273
    // They should share the same StringImpl.
 
274
    ASSERT_EQ(atomicString2.impl(), string.impl());
 
275
}
 
276
 
 
277
} // namespace