test(array): improve lv_array test coverage (#9108)

Signed-off-by: pengyiqiang <pengyiqiang@xiaomi.com>
Co-authored-by: pengyiqiang <pengyiqiang@xiaomi.com>

src/misc/lv_array.c

@@ -128,7 +128,7 @@ lv_result_t lv_array_erase(lv_array_t * array, uint32_t start, uint32_t end)
     uint8_t * start_p = lv_array_at(array, start);
     uint8_t * remaining = start_p + (end - start) * array->element_size;
     uint32_t remaining_size = (array->size - end) * array->element_size;
-    lv_memcpy(start_p, remaining, remaining_size);
+    lv_memmove(start_p, remaining, remaining_size);
     array->size -= (end - start);
     lv_array_shrink(array);
     return LV_RESULT_OK;

tests/src/test_cases/test_array.c

@@ -100,4 +100,172 @@ void test_array_concat(void)
     lv_array_deinit(&b);
 }
 
+void test_array_init_from_buf(void)
+{
+    int32_t buf[4] = { 0 };
+    lv_array_t a;
+    lv_array_init_from_buf(&a, buf, 4, sizeof(int32_t));
+
+    TEST_ASSERT_FALSE(lv_array_resize(&a, 8));
+
+    lv_array_t b;
+    lv_array_init(&b, 4, sizeof(int32_t));
+    lv_array_push_back(&b, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32(4, lv_array_capacity(&a));
+
+    for(int32_t i = 0; i < 4; i++) {
+        lv_array_push_back(&a, &i);
+    }
+
+    /* Test overflow handling, should fail */
+    TEST_ASSERT_EQUAL(LV_RESULT_INVALID, lv_array_push_back(&a, NULL));
+    TEST_ASSERT_EQUAL(LV_RESULT_INVALID, lv_array_concat(&a, &b));
+
+    TEST_ASSERT_EQUAL_UINT32(4, lv_array_size(&a));
+    for(int32_t i = 0; i < 4; i++) {
+        int32_t * v = lv_array_at(&a, i);
+        TEST_ASSERT_EQUAL_INT32(i, *v);
+    }
+
+    TEST_ASSERT_EQUAL_PTR(buf, lv_array_front(&a));
+    TEST_ASSERT_EQUAL_PTR(buf + 3, lv_array_back(&a));
+
+    lv_array_deinit(&a);
+    lv_array_deinit(&b);
+}
+
+void test_array_shrink(void)
+{
+    for(int32_t i = 0; i < 10; i++) {
+        lv_array_push_back(&array, &i);
+    }
+    TEST_ASSERT_EQUAL_UINT32(10, lv_array_size(&array));
+
+    lv_array_resize(&array, 20);
+    TEST_ASSERT_EQUAL_UINT32(20, lv_array_capacity(&array));
+
+    lv_array_shrink(&array);
+    TEST_ASSERT_EQUAL_UINT32(10, lv_array_capacity(&array));
+
+    /* Double shrink should not shrink more */
+    lv_array_shrink(&array);
+    TEST_ASSERT_EQUAL_UINT32(10, lv_array_capacity(&array));
+}
+
+void test_array_remove(void)
+{
+    for(int32_t i = 0; i < 5; i++) {
+        lv_array_push_back(&array, &i);
+    }
+    TEST_ASSERT_EQUAL_UINT32(5, lv_array_size(&array));
+
+    TEST_ASSERT_EQUAL(LV_RESULT_OK, lv_array_remove(&array, 4));
+    TEST_ASSERT_EQUAL_UINT32(4, lv_array_size(&array));
+
+    /* Test remove out of range, should fail */
+    TEST_ASSERT_EQUAL(LV_RESULT_INVALID, lv_array_remove(&array, 4));
+    TEST_ASSERT_EQUAL_UINT32(4, lv_array_size(&array));
+
+    /* remove the last element */
+    TEST_ASSERT_EQUAL(LV_RESULT_OK, lv_array_remove(&array, 3));
+    TEST_ASSERT_EQUAL_UINT32(3, lv_array_size(&array));
+
+    /* remove the first element */
+    TEST_ASSERT_EQUAL(LV_RESULT_OK, lv_array_remove(&array, 0));
+    TEST_ASSERT_EQUAL_UINT32(2, lv_array_size(&array));
+
+    /* verify the content */
+    for(int32_t i = 0; i < 2; i++) {
+        int32_t * v = lv_array_at(&array, i);
+        TEST_ASSERT_EQUAL_INT32(i + 1, *v);
+    }
+}
+
+void test_array_erase(void)
+{
+    /* Test overlapping memory regions */
+    for(int32_t i = 0; i < 5; i++) {
+        lv_array_push_back(&array, &i);
+    }
+
+    TEST_ASSERT_EQUAL(LV_RESULT_OK, lv_array_erase(&array, 0, 1));
+    TEST_ASSERT_EQUAL_UINT32(4, lv_array_size(&array));
+    for(int32_t i = 0; i < 4; i++) {
+        int32_t * v = lv_array_at(&array, i);
+        TEST_ASSERT_EQUAL_INT32(i + 1, *v);
+    }
+
+    for(int32_t i = 0; i < 10; i++) {
+        lv_array_push_back(&array, &i);
+    }
+
+    /* Test erase from the middle */
+    lv_array_clear(&array);
+    for(int32_t i = 0; i < 10; i++) {
+        lv_array_push_back(&array, &i);
+    }
+
+    TEST_ASSERT_EQUAL_UINT32(10, lv_array_size(&array));
+    lv_array_erase(&array, 3, 7);
+    TEST_ASSERT_EQUAL_UINT32(6, lv_array_size(&array));
+    for(int32_t i = 0; i < 6; i++) {
+        int32_t * v = lv_array_at(&array, i);
+        if(i < 3) {
+            TEST_ASSERT_EQUAL_INT32(i, *v);
+        }
+        else {
+            TEST_ASSERT_EQUAL_INT32(i + 4, *v);
+        }
+    }
+
+    /* Test edge cases */
+    lv_array_clear(&array);
+    for(int32_t i = 0; i < 10; i++) {
+        lv_array_push_back(&array, &i);
+    }
+
+    /* end > array->size */
+    TEST_ASSERT_EQUAL(LV_RESULT_OK, lv_array_erase(&array, 3, 15));
+    TEST_ASSERT_EQUAL_UINT32(3, lv_array_size(&array));
+    for(int32_t i = 0; i < 3; i++) {
+        int32_t * v = lv_array_at(&array, i);
+        TEST_ASSERT_EQUAL_INT32(i, *v);
+    }
+
+    /* Reset array */
+    lv_array_clear(&array);
+    for(int32_t i = 0; i < 10; i++) {
+        lv_array_push_back(&array, &i);
+    }
+
+    /* start >= end */
+    TEST_ASSERT_EQUAL(LV_RESULT_INVALID, lv_array_erase(&array, 5, 5));
+    TEST_ASSERT_EQUAL(LV_RESULT_INVALID, lv_array_erase(&array, 7, 6));
+
+    /* end == array->size */
+    TEST_ASSERT_EQUAL(LV_RESULT_OK, lv_array_erase(&array, 5, 10));
+    TEST_ASSERT_EQUAL_UINT32(5, lv_array_size(&array));
+    for(int32_t i = 0; i < 5; i++) {
+        int32_t * v = lv_array_at(&array, i);
+        TEST_ASSERT_EQUAL_INT32(i, *v);
+    }
+}
+
+void test_array_assign(void)
+{
+    for(int32_t i = 0; i < 5; i++) {
+        lv_array_push_back(&array, &i);
+    }
+
+    int32_t v = 100;
+    TEST_ASSERT_EQUAL(LV_RESULT_OK, lv_array_assign(&array, 2, &v));
+
+    int32_t * r = lv_array_at(&array, 2);
+    TEST_ASSERT_EQUAL_INT32(100, *r);
+
+    /* Test out of range, should fail */
+    TEST_ASSERT_EQUAL(LV_RESULT_INVALID, lv_array_assign(&array, 5, &v));
+}
+
 #endif