#include "include/private/base/SkASAN.h"
#include "include/private/base/SkTArray.h"
#include "src/base/SkFixedArray.h"
#include "src/base/SkRandom.h"
#include "tests/Test.h"
#include <array>
#include <cstdint>
#include <initializer_list>
#include <utility>

Classes
struct	EmplaceStruct

Functions
template<typename ArrayType >
static void	TestTSet_basic (skiatest::Reporter *reporter)

template<typename T >
static void	test_construction (skiatest::Reporter *reporter, bool hasMoveSemantics=true)

template<typename T , typename U >
static void	test_starray_compatibility (skiatest::Reporter *reporter)

template<typename T >
static void	test_swap (skiatest::Reporter reporter, SkSpan< TArray< T > > arrays, SkSpan< const int > sizes)

	DEF_TEST (TArray_Swap, reporter)

template<typename T >
static void	test_array_move (skiatest::Reporter reporter, SkSpan< TArray< T > > arrays, SkSpan< const int > sizes)

	DEF_TEST (TArray_Move, reporter)

	DEF_TEST (TArray_NoUnnecessaryAllocs, reporter)

template<typename ArrayType >
static void	test_self_assignment (skiatest::Reporter *reporter)

	DEF_TEST (TArray_SelfAssignment, reporter)

	DEF_TEST (FixedArray_SelfAssignment, reporter)

template<typename ArrayType >
static void	test_comparison (skiatest::Reporter *reporter)

	DEF_TEST (TArray_Comparison, reporter)

	DEF_TEST (FixedArray_Comparison, reporter)

template<typename Array >
static void	test_array_reserve (skiatest::Reporter reporter, Array array, int reserveCount)

template<typename Array >
static void	test_reserve (skiatest::Reporter *reporter)

template<typename T >
static void	test_inner_push (skiatest::Reporter *reporter)

template<typename T >
static void	test_inner_emplace (skiatest::Reporter *reporter)

	DEF_TEST (TArray_Basic, reporter)

	DEF_TEST (FixedArray_Basic, reporter)

	DEF_TEST (TArray_Reserve, reporter)

	DEF_TEST (TArray_Construction, reporter)

	DEF_TEST (FixedArray_Construction, reporter)

	DEF_TEST (TArray_InnerPush, reporter)

	DEF_TEST (FixedArray_InnerPush, reporter)

	DEF_TEST (TArray_InnerEmplace, reporter)

	DEF_TEST (TArray_STArrayCompatibility, reporter)

	DEF_TEST (TArray_BoundsCheck, reporter)

Function Documentation

◆ DEF_TEST() [1/17]

DEF_TEST	(	FixedArray_Basic	,
		reporter
	)

Definition at line 552 of file TArrayTest.cpp.

                                     {
    TestTSet_basic<FixedArray<5, char>>(reporter);
    TestTSet_basic<FixedArray<7, int>>(reporter);
    TestTSet_basic<FixedArray<100, double>>(reporter);
}

◆ DEF_TEST() [2/17]

DEF_TEST	(	FixedArray_Comparison	,
		reporter
	)

Definition at line 454 of file TArrayTest.cpp.

                                          {
    test_comparison<FixedArray<15, int>>(reporter);
    test_comparison<FixedArray<20, char>>(reporter);
    test_comparison<FixedArray<25, float>>(reporter);
}

◆ DEF_TEST() [3/17]

DEF_TEST	(	FixedArray_Construction	,
		reporter
	)

Definition at line 580 of file TArrayTest.cpp.

                                            {
    test_construction<FixedArray<15, int>>(reporter, /*hasMoveSemantics=*/false);
    test_construction<FixedArray<20, char>>(reporter, /*hasMoveSemantics=*/false);
    test_construction<FixedArray<25, float>>(reporter, /*hasMoveSemantics=*/false);
}

◆ DEF_TEST() [4/17]

DEF_TEST	(	FixedArray_InnerPush	,
		reporter
	)

Definition at line 593 of file TArrayTest.cpp.

                                         {
    test_inner_push<FixedArray<101, int>>(reporter);
    test_inner_push<FixedArray<150, short>>(reporter);
    test_inner_push<FixedArray<250, double>>(reporter);
}

◆ DEF_TEST() [5/17]

DEF_TEST	(	FixedArray_SelfAssignment	,
		reporter
	)

Definition at line 401 of file TArrayTest.cpp.

                                              {
    test_self_assignment<FixedArray<1, int>>(reporter);
    test_self_assignment<FixedArray<4, unsigned short>>(reporter);
}

◆ DEF_TEST() [6/17]

DEF_TEST	(	TArray_Basic	,
		reporter
	)

Definition at line 543 of file TArrayTest.cpp.

                                 {
    // ints are POD types and can work with either MEM_MOVE=true or false.
    TestTSet_basic<TArray<int, true>>(reporter);
    TestTSet_basic<TArray<int, false>>(reporter);
 
    // TestClass has a vtable and can only work with MEM_MOVE=false.
    TestTSet_basic<TArray<TestClass, false>>(reporter);
}

◆ DEF_TEST() [7/17]

DEF_TEST	(	TArray_BoundsCheck	,
		reporter
	)

Definition at line 619 of file TArrayTest.cpp.

                                       {
#if 0  // The v[0] fails
    TArray<int> v;
    v[0];
#endif
}

◆ DEF_TEST() [8/17]

DEF_TEST	(	TArray_Comparison	,
		reporter
	)

Definition at line 444 of file TArrayTest.cpp.

                                      {
    test_comparison<TArray<int>>(reporter);
    test_comparison<TArray<double>>(reporter);
    test_comparison<TArray<TestClass>>(reporter);
    test_comparison<STArray<1, int>>(reporter);
    test_comparison<STArray<5, char>>(reporter);
    test_comparison<STArray<7, TestClass>>(reporter);
    test_comparison<STArray<10, float>>(reporter);
}

◆ DEF_TEST() [9/17]

DEF_TEST	(	TArray_Construction	,
		reporter
	)

Definition at line 570 of file TArrayTest.cpp.

                                        {
    test_construction<TArray<int>>(reporter);
    test_construction<TArray<double>>(reporter);
    test_construction<TArray<TestClass>>(reporter);
    test_construction<STArray<1, int>>(reporter);
    test_construction<STArray<5, char>>(reporter);
    test_construction<STArray<7, TestClass>>(reporter);
    test_construction<STArray<10, float>>(reporter);
}

◆ DEF_TEST() [10/17]

DEF_TEST	(	TArray_InnerEmplace	,
		reporter
	)

Definition at line 599 of file TArrayTest.cpp.

                                        {
    test_inner_emplace<TArray<EmplaceStruct>>(reporter);
    test_inner_emplace<STArray<1, EmplaceStruct>>(reporter);
    test_inner_emplace<STArray<99, EmplaceStruct>>(reporter);
    test_inner_emplace<STArray<200, EmplaceStruct>>(reporter);
}

◆ DEF_TEST() [11/17]

DEF_TEST	(	TArray_InnerPush	,
		reporter
	)

Definition at line 586 of file TArrayTest.cpp.

                                     {
    test_inner_push<TArray<int>>(reporter);
    test_inner_push<STArray<1, int>>(reporter);
    test_inner_push<STArray<99, int>>(reporter);
    test_inner_push<STArray<200, int>>(reporter);
}

◆ DEF_TEST() [12/17]

DEF_TEST	(	TArray_Move	,
		reporter
	)

Definition at line 306 of file TArrayTest.cpp.

                                {
    static constexpr int kSizes[] = {0, 1, 5, 10, 15, 20, 25};
 
    TArray<int> arr;
    STArray< 5, int> arr5;
    STArray<10, int> arr10;
    STArray<20, int> arr20;
    TArray<int>* arrays[] = { &arr, &arr5, &arr10, &arr20 };
    test_array_move<int>(reporter, arrays, kSizes);
 
    TArray<MoveOnlyInt> moi;
    STArray< 5, MoveOnlyInt> moi5;
    STArray<10, MoveOnlyInt> moi10;
    STArray<20, MoveOnlyInt> moi20;
    TArray<MoveOnlyInt>* arraysMoi[] = { &moi, &moi5, &moi10, &moi20 };
    test_array_move<MoveOnlyInt>(reporter, arraysMoi, kSizes);
}

◆ DEF_TEST() [13/17]

DEF_TEST	(	TArray_NoUnnecessaryAllocs	,
		reporter
	)

Definition at line 324 of file TArrayTest.cpp.

                                               {
    {
        TArray<int> a;
        REPORTER_ASSERT(reporter, a.capacity() == 0);
    }
    {
        STArray<10, int> a;
        REPORTER_ASSERT(reporter, a.capacity() == 10);
    }
    {
        TArray<int> a(1);
        REPORTER_ASSERT(reporter, a.capacity() >= 1);
    }
    {
        TArray<int> a, b;
        b = a;
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
    {
        STArray<10, int> a;
        TArray<int> b;
        b = a;
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
    {
        TArray<int> a;
        TArray<int> b(a);  // NOLINT(performance-unnecessary-copy-initialization)
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
    {
        STArray<10, int> a;
        TArray<int> b(a);  // NOLINT(performance-unnecessary-copy-initialization)
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
    {
        TArray<int> a;
        TArray<int> b(std::move(a));
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
    {
        STArray<10, int> a;
        TArray<int> b(std::move(a));
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
    {
        TArray<int> a;
        TArray<int> b;
        b = std::move(a);
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
    {
        STArray<10, int> a;
        TArray<int> b;
        b = std::move(a);
        REPORTER_ASSERT(reporter, b.capacity() == 0);
    }
}

◆ DEF_TEST() [14/17]

DEF_TEST	(	TArray_Reserve	,
		reporter
	)

Definition at line 558 of file TArrayTest.cpp.

                                   {
    test_reserve<TArray<int>>(reporter);
    test_reserve<STArray<1, int>>(reporter);
    test_reserve<STArray<2, int>>(reporter);
    test_reserve<STArray<16, int>>(reporter);
 
    test_reserve<TArray<TestClass>>(reporter);
    test_reserve<STArray<1, TestClass>>(reporter);
    test_reserve<STArray<2, TestClass>>(reporter);
    test_reserve<STArray<16, TestClass>>(reporter);
}

◆ DEF_TEST() [15/17]

DEF_TEST	(	TArray_SelfAssignment	,
		reporter
	)

Definition at line 396 of file TArrayTest.cpp.

                                          {
    test_self_assignment<TArray<int>>(reporter);
    test_self_assignment<STArray<3, unsigned short>>(reporter);
}

◆ DEF_TEST() [16/17]

DEF_TEST	(	TArray_STArrayCompatibility	,
		reporter
	)

Definition at line 606 of file TArrayTest.cpp.

                                                {
    test_starray_compatibility<STArray<1, int>, TArray<int>>(reporter);
    test_starray_compatibility<STArray<5, char>, TArray<char>>(reporter);
    test_starray_compatibility<STArray<10, float>, TArray<float>>(reporter);
    test_starray_compatibility<TArray<int>, STArray<1, int>>(reporter);
    test_starray_compatibility<TArray<char>, STArray<5, char>>(reporter);
    test_starray_compatibility<TArray<float>, STArray<10, float>>(reporter);
    test_starray_compatibility<STArray<10, uint8_t>, STArray<1, uint8_t>>(reporter);
    test_starray_compatibility<STArray<1, long>, STArray<10, long>>(reporter);
    test_starray_compatibility<STArray<3, double>, STArray<4, double>>(reporter);
    test_starray_compatibility<STArray<2, short>, STArray<1, short>>(reporter);
}

◆ DEF_TEST() [17/17]

DEF_TEST	(	TArray_Swap	,
		reporter
	)

Definition at line 247 of file TArrayTest.cpp.

                                {
    static constexpr int kSizes[] = {0, 1, 5, 10, 15, 20, 25};
 
    TArray<int> arr;
    STArray< 5, int> arr5;
    STArray<10, int> arr10;
    STArray<20, int> arr20;
    TArray<int>* arrays[] = { &arr, &arr5, &arr10, &arr20 };
    test_swap<int>(reporter, arrays, kSizes);
 
    TArray<MoveOnlyInt> moi;
    STArray< 5, MoveOnlyInt> moi5;
    STArray<10, MoveOnlyInt> moi10;
    STArray<20, MoveOnlyInt> moi20;
    TArray<MoveOnlyInt>* arraysMoi[] = { &moi, &moi5, &moi10, &moi20 };
    test_swap<MoveOnlyInt>(reporter, arraysMoi, kSizes);
}

◆ test_array_move()

template<typename T >

static void test_array_move	(	skiatest::Reporter *	reporter,
		SkSpan< TArray< T > * >	arrays,
		SkSpan< const int >	sizes
	)

static

Definition at line 265 of file TArrayTest.cpp.

                                                                           {
    // self test is a no-op
    for (auto a : arrays) {
        for (auto sizeA : sizes) {
            a->clear();
            for (int i = 0; i < sizeA; i++) { a->push_back(i); }
            a->move_back(*a);
            REPORTER_ASSERT(reporter, a->size() == sizeA);
            for (int i = 0; i < sizeA; i++) {
                REPORTER_ASSERT(reporter, (*a)[i] == i);
            }
        }
    }
 
    for (auto a : arrays) {
    for (auto b : arrays) {
        if (a == b) {
            continue;
        }
 
        for (auto sizeA : sizes) {
        for (auto sizeB : sizes) {
            a->clear();
            b->clear();
 
            int curr = 0;
            for (int i = 0; i < sizeA; i++) { a->push_back(curr++); }
            for (int i = 0; i < sizeB; i++) { b->push_back(curr++); }
 
            a->move_back(*b);
            REPORTER_ASSERT(reporter, b->size() == 0);
            REPORTER_ASSERT(reporter, a->size() == sizeA + sizeB);
 
            curr = 0;
            for (auto&& x : *a) { REPORTER_ASSERT(reporter, x == curr++); }
        }}
    }}
}

◆ test_array_reserve()

template<typename Array >

static void test_array_reserve	(	skiatest::Reporter *	reporter,
		Array *	array,
		int	reserveCount
	)

static

Definition at line 460 of file TArrayTest.cpp.

                                                                                         {
    SkRandom random;
    REPORTER_ASSERT(reporter, array->capacity() >= reserveCount);
    array->push_back();
    REPORTER_ASSERT(reporter, array->capacity() >= reserveCount);
    array->pop_back();
    REPORTER_ASSERT(reporter, array->capacity() >= reserveCount);
    while (array->size() < reserveCount) {
        // Two steps forward, one step back
        if (random.nextULessThan(3) < 2) {
            array->push_back();
        } else if (array->size() > 0) {
            array->pop_back();
        }
        REPORTER_ASSERT(reporter, array->capacity() >= reserveCount);
    }
}

◆ test_comparison()

template<typename ArrayType >

static void test_comparison ( skiatest::Reporter * reporter )

static

Definition at line 407 of file TArrayTest.cpp.

                                                        {
    using T = typename ArrayType::value_type;
    ArrayType a, b;
 
    // Empty arrays.
    REPORTER_ASSERT(reporter, a == b);
    REPORTER_ASSERT(reporter, !(a != b));
 
    // Arrays with identical contents.
    for (int x = 0; x < 10; ++x) {
        a.push_back(T(x));
        b.push_back(T(x));
        REPORTER_ASSERT(reporter, a == b);
        REPORTER_ASSERT(reporter, !(a != b));
    }
 
    // Arrays with differing sizes.
    for (int x = 0; x < 10; ++x) {
        a.pop_back();
        REPORTER_ASSERT(reporter, a != b);
        REPORTER_ASSERT(reporter, b != a);
        REPORTER_ASSERT(reporter, !(a == b));
        REPORTER_ASSERT(reporter, !(b == a));
    }
 
    // Arrays with differing contents.
    a = b;
    for (int x = 0; x < 10; ++x) {
        a[x] = T(x + 100);
        REPORTER_ASSERT(reporter, a != b);
        REPORTER_ASSERT(reporter, b != a);
        REPORTER_ASSERT(reporter, !(a == b));
        REPORTER_ASSERT(reporter, !(b == a));
        a[x] = T(x);
    }
}

◆ test_construction()

template<typename T >

static void test_construction	(	skiatest::Reporter *	reporter,
		bool	hasMoveSemantics = `true`
	)

static

Definition at line 93 of file TArrayTest.cpp.

                                                                                        {
    using ValueType = typename T::value_type;
 
    // No arguments: Creates an empty array with no initial storage.
    T arrayNoArgs;
    REPORTER_ASSERT(reporter, arrayNoArgs.empty());
 
    // Single integer: Creates an empty array that will preallocate space for reserveCount elements.
    T arrayReserve(15);
    REPORTER_ASSERT(reporter, arrayReserve.empty());
    // May get some extra elements for free because sk_allocate_* can round up.
    REPORTER_ASSERT(reporter, arrayReserve.capacity() >= 15 && arrayReserve.capacity() < 50);
 
    // Another array, const&: Copies one array to another.
    T arrayInitial;
    arrayInitial.push_back(ValueType{1});
    arrayInitial.push_back(ValueType{2});
    arrayInitial.push_back(ValueType{3});
 
    T arrayCopy(arrayInitial);
    REPORTER_ASSERT(reporter, arrayInitial.size() == 3);
    REPORTER_ASSERT(reporter, arrayInitial[0] == ValueType{1});
    REPORTER_ASSERT(reporter, arrayInitial[1] == ValueType{2});
    REPORTER_ASSERT(reporter, arrayInitial[2] == ValueType{3});
    REPORTER_ASSERT(reporter, arrayCopy.size() == 3);
    REPORTER_ASSERT(reporter, arrayCopy[0] == ValueType{1});
    REPORTER_ASSERT(reporter, arrayCopy[1] == ValueType{2});
    REPORTER_ASSERT(reporter, arrayCopy[2] == ValueType{3});
 
    // Another array, &&: Moves one array to another.
    T arrayMove(std::move(arrayInitial));
    if (hasMoveSemantics) {
        REPORTER_ASSERT(reporter, arrayInitial.empty()); // NOLINT(bugprone-use-after-move)
    }
    REPORTER_ASSERT(reporter, arrayMove.size() == 3);
    REPORTER_ASSERT(reporter, arrayMove[0] == ValueType{1});
    REPORTER_ASSERT(reporter, arrayMove[1] == ValueType{2});
    REPORTER_ASSERT(reporter, arrayMove[2] == ValueType{3});
 
    // Pointer and count: Copies contents of a standard C array.
    typename T::value_type data[3] = { 7, 8, 9 };
    T arrayPtrCount(data, 3);
    REPORTER_ASSERT(reporter, arrayPtrCount.size() == 3);
    REPORTER_ASSERT(reporter, arrayPtrCount[0] == ValueType{7});
    REPORTER_ASSERT(reporter, arrayPtrCount[1] == ValueType{8});
    REPORTER_ASSERT(reporter, arrayPtrCount[2] == ValueType{9});
 
    // Initializer list.
    T arrayInitializer{8, 6, 7, 5, 3, 0, 9};
    REPORTER_ASSERT(reporter, arrayInitializer.size() == 7);
    REPORTER_ASSERT(reporter, arrayInitializer[0] == ValueType{8});
    REPORTER_ASSERT(reporter, arrayInitializer[1] == ValueType{6});
    REPORTER_ASSERT(reporter, arrayInitializer[2] == ValueType{7});
    REPORTER_ASSERT(reporter, arrayInitializer[3] == ValueType{5});
    REPORTER_ASSERT(reporter, arrayInitializer[4] == ValueType{3});
    REPORTER_ASSERT(reporter, arrayInitializer[5] == ValueType{0});
    REPORTER_ASSERT(reporter, arrayInitializer[6] == ValueType{9});
}

◆ test_inner_emplace()

template<typename T >

static void test_inner_emplace ( skiatest::Reporter * reporter )

static

Definition at line 527 of file TArrayTest.cpp.

                                                           {
    T a;
    a.emplace_back(12345);
    for (int x=0; x<50; ++x) {
        a.emplace_back(a.front().fValue);
    }
    for (int x=0; x<50; ++x) {
        a.emplace_back(a.back().fValue);
    }
 
    REPORTER_ASSERT(reporter, a.size() == 101);
    REPORTER_ASSERT(reporter, std::all_of(a.begin(), a.end(), [](const EmplaceStruct& s) {
                        return s.fValue == 12345;
                    }));
}

◆ test_inner_push()

template<typename T >

static void test_inner_push ( skiatest::Reporter * reporter )

static

Definition at line 507 of file TArrayTest.cpp.

                                                        {
    T a;
    a.push_back(12345);
    for (int x=0; x<50; ++x) {
        a.push_back(a.front());
    }
    for (int x=0; x<50; ++x) {
        a.push_back(a.back());
    }
 
    REPORTER_ASSERT(reporter, a.size() == 101);
    REPORTER_ASSERT(reporter, std::count(a.begin(), a.end(), 12345) == a.size());
}

◆ test_reserve()

template<typename Array >

static void test_reserve ( skiatest::Reporter * reporter )

static

Definition at line 479 of file TArrayTest.cpp.

                                                                              {
    // Test that our allocated space stays >= to the reserve count until the array is filled to
    // the reserve count
    for (int reserveCount : {1, 2, 10, 100}) {
        // Test setting reserve in constructor.
        Array array1(reserveCount);
        test_array_reserve(reporter, &array1, reserveCount);
 
        // Test setting reserve after constructor.
        Array array2;
        array2.reserve(reserveCount);
        test_array_reserve(reporter, &array2, reserveCount);
 
        // Test increasing reserve after constructor.
        Array array3(reserveCount/2);
        array3.reserve(reserveCount);
        test_array_reserve(reporter, &array3, reserveCount);
 
        // Test setting reserve on non-empty array.
        Array array4;
        array4.push_back_n(reserveCount);
        array4.reserve(2 * reserveCount);
        array4.pop_back_n(reserveCount);
        test_array_reserve(reporter, &array4, 2 * reserveCount);
    }
}

◆ test_self_assignment()

template<typename ArrayType >

static void test_self_assignment ( skiatest::Reporter * reporter )

static

Definition at line 383 of file TArrayTest.cpp.

                                                             {
    ArrayType a;
    a.push_back(1);
    REPORTER_ASSERT(reporter, !a.empty());
    REPORTER_ASSERT(reporter, a.size() == 1);
    REPORTER_ASSERT(reporter, a[0] == 1);
 
    a = static_cast<ArrayType&>(a);
    REPORTER_ASSERT(reporter, !a.empty());
    REPORTER_ASSERT(reporter, a.size() == 1);
    REPORTER_ASSERT(reporter, a[0] == 1);
}

◆ test_starray_compatibility()

template<typename T , typename U >

static void test_starray_compatibility ( skiatest::Reporter * reporter )

static

Definition at line 153 of file TArrayTest.cpp.

                                                                   {
    // We expect TArrays of the same type to be copyable and movable, even when:
    // - one side is an TArray, and the other side is an STArray
    // - both sides are STArray, but each side has a different internal capacity
    T tArray;
    tArray.push_back(1);
    tArray.push_back(2);
    tArray.push_back(3);
    T tArray2 = tArray;
 
    // Copy construction from other-type array.
    U arrayCopy(tArray);
    REPORTER_ASSERT(reporter, tArray.size() == 3);
    REPORTER_ASSERT(reporter, tArray[0] == 1);
    REPORTER_ASSERT(reporter, tArray[1] == 2);
    REPORTER_ASSERT(reporter, tArray[2] == 3);
    REPORTER_ASSERT(reporter, arrayCopy.size() == 3);
    REPORTER_ASSERT(reporter, arrayCopy[0] == 1);
    REPORTER_ASSERT(reporter, arrayCopy[1] == 2);
    REPORTER_ASSERT(reporter, arrayCopy[2] == 3);
 
    // Assignment from other-type array.
    U arrayAssignment;
    arrayAssignment = tArray;
    REPORTER_ASSERT(reporter, tArray.size() == 3);
    REPORTER_ASSERT(reporter, tArray[0] == 1);
    REPORTER_ASSERT(reporter, tArray[1] == 2);
    REPORTER_ASSERT(reporter, tArray[2] == 3);
    REPORTER_ASSERT(reporter, arrayAssignment.size() == 3);
    REPORTER_ASSERT(reporter, arrayAssignment[0] == 1);
    REPORTER_ASSERT(reporter, arrayAssignment[1] == 2);
    REPORTER_ASSERT(reporter, arrayAssignment[2] == 3);
 
    // Move construction from other-type array.
    U arrayMove(std::move(tArray));
    REPORTER_ASSERT(reporter, tArray.empty()); // NOLINT(bugprone-use-after-move)
    REPORTER_ASSERT(reporter, arrayMove.size() == 3);
    REPORTER_ASSERT(reporter, arrayMove[0] == 1);
    REPORTER_ASSERT(reporter, arrayMove[1] == 2);
    REPORTER_ASSERT(reporter, arrayMove[2] == 3);
 
    // Move assignment from other-type array.
    U arrayMoveAssign;
    arrayMoveAssign = std::move(tArray2);
    REPORTER_ASSERT(reporter, tArray2.empty()); // NOLINT(bugprone-use-after-move)
    REPORTER_ASSERT(reporter, arrayMoveAssign.size() == 3);
    REPORTER_ASSERT(reporter, arrayMoveAssign[0] == 1);
    REPORTER_ASSERT(reporter, arrayMoveAssign[1] == 2);
    REPORTER_ASSERT(reporter, arrayMoveAssign[2] == 3);
}

◆ test_swap()

template<typename T >

static void test_swap	(	skiatest::Reporter *	reporter,
		SkSpan< TArray< T > * >	arrays,
		SkSpan< const int >	sizes
	)

static

Definition at line 214 of file TArrayTest.cpp.

                                                                     {
    for (auto a : arrays) {
    for (auto b : arrays) {
        if (a == b) {
            continue;
        }
 
        for (auto sizeA : sizes) {
        for (auto sizeB : sizes) {
            a->clear();
            b->clear();
 
            int curr = 0;
            for (int i = 0; i < sizeA; i++) { a->push_back(curr++); }
            for (int i = 0; i < sizeB; i++) { b->push_back(curr++); }
 
            a->swap(*b);
            REPORTER_ASSERT(reporter, b->size() == sizeA);
            REPORTER_ASSERT(reporter, a->size() == sizeB);
 
            curr = 0;
            for (auto&& x : *b) { REPORTER_ASSERT(reporter, x == curr++); }
            for (auto&& x : *a) { REPORTER_ASSERT(reporter, x == curr++); }
 
            a->swap(*a);
            curr = sizeA;
            for (auto&& x : *a) { REPORTER_ASSERT(reporter, x == curr++); }
        }}
    }}
}

◆ TestTSet_basic()

template<typename ArrayType >

static void TestTSet_basic ( skiatest::Reporter * reporter )

static

Definition at line 44 of file TArrayTest.cpp.

                                                       {
    using T = typename ArrayType::value_type;
    ArrayType a;
 
    // Starts empty.
    REPORTER_ASSERT(reporter, a.empty());
    REPORTER_ASSERT(reporter, a.size() == 0);
 
    // { }, add a default constructed element
    a.push_back() = T{0};
    REPORTER_ASSERT(reporter, !a.empty());
    REPORTER_ASSERT(reporter, a.size() == 1);
 
    // { 0 }, removeShuffle the only element.
    a.removeShuffle(0);
    REPORTER_ASSERT(reporter, a.empty());
    REPORTER_ASSERT(reporter, a.size() == 0);
 
    // { }, add a default, add a 1, remove first
    a.push_back() = T{0};
    a.push_back() = T{1};
    a.removeShuffle(0);
    REPORTER_ASSERT(reporter, !a.empty());
    REPORTER_ASSERT(reporter, a.size() == 1);
    REPORTER_ASSERT(reporter, a[0] == T{1});
 
    // { 1 }, replace with new array
    T b[5] = {T{0}, T{1}, T{2}, T{3}, T{4}};
    a.reset(b, std::size(b));
    REPORTER_ASSERT(reporter, a.size() == std::size(b));
    REPORTER_ASSERT(reporter, a[2] == T{2});
    REPORTER_ASSERT(reporter, a[4] == T{4});
 
    // { 0, 1, 2, 3, 4 }, removeShuffle the last
    a.removeShuffle(4);
    REPORTER_ASSERT(reporter, a.size() == std::size(b) - 1);
    REPORTER_ASSERT(reporter, a[3] == T{3});
 
    // { 0, 1, 2, 3 }, remove a middle, note shuffle
    a.removeShuffle(1);
    REPORTER_ASSERT(reporter, a.size() == std::size(b) - 2);
    REPORTER_ASSERT(reporter, a[0] == T{0});
    REPORTER_ASSERT(reporter, a[1] == T{3});
    REPORTER_ASSERT(reporter, a[2] == T{2});
 
    // { 0, 3, 2 }
}

Classes

Functions

Function Documentation

◆ DEF_TEST() [1/17]

◆ DEF_TEST() [2/17]

◆ DEF_TEST() [3/17]

◆ DEF_TEST() [4/17]

◆ DEF_TEST() [5/17]

◆ DEF_TEST() [6/17]

◆ DEF_TEST() [7/17]

◆ DEF_TEST() [8/17]

◆ DEF_TEST() [9/17]

◆ DEF_TEST() [10/17]

◆ DEF_TEST() [11/17]

◆ DEF_TEST() [12/17]

◆ DEF_TEST() [13/17]

◆ DEF_TEST() [14/17]

◆ DEF_TEST() [15/17]

◆ DEF_TEST() [16/17]

◆ DEF_TEST() [17/17]

◆ test_array_move()

◆ test_array_reserve()

◆ test_comparison()

◆ test_construction()

◆ test_inner_emplace()

◆ test_inner_push()

◆ test_reserve()

◆ test_self_assignment()

◆ test_starray_compatibility()

◆ test_swap()

◆ TestTSet_basic()