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