Revision f230a1cf deps/v8/test/cctest/test-unique.cc
deps/v8/test/cctest/test-unique.cc | ||
---|---|---|
36 | 36 |
|
37 | 37 |
using namespace v8::internal; |
38 | 38 |
|
39 |
#define MAKE_HANDLES_AND_DISALLOW_ALLOCATION \ |
|
40 |
Isolate* isolate = CcTest::i_isolate(); \ |
|
41 |
Factory* factory = isolate->factory(); \ |
|
42 |
HandleScope sc(isolate); \ |
|
43 |
Handle<String> handles[] = { \ |
|
44 |
factory->InternalizeUtf8String("A"), \ |
|
45 |
factory->InternalizeUtf8String("B"), \ |
|
46 |
factory->InternalizeUtf8String("C"), \ |
|
47 |
factory->InternalizeUtf8String("D"), \ |
|
48 |
factory->InternalizeUtf8String("E"), \ |
|
49 |
factory->InternalizeUtf8String("F"), \ |
|
50 |
factory->InternalizeUtf8String("G") \ |
|
51 |
}; \ |
|
52 |
DisallowHeapAllocation _disable |
|
53 |
|
|
54 |
#define MAKE_UNIQUES_A_B_C \ |
|
55 |
Unique<String> A(handles[0]); \ |
|
56 |
Unique<String> B(handles[1]); \ |
|
57 |
Unique<String> C(handles[2]) |
|
58 |
|
|
59 |
#define MAKE_UNIQUES_A_B_C_D_E_F_G \ |
|
60 |
Unique<String> A(handles[0]); \ |
|
61 |
Unique<String> B(handles[1]); \ |
|
62 |
Unique<String> C(handles[2]); \ |
|
63 |
Unique<String> D(handles[3]); \ |
|
64 |
Unique<String> E(handles[4]); \ |
|
65 |
Unique<String> F(handles[5]); \ |
|
66 |
Unique<String> G(handles[6]) |
|
67 |
|
|
39 | 68 |
template <class T, class U> |
40 | 69 |
void CheckHashCodeEqual(Unique<T> a, Unique<U> b) { |
41 | 70 |
int64_t hasha = static_cast<int64_t>(a.Hashcode()); |
... | ... | |
58 | 87 |
|
59 | 88 |
TEST(UniqueCreate) { |
60 | 89 |
CcTest::InitializeVM(); |
61 |
Isolate* isolate = Isolate::Current(); |
|
62 |
Factory* factory = isolate->factory(); |
|
63 |
HandleScope sc(isolate); |
|
90 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
91 |
Handle<String> A = handles[0], B = handles[1]; |
|
64 | 92 |
|
65 |
Handle<String> A = factory->InternalizeUtf8String("A"); |
|
66 | 93 |
Unique<String> HA(A); |
67 | 94 |
|
68 | 95 |
CHECK(*HA.handle() == *A); |
... | ... | |
77 | 104 |
CHECK(HA2 == HA); |
78 | 105 |
CHECK_EQ(*HA2.handle(), *HA.handle()); |
79 | 106 |
|
80 |
Handle<String> B = factory->InternalizeUtf8String("B"); |
|
81 | 107 |
Unique<String> HB(B); |
82 | 108 |
|
83 | 109 |
CheckHashCodeNotEqual(HA, HB); |
... | ... | |
93 | 119 |
|
94 | 120 |
TEST(UniqueSubsume) { |
95 | 121 |
CcTest::InitializeVM(); |
96 |
Isolate* isolate = Isolate::Current(); |
|
97 |
Factory* factory = isolate->factory(); |
|
98 |
HandleScope sc(isolate); |
|
122 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
123 |
Handle<String> A = handles[0]; |
|
99 | 124 |
|
100 |
Handle<String> A = factory->InternalizeUtf8String("A"); |
|
101 | 125 |
Unique<String> HA(A); |
102 | 126 |
|
103 | 127 |
CHECK(*HA.handle() == *A); |
... | ... | |
116 | 140 |
|
117 | 141 |
TEST(UniqueSet_Add) { |
118 | 142 |
CcTest::InitializeVM(); |
119 |
Isolate* isolate = Isolate::Current(); |
|
120 |
Factory* factory = isolate->factory(); |
|
121 |
HandleScope sc(isolate); |
|
122 |
|
|
123 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
124 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
125 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
143 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
144 |
MAKE_UNIQUES_A_B_C; |
|
126 | 145 |
|
127 | 146 |
Zone zone(isolate); |
128 | 147 |
|
... | ... | |
146 | 165 |
} |
147 | 166 |
|
148 | 167 |
|
168 |
TEST(UniqueSet_Remove) { |
|
169 |
CcTest::InitializeVM(); |
|
170 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
171 |
MAKE_UNIQUES_A_B_C; |
|
172 |
|
|
173 |
Zone zone(isolate); |
|
174 |
|
|
175 |
UniqueSet<String>* set = new(&zone) UniqueSet<String>(); |
|
176 |
|
|
177 |
set->Add(A, &zone); |
|
178 |
set->Add(B, &zone); |
|
179 |
set->Add(C, &zone); |
|
180 |
CHECK_EQ(3, set->size()); |
|
181 |
|
|
182 |
set->Remove(A); |
|
183 |
CHECK_EQ(2, set->size()); |
|
184 |
CHECK(!set->Contains(A)); |
|
185 |
CHECK(set->Contains(B)); |
|
186 |
CHECK(set->Contains(C)); |
|
187 |
|
|
188 |
set->Remove(A); |
|
189 |
CHECK_EQ(2, set->size()); |
|
190 |
CHECK(!set->Contains(A)); |
|
191 |
CHECK(set->Contains(B)); |
|
192 |
CHECK(set->Contains(C)); |
|
193 |
|
|
194 |
set->Remove(B); |
|
195 |
CHECK_EQ(1, set->size()); |
|
196 |
CHECK(!set->Contains(A)); |
|
197 |
CHECK(!set->Contains(B)); |
|
198 |
CHECK(set->Contains(C)); |
|
199 |
|
|
200 |
set->Remove(C); |
|
201 |
CHECK_EQ(0, set->size()); |
|
202 |
CHECK(!set->Contains(A)); |
|
203 |
CHECK(!set->Contains(B)); |
|
204 |
CHECK(!set->Contains(C)); |
|
205 |
} |
|
206 |
|
|
207 |
|
|
208 |
TEST(UniqueSet_Contains) { |
|
209 |
CcTest::InitializeVM(); |
|
210 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
211 |
MAKE_UNIQUES_A_B_C; |
|
212 |
|
|
213 |
Zone zone(isolate); |
|
214 |
|
|
215 |
UniqueSet<String>* set = new(&zone) UniqueSet<String>(); |
|
216 |
|
|
217 |
CHECK_EQ(0, set->size()); |
|
218 |
set->Add(A, &zone); |
|
219 |
CHECK(set->Contains(A)); |
|
220 |
CHECK(!set->Contains(B)); |
|
221 |
CHECK(!set->Contains(C)); |
|
222 |
|
|
223 |
set->Add(A, &zone); |
|
224 |
CHECK(set->Contains(A)); |
|
225 |
CHECK(!set->Contains(B)); |
|
226 |
CHECK(!set->Contains(C)); |
|
227 |
|
|
228 |
set->Add(B, &zone); |
|
229 |
CHECK(set->Contains(A)); |
|
230 |
CHECK(set->Contains(B)); |
|
231 |
|
|
232 |
set->Add(C, &zone); |
|
233 |
CHECK(set->Contains(A)); |
|
234 |
CHECK(set->Contains(B)); |
|
235 |
CHECK(set->Contains(C)); |
|
236 |
} |
|
237 |
|
|
238 |
|
|
239 |
TEST(UniqueSet_At) { |
|
240 |
CcTest::InitializeVM(); |
|
241 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
242 |
MAKE_UNIQUES_A_B_C; |
|
243 |
|
|
244 |
Zone zone(isolate); |
|
245 |
|
|
246 |
UniqueSet<String>* set = new(&zone) UniqueSet<String>(); |
|
247 |
|
|
248 |
CHECK_EQ(0, set->size()); |
|
249 |
set->Add(A, &zone); |
|
250 |
CHECK(A == set->at(0)); |
|
251 |
|
|
252 |
set->Add(A, &zone); |
|
253 |
CHECK(A == set->at(0)); |
|
254 |
|
|
255 |
set->Add(B, &zone); |
|
256 |
CHECK(A == set->at(0) || B == set->at(0)); |
|
257 |
CHECK(A == set->at(1) || B == set->at(1)); |
|
258 |
|
|
259 |
set->Add(C, &zone); |
|
260 |
CHECK(A == set->at(0) || B == set->at(0) || C == set->at(0)); |
|
261 |
CHECK(A == set->at(1) || B == set->at(1) || C == set->at(1)); |
|
262 |
CHECK(A == set->at(2) || B == set->at(2) || C == set->at(2)); |
|
263 |
} |
|
264 |
|
|
265 |
|
|
149 | 266 |
template <class T> |
150 | 267 |
static void CHECK_SETS( |
151 | 268 |
UniqueSet<T>* set1, UniqueSet<T>* set2, bool expected) { |
... | ... | |
158 | 275 |
|
159 | 276 |
TEST(UniqueSet_Equals) { |
160 | 277 |
CcTest::InitializeVM(); |
161 |
Isolate* isolate = Isolate::Current(); |
|
162 |
Factory* factory = isolate->factory(); |
|
163 |
HandleScope sc(isolate); |
|
164 |
|
|
165 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
166 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
167 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
278 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
279 |
MAKE_UNIQUES_A_B_C; |
|
168 | 280 |
|
169 | 281 |
Zone zone(isolate); |
170 | 282 |
|
... | ... | |
201 | 313 |
|
202 | 314 |
TEST(UniqueSet_IsSubset1) { |
203 | 315 |
CcTest::InitializeVM(); |
204 |
Isolate* isolate = Isolate::Current(); |
|
205 |
Factory* factory = isolate->factory(); |
|
206 |
HandleScope sc(isolate); |
|
207 |
|
|
208 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
209 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
210 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
316 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
317 |
MAKE_UNIQUES_A_B_C; |
|
211 | 318 |
|
212 | 319 |
Zone zone(isolate); |
213 | 320 |
|
... | ... | |
241 | 348 |
|
242 | 349 |
TEST(UniqueSet_IsSubset2) { |
243 | 350 |
CcTest::InitializeVM(); |
244 |
Isolate* isolate = Isolate::Current(); |
|
245 |
Factory* factory = isolate->factory(); |
|
246 |
HandleScope sc(isolate); |
|
247 |
|
|
248 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
249 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
250 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
251 |
Unique<String> D(factory->InternalizeUtf8String("D")); |
|
252 |
Unique<String> E(factory->InternalizeUtf8String("E")); |
|
253 |
Unique<String> F(factory->InternalizeUtf8String("F")); |
|
254 |
Unique<String> G(factory->InternalizeUtf8String("G")); |
|
351 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
352 |
MAKE_UNIQUES_A_B_C_D_E_F_G; |
|
255 | 353 |
|
256 | 354 |
Zone zone(isolate); |
257 | 355 |
|
... | ... | |
293 | 391 |
const int kSetSize = 6; |
294 | 392 |
|
295 | 393 |
CcTest::InitializeVM(); |
296 |
Isolate* isolate = Isolate::Current(); |
|
297 |
Factory* factory = isolate->factory(); |
|
298 |
HandleScope sc(isolate); |
|
394 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
395 |
MAKE_UNIQUES_A_B_C_D_E_F_G; |
|
299 | 396 |
|
300 | 397 |
Zone zone(isolate); |
301 | 398 |
|
302 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
303 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
304 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
305 |
Unique<String> D(factory->InternalizeUtf8String("D")); |
|
306 |
Unique<String> E(factory->InternalizeUtf8String("E")); |
|
307 |
Unique<String> F(factory->InternalizeUtf8String("F")); |
|
308 |
Unique<String> G(factory->InternalizeUtf8String("G")); |
|
309 |
|
|
310 | 399 |
Unique<String> elements[] = { |
311 | 400 |
A, B, C, D, E, F, G |
312 | 401 |
}; |
... | ... | |
325 | 414 |
|
326 | 415 |
TEST(UniqueSet_Intersect1) { |
327 | 416 |
CcTest::InitializeVM(); |
328 |
Isolate* isolate = Isolate::Current(); |
|
329 |
Factory* factory = isolate->factory(); |
|
330 |
HandleScope sc(isolate); |
|
331 |
|
|
332 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
333 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
334 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
417 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
418 |
MAKE_UNIQUES_A_B_C; |
|
335 | 419 |
|
336 | 420 |
Zone zone(isolate); |
337 | 421 |
|
... | ... | |
371 | 455 |
const int kSetSize = 6; |
372 | 456 |
|
373 | 457 |
CcTest::InitializeVM(); |
374 |
Isolate* isolate = Isolate::Current(); |
|
375 |
Factory* factory = isolate->factory(); |
|
376 |
HandleScope sc(isolate); |
|
458 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
459 |
MAKE_UNIQUES_A_B_C_D_E_F_G; |
|
377 | 460 |
|
378 | 461 |
Zone zone(isolate); |
379 | 462 |
|
380 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
381 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
382 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
383 |
Unique<String> D(factory->InternalizeUtf8String("D")); |
|
384 |
Unique<String> E(factory->InternalizeUtf8String("E")); |
|
385 |
Unique<String> F(factory->InternalizeUtf8String("F")); |
|
386 |
Unique<String> G(factory->InternalizeUtf8String("G")); |
|
387 |
|
|
388 | 463 |
Unique<String> elements[] = { |
389 | 464 |
A, B, C, D, E, F, G |
390 | 465 |
}; |
... | ... | |
407 | 482 |
|
408 | 483 |
TEST(UniqueSet_Union1) { |
409 | 484 |
CcTest::InitializeVM(); |
410 |
Isolate* isolate = Isolate::Current(); |
|
411 |
Factory* factory = isolate->factory(); |
|
412 |
HandleScope sc(isolate); |
|
413 |
|
|
414 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
415 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
416 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
485 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
486 |
MAKE_UNIQUES_A_B_C; |
|
417 | 487 |
|
418 | 488 |
Zone zone(isolate); |
419 | 489 |
|
... | ... | |
453 | 523 |
const int kSetSize = 6; |
454 | 524 |
|
455 | 525 |
CcTest::InitializeVM(); |
456 |
Isolate* isolate = Isolate::Current(); |
|
457 |
Factory* factory = isolate->factory(); |
|
458 |
HandleScope sc(isolate); |
|
526 |
MAKE_HANDLES_AND_DISALLOW_ALLOCATION; |
|
527 |
MAKE_UNIQUES_A_B_C_D_E_F_G; |
|
459 | 528 |
|
460 | 529 |
Zone zone(isolate); |
461 | 530 |
|
462 |
Unique<String> A(factory->InternalizeUtf8String("A")); |
|
463 |
Unique<String> B(factory->InternalizeUtf8String("B")); |
|
464 |
Unique<String> C(factory->InternalizeUtf8String("C")); |
|
465 |
Unique<String> D(factory->InternalizeUtf8String("D")); |
|
466 |
Unique<String> E(factory->InternalizeUtf8String("E")); |
|
467 |
Unique<String> F(factory->InternalizeUtf8String("F")); |
|
468 |
Unique<String> G(factory->InternalizeUtf8String("G")); |
|
469 |
|
|
470 | 531 |
Unique<String> elements[] = { |
471 | 532 |
A, B, C, D, E, F, G |
472 | 533 |
}; |
Also available in: Unified diff