path: root/util/generic/vector_ut.cpp

#include "vector.h"
 
#include <library/cpp/testing/unittest/registar.h>

#include <utility>
#include "yexception.h"
 
#include <stdexcept>

class TYVectorTest: public TTestBase { 
    UNIT_TEST_SUITE(TYVectorTest);
    UNIT_TEST(TestConstructorsAndAssignments)
    UNIT_TEST(TestTildeEmptyToNull)
    UNIT_TEST(TestTilde)
    UNIT_TEST(Test1)
    UNIT_TEST(Test2)
    UNIT_TEST(Test3)
    UNIT_TEST(Test4)
    UNIT_TEST(Test5)
    UNIT_TEST(Test6)
    UNIT_TEST(Test7)
    UNIT_TEST(TestCapacity)
    UNIT_TEST(TestAt)
    UNIT_TEST(TestPointer)
    UNIT_TEST(TestAutoRef)
    UNIT_TEST(TestIterators)
    UNIT_TEST(TestShrink)
    //UNIT_TEST(TestEbo)
    UNIT_TEST(TestFillInConstructor)
    UNIT_TEST(TestYResize)
    UNIT_TEST(TestCrop)
    UNIT_TEST(TestInitializeList)
    UNIT_TEST_SUITE_END();

private:
    void TestConstructorsAndAssignments() {
        using container = TVector<int>;

        container c1;
        c1.push_back(100);
        c1.push_back(200);

        container c2(c1);

        UNIT_ASSERT_VALUES_EQUAL(2, c1.size());
        UNIT_ASSERT_VALUES_EQUAL(2, c2.size());
        UNIT_ASSERT_VALUES_EQUAL(100, c1.at(0));
        UNIT_ASSERT_VALUES_EQUAL(200, c2.at(1));

        container c3(std::move(c1));

        UNIT_ASSERT_VALUES_EQUAL(0, c1.size());
        UNIT_ASSERT_VALUES_EQUAL(2, c3.size());
        UNIT_ASSERT_VALUES_EQUAL(100, c3.at(0));

        c2.push_back(300);
        c3 = c2;

        UNIT_ASSERT_VALUES_EQUAL(3, c2.size());
        UNIT_ASSERT_VALUES_EQUAL(3, c3.size());
        UNIT_ASSERT_VALUES_EQUAL(300, c3.at(2));

        c2.push_back(400);
        c3 = std::move(c2);

        UNIT_ASSERT_VALUES_EQUAL(0, c2.size());
        UNIT_ASSERT_VALUES_EQUAL(4, c3.size());
        UNIT_ASSERT_VALUES_EQUAL(400, c3.at(3));
    }

    inline void TestTildeEmptyToNull() {
        TVector<int> v;
        UNIT_ASSERT_EQUAL(nullptr, v.data());
    }

    inline void TestTilde() {
        TVector<int> v;
        v.push_back(10);
        v.push_back(20);

        UNIT_ASSERT_EQUAL(10, (v.data())[0]);
        UNIT_ASSERT_EQUAL(20, (v.data())[1]);

        for (int i = 0; i < 10000; ++i) {
            v.push_back(99);
        }

        UNIT_ASSERT_EQUAL(10, (v.data())[0]);
        UNIT_ASSERT_EQUAL(20, (v.data())[1]);
        UNIT_ASSERT_EQUAL(99, (v.data())[3]);
        UNIT_ASSERT_EQUAL(99, (v.data())[4]);
    }

    // Copy-paste of STLPort tests
 
    void Test1() {
        TVector<int> v1; // Empty vector of integers.
 
        UNIT_ASSERT(v1.empty() == true);
        UNIT_ASSERT(v1.size() == 0);
        UNIT_ASSERT(!v1);
 
        // UNIT_ASSERT(v1.max_size() == INT_MAX / sizeof(int));
        // cout << "max_size = " << v1.max_size() << endl;
        v1.push_back(42); // Add an integer to the vector.
 
        UNIT_ASSERT(v1.size() == 1);
        UNIT_ASSERT(v1);
 
        UNIT_ASSERT(v1[0] == 42);
 
        {
            TVector<TVector<int>> vect(10);
            TVector<TVector<int>>::iterator it(vect.begin()), end(vect.end());
            for (; it != end; ++it) {
                UNIT_ASSERT((*it).empty());
                UNIT_ASSERT((*it).size() == 0);
                UNIT_ASSERT((*it).capacity() == 0);
                UNIT_ASSERT((*it).begin() == (*it).end());
            } 
        } 
    }
 
    void Test2() {
        TVector<double> v1; // Empty vector of doubles.
        v1.push_back(32.1);
        v1.push_back(40.5);
        TVector<double> v2; // Another empty vector of doubles.
        v2.push_back(3.56);
 
        UNIT_ASSERT(v1.size() == 2);
        UNIT_ASSERT(v1[0] == 32.1);
        UNIT_ASSERT(v1[1] == 40.5);
 
        UNIT_ASSERT(v2.size() == 1);
        UNIT_ASSERT(v2[0] == 3.56);
        v1.swap(v2); // Swap the vector's contents.
 
        UNIT_ASSERT(v1.size() == 1);
        UNIT_ASSERT(v1[0] == 3.56);
 
        UNIT_ASSERT(v2.size() == 2);
        UNIT_ASSERT(v2[0] == 32.1);
        UNIT_ASSERT(v2[1] == 40.5);
 
        v2 = v1; // Assign one vector to another.
 
        UNIT_ASSERT(v2.size() == 1);
        UNIT_ASSERT(v2[0] == 3.56);
    }
 
    void Test3() {
        using vec_type = TVector<char>;
 
        vec_type v1; // Empty vector of characters.
        v1.push_back('h');
        v1.push_back('i');
 
        UNIT_ASSERT(v1.size() == 2);
        UNIT_ASSERT(v1[0] == 'h');
        UNIT_ASSERT(v1[1] == 'i');
 
        vec_type v2(v1.begin(), v1.end());
        v2[1] = 'o'; // Replace second character.
 
        UNIT_ASSERT(v2.size() == 2);
        UNIT_ASSERT(v2[0] == 'h');
        UNIT_ASSERT(v2[1] == 'o');
 
        UNIT_ASSERT((v1 == v2) == false);
 
        UNIT_ASSERT((v1 < v2) == true);
    }
 
    void Test4() {
        TVector<int> v(4);
 
        v[0] = 1;
        v[1] = 4;
        v[2] = 9;
        v[3] = 16;
 
        UNIT_ASSERT(v.front() == 1);
        UNIT_ASSERT(v.back() == 16);
 
        v.push_back(25);
 
        UNIT_ASSERT(v.back() == 25);
        UNIT_ASSERT(v.size() == 5);
 
        v.pop_back();
 
        UNIT_ASSERT(v.back() == 16);
        UNIT_ASSERT(v.size() == 4);
    }
 
    void Test5() {
        int array[] = {1, 4, 9, 16};
 
        TVector<int> v(array, array + 4);
 
        UNIT_ASSERT(v.size() == 4);
 
        UNIT_ASSERT(v[0] == 1);
        UNIT_ASSERT(v[1] == 4);
        UNIT_ASSERT(v[2] == 9);
        UNIT_ASSERT(v[3] == 16);
    }
 
    void Test6() {
        int array[] = {1, 4, 9, 16, 25, 36};
 
        TVector<int> v(array, array + 6);
        TVector<int>::iterator vit;
 
        UNIT_ASSERT(v.size() == 6);
        UNIT_ASSERT(v[0] == 1);
        UNIT_ASSERT(v[1] == 4);
        UNIT_ASSERT(v[2] == 9);
        UNIT_ASSERT(v[3] == 16);
        UNIT_ASSERT(v[4] == 25);
        UNIT_ASSERT(v[5] == 36);
 
        vit = v.erase(v.begin()); // Erase first element.
        UNIT_ASSERT(*vit == 4);
 
        UNIT_ASSERT(v.size() == 5);
        UNIT_ASSERT(v[0] == 4);
        UNIT_ASSERT(v[1] == 9);
        UNIT_ASSERT(v[2] == 16);
        UNIT_ASSERT(v[3] == 25);
        UNIT_ASSERT(v[4] == 36);
 
        vit = v.erase(v.end() - 1); // Erase last element.
        UNIT_ASSERT(vit == v.end());
 
        UNIT_ASSERT(v.size() == 4);
        UNIT_ASSERT(v[0] == 4);
        UNIT_ASSERT(v[1] == 9);
        UNIT_ASSERT(v[2] == 16);
        UNIT_ASSERT(v[3] == 25);
 
        v.erase(v.begin() + 1, v.end() - 1); // Erase all but first and last.
 
        UNIT_ASSERT(v.size() == 2);
        UNIT_ASSERT(v[0] == 4);
        UNIT_ASSERT(v[1] == 25);
    }
 
    void Test7() {
        int array1[] = {1, 4, 25};
        int array2[] = {9, 16};
 
        TVector<int> v(array1, array1 + 3);
        TVector<int>::iterator vit;
        vit = v.insert(v.begin(), 0); // Insert before first element.
        UNIT_ASSERT(*vit == 0);
 
        vit = v.insert(v.end(), 36); // Insert after last element.
        UNIT_ASSERT(*vit == 36);
 
        UNIT_ASSERT(v.size() == 5);
        UNIT_ASSERT(v[0] == 0);
        UNIT_ASSERT(v[1] == 1);
        UNIT_ASSERT(v[2] == 4);
        UNIT_ASSERT(v[3] == 25);
        UNIT_ASSERT(v[4] == 36);
 
        // Insert contents of array2 before fourth element.
        v.insert(v.begin() + 3, array2, array2 + 2);
 
        UNIT_ASSERT(v.size() == 7);
 
        UNIT_ASSERT(v[0] == 0);
        UNIT_ASSERT(v[1] == 1);
        UNIT_ASSERT(v[2] == 4);
        UNIT_ASSERT(v[3] == 9);
        UNIT_ASSERT(v[4] == 16);
        UNIT_ASSERT(v[5] == 25);
        UNIT_ASSERT(v[6] == 36);
 
        size_t curCapacity = v.capacity();
        v.clear();
        UNIT_ASSERT(v.empty());
 
        //check that clear save reserved data
        UNIT_ASSERT_EQUAL(curCapacity, v.capacity());

        v.insert(v.begin(), 5, 10);
        UNIT_ASSERT(v.size() == 5);
        UNIT_ASSERT(v[0] == 10);
        UNIT_ASSERT(v[1] == 10);
        UNIT_ASSERT(v[2] == 10);
        UNIT_ASSERT(v[3] == 10);
        UNIT_ASSERT(v[4] == 10);
    }
 
    struct TestStruct {
        unsigned int a[3];
    };
 
    void TestCapacity() {
        {
            TVector<int> v;
 
            UNIT_ASSERT(v.capacity() == 0);
            v.push_back(42);
            UNIT_ASSERT(v.capacity() >= 1);
            v.reserve(5000);
            UNIT_ASSERT(v.capacity() >= 5000);
        }
 
        {
            TVector<int> v(Reserve(100));

            UNIT_ASSERT(v.capacity() >= 100);
            UNIT_ASSERT(v.size() == 0);
        }

        {
            //Test that used to generate an assertion when using __debug_alloc.
            TVector<TestStruct> va;
            va.reserve(1);
            va.reserve(2);
        } 
    }
 
    void TestAt() {
        TVector<int> v;
        TVector<int> const& cv = v;
 
        v.push_back(10);
        UNIT_ASSERT(v.at(0) == 10);
        v.at(0) = 20;
        UNIT_ASSERT(cv.at(0) == 20);
 
        for (;;) {
            try {
                v.at(1) = 20;
                UNIT_ASSERT(false);
            } catch (std::out_of_range const&) {
                return;
            } catch (...) {
                UNIT_ASSERT(false);
            } 
        } 
    }
 
    void TestPointer() {
        TVector<int*> v1;
        TVector<int*> v2 = v1;
        TVector<int*> v3;
 
        v3.insert(v3.end(), v1.begin(), v1.end());
    }

    void TestAutoRef() {
        TVector<int> ref;
        for (int i = 0; i < 5; ++i) {
            ref.push_back(i);
        } 
 
        TVector<TVector<int>> v_v_int(1, ref);
        v_v_int.push_back(v_v_int[0]);
        v_v_int.push_back(ref);
        v_v_int.push_back(v_v_int[0]);
        v_v_int.push_back(v_v_int[0]);
        v_v_int.push_back(ref);
 
        TVector<TVector<int>>::iterator vvit(v_v_int.begin()), vvitEnd(v_v_int.end());
        for (; vvit != vvitEnd; ++vvit) {
            UNIT_ASSERT(*vvit == ref);
        } 
    }
 
    struct Point {
        int x, y;
    };
 
    struct PointEx: public Point {
        PointEx()
            : builtFromBase(false)
        {
        }
        PointEx(const Point&)
            : builtFromBase(true)
        {
        }
 
        bool builtFromBase;
    };
 
    void TestIterators() {
        TVector<int> vint(10, 0);
        TVector<int> const& crvint = vint;
 
        UNIT_ASSERT(vint.begin() == vint.begin());
        UNIT_ASSERT(crvint.begin() == vint.begin());
        UNIT_ASSERT(vint.begin() == crvint.begin());
        UNIT_ASSERT(crvint.begin() == crvint.begin());
 
        UNIT_ASSERT(vint.begin() != vint.end());
        UNIT_ASSERT(crvint.begin() != vint.end());
        UNIT_ASSERT(vint.begin() != crvint.end());
        UNIT_ASSERT(crvint.begin() != crvint.end());
 
        UNIT_ASSERT(vint.rbegin() == vint.rbegin());
        // Not Standard:
        //UNIT_ASSERT(vint.rbegin() == crvint.rbegin());
        //UNIT_ASSERT(crvint.rbegin() == vint.rbegin());
        UNIT_ASSERT(crvint.rbegin() == crvint.rbegin());
 
        UNIT_ASSERT(vint.rbegin() != vint.rend());
        // Not Standard:
        //UNIT_ASSERT(vint.rbegin() != crvint.rend());
        //UNIT_ASSERT(crvint.rbegin() != vint.rend());
        UNIT_ASSERT(crvint.rbegin() != crvint.rend());
    }
 
    void TestShrink() {
        TVector<int> v;
        v.resize(1000);
        v.resize(10);
        v.shrink_to_fit();
        UNIT_ASSERT_EQUAL(v.capacity(), 10);
        v.push_back(0);
        v.shrink_to_fit();
        UNIT_ASSERT_EQUAL(v.capacity(), 11);
    }

    /* This test check a potential issue with empty base class
         * optimization. Some compilers (VC6) do not implement it 
         * correctly resulting ina wrong behavior. */ 
    void TestEbo() {
        // We use heap memory as test failure can corrupt vector internal
        // representation making executable crash on vector destructor invocation.
        // We prefer a simple memory leak, internal corruption should be reveal
        // by size or capacity checks.
        using V = TVector<int>;
        V* pv1 = new V(1, 1);
        V* pv2 = new V(10, 2);
 
        size_t v1Capacity = pv1->capacity();
        size_t v2Capacity = pv2->capacity();
 
        pv1->swap(*pv2);
 
        UNIT_ASSERT(pv1->size() == 10);
        UNIT_ASSERT(pv1->capacity() == v2Capacity);
        UNIT_ASSERT((*pv1)[5] == 2);
 
        UNIT_ASSERT(pv2->size() == 1);
        UNIT_ASSERT(pv2->capacity() == v1Capacity);
        UNIT_ASSERT((*pv2)[0] == 1);
 
        delete pv2;
        delete pv1;
    }
 
    void TestFillInConstructor() {
        for (int k = 0; k < 3; ++k) {
            TVector<int> v(100);
            UNIT_ASSERT_VALUES_EQUAL(100u, v.size());
            for (size_t i = 0; i < v.size(); ++i) {
                UNIT_ASSERT_VALUES_EQUAL(0, v[i]);
            } 
            // fill with garbage for the next iteration
            for (size_t i = 0; i < v.size(); ++i) {
                v[i] = 10;
            }
        } 
    }

    struct TPod {
        int x;

        operator int() {
            return x;
        }
    };

    struct TNonPod {
        int x;
        TNonPod() {
            x = 0;
        }

        operator int() {
            return x;
        }
    };

    template <typename T>
    class TDebugAlloc: public std::allocator<T> {
    public:
        using TBase = std::allocator<T>;

        T* allocate(typename TBase::size_type n) {
            auto p = TBase::allocate(n);
            for (size_t i = 0; i < n; ++i) {
                memset(p + i, 0xab, sizeof(T));
            }
            return p;
        }

        template <class TOther>
        struct rebind {
            using other = TDebugAlloc<TOther>;
        };
    };

    template <typename T>
    void TestYResize() {
#ifdef _YNDX_LIBCXX_ENABLE_VECTOR_POD_RESIZE_UNINITIALIZED
        constexpr bool ALLOW_UNINITIALIZED = std::is_pod_v<T>;
#else
        constexpr bool ALLOW_UNINITIALIZED = false;
#endif

        TVector<T, TDebugAlloc<T>> v;

        v.reserve(5);
        auto firstBegin = v.begin();

        v.yresize(5); // No realloc, no initialization if allowed
        UNIT_ASSERT(firstBegin == v.begin());
        for (int i = 0; i < 5; ++i) {
            UNIT_ASSERT_VALUES_EQUAL(bool(v[i]), ALLOW_UNINITIALIZED);
        }

        v.yresize(20); // Realloc, still no initialization
        UNIT_ASSERT(firstBegin != v.begin());
        for (int i = 0; i < 20; ++i) {
            UNIT_ASSERT_VALUES_EQUAL(bool(v[i]), ALLOW_UNINITIALIZED);
        }
    }

    struct TNoDefaultConstructor {
        TNoDefaultConstructor() = delete;
        explicit TNoDefaultConstructor(int val)
            : Val(val)
        {
        }

        int Val;
    };

    void TestCrop() {
        TVector<TNoDefaultConstructor> vec;
        vec.emplace_back(42);
        vec.emplace_back(1337);
        vec.emplace_back(8888);
        vec.crop(1); // Should not require default constructor
        UNIT_ASSERT(vec.size() == 1);
        UNIT_ASSERT(vec[0].Val == 42);
        vec.crop(50); // Does nothing if new size is greater than the current size()
        UNIT_ASSERT(vec.size() == 1);
        UNIT_ASSERT(vec[0].Val == 42);
    }

    void TestYResize() {
        TestYResize<int>();
        TestYResize<TPod>();
        TestYResize<TNonPod>();
    }

    void CheckInitializeList(const TVector<int>& v) {
        for (size_t i = 0; i < v.size(); ++i) {
            UNIT_ASSERT_EQUAL(v[i], static_cast<int>(i));
        }
    }

    void TestInitializeList() {
        {
            TVector<int> v;
            v.assign({0, 1, 2});
            CheckInitializeList(v);
        }
        {
            TVector<int> v = {0, 1, 2};
            CheckInitializeList(v);
        }
        {
            TVector<int> v;
            v = {0, 1, 2};
            CheckInitializeList(v);
        }
        {
            TVector<int> v = {0, 3};
            v.insert(v.begin() + 1, {1, 2});
            CheckInitializeList(v);
        }
    }
}; 
 
UNIT_TEST_SUITE_REGISTRATION(TYVectorTest);