add testing for push_pack and emplace

Author: evvic

vector/include/vector.hpp

@@ -12,7 +12,7 @@ class vector {
     // TODO: provide allocator felxibility
     vector() {
         // allocate memory in cosntructor
-        reallocate(2); // initial capacity of 2
+        reallocate(4); // initial capacity of 2
     }
 
     ~vector() {
@@ -34,6 +34,59 @@ class vector {
         m_size++;
     }
 
+    /**
+     *  @brief  Add an element to the end of the vector.
+     *  @param  value  The (R-value ref) value to add to the end of the vector.
+     *  @return void.
+     */
+    void push_back(T&& value) {
+        if (m_size >= m_capacity) {
+            reallocate(m_capacity * 2); // double the capacity - TODO: use an allcoater to be dynamic
+        }
+
+        // add element to the end of the vector
+        m_data[m_size] = std2::move(value);
+        m_size++;
+    }
+
+    /**
+     *  @brief  Add an element to the end of the vector.
+     *  @param  args  Arguments to forward to the constructor of T.
+     *  @return T reference.
+     */
+    template <typename... Args> //variadic template
+    T& emplace_back(Args&&... args) {
+        if (m_size >= m_capacity) {
+            reallocate(m_capacity * 2); // double the capacity - TODO: use an allcoater to be dynamic
+        }
+
+        // add element to the end of the vector
+        m_data[m_size] = T(std2::forward<Args>(args)...);
+        return m_data[m_size++];
+    }
+
+    /**
+     *  @brief  Remove the last element from the vector.
+     *  @return void.
+     */
+    void pop_back() {
+        if (m_size > 0) {
+            m_size--;
+            m_data[m_size].~T(); // call destructor explicitly
+        }
+    }
+
+    /**
+     *  @brief  Clear the vector - remove all elements.
+     *  @return void.
+     */
+    void clear() {
+        for (size_t i = 0; i < m_size; ++i) {
+            m_data[i].~T(); // call destructor explicitly
+        }
+        m_size = 0;
+    }
+
     /**
      *  @brief  Get the number of elements in the vector.
      *  @return the number of elements in the vector.
@@ -54,7 +107,7 @@ class vector {
     /**
      *  @brief  Index operator - access element at the given index.
      *  @param  index  The index of the element to access.
-     *  @return the value at the index.
+     *  @return the referecne to the value at the index.
      */
     T& operator[](std::size_t index) {
         return m_data[index];
@@ -77,8 +130,8 @@ class vector {
         T* new_block = new T[new_capacity];
 
         for (std::size_t i = 0; i < m_size; ++i) {
-            // new_block[i] = std2::move(m_data[i]);
-            new_block[i] = m_data[i];
+            new_block[i] = std2::move(m_data[i]);
+            // new_block[i] = m_data[i];
         }
 
         delete[] m_data; // free old memory block

vector/tests/vector_test.cpp

@@ -114,17 +114,99 @@ TEST_F(VectorTest, PushBackAndSize) {
     points.push_back(Point3D());
 
     print_vector(points);
+}
+
+// Test push_back and size
+TEST_F(VectorTest, EmplaceBackAndSize) {
 
+    std2::vector<int> vals;
+    vals.emplace_back(10);
+    vals.emplace_back(20);
+    vals.emplace_back(30);
+    print_vector(vals);
+    EXPECT_EQ(vals.size(), 3);
 
+    std2::vector<Point3D> points;
+
+    points.emplace_back(1.0f, 2.0f, 3.0f);
+    points.emplace_back(1.0f);
+    points.emplace_back();
+
+    print_vector(points);
 }
 
-// Test push_back and size
+// Test [] operator accessing elements
 TEST_F(VectorTest, IndexOperator) {
 
     std2::vector<int> vals;
     vals.push_back(10);
 
+    std::cout << "Replacing element at index 0 from " << 10 << " to " << 20 << std::endl;
+    print_vector(vals);
+
     EXPECT_EQ(vals[0], 10);
+
+    // Update an element
+    vals[0] = 20;
+
+    print_vector(vals);
+
+    EXPECT_EQ(vals[0], 20);
+
+    std2::vector<Point3D> points;
+    
+    // Add a point
+    points.push_back(Point3D(1.0f, 2.0f, 3.0f));
+    std::cout << "Initial vector: ";
+    print_vector(points);
+    
+    // Get reference and modify
+    Point3D& point_ref = points[0];
+    point_ref.x = 10.0f;
+    std::cout << "After modifying through reference: ";
+    print_vector(points);
+    EXPECT_EQ(points[0].x, 10.0f);
+    
+    // Direct assignment through operator[]
+    points[0] = Point3D(20.0f, 20.0f, 20.0f);
+    std::cout << "After direct assignment: ";
+    print_vector(points);
+    EXPECT_EQ(points[0].x, 20.0f);
+    
+    // Test const access
+    const std2::vector<Point3D>& const_points = points;
+    EXPECT_EQ(const_points[0].x, 20.0f);
+    // Following line would not compile (good!):
+    // const_points[0] = Point3D(); // Error: assignment of read-only location
 }
 
+// Test clear
+TEST_F(VectorTest, Clear) {
+
+    std2::vector<int> vals;
+    vals.push_back(10);
+    vals.push_back(10);
+    vals.push_back(10);
+
+    EXPECT_EQ(vals.size(), 3);
+
+    vals.clear();
+
+    EXPECT_EQ(vals.size(), 0);
+}
 
+// Test pop_back
+TEST_F(VectorTest, PopBack) {
+
+    std2::vector<int> vals;
+    vals.push_back(10);
+    vals.push_back(10);
+    vals.push_back(10);
+
+    EXPECT_EQ(vals.size(), 3);
+
+    vals.pop_back();
+    vals.pop_back();
+
+    EXPECT_EQ(vals.size(), 1);
+}