Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : #include "estd/deque.h"
       4             : 
       5             : #include "estd/algorithm.h"
       6             : #include "estd/constructor.h"
       7             : 
       8             : #include <gtest/gtest.h>
       9             : 
      10             : #ifdef __clang__
      11             : #pragma clang diagnostic ignored "-Wunused-private-field"
      12             : #endif
      13             : 
      14             : namespace
      15             : {
      16           1 : void example_construction()
      17             : {
      18             :     // EXAMPLE_START declare
      19             :     // construction of a defaulted estd::declare::deque that stores up to 10 elements
      20           1 :     ::estd::declare::deque<uint8_t, 10> deq1;
      21             : 
      22             :     // construction of deques prefilled with a given number of elements
      23           1 :     ::estd::declare::deque<uint8_t, 10> deq2(8);
      24           1 :     ::estd::declare::deque<uint8_t, 10> deq3(8, 255);
      25             : 
      26             :     // construction of a deque from another deque
      27           1 :     ::estd::declare::deque<uint8_t, 20> deq4(deq3);
      28             : 
      29             :     // function taking an estd::deque parameter
      30           1 :     auto size = [](::estd::deque<uint8_t> const& d) { return d.size(); };
      31           1 :     size(deq4);
      32             :     // EXAMPLE_END declare
      33           1 : }
      34             : 
      35             : using IntDeque = ::estd::deque<int32_t>;
      36             : 
      37             : // EXAMPLE_START iterate
      38           3 : TEST(DequeIterator, Comparable)
      39             : {
      40           1 :     IntDeque::iterator itr;
      41           1 :     IntDeque::iterator itr2(itr);
      42           1 :     ASSERT_TRUE(itr == itr2);
      43           1 :     ASSERT_FALSE(itr != itr2);
      44             : }
      45             : 
      46             : // EXAMPLE_END iterate
      47             : 
      48           1 : void example_capacity()
      49             : {
      50             :     // EXAMPLE_START capacity
      51           1 :     ::estd::declare::deque<uint8_t, 10> deq6;
      52           1 :     deq6.push_back(1);
      53           1 :     deq6.push_back(2);
      54             : 
      55           1 :     assert(deq6.size() == 2);        // returns true if the size of deq6 is 2
      56           1 :     ASSERT_EQ(10U, deq6.max_size()); // returns true if value matches maximum size of deq6
      57             : 
      58           1 :     deq6.clear();
      59           2 :     ASSERT_TRUE(deq6.empty()); // returns true if the deq6 is empty or not
      60             :     // EXAMPLE_END capacity
      61           1 : }
      62             : 
      63             : class Foo
      64             : {
      65             : public:
      66             :     Foo() = default;
      67             : 
      68           1 :     Foo(int x, int y) : x_(x), y_(y) {}
      69             : 
      70             :     Foo(Foo const&)            = delete; // Copy constructor
      71             :     Foo& operator=(Foo const&) = delete; // Copy assignment operator
      72             : 
      73             : private:
      74             :     int x_;
      75             :     int y_;
      76             : };
      77             : 
      78           1 : void example_construct()
      79             : {
      80             :     // EXAMPLE_START modify
      81           1 :     using std::begin;
      82           1 :     using std::end;
      83             : 
      84           1 :     ::estd::declare::deque<uint8_t, 10> deq7;
      85             : 
      86             :     // resize deque from size 0 to size 2, growing two elements with value 255
      87           1 :     deq7.resize(2, 255);
      88             : 
      89           1 :     ::estd::declare::deque<uint8_t, 5> deq8;
      90             : 
      91             :     // assign range to deque
      92           1 :     uint8_t testData[] = {0, 1, 2, 3, 4};
      93           1 :     deq8.assign(begin(testData), end(testData));
      94             : 
      95             :     // pushing beyond the limit will result in a failed assert.
      96           1 :     ::estd::declare::deque<uint8_t, 10> deq9;
      97           1 :     deq9.push_back(1);
      98           1 :     deq9.push_front(0);
      99           1 :     deq9.insert(deq9.cbegin(), 3, 5);
     100           1 :     deq9.insert(deq9.cbegin(), -1);
     101             : 
     102           1 :     deq9.pop_front(); // removes one element in the front()
     103           1 :     deq9.pop_back();  // removes one element in the back()
     104             : 
     105           1 :     deq9.erase(deq9.cbegin());              // erase using position
     106           1 :     deq9.erase(deq9.cbegin(), deq9.cend()); // erase using range of position
     107             : 
     108             :     // instantiation of a deque of a noncopyable non default constructible type
     109           1 :     ::estd::declare::deque<Foo, 10> deq10;
     110           1 :     deq10.emplace_back().construct(13, 17);
     111             :     // EXAMPLE_END modify
     112           1 : }
     113             : 
     114           1 : void example_compare()
     115             : {
     116             :     // EXAMPLE_START compare
     117             :     // create deques and push elements to them
     118           1 :     ::estd::declare::deque<uint8_t, 10> deq11;
     119           1 :     ::estd::declare::deque<uint8_t, 10> deq12;
     120             : 
     121           1 :     deq11.push_back(1);
     122           1 :     deq12.push_back(1);
     123           1 :     deq11.push_back(2);
     124             : 
     125             :     // deques with different sizes are compared below
     126             : 
     127           1 :     ASSERT_NE(deq11, deq12);
     128           1 :     ASSERT_FALSE(deq11 < deq12);
     129             : 
     130           1 :     deq12.push_back(2);
     131             : 
     132             :     // deques with same sizes are compared below
     133           1 :     ASSERT_EQ(deq11, deq12);
     134           1 :     ASSERT_TRUE((deq11 == deq12));
     135           1 :     ASSERT_GE(deq11, deq12);
     136           1 :     ASSERT_TRUE((deq11 >= deq12));
     137           1 :     ASSERT_GE(deq12, deq11);
     138           1 :     ASSERT_TRUE((deq12 >= deq11));
     139           1 :     ASSERT_LE(deq11, deq12);
     140           1 :     ASSERT_TRUE((deq11 <= deq12));
     141           1 :     ASSERT_LE(deq12, deq11);
     142           2 :     ASSERT_TRUE((deq12 <= deq11));
     143             :     // EXAMPLE_END compare
     144           1 : }
     145             : } // namespace
     146             : 
     147           3 : TEST(Deque, run_examples)
     148             : {
     149           1 :     example_construction();
     150           1 :     example_capacity();
     151           1 :     example_construct();
     152           1 :     example_compare();
     153           1 : }