e0d99106cd9333a66f13079a367efc1daa3e0a2e
[WebKit-https.git] / Tools / TestWebKitAPI / Tests / WTF / Poisoned.cpp
1 /*
2  * Copyright (C) 2017-2018 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. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27
28 #include "RefLogger.h"
29 #include <mutex>
30 #include <wtf/Poisoned.h>
31
32 namespace TestWebKitAPI {
33
34 namespace {
35
36 uintptr_t g_testPoisonA;
37 uintptr_t g_testPoisonB;
38
39 using TestPoisonA = Poison<g_testPoisonA>;
40 using TestPoisonB = Poison<g_testPoisonB>;
41
42 static void initializeTestPoison()
43 {
44     static std::once_flag initializeOnceFlag;
45     std::call_once(initializeOnceFlag, [] {
46         // Make sure we get 2 different poison values.
47         g_testPoisonA = makePoison();
48         while (!g_testPoisonB || g_testPoisonB == g_testPoisonA)
49             g_testPoisonB = makePoison();
50     });
51 }
52
53 } // namespace anonymous
54
55 // For these tests, we need a base class and a derived class. For this purpose,
56 // we reuse the RefLogger and DerivedRefLogger classes.
57
58 TEST(WTF_Poisoned, DISABLED_Basic)
59 {
60     initializeTestPoison();
61     DerivedRefLogger a("a");
62
63     {
64         Poisoned<TestPoisonA, RefLogger*> empty;
65         ASSERT_EQ(nullptr, empty.unpoisoned());
66     }
67
68     {
69         Poisoned<TestPoisonA, RefLogger*> empty(nullptr);
70         ASSERT_EQ(nullptr, empty.unpoisoned());
71     }
72
73     {
74         Poisoned<TestPoisonA, RefLogger*> ptr(&a);
75         ASSERT_EQ(&a, ptr.unpoisoned());
76         ASSERT_EQ(&a, &*ptr);
77         ASSERT_EQ(&a.name, &ptr->name);
78
79 #if ENABLE(POISON)
80         uintptr_t ptrBits;
81         std::memcpy(&ptrBits, &ptr, sizeof(ptrBits));
82         ASSERT_TRUE(ptrBits != bitwise_cast<uintptr_t>(&a));
83 #if ENABLE(POISON_ASSERTS)
84         ASSERT_TRUE((Poisoned<TestPoisonA, RefLogger*>::isPoisoned(ptrBits)));
85 #endif
86 #endif // ENABLE(POISON)
87     }
88
89     {
90         Poisoned<TestPoisonA, RefLogger*> ptr = &a;
91         ASSERT_EQ(&a, ptr.unpoisoned());
92     }
93
94     {
95         Poisoned<TestPoisonA, RefLogger*> p1 = &a;
96         Poisoned<TestPoisonA, RefLogger*> p2(p1);
97
98         ASSERT_EQ(&a, p1.unpoisoned());
99         ASSERT_EQ(&a, p2.unpoisoned());
100         ASSERT_TRUE(p1 == p2);
101         ASSERT_TRUE(p1.bits() == p2.bits());
102
103         Poisoned<TestPoisonB, RefLogger*> p3(p1);
104         ASSERT_EQ(&a, p3.unpoisoned());
105         ASSERT_TRUE(p1 == p3);
106         ASSERT_TRUE(p1.bits() != p3.bits());
107     }
108
109     {
110         Poisoned<TestPoisonA, RefLogger*> p1 = &a;
111         Poisoned<TestPoisonA, RefLogger*> p2 = p1;
112         ASSERT_EQ(&a, p1.unpoisoned());
113         ASSERT_EQ(&a, p2.unpoisoned());
114         ASSERT_TRUE(p1 == p2);
115         ASSERT_TRUE(p1.bits() == p2.bits());
116
117         Poisoned<TestPoisonB, RefLogger*> p3 = p1;
118         ASSERT_EQ(&a, p3.unpoisoned());
119         ASSERT_TRUE(p1 == p3);
120         ASSERT_TRUE(p1.bits() != p3.bits());
121     }
122
123     {
124         Poisoned<TestPoisonA, RefLogger*> p1 = &a;
125         Poisoned<TestPoisonA, RefLogger*> p2 = WTFMove(p1);
126         ASSERT_EQ(&a, p1.unpoisoned());
127         ASSERT_EQ(&a, p2.unpoisoned());
128         ASSERT_TRUE(p1 == p2);
129         ASSERT_TRUE(p1.bits() == p2.bits());
130
131         Poisoned<TestPoisonA, RefLogger*> p3 = &a;
132         Poisoned<TestPoisonB, RefLogger*> p4 = WTFMove(p3);
133         ASSERT_EQ(&a, p3.unpoisoned());
134         ASSERT_EQ(&a, p4.unpoisoned());
135         ASSERT_TRUE(p3 == p4);
136         ASSERT_TRUE(p3.bits() != p4.bits());
137     }
138
139     {
140         Poisoned<TestPoisonA, RefLogger*> p1 = &a;
141         Poisoned<TestPoisonA, RefLogger*> p2(WTFMove(p1));
142         ASSERT_EQ(&a, p1.unpoisoned());
143         ASSERT_EQ(&a, p2.unpoisoned());
144         ASSERT_TRUE(p1 == p2);
145         ASSERT_TRUE(p1.bits() == p2.bits());
146
147         Poisoned<TestPoisonA, RefLogger*> p3 = &a;
148         Poisoned<TestPoisonB, RefLogger*> p4(WTFMove(p3));
149         ASSERT_EQ(&a, p3.unpoisoned());
150         ASSERT_EQ(&a, p4.unpoisoned());
151         ASSERT_TRUE(p3 == p4);
152         ASSERT_TRUE(p3.bits() != p4.bits());
153     }
154
155     {
156         Poisoned<TestPoisonA, DerivedRefLogger*> p1 = &a;
157         Poisoned<TestPoisonA, RefLogger*> p2 = p1;
158         ASSERT_EQ(&a, p1.unpoisoned());
159         ASSERT_EQ(&a, p2.unpoisoned());
160         ASSERT_TRUE(p1 == p2);
161         ASSERT_TRUE(p2 == p1);
162         ASSERT_TRUE(p1.bits() == p2.bits());
163
164         Poisoned<TestPoisonB, RefLogger*> p3 = p1;
165         ASSERT_EQ(&a, p3.unpoisoned());
166         ASSERT_TRUE(p1 == p3);
167         ASSERT_TRUE(p3 == p1);
168         ASSERT_TRUE(p1.bits() != p3.bits());
169     }
170
171     {
172         Poisoned<TestPoisonA, DerivedRefLogger*> p1 = &a;
173         Poisoned<TestPoisonA, RefLogger*> p2 = WTFMove(p1);
174         ASSERT_EQ(&a, p1.unpoisoned());
175         ASSERT_EQ(&a, p2.unpoisoned());
176         ASSERT_TRUE(p1 == p2);
177         ASSERT_TRUE(p2 == p1);
178         ASSERT_TRUE(p1.bits() == p2.bits());
179
180         Poisoned<TestPoisonA, DerivedRefLogger*> p3 = &a;
181         Poisoned<TestPoisonB, RefLogger*> p4 = WTFMove(p3);
182         ASSERT_EQ(&a, p3.unpoisoned());
183         ASSERT_EQ(&a, p4.unpoisoned());
184         ASSERT_TRUE(p3 == p4);
185         ASSERT_TRUE(p4 == p3);
186         ASSERT_TRUE(p3.bits() != p4.bits());
187     }
188
189     {
190         Poisoned<TestPoisonA, RefLogger*> ptr(&a);
191         ASSERT_EQ(&a, ptr.unpoisoned());
192         ptr.clear();
193         ASSERT_EQ(nullptr, ptr.unpoisoned());
194     }
195
196     {
197         Poisoned<TestPoisonA, RefLogger*> pA1000a = reinterpret_cast<RefLogger*>(0x1000);
198         Poisoned<TestPoisonB, RefLogger*> pB2000a = reinterpret_cast<RefLogger*>(0x2000);
199
200         Poisoned<TestPoisonA, RefLogger*> pA1000b = reinterpret_cast<RefLogger*>(0x1000);
201         Poisoned<TestPoisonA, RefLogger*> pA2000b = reinterpret_cast<RefLogger*>(0x2000);
202
203         Poisoned<TestPoisonB, RefLogger*> pB1000c = reinterpret_cast<RefLogger*>(0x1000);
204         Poisoned<TestPoisonB, RefLogger*> pB2000c = reinterpret_cast<RefLogger*>(0x2000);
205
206
207         ASSERT_EQ(pA1000a == pA1000a, true);
208         ASSERT_EQ(pA1000a == pA1000b, true);
209         ASSERT_EQ(pA1000a == pA2000b, false);
210         ASSERT_EQ(pA1000a == pB1000c, true);
211         ASSERT_EQ(pA1000a == pB2000c, false);
212
213         ASSERT_EQ(pA1000a != pA1000a, false);
214         ASSERT_EQ(pA1000a != pA1000b, false);
215         ASSERT_EQ(pA1000a != pA2000b, true);
216         ASSERT_EQ(pA1000a != pB1000c, false);
217         ASSERT_EQ(pA1000a != pB2000c, true);
218
219         ASSERT_EQ(pA1000a < pA1000a, false);
220         ASSERT_EQ(pA1000a < pA1000b, false);
221         ASSERT_EQ(pA1000a < pA2000b, true);
222         ASSERT_EQ(pA1000a < pB1000c, false);
223         ASSERT_EQ(pA1000a < pB2000c, true);
224
225         ASSERT_EQ(pB2000a < pB2000a, false);
226         ASSERT_EQ(pB2000a < pA1000b, false);
227         ASSERT_EQ(pB2000a < pA2000b, false);
228         ASSERT_EQ(pB2000a < pB1000c, false);
229         ASSERT_EQ(pB2000a < pB2000c, false);
230
231         ASSERT_EQ(pA1000a <= pA1000a, true);
232         ASSERT_EQ(pA1000a <= pA1000b, true);
233         ASSERT_EQ(pA1000a <= pA2000b, true);
234         ASSERT_EQ(pA1000a <= pB1000c, true);
235         ASSERT_EQ(pA1000a <= pB2000c, true);
236
237         ASSERT_EQ(pB2000a <= pB2000a, true);
238         ASSERT_EQ(pB2000a <= pA1000b, false);
239         ASSERT_EQ(pB2000a <= pA2000b, true);
240         ASSERT_EQ(pB2000a <= pB1000c, false);
241         ASSERT_EQ(pB2000a <= pB2000c, true);
242
243         ASSERT_EQ(pA1000a > pA1000a, false);
244         ASSERT_EQ(pA1000a > pA1000b, false);
245         ASSERT_EQ(pA1000a > pA2000b, false);
246         ASSERT_EQ(pA1000a > pB1000c, false);
247         ASSERT_EQ(pA1000a > pB2000c, false);
248
249         ASSERT_EQ(pB2000a > pB2000a, false);
250         ASSERT_EQ(pB2000a > pA1000b, true);
251         ASSERT_EQ(pB2000a > pA2000b, false);
252         ASSERT_EQ(pB2000a > pB1000c, true);
253         ASSERT_EQ(pB2000a > pB2000c, false);
254
255         ASSERT_EQ(pA1000a >= pA1000a, true);
256         ASSERT_EQ(pA1000a >= pA1000b, true);
257         ASSERT_EQ(pA1000a >= pA2000b, false);
258         ASSERT_EQ(pA1000a >= pB1000c, true);
259         ASSERT_EQ(pA1000a >= pB2000c, false);
260
261         ASSERT_EQ(pB2000a >= pB2000a, true);
262         ASSERT_EQ(pB2000a >= pA1000b, true);
263         ASSERT_EQ(pB2000a >= pA2000b, true);
264         ASSERT_EQ(pB2000a >= pB1000c, true);
265         ASSERT_EQ(pB2000a >= pB2000c, true);
266     }
267
268     {
269         Poisoned<TestPoisonA, RefLogger*> prA1000 = reinterpret_cast<DerivedRefLogger*>(0x1000);
270         Poisoned<TestPoisonA, DerivedRefLogger*> pdA1000 = reinterpret_cast<DerivedRefLogger*>(0x1000);
271         Poisoned<TestPoisonB, RefLogger*> prB1000 = reinterpret_cast<DerivedRefLogger*>(0x1000);
272         Poisoned<TestPoisonB, DerivedRefLogger*> pdB1000 = reinterpret_cast<DerivedRefLogger*>(0x1000);
273
274         Poisoned<TestPoisonA, RefLogger*> prA2000 = reinterpret_cast<DerivedRefLogger*>(0x2000);
275         Poisoned<TestPoisonA, DerivedRefLogger*> pdA2000 = reinterpret_cast<DerivedRefLogger*>(0x2000);
276         Poisoned<TestPoisonB, RefLogger*> prB2000 = reinterpret_cast<DerivedRefLogger*>(0x2000);
277         Poisoned<TestPoisonB, DerivedRefLogger*> pdB2000 = reinterpret_cast<DerivedRefLogger*>(0x2000);
278
279         ASSERT_EQ(prA1000 == pdA1000, true);
280         ASSERT_EQ(prA1000 == pdB1000, true);
281         ASSERT_EQ(prA1000 == pdA2000, false);
282         ASSERT_EQ(prA1000 == pdB2000, false);
283         ASSERT_EQ(pdA1000 == prA1000, true);
284         ASSERT_EQ(pdA1000 == prB1000, true);
285         ASSERT_EQ(pdA1000 == prA2000, false);
286         ASSERT_EQ(pdA1000 == prB2000, false);
287
288         ASSERT_EQ(prA1000 != pdA1000, false);
289         ASSERT_EQ(prA1000 != pdB1000, false);
290         ASSERT_EQ(prA1000 != pdA2000, true);
291         ASSERT_EQ(prA1000 != pdB2000, true);
292         ASSERT_EQ(pdA1000 != prA1000, false);
293         ASSERT_EQ(pdA1000 != prB1000, false);
294         ASSERT_EQ(pdA1000 != prA2000, true);
295         ASSERT_EQ(pdA1000 != prB2000, true);
296
297         ASSERT_EQ(prA1000 < pdA1000, false);
298         ASSERT_EQ(prA1000 < pdB1000, false);
299         ASSERT_EQ(prA1000 < pdA2000, true);
300         ASSERT_EQ(prA1000 < pdB2000, true);
301         ASSERT_EQ(pdA1000 < prA1000, false);
302         ASSERT_EQ(pdA1000 < prB1000, false);
303         ASSERT_EQ(pdA1000 < prA2000, true);
304         ASSERT_EQ(pdA1000 < prB2000, true);
305
306         ASSERT_EQ(prA2000 < pdA1000, false);
307         ASSERT_EQ(prA2000 < pdB1000, false);
308         ASSERT_EQ(prA2000 < pdA2000, false);
309         ASSERT_EQ(prA2000 < pdB2000, false);
310         ASSERT_EQ(pdA2000 < prA1000, false);
311         ASSERT_EQ(pdA2000 < prB1000, false);
312         ASSERT_EQ(pdA2000 < prA2000, false);
313         ASSERT_EQ(pdA2000 < prB2000, false);
314
315         ASSERT_EQ(prA1000 <= pdA1000, true);
316         ASSERT_EQ(prA1000 <= pdB1000, true);
317         ASSERT_EQ(prA1000 <= pdA2000, true);
318         ASSERT_EQ(prA1000 <= pdB2000, true);
319         ASSERT_EQ(pdA1000 <= prA1000, true);
320         ASSERT_EQ(pdA1000 <= prB1000, true);
321         ASSERT_EQ(pdA1000 <= prA2000, true);
322         ASSERT_EQ(pdA1000 <= prB2000, true);
323
324         ASSERT_EQ(prA2000 <= pdA1000, false);
325         ASSERT_EQ(prA2000 <= pdB1000, false);
326         ASSERT_EQ(prA2000 <= pdA2000, true);
327         ASSERT_EQ(prA2000 <= pdB2000, true);
328         ASSERT_EQ(pdA2000 <= prA1000, false);
329         ASSERT_EQ(pdA2000 <= prB1000, false);
330         ASSERT_EQ(pdA2000 <= prA2000, true);
331         ASSERT_EQ(pdA2000 <= prB2000, true);
332
333         ASSERT_EQ(prA1000 > pdA1000, false);
334         ASSERT_EQ(prA1000 > pdB1000, false);
335         ASSERT_EQ(prA1000 > pdA2000, false);
336         ASSERT_EQ(prA1000 > pdB2000, false);
337         ASSERT_EQ(pdA1000 > prA1000, false);
338         ASSERT_EQ(pdA1000 > prB1000, false);
339         ASSERT_EQ(pdA1000 > prA2000, false);
340         ASSERT_EQ(pdA1000 > prB2000, false);
341
342         ASSERT_EQ(prA2000 > pdA1000, true);
343         ASSERT_EQ(prA2000 > pdB1000, true);
344         ASSERT_EQ(prA2000 > pdA2000, false);
345         ASSERT_EQ(prA2000 > pdB2000, false);
346         ASSERT_EQ(pdA2000 > prA1000, true);
347         ASSERT_EQ(pdA2000 > prB1000, true);
348         ASSERT_EQ(pdA2000 > prA2000, false);
349         ASSERT_EQ(pdA2000 > prB2000, false);
350
351         ASSERT_EQ(prA1000 >= pdA1000, true);
352         ASSERT_EQ(prA1000 >= pdB1000, true);
353         ASSERT_EQ(prA1000 >= pdA2000, false);
354         ASSERT_EQ(prA1000 >= pdB2000, false);
355         ASSERT_EQ(pdA1000 >= prA1000, true);
356         ASSERT_EQ(pdA1000 >= prB1000, true);
357         ASSERT_EQ(pdA1000 >= prA2000, false);
358         ASSERT_EQ(pdA1000 >= prB2000, false);
359
360         ASSERT_EQ(prA2000 >= pdA1000, true);
361         ASSERT_EQ(prA2000 >= pdB1000, true);
362         ASSERT_EQ(prA2000 >= pdA2000, true);
363         ASSERT_EQ(prA2000 >= pdB2000, true);
364         ASSERT_EQ(pdA2000 >= prA1000, true);
365         ASSERT_EQ(pdA2000 >= prB1000, true);
366         ASSERT_EQ(pdA2000 >= prA2000, true);
367         ASSERT_EQ(pdA2000 >= prB2000, true);
368     }
369 }
370
371 TEST(WTF_Poisoned, DISABLED_Assignment)
372 {
373     initializeTestPoison();
374     DerivedRefLogger a("a");
375     RefLogger b("b");
376     DerivedRefLogger c("c");
377
378     {
379         Poisoned<TestPoisonA, RefLogger*> p1(&a);
380         Poisoned<TestPoisonA, RefLogger*> p2(&b);
381         ASSERT_EQ(&a, p1.unpoisoned());
382         ASSERT_EQ(&b, p2.unpoisoned());
383         p1 = p2;
384         ASSERT_EQ(&b, p1.unpoisoned());
385         ASSERT_EQ(&b, p2.unpoisoned());
386         ASSERT_TRUE(p1.bits() == p2.bits());
387
388         Poisoned<TestPoisonA, RefLogger*> p3(&a);
389         Poisoned<TestPoisonB, RefLogger*> p4(&b);
390         ASSERT_EQ(&a, p3.unpoisoned());
391         ASSERT_EQ(&b, p4.unpoisoned());
392         p3 = p4;
393         ASSERT_EQ(&b, p3.unpoisoned());
394         ASSERT_EQ(&b, p4.unpoisoned());
395         ASSERT_TRUE(p3.bits() != p4.bits());
396     }
397
398     {
399         Poisoned<TestPoisonA, RefLogger*> ptr(&a);
400         ASSERT_EQ(&a, ptr.unpoisoned());
401         ptr = &b;
402         ASSERT_EQ(&b, ptr.unpoisoned());
403     }
404
405     {
406         Poisoned<TestPoisonA, RefLogger*> ptr(&a);
407         ASSERT_EQ(&a, ptr.unpoisoned());
408         ptr = nullptr;
409         ASSERT_EQ(nullptr, ptr.unpoisoned());
410     }
411
412     {
413         Poisoned<TestPoisonA, RefLogger*> p1(&a);
414         Poisoned<TestPoisonA, RefLogger*> p2(&b);
415         ASSERT_EQ(&a, p1.unpoisoned());
416         ASSERT_EQ(&b, p2.unpoisoned());
417         p1 = WTFMove(p2);
418         ASSERT_EQ(&b, p1.unpoisoned());
419         ASSERT_EQ(&b, p2.unpoisoned());
420         ASSERT_TRUE(p1.bits() == p2.bits());
421
422         Poisoned<TestPoisonA, RefLogger*> p3(&a);
423         Poisoned<TestPoisonB, RefLogger*> p4(&b);
424         ASSERT_EQ(&a, p3.unpoisoned());
425         ASSERT_EQ(&b, p4.unpoisoned());
426         p3 = WTFMove(p4);
427         ASSERT_EQ(&b, p3.unpoisoned());
428         ASSERT_EQ(&b, p4.unpoisoned());
429         ASSERT_TRUE(p3.bits() != p4.bits());
430     }
431
432     {
433         Poisoned<TestPoisonA, RefLogger*> p1(&a);
434         Poisoned<TestPoisonA, DerivedRefLogger*> p2(&c);
435         ASSERT_EQ(&a, p1.unpoisoned());
436         ASSERT_EQ(&c, p2.unpoisoned());
437         p1 = p2;
438         ASSERT_EQ(&c, p1.unpoisoned());
439         ASSERT_EQ(&c, p2.unpoisoned());
440         ASSERT_TRUE(p1.bits() == p2.bits());
441
442         Poisoned<TestPoisonA, RefLogger*> p3(&a);
443         Poisoned<TestPoisonB, DerivedRefLogger*> p4(&c);
444         ASSERT_EQ(&a, p3.unpoisoned());
445         ASSERT_EQ(&c, p4.unpoisoned());
446         p3 = p4;
447         ASSERT_EQ(&c, p3.unpoisoned());
448         ASSERT_EQ(&c, p4.unpoisoned());
449         ASSERT_TRUE(p3.bits() != p4.bits());
450     }
451
452     {
453         Poisoned<TestPoisonA, RefLogger*> ptr(&a);
454         ASSERT_EQ(&a, ptr.unpoisoned());
455         ptr = &c;
456         ASSERT_EQ(&c, ptr.unpoisoned());
457     }
458
459     {
460         Poisoned<TestPoisonA, RefLogger*> p1(&a);
461         Poisoned<TestPoisonA, DerivedRefLogger*> p2(&c);
462         ASSERT_EQ(&a, p1.unpoisoned());
463         ASSERT_EQ(&c, p2.unpoisoned());
464         p1 = WTFMove(p2);
465         ASSERT_EQ(&c, p1.unpoisoned());
466         ASSERT_EQ(&c, p2.unpoisoned());
467         ASSERT_TRUE(p1.bits() == p2.bits());
468
469         Poisoned<TestPoisonA, RefLogger*> p3(&a);
470         Poisoned<TestPoisonB, DerivedRefLogger*> p4(&c);
471         ASSERT_EQ(&a, p3.unpoisoned());
472         ASSERT_EQ(&c, p4.unpoisoned());
473         p3 = WTFMove(p4);
474         ASSERT_EQ(&c, p3.unpoisoned());
475         ASSERT_EQ(&c, p4.unpoisoned());
476         ASSERT_TRUE(p3.bits() != p4.bits());
477     }
478
479     {
480         Poisoned<TestPoisonA, RefLogger*> ptr(&a);
481         ASSERT_EQ(&a, ptr.unpoisoned());
482 #if COMPILER(CLANG)
483 #pragma clang diagnostic push
484 #pragma clang diagnostic ignored "-Wunknown-pragmas"
485 #pragma clang diagnostic ignored "-Wunknown-warning-option"
486 #pragma clang diagnostic ignored "-Wself-assign-overloaded"
487 #endif
488         ptr = ptr;
489 #if COMPILER(CLANG)
490 #pragma clang diagnostic pop
491 #endif
492         ASSERT_EQ(&a, ptr.unpoisoned());
493     }
494
495     {
496         Poisoned<TestPoisonA, RefLogger*> ptr(&a);
497         ASSERT_EQ(&a, ptr.unpoisoned());
498 #if COMPILER(CLANG)
499 #pragma clang diagnostic push
500 #pragma clang diagnostic ignored "-Wunknown-pragmas"
501 #pragma clang diagnostic ignored "-Wself-move"
502 #endif
503         ptr = WTFMove(ptr);
504 #if COMPILER(CLANG)
505 #pragma clang diagnostic pop
506 #endif
507         ASSERT_EQ(&a, ptr.unpoisoned());
508     }
509 }
510
511 TEST(WTF_Poisoned, DISABLED_Swap)
512 {
513     initializeTestPoison();
514     RefLogger a("a");
515     RefLogger b("b");
516
517     {
518         Poisoned<TestPoisonA, RefLogger*> p1(&a);
519         Poisoned<TestPoisonA, RefLogger*> p2(&b);
520         ASSERT_EQ(&a, p1.unpoisoned());
521         ASSERT_EQ(&b, p2.unpoisoned());
522         p1.swap(p2);
523         ASSERT_EQ(&b, p1.unpoisoned());
524         ASSERT_EQ(&a, p2.unpoisoned());
525
526         ASSERT_TRUE(p1.bits() != p2.bits());
527
528         Poisoned<TestPoisonA, RefLogger*> p3(&a);
529         Poisoned<TestPoisonB, RefLogger*> p4(&b);
530         ASSERT_EQ(&a, p3.unpoisoned());
531         ASSERT_EQ(&b, p4.unpoisoned());
532         p3.swap(p4);
533         ASSERT_EQ(&b, p3.unpoisoned());
534         ASSERT_EQ(&a, p4.unpoisoned());
535
536         ASSERT_TRUE(p3.bits() != p4.bits());
537         ASSERT_TRUE(p1.bits() == p3.bits());
538         ASSERT_TRUE(p2.bits() != p4.bits());
539     }
540
541     {
542         Poisoned<TestPoisonA, RefLogger*> p1(&a);
543         Poisoned<TestPoisonA, RefLogger*> p2(&b);
544         ASSERT_EQ(&a, p1.unpoisoned());
545         ASSERT_EQ(&b, p2.unpoisoned());
546         swap(p1, p2);
547         ASSERT_EQ(&b, p1.unpoisoned());
548         ASSERT_EQ(&a, p2.unpoisoned());
549
550         ASSERT_TRUE(p1.bits() != p2.bits());
551
552         Poisoned<TestPoisonA, RefLogger*> p3(&a);
553         Poisoned<TestPoisonB, RefLogger*> p4(&b);
554         ASSERT_EQ(&a, p3.unpoisoned());
555         ASSERT_EQ(&b, p4.unpoisoned());
556         swap(p3, p4);
557         ASSERT_EQ(&b, p3.unpoisoned());
558         ASSERT_EQ(&a, p4.unpoisoned());
559
560         ASSERT_TRUE(p3.bits() != p4.bits());
561         ASSERT_TRUE(p1.bits() == p3.bits());
562         ASSERT_TRUE(p2.bits() != p4.bits());
563     }
564
565     {
566         Poisoned<TestPoisonA, RefLogger*> p1(&a);
567         RefLogger* p2(&b);
568         ASSERT_EQ(&a, p1.unpoisoned());
569         ASSERT_EQ(&b, p2);
570         swap(p1, p2);
571         ASSERT_EQ(&b, p1.unpoisoned());
572         ASSERT_EQ(&a, p2);
573
574         ASSERT_TRUE(p1.bits() != bitwise_cast<uintptr_t>(p2));
575     }
576
577     {
578         Poisoned<TestPoisonA, RefLogger*> p1(&a);
579         RefLogger* p2(&b);
580         ASSERT_EQ(&a, p1.unpoisoned());
581         ASSERT_EQ(&b, p2);
582         p1.swap(p2);
583         ASSERT_EQ(&b, p1.unpoisoned());
584         ASSERT_EQ(&a, p2);
585
586         ASSERT_TRUE(p1.bits() != bitwise_cast<uintptr_t>(p2));
587     }
588 }
589
590 static Poisoned<TestPoisonA, RefLogger*> poisonedPtrFoo(RefLogger& logger)
591 {
592     return Poisoned<TestPoisonA, RefLogger*>(&logger);
593 }
594
595 TEST(WTF_Poisoned, DISABLED_ReturnValue)
596 {
597     initializeTestPoison();
598     DerivedRefLogger a("a");
599
600     {
601         auto ptr = poisonedPtrFoo(a);
602         ASSERT_EQ(&a, ptr.unpoisoned());
603         ASSERT_EQ(&a, &*ptr);
604         ASSERT_EQ(&a.name, &ptr->name);
605     }
606 }
607
608 } // namespace TestWebKitAPI
609