Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : #include "estd/vec.h"
       4             : 
       5             : #include "estd/slice.h"
       6             : 
       7             : #include <gtest/gtest.h>
       8             : 
       9             : #include <cassert>
      10             : 
      11             : namespace
      12             : {
      13           1 : void example_construction()
      14             : {
      15             :     // EXAMPLE_START construction
      16             :     // default constructed - size() = 0, max_size = 8, free() = 8
      17           1 :     ::estd::vec<int, 8> int_vec;
      18             : 
      19             :     // construction of vec prefilled with a given number of elements
      20           1 :     ::estd::vec<uint8_t, 10> byte_vec1(8);      // 8 elements of value 0
      21           1 :     ::estd::vec<uint8_t, 10> byte_vec2(8, 255); // 8 elements of value 255
      22             :     // EXAMPLE_END construction
      23           1 : }
      24             : 
      25           1 : void example_iterate()
      26             : {
      27             :     // EXAMPLE_START iterate
      28             : 
      29           1 :     ::estd::vec<uint8_t, 10> vec5(8);
      30             : 
      31             :     // iterate over all elements, modify them
      32           1 :     uint8_t counter = 0;
      33           1 :     for (auto& x : vec5)
      34             :     {
      35             :         x = counter++;
      36             :     }
      37             : 
      38             :     // iterate over elements in reverse order
      39           1 :     for (auto rev_it = vec5.rbegin(); rev_it != vec5.rend(); ++rev_it)
      40             :     {
      41             :         *rev_it = (*rev_it) * (*rev_it);
      42             :     }
      43             : 
      44             :     // EXAMPLE_END iterate
      45           1 : }
      46             : 
      47             : #if 0
      48             : void example_element_access() // don't run - asserts on purpose!
      49             : {
      50             :     // EXAMPLE_START element_access
      51             :     ::estd::vec<uint8_t, 10> v;
      52             :     v.push_back(1);
      53             :     v.push_back(2);
      54             :     EXPECT_EQ(2, v.size());
      55             :     EXPECT_EQ(8, v.free());
      56             : 
      57             :     v.at(0) = 42; // assign 42 to the first element
      58             :     v[1]    = 43; // assign 43 to the second element
      59             : 
      60             :     // access out of bounds - will fail an assert
      61             :     v.at(2);
      62             :     // access out of bounds - undefined behavior (use operator[] with caution!)
      63             :     v[2];
      64             : 
      65             :     uint8_t* ptr = v.data(); // points to first element
      66             :     EXPECT_EQ(ptr, &v.front());
      67             :     // EXAMPLE_END element_access
      68             : }
      69             : #endif
      70             : 
      71             : #if 0
      72             : void example_modify() // don't run - asserts on purpose!
      73             : {
      74             :     // EXAMPLE_START modify
      75             :     ::estd::vec<int32_t, 10> vec_int;
      76             : 
      77             :     // resize vec from size 0 to size 7, default constructing elements (value 0 for integers)
      78             :     vec_int.resize(7);
      79             : 
      80             :     // assign range to vec
      81             :     uint8_t const testData[] = {0, 1, 2, 3, 4};
      82             :     vec_int.assign(std::begin(testData), std::end(testData));
      83             : 
      84             :     // pushing beyond the limit will result in a failed assert.
      85             :     ::estd::vec<uint8_t, 1> vec_1;
      86             :     vec_1.push_back(0);
      87             :     vec_1.push_back(1); // assert fails!
      88             : 
      89             :     class Foo
      90             :     {
      91             :     public:
      92             :         Foo(int32_t m, int32_t n) : _m(m), _n(n) {}
      93             : 
      94             :         Foo(Foo const&)            = delete;
      95             :         void operator=(Foo const&) = delete;
      96             : 
      97             :         int32_t _m;
      98             :         int32_t _n;
      99             :     };
     100             : 
     101             :     // instantiation of a vec of a noncopyable non default constructible type
     102             :     ::estd::vec<Foo, 10> vec_foo;
     103             :     vec_foo.emplace_back(13, 17);
     104             :     // EXAMPLE_END modify
     105             : }
     106             : #endif
     107             : 
     108             : } // namespace
     109             : 
     110           3 : TEST(Vec, run_examples)
     111             : {
     112           1 :     example_construction();
     113           1 :     example_iterate();
     114           1 : }