Add/fixes unit test

Author: GOB52

test/base64_test.cpp

@@ -0,0 +1,138 @@
+/*
+ * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
+ *
+ * SPDX-License-Identifier: MIT
+ */
+/*
+  UnitTest for compatibility_feature (Arduino API compatibility)
+*/
+#include <gtest/gtest.h>
+#include <M5Utility.hpp>
+
+using m5::utility::delay;
+using m5::utility::delayMicroseconds;
+using m5::utility::micros;
+using m5::utility::millis;
+
+TEST(CompatibilityFeature, MillisIncreasing)
+{
+    // millis() should return increasing values
+    unsigned long t1 = millis();
+    delay(10);
+    unsigned long t2 = millis();
+
+    EXPECT_GT(t2, t1) << "millis() should increase over time";
+}
+
+TEST(CompatibilityFeature, MicrosIncreasing)
+{
+    // micros() should return increasing values
+    unsigned long t1 = micros();
+    delayMicroseconds(100);
+    unsigned long t2 = micros();
+
+    EXPECT_GT(t2, t1) << "micros() should increase over time";
+}
+
+TEST(CompatibilityFeature, MicrosGreaterThanMillis)
+{
+    // micros() should be approximately millis() * 1000
+    unsigned long ms = millis();
+    unsigned long us = micros();
+
+    // Allow some tolerance for execution time between calls
+    // micros should be at least millis * 1000 (minus small tolerance)
+    EXPECT_GE(us + 1000, ms * 1000) << "micros() should be >= millis() * 1000";
+}
+
+TEST(CompatibilityFeature, DelayApproximateTime)
+{
+    // delay() should pause for approximately the specified time
+    const unsigned long delay_ms = 50;
+    const unsigned long tolerance_ms = 20;  // Allow 20ms tolerance
+
+    unsigned long start = millis();
+    delay(delay_ms);
+    unsigned long elapsed = millis() - start;
+
+    EXPECT_GE(elapsed, delay_ms - tolerance_ms)
+        << "delay() should pause for at least " << (delay_ms - tolerance_ms) << "ms";
+    EXPECT_LE(elapsed, delay_ms + tolerance_ms)
+        << "delay() should not pause for more than " << (delay_ms + tolerance_ms) << "ms";
+}
+
+TEST(CompatibilityFeature, DelayMicrosecondsApproximateTime)
+{
+    // delayMicroseconds() should pause for approximately the specified time
+    const unsigned int delay_us   = 5000;   // 5ms in microseconds
+    const unsigned long tolerance_us = 3000;  // Allow 3ms tolerance
+
+    unsigned long start = micros();
+    delayMicroseconds(delay_us);
+    unsigned long elapsed = micros() - start;
+
+    EXPECT_GE(elapsed, delay_us - tolerance_us)
+        << "delayMicroseconds() should pause for at least " << (delay_us - tolerance_us) << "us";
+    EXPECT_LE(elapsed, delay_us + tolerance_us)
+        << "delayMicroseconds() should not pause for more than " << (delay_us + tolerance_us) << "us";
+}
+
+TEST(CompatibilityFeature, DelayZero)
+{
+    // delay(0) should return quickly
+    unsigned long start = millis();
+    delay(0);
+    unsigned long elapsed = millis() - start;
+
+    EXPECT_LE(elapsed, 5U) << "delay(0) should return quickly";
+}
+
+TEST(CompatibilityFeature, DelayMicrosecondsZero)
+{
+    // delayMicroseconds(0) should return quickly
+    unsigned long start = micros();
+    delayMicroseconds(0);
+    unsigned long elapsed = micros() - start;
+
+    EXPECT_LE(elapsed, 1000U) << "delayMicroseconds(0) should return quickly";
+}
+
+TEST(CompatibilityFeature, MultipleDelays)
+{
+    // Multiple delays should accumulate
+    const unsigned long delay_ms = 20;
+    const int count = 3;
+    const unsigned long tolerance_ms = 30;
+
+    unsigned long start = millis();
+    for (int i = 0; i < count; ++i) {
+        delay(delay_ms);
+    }
+    unsigned long elapsed = millis() - start;
+
+    unsigned long expected = delay_ms * count;
+    EXPECT_GE(elapsed, expected - tolerance_ms);
+    EXPECT_LE(elapsed, expected + tolerance_ms);
+}
+
+TEST(CompatibilityFeature, ConsistencyBetweenMillisAndMicros)
+{
+    // The difference between consecutive millis/micros calls should be consistent
+    unsigned long ms1 = millis();
+    unsigned long us1 = micros();
+
+    delay(100);
+
+    unsigned long ms2 = millis();
+    unsigned long us2 = micros();
+
+    unsigned long ms_diff = ms2 - ms1;
+    unsigned long us_diff = us2 - us1;
+
+    // us_diff should be approximately ms_diff * 1000 (with tolerance)
+    unsigned long expected_us = ms_diff * 1000;
+    unsigned long tolerance = 10000;  // 10ms tolerance
+
+    EXPECT_GE(us_diff + tolerance, expected_us);
+    EXPECT_LE(us_diff, expected_us + tolerance);
+}

test/bit_segment_test.cpp

@@ -462,6 +462,247 @@ void cb_iterator_test()
     }
 }
 
+void cb_copy_move_test()
+{
+    SCOPED_TRACE("Copy/Move");
+
+    // Copy constructor
+    {
+        FixedCircularBuffer<int, 4> original = {1, 2, 3};
+        FixedCircularBuffer<int, 4> copied(original);
+
+        EXPECT_EQ(copied.size(), 3U);
+        EXPECT_EQ(copied[0], 1);
+        EXPECT_EQ(copied[1], 2);
+        EXPECT_EQ(copied[2], 3);
+
+        // Verify original unchanged
+        EXPECT_EQ(original.size(), 3U);
+        EXPECT_EQ(original[0], 1);
+    }
+
+    // Move constructor
+    {
+        FixedCircularBuffer<int, 4> original = {4, 5, 6};
+        FixedCircularBuffer<int, 4> moved(std::move(original));
+
+        EXPECT_EQ(moved.size(), 3U);
+        EXPECT_EQ(moved[0], 4);
+        EXPECT_EQ(moved[1], 5);
+        EXPECT_EQ(moved[2], 6);
+    }
+
+    // Copy assignment
+    {
+        FixedCircularBuffer<int, 4> original = {7, 8};
+        FixedCircularBuffer<int, 4> assigned;
+        assigned = original;
+
+        EXPECT_EQ(assigned.size(), 2U);
+        EXPECT_EQ(assigned[0], 7);
+        EXPECT_EQ(assigned[1], 8);
+    }
+
+    // Move assignment
+    {
+        FixedCircularBuffer<int, 4> original = {9, 10};
+        FixedCircularBuffer<int, 4> assigned;
+        assigned = std::move(original);
+
+        EXPECT_EQ(assigned.size(), 2U);
+        EXPECT_EQ(assigned[0], 9);
+        EXPECT_EQ(assigned[1], 10);
+    }
+}
+
+void cb_swap_test()
+{
+    SCOPED_TRACE("Swap");
+
+    // Member swap
+    {
+        FixedCircularBuffer<int, 4> a = {1, 2, 3};
+        FixedCircularBuffer<int, 4> b = {4, 5};
+
+        a.swap(b);
+
+        EXPECT_EQ(a.size(), 2U);
+        EXPECT_EQ(a[0], 4);
+        EXPECT_EQ(a[1], 5);
+
+        EXPECT_EQ(b.size(), 3U);
+        EXPECT_EQ(b[0], 1);
+        EXPECT_EQ(b[1], 2);
+        EXPECT_EQ(b[2], 3);
+    }
+
+    // std::swap specialization
+    {
+        FixedCircularBuffer<int, 4> a = {10, 20};
+        FixedCircularBuffer<int, 4> b = {30, 40, 50};
+
+        std::swap(a, b);
+
+        EXPECT_EQ(a.size(), 3U);
+        EXPECT_EQ(a[0], 30);
+        EXPECT_EQ(a[1], 40);
+        EXPECT_EQ(a[2], 50);
+
+        EXPECT_EQ(b.size(), 2U);
+        EXPECT_EQ(b[0], 10);
+        EXPECT_EQ(b[1], 20);
+    }
+
+    // Swap with empty
+    {
+        FixedCircularBuffer<int, 4> a = {1, 2, 3, 4};
+        FixedCircularBuffer<int, 4> b;
+
+        a.swap(b);
+
+        EXPECT_TRUE(a.empty());
+        EXPECT_TRUE(b.full());
+        EXPECT_EQ(b.size(), 4U);
+    }
+
+    // Self swap
+    {
+        FixedCircularBuffer<int, 4> a = {1, 2, 3};
+        a.swap(a);
+
+        EXPECT_EQ(a.size(), 3U);
+        EXPECT_EQ(a[0], 1);
+        EXPECT_EQ(a[1], 2);
+        EXPECT_EQ(a[2], 3);
+    }
+}
+
+void cb_assign_test()
+{
+    SCOPED_TRACE("Assign");
+
+    // assign with initializer_list
+    {
+        FixedCircularBuffer<int, 4> rb = {1, 2, 3, 4};
+        rb.assign({10, 20});
+
+        EXPECT_EQ(rb.size(), 2U);
+        EXPECT_EQ(rb[0], 10);
+        EXPECT_EQ(rb[1], 20);
+    }
+
+    // assign with count and value (use size_t to avoid template overload)
+    {
+        FixedCircularBuffer<int, 4> rb;
+        rb.assign(size_t(3), 42);
+
+        EXPECT_EQ(rb.size(), 3U);
+        EXPECT_EQ(rb[0], 42);
+        EXPECT_EQ(rb[1], 42);
+        EXPECT_EQ(rb[2], 42);
+    }
+
+    // assign with iterators
+    {
+        std::vector<int> src = {100, 200, 300};
+        FixedCircularBuffer<int, 4> rb;
+        rb.assign(src.begin(), src.end());
+
+        EXPECT_EQ(rb.size(), 3U);
+        EXPECT_EQ(rb[0], 100);
+        EXPECT_EQ(rb[1], 200);
+        EXPECT_EQ(rb[2], 300);
+    }
+}
+
+void cb_dynamic_buffer_test()
+{
+    SCOPED_TRACE("DynamicBuffer");
+
+    // CircularBuffer (dynamic size)
+    {
+        CircularBuffer<int> rb(4);
+
+        EXPECT_TRUE(rb.empty());
+        EXPECT_EQ(rb.capacity(), 4U);
+
+        rb.push_back(1);
+        rb.push_back(2);
+        rb.push_back(3);
+
+        EXPECT_EQ(rb.size(), 3U);
+        EXPECT_EQ(rb[0], 1);
+        EXPECT_EQ(rb[1], 2);
+        EXPECT_EQ(rb[2], 3);
+    }
+
+    // CircularBuffer with assign (full fill)
+    {
+        CircularBuffer<int> rb(4);
+        rb.assign(size_t(4), 99);
+
+        EXPECT_TRUE(rb.full());
+        EXPECT_EQ(rb.size(), 4U);
+        EXPECT_EQ(rb[0], 99);
+        EXPECT_EQ(rb[1], 99);
+        EXPECT_EQ(rb[2], 99);
+        EXPECT_EQ(rb[3], 99);
+    }
+
+    // CircularBuffer with assign (partial fill)
+    {
+        CircularBuffer<int> rb(4);
+        rb.assign(size_t(3), 99);
+
+        EXPECT_EQ(rb.size(), 3U);
+        EXPECT_EQ(rb[0], 99);
+        EXPECT_EQ(rb[1], 99);
+        EXPECT_EQ(rb[2], 99);
+    }
+
+    // CircularBuffer with iterator constructor
+    {
+        std::vector<int> src = {1, 2, 3, 4, 5};
+        CircularBuffer<int> rb(3, src.begin(), src.end());
+
+        EXPECT_TRUE(rb.full());
+        EXPECT_EQ(rb.size(), 3U);
+        EXPECT_EQ(rb[0], 3);  // Last 3 elements
+        EXPECT_EQ(rb[1], 4);
+        EXPECT_EQ(rb[2], 5);
+    }
+
+    // CircularBuffer with initializer_list constructor
+    {
+        CircularBuffer<int> rb(4, {10, 20, 30});
+
+        EXPECT_EQ(rb.size(), 3U);
+        EXPECT_EQ(rb[0], 10);
+        EXPECT_EQ(rb[1], 20);
+        EXPECT_EQ(rb[2], 30);
+    }
+
+    // CircularBuffer swap
+    {
+        CircularBuffer<int> a(4);
+        CircularBuffer<int> b(6);
+
+        a.push_back(1);
+        a.push_back(2);
+        b.push_back(10);
+
+        a.swap(b);
+
+        EXPECT_EQ(a.capacity(), 6U);
+        EXPECT_EQ(a.size(), 1U);
+        EXPECT_EQ(a[0], 10);
+
+        EXPECT_EQ(b.capacity(), 4U);
+        EXPECT_EQ(b.size(), 2U);
+        EXPECT_EQ(b[0], 1);
+    }
+}
+
 }  // namespace
 
 TEST(Utility, CircularBuffer)
@@ -470,4 +711,8 @@ TEST(Utility, CircularBuffer)
     cb_constructor_test();
     cb_read();
     cb_iterator_test();
+    cb_copy_move_test();
+    cb_swap_test();
+    cb_assign_test();
+    cb_dynamic_buffer_test();
 }