1 // Copyright 2016 The Fuchsia Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <unittest/unittest.h> 6 #include <fbl/intrusive_single_list.h> 7 #include <fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h> 8 #include <fbl/tests/intrusive_containers/sequence_container_test_environment.h> 9 #include <fbl/tests/intrusive_containers/test_thunks.h> 10 11 namespace fbl { 12 namespace tests { 13 namespace intrusive_containers { 14 15 template <typename ContainerStateType> 16 struct OtherListTraits { 17 using PtrTraits = typename ContainerStateType::PtrTraits; node_statefbl::tests::intrusive_containers::OtherListTraits18 static ContainerStateType& node_state(typename PtrTraits::RefType obj) { 19 return obj.other_container_state_; 20 } 21 }; 22 23 template <typename PtrType> 24 class SLLTraits { 25 public: 26 using TestObjBaseType = TestObjBase; 27 28 using ContainerType = SinglyLinkedList<PtrType>; 29 using ContainableBaseClass = SinglyLinkedListable<PtrType>; 30 using ContainerStateType = SinglyLinkedListNodeState<PtrType>; 31 32 using OtherContainerStateType = ContainerStateType; 33 using OtherContainerTraits = OtherListTraits<OtherContainerStateType>; 34 using OtherContainerType = SinglyLinkedList<PtrType, OtherContainerTraits>; 35 }; 36 37 DEFINE_TEST_OBJECTS(SLL); 38 using UMTE = DEFINE_TEST_THUNK(Sequence, SLL, Unmanaged); 39 using UPTE = DEFINE_TEST_THUNK(Sequence, SLL, UniquePtr); 40 using SUPDDTE = DEFINE_TEST_THUNK(Sequence, SLL, StdUniquePtrDefaultDeleter); 41 using SUPCDTE = DEFINE_TEST_THUNK(Sequence, SLL, StdUniquePtrCustomDeleter); 42 using RPTE = DEFINE_TEST_THUNK(Sequence, SLL, RefPtr); 43 44 BEGIN_TEST_CASE(single_linked_list_tests) 45 ////////////////////////////////////////// 46 // General container specific tests. 47 ////////////////////////////////////////// 48 RUN_NAMED_TEST("Clear (unmanaged)", UMTE::ClearTest) 49 RUN_NAMED_TEST("Clear (unique)", UPTE::ClearTest) 50 RUN_NAMED_TEST("Clear (std::uptr)", SUPDDTE::ClearTest) 51 RUN_NAMED_TEST("Clear (std::uptr<Del>)", SUPCDTE::ClearTest) 52 RUN_NAMED_TEST("Clear (RefPtr)", RPTE::ClearTest) 53 54 RUN_NAMED_TEST("ClearUnsafe (unmanaged)", UMTE::ClearUnsafeTest) 55 #if TEST_WILL_NOT_COMPILE || 0 56 RUN_NAMED_TEST("ClearUnsafe (unique)", UPTE::ClearUnsafeTest) 57 RUN_NAMED_TEST("ClearUnsafe (std::uptr)", SUPDDTE::ClearUnsafeTest) 58 RUN_NAMED_TEST("ClearUnsafe (std::uptr<Del>)", SUPCDTE::ClearUnsafeTest) 59 RUN_NAMED_TEST("ClearUnsafe (RefPtr)", RPTE::ClearUnsafeTest) 60 #endif 61 62 RUN_NAMED_TEST("IsEmpty (unmanaged)", UMTE::IsEmptyTest) 63 RUN_NAMED_TEST("IsEmpty (unique)", UPTE::IsEmptyTest) 64 RUN_NAMED_TEST("IsEmpty (std::uptr)", SUPDDTE::IsEmptyTest) 65 RUN_NAMED_TEST("IsEmpty (std::uptr<Del>)", SUPCDTE::IsEmptyTest) 66 RUN_NAMED_TEST("IsEmpty (RefPtr)", RPTE::IsEmptyTest) 67 68 RUN_NAMED_TEST("Iterate (unmanaged)", UMTE::IterateTest) 69 RUN_NAMED_TEST("Iterate (unique)", UPTE::IterateTest) 70 RUN_NAMED_TEST("Iterate (std::uptr)", SUPDDTE::IterateTest) 71 RUN_NAMED_TEST("Iterate (std::uptr<Del>)", SUPCDTE::IterateTest) 72 RUN_NAMED_TEST("Iterate (RefPtr)", RPTE::IterateTest) 73 74 // SinglyLinkedLists cannot perform direct erase operations, nor can they erase 75 // using an iterator. 76 #if TEST_WILL_NOT_COMPILE || 0 77 RUN_NAMED_TEST("IterErase (unmanaged)", UMTE::IterEraseTest) 78 RUN_NAMED_TEST("IterErase (unique)", UPTE::IterEraseTest) 79 RUN_NAMED_TEST("IterErase (std::uptr)", SUPDDTE::IterEraseTest) 80 RUN_NAMED_TEST("IterErase (std::uptr<Del>)", SUPCDTE::IterEraseTest) 81 RUN_NAMED_TEST("IterErase (RefPtr)", RPTE::IterEraseTest) 82 83 RUN_NAMED_TEST("DirectErase (unmanaged)", UMTE::DirectEraseTest) 84 RUN_NAMED_TEST("DirectErase (unique)", UPTE::DirectEraseTest) 85 RUN_NAMED_TEST("DirectErase (std::uptr)", SUPDDTE::DirectEraseTest) 86 RUN_NAMED_TEST("DirectErase (std::uptr<Del>)", SUPCDTE::DirectEraseTest) 87 RUN_NAMED_TEST("DirectErase (RefPtr)", RPTE::DirectEraseTest) 88 #endif 89 90 RUN_NAMED_TEST("MakeIterator (unmanaged)", UMTE::MakeIteratorTest) 91 #if TEST_WILL_NOT_COMPILE || 0 92 RUN_NAMED_TEST("MakeIterator (unique)", UPTE::MakeIteratorTest) 93 RUN_NAMED_TEST("MakeIterator (std::uptr)", SUPDDTE::MakeIteratorTest) 94 RUN_NAMED_TEST("MakeIterator (std::uptr<Del>)", SUPCDTE::MakeIteratorTest) 95 #endif 96 RUN_NAMED_TEST("MakeIterator (RefPtr)", RPTE::MakeIteratorTest) 97 98 // SinglyLinkedLists cannot iterate backwards. 99 #if TEST_WILL_NOT_COMPILE || 0 100 RUN_NAMED_TEST("ReverseIterErase (unmanaged)", UMTE::ReverseIterEraseTest) 101 RUN_NAMED_TEST("ReverseIterErase (unique)", UPTE::ReverseIterEraseTest) 102 RUN_NAMED_TEST("ReverseIterErase (std::uptr)", SUPDDTE::ReverseIterEraseTest) 103 RUN_NAMED_TEST("ReverseIterErase (std::uptr<Del>)", SUPCDTE::ReverseIterEraseTest) 104 RUN_NAMED_TEST("ReverseIterErase (RefPtr)", RPTE::ReverseIterEraseTest) 105 106 RUN_NAMED_TEST("ReverseIterate (unmanaged)", UMTE::ReverseIterateTest) 107 RUN_NAMED_TEST("ReverseIterate (unique)", UPTE::ReverseIterateTest) 108 RUN_NAMED_TEST("ReverseIterate (std::uptr)", SUPDDTE::ReverseIterateTest) 109 RUN_NAMED_TEST("ReverseIterate (std::uptr<Del>)", SUPCDTE::ReverseIterateTest) 110 RUN_NAMED_TEST("ReverseIterate (RefPtr)", RPTE::ReverseIterateTest) 111 #endif 112 113 RUN_NAMED_TEST("Swap (unmanaged)", UMTE::SwapTest) 114 RUN_NAMED_TEST("Swap (unique)", UPTE::SwapTest) 115 RUN_NAMED_TEST("Swap (std::uptr)", SUPDDTE::SwapTest) 116 RUN_NAMED_TEST("Swap (std::uptr<Del>)", SUPCDTE::SwapTest) 117 RUN_NAMED_TEST("Swap (RefPtr)", RPTE::SwapTest) 118 119 RUN_NAMED_TEST("Rvalue Ops (unmanaged)", UMTE::RvalueOpsTest) 120 RUN_NAMED_TEST("Rvalue Ops (unique)", UPTE::RvalueOpsTest) 121 RUN_NAMED_TEST("Rvalue Ops (std::uptr)", SUPDDTE::RvalueOpsTest) 122 RUN_NAMED_TEST("Rvalue Ops (std::uptr<Del>)", SUPCDTE::RvalueOpsTest) 123 RUN_NAMED_TEST("Rvalue Ops (RefPtr)", RPTE::RvalueOpsTest) 124 125 RUN_NAMED_TEST("Scope (unique)", UPTE::ScopeTest) 126 RUN_NAMED_TEST("Scope (std::uptr)", SUPDDTE::ScopeTest) 127 RUN_NAMED_TEST("Scope (std::uptr<Del>)", SUPCDTE::ScopeTest) 128 RUN_NAMED_TEST("Scope (RefPtr)", RPTE::ScopeTest) 129 130 RUN_NAMED_TEST("TwoContainer (unmanaged)", UMTE::TwoContainerTest) 131 #if TEST_WILL_NOT_COMPILE || 0 132 RUN_NAMED_TEST("TwoContainer (unique)", UPTE::TwoContainerTest) 133 RUN_NAMED_TEST("TwoContainer (std::uptr)", SUPDDTE::TwoContainerTest) 134 RUN_NAMED_TEST("TwoContainer (std::uptr<Del>)", SUPCDTE::TwoContainerTest) 135 #endif 136 RUN_NAMED_TEST("TwoContainer (RefPtr)", RPTE::TwoContainerTest) 137 138 RUN_NAMED_TEST("IterCopyPointer (unmanaged)", UMTE::IterCopyPointerTest) 139 #if TEST_WILL_NOT_COMPILE || 0 140 RUN_NAMED_TEST("IterCopyPointer (unique)", UPTE::IterCopyPointerTest) 141 RUN_NAMED_TEST("IterCopyPointer (std::uptr)", SUPDDTE::IterCopyPointerTest) 142 RUN_NAMED_TEST("IterCopyPointer (std::uptr<Del>)", SUPCDTE::IterCopyPointerTest) 143 #endif 144 RUN_NAMED_TEST("IterCopyPointer (RefPtr)", RPTE::IterCopyPointerTest) 145 146 RUN_NAMED_TEST("EraseIf (unmanaged)", UMTE::EraseIfTest) 147 RUN_NAMED_TEST("EraseIf (unique)", UPTE::EraseIfTest) 148 RUN_NAMED_TEST("EraseIf (std::uptr)", SUPDDTE::EraseIfTest) 149 RUN_NAMED_TEST("EraseIf (std::uptr<Del>)", SUPCDTE::EraseIfTest) 150 RUN_NAMED_TEST("EraseIf (RefPtr)", RPTE::EraseIfTest) 151 152 RUN_NAMED_TEST("FindIf (unmanaged)", UMTE::FindIfTest) 153 RUN_NAMED_TEST("FindIf (unique)", UPTE::FindIfTest) 154 RUN_NAMED_TEST("FindIf (std::uptr)", SUPDDTE::FindIfTest) 155 RUN_NAMED_TEST("FindIf (std::uptr<Del>)", SUPCDTE::FindIfTest) 156 RUN_NAMED_TEST("FindIf (RefPtr)", RPTE::FindIfTest) 157 158 ////////////////////////////////////////// 159 // Sequence container specific tests. 160 ////////////////////////////////////////// 161 RUN_NAMED_TEST("PushFront (unmanaged)", UMTE::PushFrontTest) 162 RUN_NAMED_TEST("PushFront (unique)", UPTE::PushFrontTest) 163 RUN_NAMED_TEST("PushFront (std::uptr)", SUPDDTE::PushFrontTest) 164 RUN_NAMED_TEST("PushFront (std::uptr<Del>)", SUPCDTE::PushFrontTest) 165 RUN_NAMED_TEST("PushFront (RefPtr)", RPTE::PushFrontTest) 166 167 RUN_NAMED_TEST("PopFront (unmanaged)", UMTE::PopFrontTest) 168 RUN_NAMED_TEST("PopFront (unique)", UPTE::PopFrontTest) 169 RUN_NAMED_TEST("PopFront (std::uptr)", SUPDDTE::PopFrontTest) 170 RUN_NAMED_TEST("PopFront (std::uptr<Del>)", SUPCDTE::PopFrontTest) 171 RUN_NAMED_TEST("PopFront (RefPtr)", RPTE::PopFrontTest) 172 173 // Singly linked lists cannot push/pop to/from the back 174 #if TEST_WILL_NOT_COMPILE || 0 175 RUN_NAMED_TEST("PushBack (unmanaged)", UMTE::PushBackTest) 176 RUN_NAMED_TEST("PushBack (unique)", UPTE::PushBackTest) 177 RUN_NAMED_TEST("PushBack (std::uptr)", SUPDDTE::PushBackTest) 178 RUN_NAMED_TEST("PushBack (std::uptr<Del>)", SUPCDTE::PushBackTest) 179 RUN_NAMED_TEST("PushBack (RefPtr)", RPTE::PushBackTest) 180 181 RUN_NAMED_TEST("PopBack (unmanaged)", UMTE::PopBackTest) 182 RUN_NAMED_TEST("PopBack (unique)", UPTE::PopBackTest) 183 RUN_NAMED_TEST("PopBack (std::uptr)", SUPDDTE::PopBackTest) 184 RUN_NAMED_TEST("PopBack (std::uptr<Del>)", SUPCDTE::PopBackTest) 185 RUN_NAMED_TEST("PopBack (RefPtr)", RPTE::PopBackTest) 186 #endif 187 188 RUN_NAMED_TEST("SeqIterate (unmanaged)", UMTE::SeqIterateTest) 189 RUN_NAMED_TEST("SeqIterate (unique)", UPTE::SeqIterateTest) 190 RUN_NAMED_TEST("SeqIterate (std::uptr)", SUPDDTE::SeqIterateTest) 191 RUN_NAMED_TEST("SeqIterate (std::uptr<Del>)", SUPCDTE::SeqIterateTest) 192 RUN_NAMED_TEST("SeqIterate (RefPtr)", RPTE::SeqIterateTest) 193 194 // SinglyLinkedLists cannot iterate backwards. 195 #if TEST_WILL_NOT_COMPILE || 0 196 RUN_NAMED_TEST("SeqReverseIterate (unmanaged)", UMTE::SeqReverseIterateTest) 197 RUN_NAMED_TEST("SeqReverseIterate (unique)", UPTE::SeqReverseIterateTest) 198 RUN_NAMED_TEST("SeqReverseIterate (std::uptr)", SUPDDTE::SeqReverseIterateTest) 199 RUN_NAMED_TEST("SeqReverseIterate (std::uptr<Del>)", SUPCDTE::SeqReverseIterateTest) 200 RUN_NAMED_TEST("SeqReverseIterate (RefPtr)", RPTE::SeqReverseIterateTest) 201 #endif 202 203 RUN_NAMED_TEST("EraseNext (unmanaged)", UMTE::EraseNextTest) 204 RUN_NAMED_TEST("EraseNext (unique)", UPTE::EraseNextTest) 205 RUN_NAMED_TEST("EraseNext (std::uptr)", SUPDDTE::EraseNextTest) 206 RUN_NAMED_TEST("EraseNext (std::uptr<Del>)", SUPCDTE::EraseNextTest) 207 RUN_NAMED_TEST("EraseNext (RefPtr)", RPTE::EraseNextTest) 208 209 RUN_NAMED_TEST("InsertAfter (unmanaged)", UMTE::InsertAfterTest) 210 RUN_NAMED_TEST("InsertAfter (unique)", UPTE::InsertAfterTest) 211 RUN_NAMED_TEST("InsertAfter (std::uptr)", SUPDDTE::InsertAfterTest) 212 RUN_NAMED_TEST("InsertAfter (std::uptr<Del>)", SUPCDTE::InsertAfterTest) 213 RUN_NAMED_TEST("InsertAfter (RefPtr)", RPTE::InsertAfterTest) 214 215 // SinglyLinkedLists cannot perform inserts-bef ore operations, either with an 216 // iterator or with a direct object reference. 217 #if TEST_WILL_NOT_COMPILE || 0 218 RUN_NAMED_TEST("Insert (unmanaged)", UMTE::InsertTest) 219 RUN_NAMED_TEST("Insert (unique)", UPTE::InsertTest) 220 RUN_NAMED_TEST("Insert (std::uptr)", SUPDDTE::InsertTest) 221 RUN_NAMED_TEST("Insert (std::uptr<Del>)", SUPCDTE::InsertTest) 222 RUN_NAMED_TEST("Insert (RefPtr)", RPTE::InsertTest) 223 224 RUN_NAMED_TEST("DirectInsert (unmanaged)", UMTE::DirectInsertTest) 225 RUN_NAMED_TEST("DirectInsert (unique)", UPTE::DirectInsertTest) 226 RUN_NAMED_TEST("DirectInsert (std::uptr)", SUPDDTE::DirectInsertTest) 227 RUN_NAMED_TEST("DirectInsert (std::uptr<Del>)", SUPCDTE::DirectInsertTest) 228 RUN_NAMED_TEST("DirectInsert (RefPtr)", RPTE::DirectInsertTest) 229 #endif 230 231 // SinglyLinkedLists cannot perform splice oper ations. 232 #if TEST_WILL_NOT_COMPILE || 0 233 RUN_NAMED_TEST("Splice (unmanaged)", UMTE::SpliceTest) 234 RUN_NAMED_TEST("Splice (unique)", UPTE::SpliceTest) 235 RUN_NAMED_TEST("Splice (std::uptr)", SUPDDTE::SpliceTest) 236 RUN_NAMED_TEST("Splice (std::uptr<Del>)", SUPCDTE::SpliceTest) 237 RUN_NAMED_TEST("Splice (RefPtr)", RPTE::SpliceTest) 238 #endif 239 240 RUN_NAMED_TEST("ReplaceIfCopy (unmanaged)", UMTE::ReplaceIfCopyTest) 241 #if TEST_WILL_NOT_COMPILE || 0 242 RUN_NAMED_TEST("ReplaceIfCopy (unique)", UPTE::ReplaceIfCopyTest) 243 RUN_NAMED_TEST("ReplaceIfCopy (std::uptr)", SUPDDTE::ReplaceIfCopyTest) 244 RUN_NAMED_TEST("ReplaceIfCopy (std::uptr<Del>)", SUPCDTE::ReplaceIfCopyTest) 245 #endif 246 RUN_NAMED_TEST("ReplaceIfCopy (RefPtr)", RPTE::ReplaceIfCopyTest) 247 248 RUN_NAMED_TEST("ReplaceIfMove (unmanaged)", UMTE::ReplaceIfMoveTest) 249 RUN_NAMED_TEST("ReplaceIfMove (unique)", UPTE::ReplaceIfMoveTest) 250 RUN_NAMED_TEST("ReplaceIfMove (std::uptr)", SUPDDTE::ReplaceIfMoveTest) 251 RUN_NAMED_TEST("ReplaceIfMove (std::uptr<Del>)", SUPCDTE::ReplaceIfMoveTest) 252 RUN_NAMED_TEST("ReplaceIfMove (RefPtr)", RPTE::ReplaceIfMoveTest) 253 254 END_TEST_CASE(single_linked_list_tests); 255 256 } // namespace intrusive_containers 257 } // namespace tests 258 } // namespace fbl 259