1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
* Copyright (c) 2021, Brian Gianforcaro <bgianf@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibTest/TestCase.h>
#include <AK/IntrusiveList.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/RefPtr.h>
class IntrusiveTestItem {
public:
IntrusiveTestItem() = default;
IntrusiveListNode<IntrusiveTestItem> m_list_node;
};
using IntrusiveTestList = IntrusiveList<IntrusiveTestItem, RawPtr<IntrusiveTestItem>, &IntrusiveTestItem::m_list_node>;
TEST_CASE(construct)
{
IntrusiveTestList empty;
EXPECT(empty.is_empty());
}
TEST_CASE(insert)
{
IntrusiveTestList list;
list.append(*new IntrusiveTestItem());
EXPECT(!list.is_empty());
delete list.take_last();
}
TEST_CASE(enumeration)
{
constexpr size_t expected_size = 10;
IntrusiveTestList list;
for (size_t i = 0; i < expected_size; i++) {
list.append(*new IntrusiveTestItem());
}
size_t actual_size = 0;
for (auto& elem : list) {
(void)elem;
actual_size++;
}
EXPECT_EQ(expected_size, actual_size);
EXPECT_EQ(expected_size, list.size_slow());
size_t reverse_actual_size = 0;
for (auto it = list.rbegin(); it != list.rend(); ++it) {
reverse_actual_size++;
}
EXPECT_EQ(expected_size, reverse_actual_size);
while (auto elem = list.take_first()) {
delete elem;
}
}
class IntrusiveRefPtrItem : public RefCounted<IntrusiveRefPtrItem> {
public:
IntrusiveRefPtrItem() = default;
IntrusiveListNode<IntrusiveRefPtrItem, RefPtr<IntrusiveRefPtrItem>> m_list_node;
};
using IntrusiveRefPtrList = IntrusiveList<IntrusiveRefPtrItem, RefPtr<IntrusiveRefPtrItem>, &IntrusiveRefPtrItem::m_list_node>;
TEST_CASE(intrusive_ref_ptr_no_ref_leaks)
{
auto item = adopt_ref(*new IntrusiveRefPtrItem());
EXPECT_EQ(1u, item->ref_count());
IntrusiveRefPtrList ref_list;
ref_list.append(*item);
EXPECT_EQ(2u, item->ref_count());
ref_list.remove(*item);
EXPECT_EQ(1u, item->ref_count());
}
TEST_CASE(intrusive_ref_ptr_clear)
{
auto item = adopt_ref(*new IntrusiveRefPtrItem());
EXPECT_EQ(1u, item->ref_count());
IntrusiveRefPtrList ref_list;
ref_list.append(*item);
EXPECT_EQ(2u, item->ref_count());
ref_list.clear();
EXPECT_EQ(1u, item->ref_count());
}
TEST_CASE(intrusive_ref_ptr_destructor)
{
auto item = adopt_ref(*new IntrusiveRefPtrItem());
EXPECT_EQ(1u, item->ref_count());
{
IntrusiveRefPtrList ref_list;
ref_list.append(*item);
EXPECT_EQ(2u, item->ref_count());
}
EXPECT_EQ(1u, item->ref_count());
}
class IntrusiveNonnullRefPtrItem : public RefCounted<IntrusiveNonnullRefPtrItem> {
public:
IntrusiveNonnullRefPtrItem() = default;
IntrusiveListNode<IntrusiveNonnullRefPtrItem, NonnullRefPtr<IntrusiveNonnullRefPtrItem>> m_list_node;
};
using IntrusiveNonnullRefPtrList = IntrusiveList<IntrusiveNonnullRefPtrItem, NonnullRefPtr<IntrusiveNonnullRefPtrItem>, &IntrusiveNonnullRefPtrItem::m_list_node>;
TEST_CASE(intrusive_nonnull_ref_ptr_intrusive)
{
auto item = adopt_ref(*new IntrusiveNonnullRefPtrItem());
EXPECT_EQ(1u, item->ref_count());
IntrusiveNonnullRefPtrList nonnull_ref_list;
nonnull_ref_list.append(*item);
EXPECT_EQ(2u, item->ref_count());
EXPECT(!nonnull_ref_list.is_empty());
nonnull_ref_list.remove(*item);
EXPECT_EQ(1u, item->ref_count());
EXPECT(nonnull_ref_list.is_empty());
}
|
