utl/test/tests/deque.cpp

/*!
 * \file deque.cpp
 * \brief
 *      Unit tests for deque
 *
 * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net>
 *
 * <dl class=\"section copyright\"><dt>License</dt><dd>
 * The MIT License (MIT)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * </dd></dl>
 *
 */
#include <utl/container/deque.h>
//#include <utl/container/span.h>
#include <gtest/gtest.h>

#include <array>
#include <type_traits>
#include <cstring>
#ifndef WIN_TRHEADS
#include <mutex>
#include <thread>
#else
#include <mingw.thread.h>
#include <mingw.mutex.h>
#endif

namespace Tdeque {
    using namespace utl;

//    template <typename>
//    struct is_span : std::false_type {};
//
//    template <typename T, std::size_t S>
//    struct is_span<tbx::span<T, S>> : std::true_type {};

    template <typename>
    struct is_std_array : std::false_type {};

    template <typename T, std::size_t N>
    struct is_std_array<std::array<T, N>> : std::true_type {};

    template <typename, typename = void>
    struct has_size_and_data : std::false_type {};

    template <typename T>
    struct has_size_and_data<T, std::void_t<decltype(std::declval<T>().size()),
                                            decltype(std::declval<T>().data())>>
        : std::true_type {};

    // Concept
    TEST(Tdeque, concept) {
        using deque_t = deque<int, 8>;

        EXPECT_EQ ( std::is_default_constructible<deque_t>::value, true);
        EXPECT_EQ ( std::is_nothrow_default_constructible<deque_t>::value, true);
        EXPECT_EQ (!std::is_copy_constructible<deque_t>::value, true);
        EXPECT_EQ (!std::is_copy_assignable<deque_t>::value, true);

//        EXPECT_EQ (true, !is_span<deque_t>::value);
        EXPECT_EQ (true, !is_std_array<deque_t>::value);
        EXPECT_EQ (true, !std::is_array<deque_t>::value);
        EXPECT_EQ (true,  has_size_and_data<deque_t>::value);
    }
    // Test construction
    TEST(Tdeque, contruct) {
        deque<int, 8> q1;
        deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8};
        deque<int, 8> q3{1, 2, 3, 4, 5};

        EXPECT_EQ (8UL, q1.capacity());
        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (8UL, q2.capacity());
        EXPECT_EQ (8UL, q2.size());
        EXPECT_EQ (8UL, q3.capacity());
        EXPECT_EQ (5UL, q3.size());
    }

    // simple push-pop functionality
    TEST(Tdeque, push_pop) {
        deque<int, 8> q1;
        deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8};

        q1.push_front(1);
        q1.push_front(2);
        EXPECT_EQ (1, q1.pop_back());
        EXPECT_EQ (2, q1.pop_back());

        q1.push_back(1);
        q1.push_back(2);
        EXPECT_EQ (1, q1.pop_front());
        EXPECT_EQ (2, q1.pop_front());

        q1.push_front(2);
        q1.push_back(3);
        q1.push_front(1);
        q1.push_back(4);

        for (int i=1 ; i<= 4 ; ++i)
            EXPECT_EQ ((int)i, q1.pop_front());
    }

    // front-back
    TEST(Tdeque, front_back) {
        deque<int, 8> q1;
        deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8};

        q1.push_front(2);
        q1.push_front(1);
        q1.push_back(3);
        q1.push_back(4);

        EXPECT_EQ (1, q1.front());
        EXPECT_EQ (4, q1.back());
        EXPECT_EQ (1, q2.front());
        EXPECT_EQ (8, q2.back());
    }

    // capacity
    TEST(Tdeque, capacity) {
        deque<int, 8> q1;
        deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8};

        q1.push_back(1);
        q1.clear();
        EXPECT_EQ (true, q1.empty());
        EXPECT_EQ (true, q2.full());

        EXPECT_EQ (8UL, q1.capacity());
        EXPECT_EQ (8UL, q2.capacity());

        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (8UL, q2.size());

        q1.push_back(2);
        EXPECT_EQ (1UL, q1.size());
        q1.push_front(1);
        EXPECT_EQ (2UL, q1.size());

        q1.pop_back();
        EXPECT_EQ (1UL, q1.size());
        q1.pop_front();
        EXPECT_EQ (0UL, q1.size());
    }

    // push-pop limits
    TEST (Tdeque, push_pop_limits) {
        deque<int, 8> q1;
        deque<int, 8> q2{1, 2, 3, 4, 5, 6, 7, 8};

        EXPECT_EQ (int{}, q1.pop_back());
        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (true, q1.empty());
        EXPECT_EQ (false, q1.full());

        EXPECT_EQ (int{}, q1.pop_front());
        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (true, q1.empty());
        EXPECT_EQ (false, q1.full());

        q2.push_front(0);
        EXPECT_EQ (1, q2.front());
        EXPECT_EQ (8, q2.back());
        EXPECT_EQ (8UL, q2.size());
        EXPECT_EQ (false, q2.empty());
        EXPECT_EQ (true, q2.full());

        q2.push_back(9);
        EXPECT_EQ (1, q2.front());
        EXPECT_EQ (8, q2.back());
        EXPECT_EQ (8UL, q2.size());
        EXPECT_EQ (false, q2.empty());
        EXPECT_EQ (true, q2.full());
    }

    // iterators
    TEST (Tdeque, iterators) {
        deque<int, 8> q1{1, 2, 3, 4, 5, 6, 7, 8};
        int check_it=1;

        EXPECT_EQ (q1.begin().base(), q1.end().base());
        EXPECT_NE (q1.begin().iter(), q1.end().iter());
        EXPECT_EQ (1, *q1.begin());
        EXPECT_EQ (true, (q1.begin() == ++q1.end()));   // loop edge iterators

        for (auto it = q1.begin() ; it != q1.end() ; ++it)
            EXPECT_EQ(*it, check_it++);
        EXPECT_EQ(9, check_it);         // run through all

        EXPECT_EQ (1, q1.front());      // queue stays intact
        EXPECT_EQ (8, q1.back());
        EXPECT_EQ (8UL, q1.size());
        EXPECT_EQ (false, q1.empty());
        EXPECT_EQ (true, q1.full());

        q1.pop_front();
        q1.pop_back();

        check_it=2;
        for (auto& it : q1)
            EXPECT_EQ(it, check_it++);
        EXPECT_EQ(8, check_it);         // run through all

        EXPECT_EQ (2, q1.front());      // queue stays intact
        EXPECT_EQ (7, q1.back());
        EXPECT_EQ (6UL, q1.size());
        EXPECT_EQ (false, q1.empty());
        EXPECT_EQ (false, q1.full());

        deque<int, 8> q2;
        q2.push_front(2);
        q2.push_front(1);
        q2.push_back(3);
        q2.push_back(4);
        q2.push_back(5);
        check_it =1;
        for (auto& it : q2)
            EXPECT_EQ(it, check_it++);
        EXPECT_EQ(6, check_it);         // run through all

    }
    TEST (Tdeque, range) {
        deque<int, 8> q1{1, 2, 3, 4, 5, 6, 7, 8};
        int check_it=1;

        for (auto& it : q1.contents())
            EXPECT_EQ(it, check_it++);

        EXPECT_EQ(9, check_it);         // run through all
    }


    // Concept
    TEST(Tdeque, concept_atomic) {
        using deque_t = deque<int, 8, true>;

//        EXPECT_EQ (true, !is_span<deque_t>::value);
        EXPECT_EQ (true, !is_std_array<deque_t>::value);
        EXPECT_EQ (true, !std::is_array<deque_t>::value);
        EXPECT_EQ (true,  has_size_and_data<deque_t>::value);
    }
    // Test construction
    TEST(Tdeque, contruct_atomic) {
        deque<int, 8, true> q1;
        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};
        deque<int, 8, true> q3{1, 2, 3, 4, 5};

        EXPECT_EQ (8UL, q1.capacity());
        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (8UL, q2.capacity());
        EXPECT_EQ (8UL, q2.size());
        EXPECT_EQ (8UL, q3.capacity());
        EXPECT_EQ (5UL, q3.size());
    }

    // simple push-pop functionality
    TEST(Tdeque, push_pop_atomic) {
        deque<int, 8, true> q1;
        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};

        q1.push_front(1);
        q1.push_front(2);
        EXPECT_EQ (1, q1.pop_back());
        EXPECT_EQ (2, q1.pop_back());

        q1.push_back(1);
        q1.push_back(2);
        EXPECT_EQ (1, q1.pop_front());
        EXPECT_EQ (2, q1.pop_front());

        q1.push_front(2);
        q1.push_back(3);
        q1.push_front(1);
        q1.push_back(4);

        for (int i=1 ; i<= 4 ; ++i)
            EXPECT_EQ ((int)i, q1.pop_front());
    }

    // front-back
    TEST(Tdeque, front_back_atomic) {
        deque<int, 8, true> q1;
        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};

        q1.push_front(2);
        q1.push_front(1);
        q1.push_back(3);
        q1.push_back(4);

        EXPECT_EQ (1, q1.front());
        EXPECT_EQ (4, q1.back());
        EXPECT_EQ (1, q2.front());
        EXPECT_EQ (8, q2.back());
    }

    // capacity
    TEST(Tdeque, capacity_atomic) {
        deque<int, 8, true> q1;
        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};

        q1.push_back(1);
        q1.clear();
        EXPECT_EQ (true, q1.empty());
        EXPECT_EQ (true, q2.full());

        EXPECT_EQ (8UL, q1.capacity());
        EXPECT_EQ (8UL, q2.capacity());

        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (8UL, q2.size());

        q1.push_back(2);
        EXPECT_EQ (1UL, q1.size());
        q1.push_front(1);
        EXPECT_EQ (2UL, q1.size());

        q1.pop_back();
        EXPECT_EQ (1UL, q1.size());
        q1.pop_front();
        EXPECT_EQ (0UL, q1.size());
    }

    // push-pop limits
    TEST (Tdeque, push_pop_limits_atomic) {
        deque<int, 8, true> q1;
        deque<int, 8, true> q2{1, 2, 3, 4, 5, 6, 7, 8};

        EXPECT_EQ (int{}, q1.pop_back());
        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (true, q1.empty());
        EXPECT_EQ (false, q1.full());

        EXPECT_EQ (int{}, q1.pop_front());
        EXPECT_EQ (0UL, q1.size());
        EXPECT_EQ (true, q1.empty());
        EXPECT_EQ (false, q1.full());

        q2.push_front(0);
        EXPECT_EQ (1, q2.front());
        EXPECT_EQ (8, q2.back());
        EXPECT_EQ (8UL, q2.size());
        EXPECT_EQ (false, q2.empty());
        EXPECT_EQ (true, q2.full());

        q2.push_back(9);
        EXPECT_EQ (1, q2.front());
        EXPECT_EQ (8, q2.back());
        EXPECT_EQ (8UL, q2.size());
        EXPECT_EQ (false, q2.empty());
        EXPECT_EQ (true, q2.full());
    }

    // iterators
    TEST (Tdeque, iterators_atomic) {
        deque<int, 8, true> q1{1, 2, 3, 4, 5, 6, 7, 8};
        int check_it=1;

        EXPECT_EQ (q1.begin().base(), q1.end().base());
        EXPECT_NE (q1.begin().iter(), q1.end().iter());
        EXPECT_EQ (1, *q1.begin());
        EXPECT_EQ (true, (q1.begin() == ++q1.end()));   // loop edge iterators

        for (auto it = q1.begin() ; it != q1.end() ; ++it)
            EXPECT_EQ(*it, check_it++);
        EXPECT_EQ(9, check_it);         // run through all

        EXPECT_EQ (1, q1.front());      // queue stays intact
        EXPECT_EQ (8, q1.back());
        EXPECT_EQ (8UL, q1.size());
        EXPECT_EQ (false, q1.empty());
        EXPECT_EQ (true, q1.full());

        q1.pop_front();
        q1.pop_back();

        check_it=2;
        for (auto& it : q1)
            EXPECT_EQ(it, check_it++);
        EXPECT_EQ(8, check_it);         // run through all

        EXPECT_EQ (2, q1.front());      // queue stays intact
        EXPECT_EQ (7, q1.back());
        EXPECT_EQ (6UL, q1.size());
        EXPECT_EQ (false, q1.empty());
        EXPECT_EQ (false, q1.full());

        deque<int, 8, true> q2;
        q2.push_front(2);
        q2.push_front(1);
        q2.push_back(3);
        q2.push_back(4);
        q2.push_back(5);
        check_it =1;
        for (auto& it : q2)
            EXPECT_EQ(it, check_it++);
        EXPECT_EQ(6, check_it);         // run through all

    }
    TEST (Tdeque, range_atomic) {
        deque<int, 8, true> q1{1, 2, 3, 4, 5, 6, 7, 8};
        int check_it=1;

        for (auto& it : q1.contents())
            EXPECT_EQ(it, check_it++);

        EXPECT_EQ(9, check_it);         // run through all
    }

    TEST(Tdeque, race) {
        constexpr size_t N = 1000000;
        deque<int, N, true> q;
        int result[N];

        auto push_front = [&](){
            for (size_t i=1 ; i<=N ; ++i)   q.push_front(i);
        };
        auto push_back = [&](){
            for (size_t i=1 ; i<=N ; ++i)   q.push_back(i);
        };
        auto pop_front = [&](){
            for (size_t i=0 ; i<N ; ) {
                result[i] = q.pop_front();
                if (result[i] != int{})
                    ++i;
            }
        };
        auto pop_back = [&](){
            for (size_t i=0 ; i<N ; ) {
                result[i] = q.pop_back();
                if (result[i] != int{})
                    ++i;
            }
        };

        std::memset(result, 0, sizeof result);
        std::thread th1 (push_front);
        std::thread th2 (pop_back);
        th1.join();
        th2.join();
        for (size_t i=0 ; i<N ; ++i)
            EXPECT_EQ (result[i], (int)i+1);

        std::memset(result, 0, sizeof result);
        std::thread th3 (push_back);
        std::thread th4 (pop_front);
        th3.join();
        th4.join();
        for (size_t i=0 ; i<N ; ++i)
            EXPECT_EQ (result[i], (int)i+1);
    }
}