tbx/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 <cont/deque.h>
#include <gtest/gtest.h>

namespace Tdeque {
    using namespace tbx;


    // 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

    }

}