// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <unittest/unittest.h>
#include <fbl/intrusive_single_list.h>
#include <fbl/tests/intrusive_containers/intrusive_singly_linked_list_checker.h>
#include <fbl/tests/intrusive_containers/sequence_container_test_environment.h>
#include <fbl/tests/intrusive_containers/test_thunks.h>

namespace fbl {
namespace tests {
namespace intrusive_containers {

template <typename ContainerStateType>
struct OtherListTraits {
    using PtrTraits = typename ContainerStateType::PtrTraits;
    static ContainerStateType& node_state(typename PtrTraits::RefType obj) {
        return obj.other_container_state_;
    }
};

template <typename PtrType>
class SLLTraits {
public:
    using TestObjBaseType         = TestObjBase;

    using ContainerType           = SinglyLinkedList<PtrType>;
    using ContainableBaseClass    = SinglyLinkedListable<PtrType>;
    using ContainerStateType      = SinglyLinkedListNodeState<PtrType>;

    using OtherContainerStateType = ContainerStateType;
    using OtherContainerTraits    = OtherListTraits<OtherContainerStateType>;
    using OtherContainerType      = SinglyLinkedList<PtrType, OtherContainerTraits>;

    struct Tag1 {};
    struct Tag2 {};
    struct Tag3 {};

    using TaggedContainableBaseClasses =
        fbl::ContainableBaseClasses<SinglyLinkedListable<PtrType, Tag1>,
                                    SinglyLinkedListable<PtrType, Tag2>,
                                    SinglyLinkedListable<PtrType, Tag3>>;

    using TaggedType1 = TaggedSinglyLinkedList<PtrType, Tag1>;
    using TaggedType2 = TaggedSinglyLinkedList<PtrType, Tag2>;
    using TaggedType3 = TaggedSinglyLinkedList<PtrType, Tag3>;
};

// Just a sanity check so we know our metaprogramming nonsense is
// doing what we expect:
static_assert(std::is_same_v<typename SLLTraits<int*>::TaggedContainableBaseClasses::TagTypes,
                             std::tuple<typename SLLTraits<int*>::Tag1,
                                        typename SLLTraits<int*>::Tag2,
                                        typename SLLTraits<int*>::Tag3>>);

DEFINE_TEST_OBJECTS(SLL);
using UMTE    = DEFINE_TEST_THUNK(Sequence, SLL, Unmanaged);
using UPTE    = DEFINE_TEST_THUNK(Sequence, SLL, UniquePtr);
using SUPDDTE = DEFINE_TEST_THUNK(Sequence, SLL, StdUniquePtrDefaultDeleter);
using SUPCDTE = DEFINE_TEST_THUNK(Sequence, SLL, StdUniquePtrCustomDeleter);
using RPTE    = DEFINE_TEST_THUNK(Sequence, SLL, RefPtr);

BEGIN_TEST_CASE(single_linked_list_tests)
//////////////////////////////////////////
// General container specific tests.
//////////////////////////////////////////
RUN_NAMED_TEST("Clear (unmanaged)",                         UMTE::ClearTest)
RUN_NAMED_TEST("Clear (unique)",                            UPTE::ClearTest)
RUN_NAMED_TEST("Clear (std::uptr)",                         SUPDDTE::ClearTest)
RUN_NAMED_TEST("Clear (std::uptr<Del>)",                    SUPCDTE::ClearTest)
RUN_NAMED_TEST("Clear (RefPtr)",                            RPTE::ClearTest)

RUN_NAMED_TEST("ClearUnsafe (unmanaged)",                   UMTE::ClearUnsafeTest)
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("ClearUnsafe (unique)",                      UPTE::ClearUnsafeTest)
RUN_NAMED_TEST("ClearUnsafe (std::uptr)",                   SUPDDTE::ClearUnsafeTest)
RUN_NAMED_TEST("ClearUnsafe (std::uptr<Del>)",              SUPCDTE::ClearUnsafeTest)
RUN_NAMED_TEST("ClearUnsafe (RefPtr)",                      RPTE::ClearUnsafeTest)
#endif

RUN_NAMED_TEST("IsEmpty (unmanaged)",                       UMTE::IsEmptyTest)
RUN_NAMED_TEST("IsEmpty (unique)",                          UPTE::IsEmptyTest)
RUN_NAMED_TEST("IsEmpty (std::uptr)",                       SUPDDTE::IsEmptyTest)
RUN_NAMED_TEST("IsEmpty (std::uptr<Del>)",                  SUPCDTE::IsEmptyTest)
RUN_NAMED_TEST("IsEmpty (RefPtr)",                          RPTE::IsEmptyTest)

RUN_NAMED_TEST("Iterate (unmanaged)",                       UMTE::IterateTest)
RUN_NAMED_TEST("Iterate (unique)",                          UPTE::IterateTest)
RUN_NAMED_TEST("Iterate (std::uptr)",                       SUPDDTE::IterateTest)
RUN_NAMED_TEST("Iterate (std::uptr<Del>)",                  SUPCDTE::IterateTest)
RUN_NAMED_TEST("Iterate (RefPtr)",                          RPTE::IterateTest)

// SinglyLinkedLists cannot perform direct erase operations, nor can they erase
// using an iterator.
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("IterErase (unmanaged)",                     UMTE::IterEraseTest)
RUN_NAMED_TEST("IterErase (unique)",                        UPTE::IterEraseTest)
RUN_NAMED_TEST("IterErase (std::uptr)",                     SUPDDTE::IterEraseTest)
RUN_NAMED_TEST("IterErase (std::uptr<Del>)",                SUPCDTE::IterEraseTest)
RUN_NAMED_TEST("IterErase (RefPtr)",                        RPTE::IterEraseTest)

RUN_NAMED_TEST("DirectErase (unmanaged)",                   UMTE::DirectEraseTest)
RUN_NAMED_TEST("DirectErase (unique)",                      UPTE::DirectEraseTest)
RUN_NAMED_TEST("DirectErase (std::uptr)",                   SUPDDTE::DirectEraseTest)
RUN_NAMED_TEST("DirectErase (std::uptr<Del>)",              SUPCDTE::DirectEraseTest)
RUN_NAMED_TEST("DirectErase (RefPtr)",                      RPTE::DirectEraseTest)
#endif

RUN_NAMED_TEST("MakeIterator (unmanaged)",                  UMTE::MakeIteratorTest)
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("MakeIterator (unique)",                     UPTE::MakeIteratorTest)
RUN_NAMED_TEST("MakeIterator (std::uptr)",                  SUPDDTE::MakeIteratorTest)
RUN_NAMED_TEST("MakeIterator (std::uptr<Del>)",             SUPCDTE::MakeIteratorTest)
#endif
RUN_NAMED_TEST("MakeIterator (RefPtr)",                     RPTE::MakeIteratorTest)

// SinglyLinkedLists cannot iterate backwards.
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("ReverseIterErase (unmanaged)",              UMTE::ReverseIterEraseTest)
RUN_NAMED_TEST("ReverseIterErase (unique)",                 UPTE::ReverseIterEraseTest)
RUN_NAMED_TEST("ReverseIterErase (std::uptr)",              SUPDDTE::ReverseIterEraseTest)
RUN_NAMED_TEST("ReverseIterErase (std::uptr<Del>)",         SUPCDTE::ReverseIterEraseTest)
RUN_NAMED_TEST("ReverseIterErase (RefPtr)",                 RPTE::ReverseIterEraseTest)

RUN_NAMED_TEST("ReverseIterate (unmanaged)",                UMTE::ReverseIterateTest)
RUN_NAMED_TEST("ReverseIterate (unique)",                   UPTE::ReverseIterateTest)
RUN_NAMED_TEST("ReverseIterate (std::uptr)",                SUPDDTE::ReverseIterateTest)
RUN_NAMED_TEST("ReverseIterate (std::uptr<Del>)",           SUPCDTE::ReverseIterateTest)
RUN_NAMED_TEST("ReverseIterate (RefPtr)",                   RPTE::ReverseIterateTest)
#endif

RUN_NAMED_TEST("Swap (unmanaged)",                          UMTE::SwapTest)
RUN_NAMED_TEST("Swap (unique)",                             UPTE::SwapTest)
RUN_NAMED_TEST("Swap (std::uptr)",                          SUPDDTE::SwapTest)
RUN_NAMED_TEST("Swap (std::uptr<Del>)",                     SUPCDTE::SwapTest)
RUN_NAMED_TEST("Swap (RefPtr)",                             RPTE::SwapTest)

RUN_NAMED_TEST("Rvalue Ops (unmanaged)",                    UMTE::RvalueOpsTest)
RUN_NAMED_TEST("Rvalue Ops (unique)",                       UPTE::RvalueOpsTest)
RUN_NAMED_TEST("Rvalue Ops (std::uptr)",                    SUPDDTE::RvalueOpsTest)
RUN_NAMED_TEST("Rvalue Ops (std::uptr<Del>)",               SUPCDTE::RvalueOpsTest)
RUN_NAMED_TEST("Rvalue Ops (RefPtr)",                       RPTE::RvalueOpsTest)

RUN_NAMED_TEST("Scope (unique)",                            UPTE::ScopeTest)
RUN_NAMED_TEST("Scope (std::uptr)",                         SUPDDTE::ScopeTest)
RUN_NAMED_TEST("Scope (std::uptr<Del>)",                    SUPCDTE::ScopeTest)
RUN_NAMED_TEST("Scope (RefPtr)",                            RPTE::ScopeTest)

RUN_NAMED_TEST("TwoContainer (unmanaged)",                  UMTE::TwoContainerTest)
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("TwoContainer (unique)",                     UPTE::TwoContainerTest)
RUN_NAMED_TEST("TwoContainer (std::uptr)",                  SUPDDTE::TwoContainerTest)
RUN_NAMED_TEST("TwoContainer (std::uptr<Del>)",             SUPCDTE::TwoContainerTest)
#endif
RUN_NAMED_TEST("TwoContainer (RefPtr)",                     RPTE::TwoContainerTest)

RUN_NAMED_TEST("ThreeContainerHelper (unmanaged)",          UMTE::ThreeContainerHelperTest)
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("ThreeContainerHelper (unique)",             UPTE::ThreeContainerHelperTest)
RUN_NAMED_TEST("ThreeContainerHelper (std::uptr)",          SUPDDTE::ThreeContainerHelperTest)
RUN_NAMED_TEST("ThreeContainerHelper (std::uptr<Del>)",     SUPCDTE::ThreeContainerHelperTest)
#endif
RUN_NAMED_TEST("ThreeContainerHelper (RefPtr)",             RPTE::ThreeContainerHelperTest)

RUN_NAMED_TEST("IterCopyPointer (unmanaged)",               UMTE::IterCopyPointerTest)
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("IterCopyPointer (unique)",                  UPTE::IterCopyPointerTest)
RUN_NAMED_TEST("IterCopyPointer (std::uptr)",               SUPDDTE::IterCopyPointerTest)
RUN_NAMED_TEST("IterCopyPointer (std::uptr<Del>)",          SUPCDTE::IterCopyPointerTest)
#endif
RUN_NAMED_TEST("IterCopyPointer (RefPtr)",                  RPTE::IterCopyPointerTest)

RUN_NAMED_TEST("EraseIf (unmanaged)",                       UMTE::EraseIfTest)
RUN_NAMED_TEST("EraseIf (unique)",                          UPTE::EraseIfTest)
RUN_NAMED_TEST("EraseIf (std::uptr)",                       SUPDDTE::EraseIfTest)
RUN_NAMED_TEST("EraseIf (std::uptr<Del>)",                  SUPCDTE::EraseIfTest)
RUN_NAMED_TEST("EraseIf (RefPtr)",                          RPTE::EraseIfTest)

RUN_NAMED_TEST("FindIf (unmanaged)",                        UMTE::FindIfTest)
RUN_NAMED_TEST("FindIf (unique)",                           UPTE::FindIfTest)
RUN_NAMED_TEST("FindIf (std::uptr)",                        SUPDDTE::FindIfTest)
RUN_NAMED_TEST("FindIf (std::uptr<Del>)",                   SUPCDTE::FindIfTest)
RUN_NAMED_TEST("FindIf (RefPtr)",                           RPTE::FindIfTest)

//////////////////////////////////////////
// Sequence container specific tests.
//////////////////////////////////////////
RUN_NAMED_TEST("PushFront (unmanaged)",                     UMTE::PushFrontTest)
RUN_NAMED_TEST("PushFront (unique)",                        UPTE::PushFrontTest)
RUN_NAMED_TEST("PushFront (std::uptr)",                     SUPDDTE::PushFrontTest)
RUN_NAMED_TEST("PushFront (std::uptr<Del>)",                SUPCDTE::PushFrontTest)
RUN_NAMED_TEST("PushFront (RefPtr)",                        RPTE::PushFrontTest)

RUN_NAMED_TEST("PopFront (unmanaged)",                      UMTE::PopFrontTest)
RUN_NAMED_TEST("PopFront (unique)",                         UPTE::PopFrontTest)
RUN_NAMED_TEST("PopFront (std::uptr)",                      SUPDDTE::PopFrontTest)
RUN_NAMED_TEST("PopFront (std::uptr<Del>)",                 SUPCDTE::PopFrontTest)
RUN_NAMED_TEST("PopFront (RefPtr)",                         RPTE::PopFrontTest)

// Singly linked lists cannot push/pop to/from the back
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("PushBack (unmanaged)",                     UMTE::PushBackTest)
RUN_NAMED_TEST("PushBack (unique)",                        UPTE::PushBackTest)
RUN_NAMED_TEST("PushBack (std::uptr)",                     SUPDDTE::PushBackTest)
RUN_NAMED_TEST("PushBack (std::uptr<Del>)",                SUPCDTE::PushBackTest)
RUN_NAMED_TEST("PushBack (RefPtr)",                        RPTE::PushBackTest)

RUN_NAMED_TEST("PopBack (unmanaged)",                      UMTE::PopBackTest)
RUN_NAMED_TEST("PopBack (unique)",                         UPTE::PopBackTest)
RUN_NAMED_TEST("PopBack (std::uptr)",                      SUPDDTE::PopBackTest)
RUN_NAMED_TEST("PopBack (std::uptr<Del>)",                 SUPCDTE::PopBackTest)
RUN_NAMED_TEST("PopBack (RefPtr)",                         RPTE::PopBackTest)
#endif

RUN_NAMED_TEST("SeqIterate (unmanaged)",                   UMTE::SeqIterateTest)
RUN_NAMED_TEST("SeqIterate (unique)",                      UPTE::SeqIterateTest)
RUN_NAMED_TEST("SeqIterate (std::uptr)",                   SUPDDTE::SeqIterateTest)
RUN_NAMED_TEST("SeqIterate (std::uptr<Del>)",              SUPCDTE::SeqIterateTest)
RUN_NAMED_TEST("SeqIterate (RefPtr)",                      RPTE::SeqIterateTest)

// SinglyLinkedLists cannot iterate backwards.
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("SeqReverseIterate (unmanaged)",            UMTE::SeqReverseIterateTest)
RUN_NAMED_TEST("SeqReverseIterate (unique)",               UPTE::SeqReverseIterateTest)
RUN_NAMED_TEST("SeqReverseIterate (std::uptr)",            SUPDDTE::SeqReverseIterateTest)
RUN_NAMED_TEST("SeqReverseIterate (std::uptr<Del>)",       SUPCDTE::SeqReverseIterateTest)
RUN_NAMED_TEST("SeqReverseIterate (RefPtr)",               RPTE::SeqReverseIterateTest)
#endif

RUN_NAMED_TEST("EraseNext (unmanaged)",                    UMTE::EraseNextTest)
RUN_NAMED_TEST("EraseNext (unique)",                       UPTE::EraseNextTest)
RUN_NAMED_TEST("EraseNext (std::uptr)",                    SUPDDTE::EraseNextTest)
RUN_NAMED_TEST("EraseNext (std::uptr<Del>)",               SUPCDTE::EraseNextTest)
RUN_NAMED_TEST("EraseNext (RefPtr)",                       RPTE::EraseNextTest)

RUN_NAMED_TEST("InsertAfter (unmanaged)",                  UMTE::InsertAfterTest)
RUN_NAMED_TEST("InsertAfter (unique)",                     UPTE::InsertAfterTest)
RUN_NAMED_TEST("InsertAfter (std::uptr)",                  SUPDDTE::InsertAfterTest)
RUN_NAMED_TEST("InsertAfter (std::uptr<Del>)",             SUPCDTE::InsertAfterTest)
RUN_NAMED_TEST("InsertAfter (RefPtr)",                     RPTE::InsertAfterTest)

// SinglyLinkedLists cannot perform inserts-bef            ore operations, either with an
// iterator or with a direct object reference.
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("Insert (unmanaged)",                        UMTE::InsertTest)
RUN_NAMED_TEST("Insert (unique)",                           UPTE::InsertTest)
RUN_NAMED_TEST("Insert (std::uptr)",                        SUPDDTE::InsertTest)
RUN_NAMED_TEST("Insert (std::uptr<Del>)",                   SUPCDTE::InsertTest)
RUN_NAMED_TEST("Insert (RefPtr)",                           RPTE::InsertTest)

RUN_NAMED_TEST("DirectInsert (unmanaged)",                  UMTE::DirectInsertTest)
RUN_NAMED_TEST("DirectInsert (unique)",                     UPTE::DirectInsertTest)
RUN_NAMED_TEST("DirectInsert (std::uptr)",                  SUPDDTE::DirectInsertTest)
RUN_NAMED_TEST("DirectInsert (std::uptr<Del>)",             SUPCDTE::DirectInsertTest)
RUN_NAMED_TEST("DirectInsert (RefPtr)",                     RPTE::DirectInsertTest)
#endif

// SinglyLinkedLists cannot perform splice oper            ations.
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("Splice (unmanaged)",                        UMTE::SpliceTest)
RUN_NAMED_TEST("Splice (unique)",                           UPTE::SpliceTest)
RUN_NAMED_TEST("Splice (std::uptr)",                        SUPDDTE::SpliceTest)
RUN_NAMED_TEST("Splice (std::uptr<Del>)",                   SUPCDTE::SpliceTest)
RUN_NAMED_TEST("Splice (RefPtr)",                           RPTE::SpliceTest)
#endif

RUN_NAMED_TEST("ReplaceIfCopy (unmanaged)",                 UMTE::ReplaceIfCopyTest)
#if TEST_WILL_NOT_COMPILE || 0
RUN_NAMED_TEST("ReplaceIfCopy (unique)",                    UPTE::ReplaceIfCopyTest)
RUN_NAMED_TEST("ReplaceIfCopy (std::uptr)",                 SUPDDTE::ReplaceIfCopyTest)
RUN_NAMED_TEST("ReplaceIfCopy (std::uptr<Del>)",            SUPCDTE::ReplaceIfCopyTest)
#endif
RUN_NAMED_TEST("ReplaceIfCopy (RefPtr)",                    RPTE::ReplaceIfCopyTest)

RUN_NAMED_TEST("ReplaceIfMove (unmanaged)",                 UMTE::ReplaceIfMoveTest)
RUN_NAMED_TEST("ReplaceIfMove (unique)",                    UPTE::ReplaceIfMoveTest)
RUN_NAMED_TEST("ReplaceIfMove (std::uptr)",                 SUPDDTE::ReplaceIfMoveTest)
RUN_NAMED_TEST("ReplaceIfMove (std::uptr<Del>)",            SUPCDTE::ReplaceIfMoveTest)
RUN_NAMED_TEST("ReplaceIfMove (RefPtr)",                    RPTE::ReplaceIfMoveTest)

END_TEST_CASE(single_linked_list_tests)

}  // namespace intrusive_containers
}  // namespace tests
}  // namespace fbl