From c8b24af1b2504ca674728b503294d19451eb7408 Mon Sep 17 00:00:00 2001 From: Jacques Lucke Date: Thu, 23 Jul 2020 15:23:55 +0200 Subject: BLI: move some tests into blenlib/tests Reviewers: sybren Differential Revision: https://developer.blender.org/D8315 --- tests/gtests/blenlib/BLI_array_test.cc | 176 ------ tests/gtests/blenlib/BLI_disjoint_set_test.cc | 36 -- tests/gtests/blenlib/BLI_edgehash_test.cc | 408 -------------- tests/gtests/blenlib/BLI_index_mask_test.cc | 43 -- tests/gtests/blenlib/BLI_index_range_test.cc | 143 ----- tests/gtests/blenlib/BLI_linear_allocator_test.cc | 118 ---- tests/gtests/blenlib/BLI_map_test.cc | 590 -------------------- tests/gtests/blenlib/BLI_math_base_safe_test.cc | 37 -- tests/gtests/blenlib/BLI_memory_utils_test.cc | 159 ------ tests/gtests/blenlib/BLI_set_test.cc | 562 ------------------- tests/gtests/blenlib/BLI_span_test.cc | 298 ---------- tests/gtests/blenlib/BLI_stack_cxx_test.cc | 188 ------- tests/gtests/blenlib/BLI_string_ref_test.cc | 277 ---------- tests/gtests/blenlib/BLI_vector_set_test.cc | 164 ------ tests/gtests/blenlib/BLI_vector_test.cc | 639 ---------------------- tests/gtests/blenlib/CMakeLists.txt | 15 - 16 files changed, 3853 deletions(-) delete mode 100644 tests/gtests/blenlib/BLI_array_test.cc delete mode 100644 tests/gtests/blenlib/BLI_disjoint_set_test.cc delete mode 100644 tests/gtests/blenlib/BLI_edgehash_test.cc delete mode 100644 tests/gtests/blenlib/BLI_index_mask_test.cc delete mode 100644 tests/gtests/blenlib/BLI_index_range_test.cc delete mode 100644 tests/gtests/blenlib/BLI_linear_allocator_test.cc delete mode 100644 tests/gtests/blenlib/BLI_map_test.cc delete mode 100644 tests/gtests/blenlib/BLI_math_base_safe_test.cc delete mode 100644 tests/gtests/blenlib/BLI_memory_utils_test.cc delete mode 100644 tests/gtests/blenlib/BLI_set_test.cc delete mode 100644 tests/gtests/blenlib/BLI_span_test.cc delete mode 100644 tests/gtests/blenlib/BLI_stack_cxx_test.cc delete mode 100644 tests/gtests/blenlib/BLI_string_ref_test.cc delete mode 100644 tests/gtests/blenlib/BLI_vector_set_test.cc delete mode 100644 tests/gtests/blenlib/BLI_vector_test.cc (limited to 'tests/gtests') diff --git a/tests/gtests/blenlib/BLI_array_test.cc b/tests/gtests/blenlib/BLI_array_test.cc deleted file mode 100644 index c01ba26ffd7..00000000000 --- a/tests/gtests/blenlib/BLI_array_test.cc +++ /dev/null @@ -1,176 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_array.hh" -#include "BLI_strict_flags.h" -#include "testing/testing.h" - -namespace blender { - -TEST(array, DefaultConstructor) -{ - Array array; - EXPECT_EQ(array.size(), 0); - EXPECT_TRUE(array.is_empty()); -} - -TEST(array, SizeConstructor) -{ - Array array(5); - EXPECT_EQ(array.size(), 5); - EXPECT_FALSE(array.is_empty()); -} - -TEST(array, FillConstructor) -{ - Array array(5, 8); - EXPECT_EQ(array.size(), 5); - EXPECT_EQ(array[0], 8); - EXPECT_EQ(array[1], 8); - EXPECT_EQ(array[2], 8); - EXPECT_EQ(array[3], 8); - EXPECT_EQ(array[4], 8); -} - -TEST(array, InitializerListConstructor) -{ - Array array = {4, 5, 6, 7}; - EXPECT_EQ(array.size(), 4); - EXPECT_EQ(array[0], 4); - EXPECT_EQ(array[1], 5); - EXPECT_EQ(array[2], 6); - EXPECT_EQ(array[3], 7); -} - -TEST(array, SpanConstructor) -{ - int stackarray[4] = {6, 7, 8, 9}; - Span span(stackarray, ARRAY_SIZE(stackarray)); - Array array(span); - EXPECT_EQ(array.size(), 4); - EXPECT_EQ(array[0], 6); - EXPECT_EQ(array[1], 7); - EXPECT_EQ(array[2], 8); - EXPECT_EQ(array[3], 9); -} - -TEST(array, CopyConstructor) -{ - Array array = {5, 6, 7, 8}; - Array new_array(array); - - EXPECT_EQ(array.size(), 4); - EXPECT_EQ(new_array.size(), 4); - EXPECT_NE(array.data(), new_array.data()); - EXPECT_EQ(new_array[0], 5); - EXPECT_EQ(new_array[1], 6); - EXPECT_EQ(new_array[2], 7); - EXPECT_EQ(new_array[3], 8); -} - -TEST(array, MoveConstructor) -{ - Array array = {5, 6, 7, 8}; - Array new_array(std::move(array)); - - EXPECT_EQ(array.size(), 0); - EXPECT_EQ(new_array.size(), 4); - EXPECT_EQ(new_array[0], 5); - EXPECT_EQ(new_array[1], 6); - EXPECT_EQ(new_array[2], 7); - EXPECT_EQ(new_array[3], 8); -} - -TEST(array, CopyAssignment) -{ - Array array = {1, 2, 3}; - Array new_array = {4}; - EXPECT_EQ(new_array.size(), 1); - new_array = array; - EXPECT_EQ(new_array.size(), 3); - EXPECT_EQ(array.size(), 3); - EXPECT_NE(array.data(), new_array.data()); - EXPECT_EQ(new_array[0], 1); - EXPECT_EQ(new_array[1], 2); - EXPECT_EQ(new_array[2], 3); -} - -TEST(array, MoveAssignment) -{ - Array array = {1, 2, 3}; - Array new_array = {4}; - EXPECT_EQ(new_array.size(), 1); - new_array = std::move(array); - EXPECT_EQ(new_array.size(), 3); - EXPECT_EQ(array.size(), 0); - EXPECT_EQ(new_array[0], 1); - EXPECT_EQ(new_array[1], 2); - EXPECT_EQ(new_array[2], 3); -} - -/** - * Tests that the trivially constructible types are not zero-initialized. We do not want that for - * performance reasons. - */ -TEST(array, TrivialTypeSizeConstructor) -{ - Array *array = new Array(1); - char *ptr = &(*array)[0]; - array->~Array(); - - const char magic = 42; - *ptr = magic; - EXPECT_EQ(*ptr, magic); - - new (array) Array(1); - EXPECT_EQ((*array)[0], magic); - EXPECT_EQ(*ptr, magic); - delete array; -} - -struct ConstructibleType { - char value; - - ConstructibleType() - { - value = 42; - } -}; - -TEST(array, NoInitializationSizeConstructor) -{ - using MyArray = Array; - - TypedBuffer buffer; - memset(buffer, 100, sizeof(MyArray)); - - /* Doing this to avoid some compiler optimization. */ - for (int64_t i : IndexRange(sizeof(MyArray))) { - EXPECT_EQ(((char *)buffer.ptr())[i], 100); - } - - { - MyArray &array = *new (buffer) MyArray(1, NoInitialization()); - EXPECT_EQ(array[0].value, 100); - array.clear_without_destruct(); - array.~Array(); - } - { - MyArray &array = *new (buffer) MyArray(1); - EXPECT_EQ(array[0].value, 42); - array.~Array(); - } -} - -TEST(array, Fill) -{ - Array array(5); - array.fill(3); - EXPECT_EQ(array.size(), 5u); - EXPECT_EQ(array[0], 3); - EXPECT_EQ(array[1], 3); - EXPECT_EQ(array[2], 3); - EXPECT_EQ(array[3], 3); - EXPECT_EQ(array[4], 3); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_disjoint_set_test.cc b/tests/gtests/blenlib/BLI_disjoint_set_test.cc deleted file mode 100644 index 22663b936d9..00000000000 --- a/tests/gtests/blenlib/BLI_disjoint_set_test.cc +++ /dev/null @@ -1,36 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_disjoint_set.hh" -#include "BLI_strict_flags.h" - -#include "testing/testing.h" - -namespace blender { - -TEST(disjoint_set, Test) -{ - DisjointSet disjoint_set(6); - EXPECT_FALSE(disjoint_set.in_same_set(1, 2)); - EXPECT_FALSE(disjoint_set.in_same_set(5, 3)); - EXPECT_TRUE(disjoint_set.in_same_set(2, 2)); - EXPECT_EQ(disjoint_set.find_root(3), 3); - - disjoint_set.join(1, 2); - - EXPECT_TRUE(disjoint_set.in_same_set(1, 2)); - EXPECT_FALSE(disjoint_set.in_same_set(0, 1)); - - disjoint_set.join(3, 4); - - EXPECT_FALSE(disjoint_set.in_same_set(2, 3)); - EXPECT_TRUE(disjoint_set.in_same_set(3, 4)); - - disjoint_set.join(1, 4); - - EXPECT_TRUE(disjoint_set.in_same_set(1, 4)); - EXPECT_TRUE(disjoint_set.in_same_set(1, 3)); - EXPECT_TRUE(disjoint_set.in_same_set(2, 4)); - EXPECT_FALSE(disjoint_set.in_same_set(0, 4)); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_edgehash_test.cc b/tests/gtests/blenlib/BLI_edgehash_test.cc deleted file mode 100644 index 23ad618825b..00000000000 --- a/tests/gtests/blenlib/BLI_edgehash_test.cc +++ /dev/null @@ -1,408 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "testing/testing.h" -#include -#include -#include - -extern "C" { -#include "BLI_edgehash.h" -#include "BLI_utildefines.h" -} - -#define VALUE_1 POINTER_FROM_INT(1) -#define VALUE_2 POINTER_FROM_INT(2) -#define VALUE_3 POINTER_FROM_INT(3) - -TEST(edgehash, InsertIncreasesLength) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - ASSERT_EQ(BLI_edgehash_len(eh), 0); - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, ReinsertNewIncreasesLength) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - ASSERT_EQ(BLI_edgehash_len(eh), 0); - BLI_edgehash_reinsert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, ReinsertExistingDoesNotIncreaseLength) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - ASSERT_EQ(BLI_edgehash_len(eh), 0); - BLI_edgehash_reinsert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - BLI_edgehash_reinsert(eh, 1, 2, VALUE_2); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - BLI_edgehash_reinsert(eh, 2, 1, VALUE_2); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, ReinsertCanChangeValue) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_lookup(eh, 1, 2), VALUE_1); - BLI_edgehash_reinsert(eh, 2, 1, VALUE_2); - ASSERT_EQ(BLI_edgehash_lookup(eh, 1, 2), VALUE_2); - BLI_edgehash_reinsert(eh, 1, 2, VALUE_3); - ASSERT_EQ(BLI_edgehash_lookup(eh, 2, 1), VALUE_3); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, LookupExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_lookup(eh, 1, 2), VALUE_1); - ASSERT_EQ(BLI_edgehash_lookup(eh, 2, 1), VALUE_1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, LookupNonExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - ASSERT_EQ(BLI_edgehash_lookup(eh, 1, 2), nullptr); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, LookupNonExistingWithDefault) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - ASSERT_EQ(BLI_edgehash_lookup_default(eh, 1, 2, VALUE_1), VALUE_1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, LookupExistingWithDefault) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_lookup_default(eh, 1, 2, VALUE_2), VALUE_1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, LookupPExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - void *value = VALUE_1; - BLI_edgehash_insert(eh, 1, 2, value); - void **value_p = BLI_edgehash_lookup_p(eh, 1, 2); - ASSERT_EQ(*value_p, VALUE_1); - *value_p = VALUE_2; - ASSERT_EQ(BLI_edgehash_lookup(eh, 1, 2), VALUE_2); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, LookupPNonExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - ASSERT_EQ(BLI_edgehash_lookup_p(eh, 1, 2), nullptr); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, EnsurePNonExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - void **value_p; - bool existed = BLI_edgehash_ensure_p(eh, 1, 2, &value_p); - ASSERT_FALSE(existed); - *value_p = VALUE_1; - ASSERT_EQ(BLI_edgehash_lookup(eh, 1, 2), VALUE_1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, EnsurePExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - void **value_p; - bool existed = BLI_edgehash_ensure_p(eh, 1, 2, &value_p); - ASSERT_TRUE(existed); - ASSERT_EQ(*value_p, VALUE_1); - *value_p = VALUE_2; - ASSERT_EQ(BLI_edgehash_lookup(eh, 1, 2), VALUE_2); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, RemoveExistingDecreasesLength) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - bool has_been_removed = BLI_edgehash_remove(eh, 1, 2, nullptr); - ASSERT_EQ(BLI_edgehash_len(eh), 0); - ASSERT_TRUE(has_been_removed); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, RemoveNonExistingDoesNotDecreaseLength) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - bool has_been_removed = BLI_edgehash_remove(eh, 4, 5, nullptr); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - ASSERT_FALSE(has_been_removed); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, PopKeyTwice) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_popkey(eh, 1, 2), VALUE_1); - ASSERT_EQ(BLI_edgehash_popkey(eh, 1, 2), nullptr); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, LookupInvertedIndices) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_EQ(BLI_edgehash_lookup(eh, 2, 1), VALUE_1); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, HasKeyExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - ASSERT_TRUE(BLI_edgehash_haskey(eh, 1, 2)); - ASSERT_TRUE(BLI_edgehash_haskey(eh, 2, 1)); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, HasKeyNonExisting) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - ASSERT_FALSE(BLI_edgehash_haskey(eh, 1, 2)); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, ClearSetsLengthToZero) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - BLI_edgehash_insert(eh, 1, 2, VALUE_2); - ASSERT_EQ(BLI_edgehash_len(eh), 2); - BLI_edgehash_clear(eh, nullptr); - ASSERT_EQ(BLI_edgehash_len(eh), 0); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, IteratorFindsAllValues) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - BLI_edgehash_insert(eh, 1, 3, VALUE_2); - BLI_edgehash_insert(eh, 1, 4, VALUE_3); - - EdgeHashIterator *ehi = BLI_edgehashIterator_new(eh); - auto a = BLI_edgehashIterator_getValue(ehi); - BLI_edgehashIterator_step(ehi); - auto b = BLI_edgehashIterator_getValue(ehi); - BLI_edgehashIterator_step(ehi); - auto c = BLI_edgehashIterator_getValue(ehi); - BLI_edgehashIterator_step(ehi); - - ASSERT_NE(a, b); - ASSERT_NE(b, c); - ASSERT_NE(a, c); - ASSERT_TRUE(ELEM(a, VALUE_1, VALUE_2, VALUE_3)); - ASSERT_TRUE(ELEM(b, VALUE_1, VALUE_2, VALUE_3)); - ASSERT_TRUE(ELEM(c, VALUE_1, VALUE_2, VALUE_3)); - - BLI_edgehashIterator_free(ehi); - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, IterateIsDone) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - BLI_edgehash_insert(eh, 1, 3, VALUE_2); - BLI_edgehash_insert(eh, 1, 4, VALUE_3); - - EdgeHashIterator *ehi = BLI_edgehashIterator_new(eh); - ASSERT_FALSE(BLI_edgehashIterator_isDone(ehi)); - BLI_edgehashIterator_step(ehi); - ASSERT_FALSE(BLI_edgehashIterator_isDone(ehi)); - BLI_edgehashIterator_step(ehi); - ASSERT_FALSE(BLI_edgehashIterator_isDone(ehi)); - BLI_edgehashIterator_step(ehi); - ASSERT_TRUE(BLI_edgehashIterator_isDone(ehi)); - - BLI_edgehashIterator_free(ehi); - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgehash, DoubleRemove) -{ - EdgeHash *eh = BLI_edgehash_new(__func__); - - BLI_edgehash_insert(eh, 1, 2, VALUE_1); - BLI_edgehash_insert(eh, 1, 3, VALUE_2); - BLI_edgehash_insert(eh, 1, 4, VALUE_3); - ASSERT_EQ(BLI_edgehash_len(eh), 3); - - BLI_edgehash_remove(eh, 1, 2, nullptr); - BLI_edgehash_remove(eh, 1, 3, nullptr); - ASSERT_EQ(BLI_edgehash_len(eh), 1); - - BLI_edgehash_free(eh, nullptr); -} - -struct Edge { - uint v1, v2; -}; - -TEST(edgehash, StressTest) -{ - std::srand(0); - int amount = 10000; - - std::vector edges; - for (int i = 0; i < amount; i++) { - edges.push_back({(uint)i, amount + (uint)std::rand() % 12345}); - } - - EdgeHash *eh = BLI_edgehash_new(__func__); - - /* first insert all the edges */ - for (int i = 0; i < edges.size(); i++) { - BLI_edgehash_insert(eh, edges[i].v1, edges[i].v2, POINTER_FROM_INT(i)); - } - - std::vector shuffled = edges; - std::shuffle(shuffled.begin(), shuffled.end(), std::default_random_engine()); - - /* then remove half of them */ - int remove_until = shuffled.size() / 2; - for (int i = 0; i < remove_until; i++) { - BLI_edgehash_remove(eh, shuffled[i].v2, shuffled[i].v1, nullptr); - } - - ASSERT_EQ(BLI_edgehash_len(eh), edges.size() - remove_until); - - /* check if the right ones have been removed */ - for (int i = 0; i < shuffled.size(); i++) { - bool haskey = BLI_edgehash_haskey(eh, shuffled[i].v1, shuffled[i].v2); - if (i < remove_until) - ASSERT_FALSE(haskey); - else - ASSERT_TRUE(haskey); - } - - /* reinsert all edges */ - for (int i = 0; i < edges.size(); i++) { - BLI_edgehash_reinsert(eh, edges[i].v1, edges[i].v2, POINTER_FROM_INT(i)); - } - - ASSERT_EQ(BLI_edgehash_len(eh), edges.size()); - - /* pop all edges */ - for (int i = 0; i < edges.size(); i++) { - int value = POINTER_AS_INT(BLI_edgehash_popkey(eh, edges[i].v1, edges[i].v2)); - ASSERT_EQ(i, value); - } - - ASSERT_EQ(BLI_edgehash_len(eh), 0); - - BLI_edgehash_free(eh, nullptr); -} - -TEST(edgeset, AddNonExistingIncreasesLength) -{ - EdgeSet *es = BLI_edgeset_new(__func__); - - ASSERT_EQ(BLI_edgeset_len(es), 0); - BLI_edgeset_add(es, 1, 2); - ASSERT_EQ(BLI_edgeset_len(es), 1); - BLI_edgeset_add(es, 1, 3); - ASSERT_EQ(BLI_edgeset_len(es), 2); - BLI_edgeset_add(es, 1, 4); - ASSERT_EQ(BLI_edgeset_len(es), 3); - - BLI_edgeset_free(es); -} - -TEST(edgeset, AddExistingDoesNotIncreaseLength) -{ - EdgeSet *es = BLI_edgeset_new(__func__); - - ASSERT_EQ(BLI_edgeset_len(es), 0); - BLI_edgeset_add(es, 1, 2); - ASSERT_EQ(BLI_edgeset_len(es), 1); - BLI_edgeset_add(es, 2, 1); - ASSERT_EQ(BLI_edgeset_len(es), 1); - BLI_edgeset_add(es, 1, 2); - ASSERT_EQ(BLI_edgeset_len(es), 1); - - BLI_edgeset_free(es); -} - -TEST(edgeset, HasKeyNonExisting) -{ - EdgeSet *es = BLI_edgeset_new(__func__); - - ASSERT_FALSE(BLI_edgeset_haskey(es, 1, 2)); - - BLI_edgeset_free(es); -} - -TEST(edgeset, HasKeyExisting) -{ - EdgeSet *es = BLI_edgeset_new(__func__); - - BLI_edgeset_insert(es, 1, 2); - ASSERT_TRUE(BLI_edgeset_haskey(es, 1, 2)); - - BLI_edgeset_free(es); -} diff --git a/tests/gtests/blenlib/BLI_index_mask_test.cc b/tests/gtests/blenlib/BLI_index_mask_test.cc deleted file mode 100644 index bce467cadd9..00000000000 --- a/tests/gtests/blenlib/BLI_index_mask_test.cc +++ /dev/null @@ -1,43 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_index_mask.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(index_mask, DefaultConstructor) -{ - IndexMask mask; - EXPECT_EQ(mask.min_array_size(), 0); - EXPECT_EQ(mask.size(), 0); -} - -TEST(index_mask, ArrayConstructor) -{ - [](IndexMask mask) { - EXPECT_EQ(mask.size(), 4); - EXPECT_EQ(mask.min_array_size(), 8); - EXPECT_FALSE(mask.is_range()); - EXPECT_EQ(mask[0], 3); - EXPECT_EQ(mask[1], 5); - EXPECT_EQ(mask[2], 6); - EXPECT_EQ(mask[3], 7); - }({3, 5, 6, 7}); -} - -TEST(index_mask, RangeConstructor) -{ - IndexMask mask = IndexRange(3, 5); - EXPECT_EQ(mask.size(), 5); - EXPECT_EQ(mask.min_array_size(), 8); - EXPECT_EQ(mask.last(), 7); - EXPECT_TRUE(mask.is_range()); - EXPECT_EQ(mask.as_range().first(), 3); - EXPECT_EQ(mask.as_range().last(), 7); - Span indices = mask.indices(); - EXPECT_EQ(indices[0], 3); - EXPECT_EQ(indices[1], 4); - EXPECT_EQ(indices[2], 5); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_index_range_test.cc b/tests/gtests/blenlib/BLI_index_range_test.cc deleted file mode 100644 index 1c4d4a1a1f3..00000000000 --- a/tests/gtests/blenlib/BLI_index_range_test.cc +++ /dev/null @@ -1,143 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_index_range.hh" -#include "BLI_strict_flags.h" -#include "BLI_vector.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(index_range, DefaultConstructor) -{ - IndexRange range; - EXPECT_EQ(range.size(), 0); - - Vector vector; - for (int64_t value : range) { - vector.append(value); - } - EXPECT_EQ(vector.size(), 0); -} - -TEST(index_range, SingleElementRange) -{ - IndexRange range(4, 1); - EXPECT_EQ(range.size(), 1); - EXPECT_EQ(*range.begin(), 4); - - Vector vector; - for (int64_t value : range) { - vector.append(value); - } - - EXPECT_EQ(vector.size(), 1); - EXPECT_EQ(vector[0], 4); -} - -TEST(index_range, MultipleElementRange) -{ - IndexRange range(6, 4); - EXPECT_EQ(range.size(), 4); - - Vector vector; - for (int64_t value : range) { - vector.append(value); - } - - EXPECT_EQ(vector.size(), 4); - for (int i = 0; i < 4; i++) { - EXPECT_EQ(vector[i], i + 6); - } -} - -TEST(index_range, SubscriptOperator) -{ - IndexRange range(5, 5); - EXPECT_EQ(range[0], 5); - EXPECT_EQ(range[1], 6); - EXPECT_EQ(range[2], 7); -} - -TEST(index_range, Before) -{ - IndexRange range = IndexRange(5, 5).before(3); - EXPECT_EQ(range[0], 2); - EXPECT_EQ(range[1], 3); - EXPECT_EQ(range[2], 4); - EXPECT_EQ(range.size(), 3); -} - -TEST(index_range, After) -{ - IndexRange range = IndexRange(5, 5).after(4); - EXPECT_EQ(range[0], 10); - EXPECT_EQ(range[1], 11); - EXPECT_EQ(range[2], 12); - EXPECT_EQ(range[3], 13); - EXPECT_EQ(range.size(), 4); -} - -TEST(index_range, Contains) -{ - IndexRange range = IndexRange(5, 3); - EXPECT_TRUE(range.contains(5)); - EXPECT_TRUE(range.contains(6)); - EXPECT_TRUE(range.contains(7)); - EXPECT_FALSE(range.contains(4)); - EXPECT_FALSE(range.contains(8)); -} - -TEST(index_range, First) -{ - IndexRange range = IndexRange(5, 3); - EXPECT_EQ(range.first(), 5); -} - -TEST(index_range, Last) -{ - IndexRange range = IndexRange(5, 3); - EXPECT_EQ(range.last(), 7); -} - -TEST(index_range, OneAfterEnd) -{ - IndexRange range = IndexRange(5, 3); - EXPECT_EQ(range.one_after_last(), 8); -} - -TEST(index_range, Start) -{ - IndexRange range = IndexRange(6, 2); - EXPECT_EQ(range.start(), 6); -} - -TEST(index_range, Slice) -{ - IndexRange range = IndexRange(5, 15); - IndexRange slice = range.slice(2, 6); - EXPECT_EQ(slice.size(), 6); - EXPECT_EQ(slice.first(), 7); - EXPECT_EQ(slice.last(), 12); -} - -TEST(index_range, SliceRange) -{ - IndexRange range = IndexRange(5, 15); - IndexRange slice = range.slice(IndexRange(3, 5)); - EXPECT_EQ(slice.size(), 5); - EXPECT_EQ(slice.first(), 8); - EXPECT_EQ(slice.last(), 12); -} - -TEST(index_range, AsSpan) -{ - IndexRange range = IndexRange(4, 6); - Span span = range.as_span(); - EXPECT_EQ(span.size(), 6); - EXPECT_EQ(span[0], 4); - EXPECT_EQ(span[1], 5); - EXPECT_EQ(span[2], 6); - EXPECT_EQ(span[3], 7); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_linear_allocator_test.cc b/tests/gtests/blenlib/BLI_linear_allocator_test.cc deleted file mode 100644 index 9c2dcdc7457..00000000000 --- a/tests/gtests/blenlib/BLI_linear_allocator_test.cc +++ /dev/null @@ -1,118 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_linear_allocator.hh" -#include "BLI_strict_flags.h" -#include "testing/testing.h" - -namespace blender { - -static bool is_aligned(void *ptr, uint alignment) -{ - BLI_assert(is_power_of_2_i((int)alignment)); - return (POINTER_AS_UINT(ptr) & (alignment - 1)) == 0; -} - -TEST(linear_allocator, AllocationAlignment) -{ - LinearAllocator<> allocator; - - EXPECT_TRUE(is_aligned(allocator.allocate(10, 4), 4)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 4), 4)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 4), 4)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 8), 8)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 4), 4)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 16), 16)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 4), 4)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 64), 64)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 64), 64)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 8), 8)); - EXPECT_TRUE(is_aligned(allocator.allocate(10, 128), 128)); -} - -TEST(linear_allocator, PackedAllocation) -{ - LinearAllocator<> allocator; - blender::AlignedBuffer<256, 32> buffer; - allocator.provide_buffer(buffer); - - uintptr_t ptr1 = (uintptr_t)allocator.allocate(10, 4); /* 0 - 10 */ - uintptr_t ptr2 = (uintptr_t)allocator.allocate(10, 4); /* 12 - 22 */ - uintptr_t ptr3 = (uintptr_t)allocator.allocate(8, 32); /* 32 - 40 */ - uintptr_t ptr4 = (uintptr_t)allocator.allocate(16, 8); /* 40 - 56 */ - uintptr_t ptr5 = (uintptr_t)allocator.allocate(1, 8); /* 56 - 57 */ - uintptr_t ptr6 = (uintptr_t)allocator.allocate(1, 4); /* 60 - 61 */ - uintptr_t ptr7 = (uintptr_t)allocator.allocate(1, 1); /* 61 - 62 */ - - EXPECT_EQ(ptr2 - ptr1, 12); /* 12 - 0 = 12 */ - EXPECT_EQ(ptr3 - ptr2, 20); /* 32 - 12 = 20 */ - EXPECT_EQ(ptr4 - ptr3, 8); /* 40 - 32 = 8 */ - EXPECT_EQ(ptr5 - ptr4, 16); /* 56 - 40 = 16 */ - EXPECT_EQ(ptr6 - ptr5, 4); /* 60 - 56 = 4 */ - EXPECT_EQ(ptr7 - ptr6, 1); /* 61 - 60 = 1 */ -} - -TEST(linear_allocator, CopyString) -{ - LinearAllocator<> allocator; - blender::AlignedBuffer<256, 1> buffer; - allocator.provide_buffer(buffer); - - StringRefNull ref1 = allocator.copy_string("Hello"); - StringRefNull ref2 = allocator.copy_string("World"); - - EXPECT_EQ(ref1, "Hello"); - EXPECT_EQ(ref2, "World"); - EXPECT_EQ(ref2.data() - ref1.data(), 6); -} - -TEST(linear_allocator, AllocateArray) -{ - LinearAllocator<> allocator; - - MutableSpan span = allocator.allocate_array(5); - EXPECT_EQ(span.size(), 5); -} - -TEST(linear_allocator, Construct) -{ - LinearAllocator<> allocator; - - std::array values = {1, 2, 3, 4, 5}; - Vector *vector = allocator.construct>(values); - EXPECT_EQ(vector->size(), 5); - EXPECT_EQ((*vector)[3], 4); - vector->~Vector(); -} - -TEST(linear_allocator, ConstructElementsAndPointerArray) -{ - LinearAllocator<> allocator; - - std::array values = {1, 2, 3, 4, 5, 6, 7}; - Span *> vectors = allocator.construct_elements_and_pointer_array>( - 5, values); - - EXPECT_EQ(vectors.size(), 5); - EXPECT_EQ(vectors[3]->size(), 7); - EXPECT_EQ((*vectors[2])[5], 6); - - for (Vector *vector : vectors) { - vector->~Vector(); - } -} - -TEST(linear_allocator, ConstructArrayCopy) -{ - LinearAllocator<> allocator; - - Vector values = {1, 2, 3}; - MutableSpan span1 = allocator.construct_array_copy(values.as_span()); - MutableSpan span2 = allocator.construct_array_copy(values.as_span()); - EXPECT_NE(span1.data(), span2.data()); - EXPECT_EQ(span1.size(), 3); - EXPECT_EQ(span2.size(), 3); - EXPECT_EQ(span1[1], 2); - EXPECT_EQ(span2[2], 3); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_map_test.cc b/tests/gtests/blenlib/BLI_map_test.cc deleted file mode 100644 index cebce218112..00000000000 --- a/tests/gtests/blenlib/BLI_map_test.cc +++ /dev/null @@ -1,590 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_map.hh" -#include "BLI_rand.h" -#include "BLI_set.hh" -#include "BLI_strict_flags.h" -#include "BLI_timeit.hh" -#include "BLI_vector.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(map, DefaultConstructor) -{ - Map map; - EXPECT_EQ(map.size(), 0); - EXPECT_TRUE(map.is_empty()); -} - -TEST(map, AddIncreasesSize) -{ - Map map; - EXPECT_EQ(map.size(), 0); - EXPECT_TRUE(map.is_empty()); - map.add(2, 5.0f); - EXPECT_EQ(map.size(), 1); - EXPECT_FALSE(map.is_empty()); - map.add(6, 2.0f); - EXPECT_EQ(map.size(), 2); - EXPECT_FALSE(map.is_empty()); -} - -TEST(map, Contains) -{ - Map map; - EXPECT_FALSE(map.contains(4)); - map.add(5, 6.0f); - EXPECT_FALSE(map.contains(4)); - map.add(4, 2.0f); - EXPECT_TRUE(map.contains(4)); -} - -TEST(map, LookupExisting) -{ - Map map; - map.add(2, 6.0f); - map.add(4, 1.0f); - EXPECT_EQ(map.lookup(2), 6.0f); - EXPECT_EQ(map.lookup(4), 1.0f); -} - -TEST(map, LookupNotExisting) -{ - Map map; - map.add(2, 4.0f); - map.add(1, 1.0f); - EXPECT_EQ(map.lookup_ptr(0), nullptr); - EXPECT_EQ(map.lookup_ptr(5), nullptr); -} - -TEST(map, AddMany) -{ - Map map; - for (int i = 0; i < 100; i++) { - map.add(i * 30, i); - map.add(i * 31, i); - } -} - -TEST(map, PopItem) -{ - Map map; - map.add(2, 3.0f); - map.add(1, 9.0f); - EXPECT_TRUE(map.contains(2)); - EXPECT_TRUE(map.contains(1)); - - EXPECT_EQ(map.pop(1), 9.0f); - EXPECT_TRUE(map.contains(2)); - EXPECT_FALSE(map.contains(1)); - - EXPECT_EQ(map.pop(2), 3.0f); - EXPECT_FALSE(map.contains(2)); - EXPECT_FALSE(map.contains(1)); -} - -TEST(map, PopTry) -{ - Map map; - map.add(1, 5); - map.add(2, 7); - EXPECT_EQ(map.size(), 2); - std::optional value = map.pop_try(4); - EXPECT_EQ(map.size(), 2); - EXPECT_FALSE(value.has_value()); - value = map.pop_try(2); - EXPECT_EQ(map.size(), 1); - EXPECT_TRUE(value.has_value()); - EXPECT_EQ(*value, 7); - EXPECT_EQ(*map.pop_try(1), 5); - EXPECT_EQ(map.size(), 0); -} - -TEST(map, PopDefault) -{ - Map map; - map.add(1, 4); - map.add(2, 7); - map.add(3, 8); - EXPECT_EQ(map.size(), 3); - EXPECT_EQ(map.pop_default(4, 10), 10); - EXPECT_EQ(map.size(), 3); - EXPECT_EQ(map.pop_default(1, 10), 4); - EXPECT_EQ(map.size(), 2); - EXPECT_EQ(map.pop_default(2, 20), 7); - EXPECT_EQ(map.size(), 1); - EXPECT_EQ(map.pop_default(2, 20), 20); - EXPECT_EQ(map.size(), 1); - EXPECT_EQ(map.pop_default(3, 0), 8); - EXPECT_EQ(map.size(), 0); -} - -TEST(map, PopItemMany) -{ - Map map; - for (int i = 0; i < 100; i++) { - map.add_new(i, i); - } - for (int i = 25; i < 80; i++) { - EXPECT_EQ(map.pop(i), i); - } - for (int i = 0; i < 100; i++) { - EXPECT_EQ(map.contains(i), i < 25 || i >= 80); - } -} - -TEST(map, ValueIterator) -{ - Map map; - map.add(3, 5.0f); - map.add(1, 2.0f); - map.add(7, -2.0f); - - blender::Set values; - - int iterations = 0; - for (float value : map.values()) { - values.add(value); - iterations++; - } - - EXPECT_EQ(iterations, 3); - EXPECT_TRUE(values.contains(5.0f)); - EXPECT_TRUE(values.contains(-2.0f)); - EXPECT_TRUE(values.contains(2.0f)); -} - -TEST(map, KeyIterator) -{ - Map map; - map.add(6, 3.0f); - map.add(2, 4.0f); - map.add(1, 3.0f); - - blender::Set keys; - - int iterations = 0; - for (int key : map.keys()) { - keys.add(key); - iterations++; - } - - EXPECT_EQ(iterations, 3); - EXPECT_TRUE(keys.contains(1)); - EXPECT_TRUE(keys.contains(2)); - EXPECT_TRUE(keys.contains(6)); -} - -TEST(map, ItemIterator) -{ - Map map; - map.add(5, 3.0f); - map.add(2, 9.0f); - map.add(1, 0.0f); - - blender::Set keys; - blender::Set values; - - int iterations = 0; - const Map &const_map = map; - for (auto item : const_map.items()) { - keys.add(item.key); - values.add(item.value); - iterations++; - } - - EXPECT_EQ(iterations, 3); - EXPECT_TRUE(keys.contains(5)); - EXPECT_TRUE(keys.contains(2)); - EXPECT_TRUE(keys.contains(1)); - EXPECT_TRUE(values.contains(3.0f)); - EXPECT_TRUE(values.contains(9.0f)); - EXPECT_TRUE(values.contains(0.0f)); -} - -TEST(map, MutableValueIterator) -{ - Map map; - map.add(3, 6); - map.add(2, 1); - - for (int &value : map.values()) { - value += 10; - } - - EXPECT_EQ(map.lookup(3), 16); - EXPECT_EQ(map.lookup(2), 11); -} - -TEST(map, MutableItemIterator) -{ - Map map; - map.add(3, 6); - map.add(2, 1); - - for (auto item : map.items()) { - item.value += item.key; - } - - EXPECT_EQ(map.lookup(3), 9.0f); - EXPECT_EQ(map.lookup(2), 3.0f); -} - -TEST(map, MutableItemToItemConversion) -{ - Map map; - map.add(3, 6); - map.add(2, 1); - - Vector keys, values; - for (Map::Item item : map.items()) { - keys.append(item.key); - values.append(item.value); - } - - EXPECT_EQ(keys.size(), 2); - EXPECT_EQ(values.size(), 2); - EXPECT_TRUE(keys.contains(3)); - EXPECT_TRUE(keys.contains(2)); - EXPECT_TRUE(values.contains(6)); - EXPECT_TRUE(values.contains(1)); -} - -static float return_42() -{ - return 42.0f; -} - -TEST(map, LookupOrAddCB_SeparateFunction) -{ - Map map; - EXPECT_EQ(map.lookup_or_add_cb(0, return_42), 42.0f); - EXPECT_EQ(map.lookup(0), 42); - - map.keys(); -} - -TEST(map, LookupOrAddCB_Lambdas) -{ - Map map; - auto lambda1 = []() { return 11.0f; }; - EXPECT_EQ(map.lookup_or_add_cb(0, lambda1), 11.0f); - auto lambda2 = []() { return 20.0f; }; - EXPECT_EQ(map.lookup_or_add_cb(1, lambda2), 20.0f); - - EXPECT_EQ(map.lookup_or_add_cb(0, lambda2), 11.0f); - EXPECT_EQ(map.lookup_or_add_cb(1, lambda1), 20.0f); -} - -TEST(map, AddOrModify) -{ - Map map; - auto create_func = [](float *value) { - *value = 10.0f; - return true; - }; - auto modify_func = [](float *value) { - *value += 5; - return false; - }; - EXPECT_TRUE(map.add_or_modify(1, create_func, modify_func)); - EXPECT_EQ(map.lookup(1), 10.0f); - EXPECT_FALSE(map.add_or_modify(1, create_func, modify_func)); - EXPECT_EQ(map.lookup(1), 15.0f); -} - -TEST(map, AddOverwrite) -{ - Map map; - EXPECT_FALSE(map.contains(3)); - EXPECT_TRUE(map.add_overwrite(3, 6.0f)); - EXPECT_EQ(map.lookup(3), 6.0f); - EXPECT_FALSE(map.add_overwrite(3, 7.0f)); - EXPECT_EQ(map.lookup(3), 7.0f); - EXPECT_FALSE(map.add(3, 8.0f)); - EXPECT_EQ(map.lookup(3), 7.0f); -} - -TEST(map, LookupOrAddDefault) -{ - Map map; - map.lookup_or_add_default(3) = 6; - EXPECT_EQ(map.lookup(3), 6); - map.lookup_or_add_default(5) = 2; - EXPECT_EQ(map.lookup(5), 2); - map.lookup_or_add_default(3) += 4; - EXPECT_EQ(map.lookup(3), 10); -} - -TEST(map, LookupOrAdd) -{ - Map map; - EXPECT_EQ(map.lookup_or_add(6, 4), 4); - EXPECT_EQ(map.lookup_or_add(6, 5), 4); - map.lookup_or_add(6, 4) += 10; - EXPECT_EQ(map.lookup(6), 14); -} - -TEST(map, MoveConstructorSmall) -{ - Map map1; - map1.add(1, 2.0f); - map1.add(4, 1.0f); - Map map2(std::move(map1)); - EXPECT_EQ(map2.size(), 2); - EXPECT_EQ(map2.lookup(1), 2.0f); - EXPECT_EQ(map2.lookup(4), 1.0f); - EXPECT_EQ(map1.size(), 0); - EXPECT_EQ(map1.lookup_ptr(4), nullptr); -} - -TEST(map, MoveConstructorLarge) -{ - Map map1; - for (int i = 0; i < 100; i++) { - map1.add_new(i, i); - } - Map map2(std::move(map1)); - EXPECT_EQ(map2.size(), 100); - EXPECT_EQ(map2.lookup(1), 1); - EXPECT_EQ(map2.lookup(4), 4); - EXPECT_EQ(map1.size(), 0); - EXPECT_EQ(map1.lookup_ptr(4), nullptr); -} - -TEST(map, MoveAssignment) -{ - Map map1; - map1.add(1, 2.0f); - map1.add(4, 1.0f); - Map map2; - map2 = std::move(map1); - EXPECT_EQ(map2.size(), 2); - EXPECT_EQ(map2.lookup(1), 2.0f); - EXPECT_EQ(map2.lookup(4), 1.0f); - EXPECT_EQ(map1.size(), 0); - EXPECT_EQ(map1.lookup_ptr(4), nullptr); -} - -TEST(map, CopyAssignment) -{ - Map map1; - map1.add(1, 2.0f); - map1.add(4, 1.0f); - Map map2; - map2 = map1; - EXPECT_EQ(map2.size(), 2); - EXPECT_EQ(map2.lookup(1), 2.0f); - EXPECT_EQ(map2.lookup(4), 1.0f); - EXPECT_EQ(map1.size(), 2); - EXPECT_EQ(*map1.lookup_ptr(4), 1.0f); -} - -TEST(map, Clear) -{ - Map map; - map.add(1, 1.0f); - map.add(2, 5.0f); - - EXPECT_EQ(map.size(), 2); - EXPECT_TRUE(map.contains(1)); - EXPECT_TRUE(map.contains(2)); - - map.clear(); - - EXPECT_EQ(map.size(), 0); - EXPECT_FALSE(map.contains(1)); - EXPECT_FALSE(map.contains(2)); -} - -TEST(map, UniquePtrValue) -{ - auto value1 = std::unique_ptr(new int()); - auto value2 = std::unique_ptr(new int()); - auto value3 = std::unique_ptr(new int()); - - int *value1_ptr = value1.get(); - - Map> map; - map.add_new(1, std::move(value1)); - map.add(2, std::move(value2)); - map.add_overwrite(3, std::move(value3)); - map.lookup_or_add_cb(4, []() { return std::unique_ptr(new int()); }); - map.add_new(5, std::unique_ptr(new int())); - map.add(6, std::unique_ptr(new int())); - map.add_overwrite(7, std::unique_ptr(new int())); - map.lookup_or_add(8, std::unique_ptr(new int())); - map.pop_default(9, std::unique_ptr(new int())); - - EXPECT_EQ(map.lookup(1).get(), value1_ptr); - EXPECT_EQ(map.lookup_ptr(100), nullptr); -} - -TEST(map, Remove) -{ - Map map; - map.add(2, 4); - EXPECT_EQ(map.size(), 1); - EXPECT_FALSE(map.remove(3)); - EXPECT_EQ(map.size(), 1); - EXPECT_TRUE(map.remove(2)); - EXPECT_EQ(map.size(), 0); -} - -TEST(map, PointerKeys) -{ - char a, b, c, d; - - Map map; - EXPECT_TRUE(map.add(&a, 5)); - EXPECT_FALSE(map.add(&a, 4)); - map.add_new(&b, 1); - map.add_new(&c, 1); - EXPECT_EQ(map.size(), 3); - EXPECT_TRUE(map.remove(&b)); - EXPECT_TRUE(map.add(&b, 8)); - EXPECT_FALSE(map.remove(&d)); - EXPECT_TRUE(map.remove(&a)); - EXPECT_TRUE(map.remove(&b)); - EXPECT_TRUE(map.remove(&c)); - EXPECT_TRUE(map.is_empty()); -} - -TEST(map, ConstKeysAndValues) -{ - Map map; - map.reserve(10); - map.add("45", "643"); - EXPECT_TRUE(map.contains("45")); - EXPECT_FALSE(map.contains("54")); -} - -TEST(map, ForeachItem) -{ - Map map; - map.add(3, 4); - map.add(1, 8); - - Vector keys; - Vector values; - map.foreach_item([&](int key, int value) { - keys.append(key); - values.append(value); - }); - - EXPECT_EQ(keys.size(), 2); - EXPECT_EQ(values.size(), 2); - EXPECT_EQ(keys.first_index_of(3), values.first_index_of(4)); - EXPECT_EQ(keys.first_index_of(1), values.first_index_of(8)); -} - -/** - * Set this to 1 to activate the benchmark. It is disabled by default, because it prints a lot. - */ -#if 0 -template -BLI_NOINLINE void benchmark_random_ints(StringRef name, int amount, int factor) -{ - RNG *rng = BLI_rng_new(0); - Vector values; - for (int i = 0; i < amount; i++) { - values.append(BLI_rng_get_int(rng) * factor); - } - BLI_rng_free(rng); - - MapT map; - { - SCOPED_TIMER(name + " Add"); - for (int value : values) { - map.add(value, value); - } - } - int count = 0; - { - SCOPED_TIMER(name + " Contains"); - for (int value : values) { - count += map.contains(value); - } - } - { - SCOPED_TIMER(name + " Remove"); - for (int value : values) { - count += map.remove(value); - } - } - - /* Print the value for simple error checking and to avoid some compiler optimizations. */ - std::cout << "Count: " << count << "\n"; -} - -TEST(map, Benchmark) -{ - for (int i = 0; i < 3; i++) { - benchmark_random_ints>("blender::Map ", 1000000, 1); - benchmark_random_ints>("std::unordered_map", 1000000, 1); - } - std::cout << "\n"; - for (int i = 0; i < 3; i++) { - uint32_t factor = (3 << 10); - benchmark_random_ints>("blender::Map ", 1000000, factor); - benchmark_random_ints>( - "std::unordered_map", 1000000, factor); - } -} - -/** - * Timer 'blender::Map Add' took 61.7616 ms - * Timer 'blender::Map Contains' took 18.4989 ms - * Timer 'blender::Map Remove' took 20.5864 ms - * Count: 1999755 - * Timer 'std::unordered_map Add' took 188.674 ms - * Timer 'std::unordered_map Contains' took 44.3741 ms - * Timer 'std::unordered_map Remove' took 169.52 ms - * Count: 1999755 - * Timer 'blender::Map Add' took 37.9196 ms - * Timer 'blender::Map Contains' took 16.7361 ms - * Timer 'blender::Map Remove' took 20.9568 ms - * Count: 1999755 - * Timer 'std::unordered_map Add' took 166.09 ms - * Timer 'std::unordered_map Contains' took 40.6133 ms - * Timer 'std::unordered_map Remove' took 142.85 ms - * Count: 1999755 - * Timer 'blender::Map Add' took 37.3053 ms - * Timer 'blender::Map Contains' took 16.6731 ms - * Timer 'blender::Map Remove' took 18.8304 ms - * Count: 1999755 - * Timer 'std::unordered_map Add' took 170.964 ms - * Timer 'std::unordered_map Contains' took 38.1824 ms - * Timer 'std::unordered_map Remove' took 140.263 ms - * Count: 1999755 - * - * Timer 'blender::Map Add' took 50.1131 ms - * Timer 'blender::Map Contains' took 25.0491 ms - * Timer 'blender::Map Remove' took 32.4225 ms - * Count: 1889920 - * Timer 'std::unordered_map Add' took 150.129 ms - * Timer 'std::unordered_map Contains' took 34.6999 ms - * Timer 'std::unordered_map Remove' took 120.907 ms - * Count: 1889920 - * Timer 'blender::Map Add' took 50.4438 ms - * Timer 'blender::Map Contains' took 25.2677 ms - * Timer 'blender::Map Remove' took 32.3047 ms - * Count: 1889920 - * Timer 'std::unordered_map Add' took 144.015 ms - * Timer 'std::unordered_map Contains' took 36.3387 ms - * Timer 'std::unordered_map Remove' took 119.109 ms - * Count: 1889920 - * Timer 'blender::Map Add' took 48.6995 ms - * Timer 'blender::Map Contains' took 25.1846 ms - * Timer 'blender::Map Remove' took 33.0283 ms - * Count: 1889920 - * Timer 'std::unordered_map Add' took 143.494 ms - * Timer 'std::unordered_map Contains' took 34.8905 ms - * Timer 'std::unordered_map Remove' took 122.739 ms - * Count: 1889920 - */ - -#endif /* Benchmark */ - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_math_base_safe_test.cc b/tests/gtests/blenlib/BLI_math_base_safe_test.cc deleted file mode 100644 index 2e3e083cf92..00000000000 --- a/tests/gtests/blenlib/BLI_math_base_safe_test.cc +++ /dev/null @@ -1,37 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "testing/testing.h" - -#include "BLI_math_base_safe.h" - -TEST(math_base, SafePowf) -{ - EXPECT_FLOAT_EQ(safe_powf(4.0f, 3.0f), 64.0f); - EXPECT_FLOAT_EQ(safe_powf(3.2f, 5.6f), 674.2793796f); - EXPECT_FLOAT_EQ(safe_powf(4.0f, -2.0f), 0.0625f); - EXPECT_FLOAT_EQ(safe_powf(6.0f, -3.2f), 0.003235311f); - EXPECT_FLOAT_EQ(safe_powf(-4.0f, 6), 4096.0f); - EXPECT_FLOAT_EQ(safe_powf(-3.0f, 5.5), 0.0f); - EXPECT_FLOAT_EQ(safe_powf(-2.5f, -4.0f), 0.0256f); - EXPECT_FLOAT_EQ(safe_powf(-3.7f, -4.5f), 0.0f); -} - -TEST(math_base, SafeModf) -{ - EXPECT_FLOAT_EQ(safe_modf(3.4, 2.2f), 1.2f); - EXPECT_FLOAT_EQ(safe_modf(3.4, -2.2f), 1.2f); - EXPECT_FLOAT_EQ(safe_modf(-3.4, -2.2f), -1.2f); - EXPECT_FLOAT_EQ(safe_modf(-3.4, 0.0f), 0.0f); - EXPECT_FLOAT_EQ(safe_modf(0.0f, 3.0f), 0.0f); - EXPECT_FLOAT_EQ(safe_modf(55.0f, 10.0f), 5.0f); -} - -TEST(math_base, SafeLogf) -{ - EXPECT_FLOAT_EQ(safe_logf(3.3f, 2.5f), 1.302995247f); - EXPECT_FLOAT_EQ(safe_logf(0.0f, 3.0f), 0.0f); - EXPECT_FLOAT_EQ(safe_logf(3.0f, 0.0f), 0.0f); - EXPECT_FLOAT_EQ(safe_logf(-2.0f, 4.3f), 0.0f); - EXPECT_FLOAT_EQ(safe_logf(2.0f, -4.3f), 0.0f); - EXPECT_FLOAT_EQ(safe_logf(-2.0f, -4.3f), 0.0f); -} diff --git a/tests/gtests/blenlib/BLI_memory_utils_test.cc b/tests/gtests/blenlib/BLI_memory_utils_test.cc deleted file mode 100644 index b99db5c5eca..00000000000 --- a/tests/gtests/blenlib/BLI_memory_utils_test.cc +++ /dev/null @@ -1,159 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_float3.hh" -#include "BLI_memory_utils.hh" -#include "BLI_strict_flags.h" -#include "testing/testing.h" - -namespace blender { - -struct MyValue { - static inline int alive = 0; - - MyValue() - { - if (alive == 15) { - throw std::exception(); - } - - alive++; - } - - MyValue(const MyValue &other) - { - if (alive == 15) { - throw std::exception(); - } - - alive++; - } - - ~MyValue() - { - alive--; - } -}; - -TEST(memory_utils, DefaultConstructN_ActuallyCallsConstructor) -{ - constexpr int amount = 10; - TypedBuffer buffer; - - EXPECT_EQ(MyValue::alive, 0); - default_construct_n(buffer.ptr(), amount); - EXPECT_EQ(MyValue::alive, amount); - destruct_n(buffer.ptr(), amount); - EXPECT_EQ(MyValue::alive, 0); -} - -TEST(memory_utils, DefaultConstructN_StrongExceptionSafety) -{ - constexpr int amount = 20; - TypedBuffer buffer; - - EXPECT_EQ(MyValue::alive, 0); - EXPECT_THROW(default_construct_n(buffer.ptr(), amount), std::exception); - EXPECT_EQ(MyValue::alive, 0); -} - -TEST(memory_utils, UninitializedCopyN_ActuallyCopies) -{ - constexpr int amount = 5; - TypedBuffer buffer1; - TypedBuffer buffer2; - - EXPECT_EQ(MyValue::alive, 0); - default_construct_n(buffer1.ptr(), amount); - EXPECT_EQ(MyValue::alive, amount); - uninitialized_copy_n(buffer1.ptr(), amount, buffer2.ptr()); - EXPECT_EQ(MyValue::alive, 2 * amount); - destruct_n(buffer1.ptr(), amount); - EXPECT_EQ(MyValue::alive, amount); - destruct_n(buffer2.ptr(), amount); - EXPECT_EQ(MyValue::alive, 0); -} - -TEST(memory_utils, UninitializedCopyN_StrongExceptionSafety) -{ - constexpr int amount = 10; - TypedBuffer buffer1; - TypedBuffer buffer2; - - EXPECT_EQ(MyValue::alive, 0); - default_construct_n(buffer1.ptr(), amount); - EXPECT_EQ(MyValue::alive, amount); - EXPECT_THROW(uninitialized_copy_n(buffer1.ptr(), amount, buffer2.ptr()), std::exception); - EXPECT_EQ(MyValue::alive, amount); - destruct_n(buffer1.ptr(), amount); - EXPECT_EQ(MyValue::alive, 0); -} - -TEST(memory_utils, UninitializedFillN_ActuallyCopies) -{ - constexpr int amount = 10; - TypedBuffer buffer; - - EXPECT_EQ(MyValue::alive, 0); - { - MyValue value; - EXPECT_EQ(MyValue::alive, 1); - uninitialized_fill_n(buffer.ptr(), amount, value); - EXPECT_EQ(MyValue::alive, 1 + amount); - destruct_n(buffer.ptr(), amount); - EXPECT_EQ(MyValue::alive, 1); - } - EXPECT_EQ(MyValue::alive, 0); -} - -TEST(memory_utils, UninitializedFillN_StrongExceptionSafety) -{ - constexpr int amount = 20; - TypedBuffer buffer; - - EXPECT_EQ(MyValue::alive, 0); - { - MyValue value; - EXPECT_EQ(MyValue::alive, 1); - EXPECT_THROW(uninitialized_fill_n(buffer.ptr(), amount, value), std::exception); - EXPECT_EQ(MyValue::alive, 1); - } - EXPECT_EQ(MyValue::alive, 0); -} - -class TestBaseClass { - virtual void mymethod(){}; -}; - -class TestChildClass : public TestBaseClass { - void mymethod() override - { - } -}; - -static_assert(is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(!is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); -static_assert(is_convertible_pointer_v); - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_set_test.cc b/tests/gtests/blenlib/BLI_set_test.cc deleted file mode 100644 index fcd958dc2f1..00000000000 --- a/tests/gtests/blenlib/BLI_set_test.cc +++ /dev/null @@ -1,562 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include -#include - -#include "BLI_ghash.h" -#include "BLI_rand.h" -#include "BLI_set.hh" -#include "BLI_strict_flags.h" -#include "BLI_timeit.hh" -#include "BLI_vector.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(set, DefaultConstructor) -{ - Set set; - EXPECT_EQ(set.size(), 0); - EXPECT_TRUE(set.is_empty()); -} - -TEST(set, ContainsNotExistant) -{ - Set set; - EXPECT_FALSE(set.contains(3)); -} - -TEST(set, ContainsExistant) -{ - Set set; - EXPECT_FALSE(set.contains(5)); - EXPECT_TRUE(set.is_empty()); - set.add(5); - EXPECT_TRUE(set.contains(5)); - EXPECT_FALSE(set.is_empty()); -} - -TEST(set, AddMany) -{ - Set set; - for (int i = 0; i < 100; i++) { - set.add(i); - } - - for (int i = 50; i < 100; i++) { - EXPECT_TRUE(set.contains(i)); - } - for (int i = 100; i < 150; i++) { - EXPECT_FALSE(set.contains(i)); - } -} - -TEST(set, InitializerListConstructor) -{ - Set set = {4, 5, 6}; - EXPECT_EQ(set.size(), 3); - EXPECT_TRUE(set.contains(4)); - EXPECT_TRUE(set.contains(5)); - EXPECT_TRUE(set.contains(6)); - EXPECT_FALSE(set.contains(2)); - EXPECT_FALSE(set.contains(3)); -} - -TEST(set, CopyConstructor) -{ - Set set = {3}; - EXPECT_TRUE(set.contains(3)); - EXPECT_FALSE(set.contains(4)); - - Set set2(set); - set2.add(4); - EXPECT_TRUE(set2.contains(3)); - EXPECT_TRUE(set2.contains(4)); - - EXPECT_FALSE(set.contains(4)); -} - -TEST(set, MoveConstructor) -{ - Set set = {1, 2, 3}; - EXPECT_EQ(set.size(), 3); - Set set2(std::move(set)); - EXPECT_EQ(set.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(set, CopyAssignment) -{ - Set set = {3}; - EXPECT_TRUE(set.contains(3)); - EXPECT_FALSE(set.contains(4)); - - Set set2; - set2 = set; - set2.add(4); - EXPECT_TRUE(set2.contains(3)); - EXPECT_TRUE(set2.contains(4)); - - EXPECT_FALSE(set.contains(4)); -} - -TEST(set, MoveAssignment) -{ - Set set = {1, 2, 3}; - EXPECT_EQ(set.size(), 3); - Set set2; - set2 = std::move(set); - EXPECT_EQ(set.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(set, RemoveContained) -{ - Set set = {3, 4, 5}; - EXPECT_TRUE(set.contains(3)); - EXPECT_TRUE(set.contains(4)); - EXPECT_TRUE(set.contains(5)); - set.remove_contained(4); - EXPECT_TRUE(set.contains(3)); - EXPECT_FALSE(set.contains(4)); - EXPECT_TRUE(set.contains(5)); - set.remove_contained(3); - EXPECT_FALSE(set.contains(3)); - EXPECT_FALSE(set.contains(4)); - EXPECT_TRUE(set.contains(5)); - set.remove_contained(5); - EXPECT_FALSE(set.contains(3)); - EXPECT_FALSE(set.contains(4)); - EXPECT_FALSE(set.contains(5)); -} - -TEST(set, RemoveContainedMany) -{ - Set set; - for (int i = 0; i < 1000; i++) { - set.add(i); - } - for (int i = 100; i < 1000; i++) { - set.remove_contained(i); - } - for (int i = 900; i < 1000; i++) { - set.add(i); - } - - for (int i = 0; i < 1000; i++) { - if (i < 100 || i >= 900) { - EXPECT_TRUE(set.contains(i)); - } - else { - EXPECT_FALSE(set.contains(i)); - } - } -} - -TEST(set, Intersects) -{ - Set a = {3, 4, 5, 6}; - Set b = {1, 2, 5}; - EXPECT_TRUE(Set::Intersects(a, b)); - EXPECT_FALSE(Set::Disjoint(a, b)); -} - -TEST(set, Disjoint) -{ - Set a = {5, 6, 7, 8}; - Set b = {2, 3, 4, 9}; - EXPECT_FALSE(Set::Intersects(a, b)); - EXPECT_TRUE(Set::Disjoint(a, b)); -} - -TEST(set, AddMultiple) -{ - Set a; - a.add_multiple({5, 7}); - EXPECT_TRUE(a.contains(5)); - EXPECT_TRUE(a.contains(7)); - EXPECT_FALSE(a.contains(4)); - a.add_multiple({2, 4, 7}); - EXPECT_TRUE(a.contains(4)); - EXPECT_TRUE(a.contains(2)); - EXPECT_EQ(a.size(), 4); -} - -TEST(set, AddMultipleNew) -{ - Set a; - a.add_multiple_new({5, 6}); - EXPECT_TRUE(a.contains(5)); - EXPECT_TRUE(a.contains(6)); -} - -TEST(set, Iterator) -{ - Set set = {1, 3, 2, 5, 4}; - blender::Vector vec; - for (int value : set) { - vec.append(value); - } - EXPECT_EQ(vec.size(), 5); - EXPECT_TRUE(vec.contains(1)); - EXPECT_TRUE(vec.contains(3)); - EXPECT_TRUE(vec.contains(2)); - EXPECT_TRUE(vec.contains(5)); - EXPECT_TRUE(vec.contains(4)); -} - -TEST(set, OftenAddRemoveContained) -{ - Set set; - for (int i = 0; i < 100; i++) { - set.add(42); - EXPECT_EQ(set.size(), 1); - set.remove_contained(42); - EXPECT_EQ(set.size(), 0); - } -} - -TEST(set, UniquePtrValues) -{ - Set> set; - set.add_new(std::unique_ptr(new int())); - auto value1 = std::unique_ptr(new int()); - set.add_new(std::move(value1)); - set.add(std::unique_ptr(new int())); - - EXPECT_EQ(set.size(), 3); -} - -TEST(set, Clear) -{ - Set set = {3, 4, 6, 7}; - EXPECT_EQ(set.size(), 4); - set.clear(); - EXPECT_EQ(set.size(), 0); -} - -TEST(set, StringSet) -{ - Set set; - set.add("hello"); - set.add("world"); - EXPECT_EQ(set.size(), 2); - EXPECT_TRUE(set.contains("hello")); - EXPECT_TRUE(set.contains("world")); - EXPECT_FALSE(set.contains("world2")); -} - -TEST(set, PointerSet) -{ - int a, b, c; - Set set; - set.add(&a); - set.add(&b); - EXPECT_EQ(set.size(), 2); - EXPECT_TRUE(set.contains(&a)); - EXPECT_TRUE(set.contains(&b)); - EXPECT_FALSE(set.contains(&c)); -} - -TEST(set, Remove) -{ - Set set = {1, 2, 3, 4, 5, 6}; - EXPECT_EQ(set.size(), 6); - EXPECT_TRUE(set.remove(2)); - EXPECT_EQ(set.size(), 5); - EXPECT_FALSE(set.contains(2)); - EXPECT_FALSE(set.remove(2)); - EXPECT_EQ(set.size(), 5); - EXPECT_TRUE(set.remove(5)); - EXPECT_EQ(set.size(), 4); -} - -struct Type1 { - uint32_t value; -}; - -struct Type2 { - uint32_t value; -}; - -bool operator==(const Type1 &a, const Type1 &b) -{ - return a.value == b.value; -} -bool operator==(const Type1 &a, const Type2 &b) -{ - return a.value == b.value; -} -bool operator==(const Type2 &a, const Type1 &b) -{ - return a.value == b.value; -} - -template<> struct DefaultHash { - uint32_t operator()(const Type1 &value) const - { - return value.value; - } - - uint32_t operator()(const Type2 &value) const - { - return value.value; - } -}; - -TEST(set, ContainsAs) -{ - Set set; - set.add(Type1{5}); - EXPECT_TRUE(set.contains_as(Type1{5})); - EXPECT_TRUE(set.contains_as(Type2{5})); - EXPECT_FALSE(set.contains_as(Type1{6})); - EXPECT_FALSE(set.contains_as(Type2{6})); -} - -TEST(set, ContainsAsString) -{ - Set set; - set.add("test"); - EXPECT_TRUE(set.contains_as("test")); - EXPECT_TRUE(set.contains_as(StringRef("test"))); - EXPECT_FALSE(set.contains_as("string")); - EXPECT_FALSE(set.contains_as(StringRef("string"))); -} - -TEST(set, RemoveContainedAs) -{ - Set set; - set.add(Type1{5}); - EXPECT_TRUE(set.contains_as(Type2{5})); - set.remove_contained_as(Type2{5}); - EXPECT_FALSE(set.contains_as(Type2{5})); -} - -TEST(set, RemoveAs) -{ - Set set; - set.add(Type1{5}); - EXPECT_TRUE(set.contains_as(Type2{5})); - set.remove_as(Type2{6}); - EXPECT_TRUE(set.contains_as(Type2{5})); - set.remove_as(Type2{5}); - EXPECT_FALSE(set.contains_as(Type2{5})); - set.remove_as(Type2{5}); - EXPECT_FALSE(set.contains_as(Type2{5})); -} - -TEST(set, AddAs) -{ - Set set; - EXPECT_TRUE(set.add_as("test")); - EXPECT_TRUE(set.add_as(StringRef("qwe"))); - EXPECT_FALSE(set.add_as(StringRef("test"))); - EXPECT_FALSE(set.add_as("qwe")); -} - -template struct EqualityIntModN { - bool operator()(uint a, uint b) const - { - return (a % N) == (b % N); - } -}; - -template struct HashIntModN { - uint64_t operator()(uint value) const - { - return value % N; - } -}; - -TEST(set, CustomizeHashAndEquality) -{ - Set, EqualityIntModN<10>> set; - set.add(4); - EXPECT_TRUE(set.contains(4)); - EXPECT_TRUE(set.contains(14)); - EXPECT_TRUE(set.contains(104)); - EXPECT_FALSE(set.contains(5)); - set.add(55); - EXPECT_TRUE(set.contains(5)); - EXPECT_TRUE(set.contains(14)); - set.remove(1004); - EXPECT_FALSE(set.contains(14)); -} - -TEST(set, IntrusiveIntKey) -{ - Set, - DefaultEquality, - IntegerSetSlot> - set; - EXPECT_TRUE(set.add(4)); - EXPECT_TRUE(set.add(3)); - EXPECT_TRUE(set.add(11)); - EXPECT_TRUE(set.add(8)); - EXPECT_FALSE(set.add(3)); - EXPECT_FALSE(set.add(4)); - EXPECT_TRUE(set.remove(4)); - EXPECT_FALSE(set.remove(7)); - EXPECT_TRUE(set.add(4)); - EXPECT_TRUE(set.remove(4)); -} - -struct MyKeyType { - uint32_t key; - int32_t attached_data; - - uint64_t hash() const - { - return key; - } - - friend bool operator==(const MyKeyType &a, const MyKeyType &b) - { - return a.key == b.key; - } -}; - -TEST(set, LookupKey) -{ - Set set; - set.add({1, 10}); - set.add({2, 20}); - EXPECT_EQ(set.lookup_key({1, 30}).attached_data, 10); - EXPECT_EQ(set.lookup_key({2, 0}).attached_data, 20); -} - -TEST(set, LookupKeyDefault) -{ - Set set; - set.add({1, 10}); - set.add({2, 20}); - - MyKeyType fallback{5, 50}; - EXPECT_EQ(set.lookup_key_default({1, 66}, fallback).attached_data, 10); - EXPECT_EQ(set.lookup_key_default({4, 40}, fallback).attached_data, 50); -} - -TEST(set, LookupKeyPtr) -{ - Set set; - set.add({1, 10}); - set.add({2, 20}); - EXPECT_EQ(set.lookup_key_ptr({1, 50})->attached_data, 10); - EXPECT_EQ(set.lookup_key_ptr({2, 50})->attached_data, 20); - EXPECT_EQ(set.lookup_key_ptr({3, 50}), nullptr); -} - -/** - * Set this to 1 to activate the benchmark. It is disabled by default, because it prints a lot. - */ -#if 0 -template -BLI_NOINLINE void benchmark_random_ints(StringRef name, int amount, int factor) -{ - RNG *rng = BLI_rng_new(0); - Vector values; - for (int i = 0; i < amount; i++) { - values.append(BLI_rng_get_int(rng) * factor); - } - BLI_rng_free(rng); - - SetT set; - { - SCOPED_TIMER(name + " Add"); - for (int value : values) { - set.add(value); - } - } - int count = 0; - { - SCOPED_TIMER(name + " Contains"); - for (int value : values) { - count += set.contains(value); - } - } - { - SCOPED_TIMER(name + " Remove"); - for (int value : values) { - count += set.remove(value); - } - } - - /* Print the value for simple error checking and to avoid some compiler optimizations. */ - std::cout << "Count: " << count << "\n"; -} - -TEST(set, Benchmark) -{ - for (int i = 0; i < 3; i++) { - benchmark_random_ints>("blender::Set ", 100000, 1); - benchmark_random_ints>("std::unordered_set", 100000, 1); - } - std::cout << "\n"; - for (int i = 0; i < 3; i++) { - uint32_t factor = (3 << 10); - benchmark_random_ints>("blender::Set ", 100000, factor); - benchmark_random_ints>("std::unordered_set", 100000, factor); - } -} - -/** - * Output of the rudimentary benchmark above on my hardware. - * - * Timer 'blender::Set Add' took 5.5573 ms - * Timer 'blender::Set Contains' took 0.807384 ms - * Timer 'blender::Set Remove' took 0.953436 ms - * Count: 199998 - * Timer 'std::unordered_set Add' took 12.551 ms - * Timer 'std::unordered_set Contains' took 2.3323 ms - * Timer 'std::unordered_set Remove' took 5.07082 ms - * Count: 199998 - * Timer 'blender::Set Add' took 2.62526 ms - * Timer 'blender::Set Contains' took 0.407499 ms - * Timer 'blender::Set Remove' took 0.472981 ms - * Count: 199998 - * Timer 'std::unordered_set Add' took 6.26945 ms - * Timer 'std::unordered_set Contains' took 1.17236 ms - * Timer 'std::unordered_set Remove' took 3.77402 ms - * Count: 199998 - * Timer 'blender::Set Add' took 2.59152 ms - * Timer 'blender::Set Contains' took 0.415254 ms - * Timer 'blender::Set Remove' took 0.477559 ms - * Count: 199998 - * Timer 'std::unordered_set Add' took 6.28129 ms - * Timer 'std::unordered_set Contains' took 1.17562 ms - * Timer 'std::unordered_set Remove' took 3.77811 ms - * Count: 199998 - * - * Timer 'blender::Set Add' took 3.16514 ms - * Timer 'blender::Set Contains' took 0.732895 ms - * Timer 'blender::Set Remove' took 1.08171 ms - * Count: 198790 - * Timer 'std::unordered_set Add' took 6.57377 ms - * Timer 'std::unordered_set Contains' took 1.17008 ms - * Timer 'std::unordered_set Remove' took 3.7946 ms - * Count: 198790 - * Timer 'blender::Set Add' took 3.11439 ms - * Timer 'blender::Set Contains' took 0.740159 ms - * Timer 'blender::Set Remove' took 1.06749 ms - * Count: 198790 - * Timer 'std::unordered_set Add' took 6.35597 ms - * Timer 'std::unordered_set Contains' took 1.17713 ms - * Timer 'std::unordered_set Remove' took 3.77826 ms - * Count: 198790 - * Timer 'blender::Set Add' took 3.09876 ms - * Timer 'blender::Set Contains' took 0.742072 ms - * Timer 'blender::Set Remove' took 1.06622 ms - * Count: 198790 - * Timer 'std::unordered_set Add' took 6.4469 ms - * Timer 'std::unordered_set Contains' took 1.16515 ms - * Timer 'std::unordered_set Remove' took 3.80639 ms - * Count: 198790 - */ - -#endif /* Benchmark */ - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_span_test.cc b/tests/gtests/blenlib/BLI_span_test.cc deleted file mode 100644 index 9c2e7cf26fb..00000000000 --- a/tests/gtests/blenlib/BLI_span_test.cc +++ /dev/null @@ -1,298 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_span.hh" -#include "BLI_strict_flags.h" -#include "BLI_vector.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(span, FromSmallVector) -{ - Vector a = {1, 2, 3}; - Span a_span = a; - EXPECT_EQ(a_span.size(), 3); - EXPECT_EQ(a_span[0], 1); - EXPECT_EQ(a_span[1], 2); - EXPECT_EQ(a_span[2], 3); -} - -TEST(span, AddConstToPointer) -{ - int a = 0; - std::vector vec = {&a}; - Span span = vec; - Span const_span = span; - EXPECT_EQ(const_span.size(), 1); -} - -TEST(span, IsReferencing) -{ - int array[] = {3, 5, 8}; - MutableSpan span(array, ARRAY_SIZE(array)); - EXPECT_EQ(span.size(), 3); - EXPECT_EQ(span[1], 5); - array[1] = 10; - EXPECT_EQ(span[1], 10); -} - -TEST(span, DropBack) -{ - Vector a = {4, 5, 6, 7}; - auto slice = Span(a).drop_back(2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 4); - EXPECT_EQ(slice[1], 5); -} - -TEST(span, DropBackAll) -{ - Vector a = {4, 5, 6, 7}; - auto slice = Span(a).drop_back(a.size()); - EXPECT_EQ(slice.size(), 0); -} - -TEST(span, DropFront) -{ - Vector a = {4, 5, 6, 7}; - auto slice = Span(a).drop_front(1); - EXPECT_EQ(slice.size(), 3); - EXPECT_EQ(slice[0], 5); - EXPECT_EQ(slice[1], 6); - EXPECT_EQ(slice[2], 7); -} - -TEST(span, DropFrontAll) -{ - Vector a = {4, 5, 6, 7}; - auto slice = Span(a).drop_front(a.size()); - EXPECT_EQ(slice.size(), 0); -} - -TEST(span, TakeFront) -{ - Vector a = {4, 5, 6, 7}; - auto slice = Span(a).take_front(2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 4); - EXPECT_EQ(slice[1], 5); -} - -TEST(span, TakeBack) -{ - Vector a = {5, 6, 7, 8}; - auto slice = Span(a).take_back(2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 7); - EXPECT_EQ(slice[1], 8); -} - -TEST(span, Slice) -{ - Vector a = {4, 5, 6, 7}; - auto slice = Span(a).slice(1, 2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 5); - EXPECT_EQ(slice[1], 6); -} - -TEST(span, SliceEmpty) -{ - Vector a = {4, 5, 6, 7}; - auto slice = Span(a).slice(2, 0); - EXPECT_EQ(slice.size(), 0); -} - -TEST(span, SliceRange) -{ - Vector a = {1, 2, 3, 4, 5}; - auto slice = Span(a).slice(IndexRange(2, 2)); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 3); - EXPECT_EQ(slice[1], 4); -} - -TEST(span, Contains) -{ - Vector a = {4, 5, 6, 7}; - Span a_span = a; - EXPECT_TRUE(a_span.contains(4)); - EXPECT_TRUE(a_span.contains(5)); - EXPECT_TRUE(a_span.contains(6)); - EXPECT_TRUE(a_span.contains(7)); - EXPECT_FALSE(a_span.contains(3)); - EXPECT_FALSE(a_span.contains(8)); -} - -TEST(span, Count) -{ - Vector a = {2, 3, 4, 3, 3, 2, 2, 2, 2}; - Span a_span = a; - EXPECT_EQ(a_span.count(1), 0); - EXPECT_EQ(a_span.count(2), 5); - EXPECT_EQ(a_span.count(3), 3); - EXPECT_EQ(a_span.count(4), 1); - EXPECT_EQ(a_span.count(5), 0); -} - -static void test_ref_from_initializer_list(Span span) -{ - EXPECT_EQ(span.size(), 4); - EXPECT_EQ(span[0], 3); - EXPECT_EQ(span[1], 6); - EXPECT_EQ(span[2], 8); - EXPECT_EQ(span[3], 9); -} - -TEST(span, FromInitializerList) -{ - test_ref_from_initializer_list({3, 6, 8, 9}); -} - -TEST(span, FromVector) -{ - std::vector a = {1, 2, 3, 4}; - Span a_span(a); - EXPECT_EQ(a_span.size(), 4); - EXPECT_EQ(a_span[0], 1); - EXPECT_EQ(a_span[1], 2); - EXPECT_EQ(a_span[2], 3); - EXPECT_EQ(a_span[3], 4); -} - -TEST(span, FromArray) -{ - std::array a = {5, 6}; - Span a_span(a); - EXPECT_EQ(a_span.size(), 2); - EXPECT_EQ(a_span[0], 5); - EXPECT_EQ(a_span[1], 6); -} - -TEST(span, Fill) -{ - std::array a = {4, 5, 6, 7, 8}; - MutableSpan a_span(a); - a_span.fill(1); - EXPECT_EQ(a[0], 1); - EXPECT_EQ(a[1], 1); - EXPECT_EQ(a[2], 1); - EXPECT_EQ(a[3], 1); - EXPECT_EQ(a[4], 1); -} - -TEST(span, FillIndices) -{ - std::array a = {0, 0, 0, 0, 0}; - MutableSpan a_span(a); - a_span.fill_indices({0, 2, 3}, 1); - EXPECT_EQ(a[0], 1); - EXPECT_EQ(a[1], 0); - EXPECT_EQ(a[2], 1); - EXPECT_EQ(a[3], 1); - EXPECT_EQ(a[4], 0); -} - -TEST(span, SizeInBytes) -{ - std::array a; - Span a_span(a); - EXPECT_EQ(a_span.size_in_bytes(), (int64_t)sizeof(a)); - EXPECT_EQ(a_span.size_in_bytes(), 40); -} - -TEST(span, FirstLast) -{ - std::array a = {6, 7, 8, 9}; - Span a_span(a); - EXPECT_EQ(a_span.first(), 6); - EXPECT_EQ(a_span.last(), 9); -} - -TEST(span, FirstLast_OneElement) -{ - int a = 3; - Span a_span(&a, 1); - EXPECT_EQ(a_span.first(), 3); - EXPECT_EQ(a_span.last(), 3); -} - -TEST(span, Get) -{ - std::array a = {5, 6, 7}; - Span a_span(a); - EXPECT_EQ(a_span.get(0, 42), 5); - EXPECT_EQ(a_span.get(1, 42), 6); - EXPECT_EQ(a_span.get(2, 42), 7); - EXPECT_EQ(a_span.get(3, 42), 42); - EXPECT_EQ(a_span.get(4, 42), 42); -} - -TEST(span, ContainsPtr) -{ - std::array a = {5, 6, 7}; - int other = 10; - Span a_span(a); - EXPECT_TRUE(a_span.contains_ptr(&a[0] + 0)); - EXPECT_TRUE(a_span.contains_ptr(&a[0] + 1)); - EXPECT_TRUE(a_span.contains_ptr(&a[0] + 2)); - EXPECT_FALSE(a_span.contains_ptr(&a[0] + 3)); - EXPECT_FALSE(a_span.contains_ptr(&a[0] - 1)); - EXPECT_FALSE(a_span.contains_ptr(&other)); -} - -TEST(span, FirstIndex) -{ - std::array a = {4, 5, 4, 2, 5}; - Span a_span(a); - - EXPECT_EQ(a_span.first_index(4), 0); - EXPECT_EQ(a_span.first_index(5), 1); - EXPECT_EQ(a_span.first_index(2), 3); -} - -TEST(span, CastSameSize) -{ - int value = 0; - std::array a = {&value, nullptr, nullptr, nullptr}; - Span a_span = a; - Span new_a_span = a_span.cast(); - - EXPECT_EQ(a_span.size(), 4); - EXPECT_EQ(new_a_span.size(), 4); - - EXPECT_EQ(a_span[0], &value); - EXPECT_EQ(new_a_span[0], (float *)&value); -} - -TEST(span, CastSmallerSize) -{ - std::array a = {3, 4, 5, 6}; - Span a_span = a; - Span new_a_span = a_span.cast(); - - EXPECT_EQ(a_span.size(), 4); - EXPECT_EQ(new_a_span.size(), 8); -} - -TEST(span, CastLargerSize) -{ - std::array a = {4, 5, 6, 7}; - Span a_span = a; - Span new_a_span = a_span.cast(); - - EXPECT_EQ(a_span.size(), 4); - EXPECT_EQ(new_a_span.size(), 2); -} - -TEST(span, VoidPointerSpan) -{ - int a; - float b; - double c; - - auto func1 = [](Span span) { EXPECT_EQ(span.size(), 3); }; - func1({&a, &b, &c}); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_stack_cxx_test.cc b/tests/gtests/blenlib/BLI_stack_cxx_test.cc deleted file mode 100644 index 43b3dd8b3ae..00000000000 --- a/tests/gtests/blenlib/BLI_stack_cxx_test.cc +++ /dev/null @@ -1,188 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_stack.hh" -#include "BLI_strict_flags.h" -#include "BLI_vector.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(stack, DefaultConstructor) -{ - Stack stack; - EXPECT_EQ(stack.size(), 0); - EXPECT_TRUE(stack.is_empty()); -} - -TEST(stack, SpanConstructor) -{ - std::array array = {4, 7, 2}; - Stack stack(array); - EXPECT_EQ(stack.size(), 3); - EXPECT_EQ(stack.pop(), 2); - EXPECT_EQ(stack.pop(), 7); - EXPECT_EQ(stack.pop(), 4); - EXPECT_TRUE(stack.is_empty()); -} - -TEST(stack, CopyConstructor) -{ - Stack stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack stack2 = stack1; - EXPECT_EQ(stack1.size(), 7); - EXPECT_EQ(stack2.size(), 7); - for (int i = 7; i >= 1; i--) { - EXPECT_FALSE(stack1.is_empty()); - EXPECT_FALSE(stack2.is_empty()); - EXPECT_EQ(stack1.pop(), i); - EXPECT_EQ(stack2.pop(), i); - } - EXPECT_TRUE(stack1.is_empty()); - EXPECT_TRUE(stack2.is_empty()); -} - -TEST(stack, MoveConstructor) -{ - Stack stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack stack2 = std::move(stack1); - EXPECT_EQ(stack1.size(), 0); - EXPECT_EQ(stack2.size(), 7); - for (int i = 7; i >= 1; i--) { - EXPECT_EQ(stack2.pop(), i); - } -} - -TEST(stack, CopyAssignment) -{ - Stack stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack stack2 = {2, 3, 4, 5, 6, 7}; - stack2 = stack1; - - EXPECT_EQ(stack1.size(), 7); - EXPECT_EQ(stack2.size(), 7); - for (int i = 7; i >= 1; i--) { - EXPECT_FALSE(stack1.is_empty()); - EXPECT_FALSE(stack2.is_empty()); - EXPECT_EQ(stack1.pop(), i); - EXPECT_EQ(stack2.pop(), i); - } - EXPECT_TRUE(stack1.is_empty()); - EXPECT_TRUE(stack2.is_empty()); -} - -TEST(stack, MoveAssignment) -{ - Stack stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack stack2 = {5, 3, 7, 2, 2}; - stack2 = std::move(stack1); - EXPECT_EQ(stack1.size(), 0); - EXPECT_EQ(stack2.size(), 7); - for (int i = 7; i >= 1; i--) { - EXPECT_EQ(stack2.pop(), i); - } -} - -TEST(stack, Push) -{ - Stack stack; - EXPECT_EQ(stack.size(), 0); - stack.push(3); - EXPECT_EQ(stack.size(), 1); - stack.push(5); - EXPECT_EQ(stack.size(), 2); -} - -TEST(stack, PushMultiple) -{ - Stack stack; - EXPECT_EQ(stack.size(), 0); - stack.push_multiple({1, 2, 3}); - EXPECT_EQ(stack.size(), 3); - EXPECT_EQ(stack.pop(), 3); - EXPECT_EQ(stack.pop(), 2); - EXPECT_EQ(stack.pop(), 1); -} - -TEST(stack, PushPopMany) -{ - Stack stack; - for (int i = 0; i < 1000; i++) { - stack.push(i); - EXPECT_EQ(stack.size(), static_cast(i + 1)); - } - for (int i = 999; i > 50; i--) { - EXPECT_EQ(stack.pop(), i); - EXPECT_EQ(stack.size(), static_cast(i)); - } - for (int i = 51; i < 5000; i++) { - stack.push(i); - EXPECT_EQ(stack.size(), static_cast(i + 1)); - } - for (int i = 4999; i >= 0; i--) { - EXPECT_EQ(stack.pop(), i); - EXPECT_EQ(stack.size(), static_cast(i)); - } -} - -TEST(stack, PushMultipleAfterPop) -{ - Stack stack; - for (int i = 0; i < 1000; i++) { - stack.push(i); - } - for (int i = 999; i >= 0; i--) { - EXPECT_EQ(stack.pop(), i); - } - - Vector values; - for (int i = 0; i < 5000; i++) { - values.append(i); - } - stack.push_multiple(values); - EXPECT_EQ(stack.size(), 5000); - - for (int i = 4999; i >= 0; i--) { - EXPECT_EQ(stack.pop(), i); - } -} - -TEST(stack, Pop) -{ - Stack stack; - stack.push(4); - stack.push(6); - EXPECT_EQ(stack.pop(), 6); - EXPECT_EQ(stack.pop(), 4); -} - -TEST(stack, Peek) -{ - Stack stack; - stack.push(3); - stack.push(4); - EXPECT_EQ(stack.peek(), 4); - EXPECT_EQ(stack.peek(), 4); - stack.pop(); - EXPECT_EQ(stack.peek(), 3); -} - -TEST(stack, UniquePtrValues) -{ - Stack> stack; - stack.push(std::unique_ptr(new int())); - stack.push(std::unique_ptr(new int())); - std::unique_ptr a = stack.pop(); - std::unique_ptr &b = stack.peek(); - UNUSED_VARS(a, b); -} - -TEST(stack, OveralignedValues) -{ - Stack, 2> stack; - for (int i = 0; i < 100; i++) { - stack.push({}); - EXPECT_EQ((uintptr_t)&stack.peek() % 512, 0); - } -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_string_ref_test.cc b/tests/gtests/blenlib/BLI_string_ref_test.cc deleted file mode 100644 index 83099741c29..00000000000 --- a/tests/gtests/blenlib/BLI_string_ref_test.cc +++ /dev/null @@ -1,277 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_strict_flags.h" -#include "BLI_string_ref.hh" -#include "BLI_vector.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(string_ref_null, DefaultConstructor) -{ - StringRefNull ref; - EXPECT_EQ(ref.size(), 0); - EXPECT_EQ(ref[0], '\0'); -} - -TEST(string_ref_null, CStringConstructor) -{ - const char *str = "Hello"; - StringRefNull ref(str); - EXPECT_EQ(ref.size(), 5); - EXPECT_EQ(ref.data(), str); -} - -TEST(string_ref_null, CStringLengthConstructor) -{ - const char *str = "Hello"; - StringRefNull ref(str, 5); - EXPECT_EQ(ref.size(), 5); - EXPECT_EQ(ref.data(), str); -} - -TEST(string_ref, DefaultConstructor) -{ - StringRef ref; - EXPECT_EQ(ref.size(), 0); -} - -TEST(string_ref, StartEndConstructor) -{ - const char *text = "hello world"; - StringRef ref(text, text + 5); - EXPECT_EQ(ref.size(), 5); - EXPECT_TRUE(ref == "hello"); - EXPECT_FALSE(ref == "hello "); -} - -TEST(string_ref, StartEndConstructorNullptr) -{ - StringRef ref(nullptr, nullptr); - EXPECT_EQ(ref.size(), 0); - EXPECT_TRUE(ref == ""); -} - -TEST(string_ref, StartEndConstructorSame) -{ - const char *text = "hello world"; - StringRef ref(text, text); - EXPECT_EQ(ref.size(), 0); - EXPECT_TRUE(ref == ""); -} - -TEST(string_ref, CStringConstructor) -{ - const char *str = "Test"; - StringRef ref(str); - EXPECT_EQ(ref.size(), 4); - EXPECT_EQ(ref.data(), str); -} - -TEST(string_ref, PointerWithLengthConstructor) -{ - const char *str = "Test"; - StringRef ref(str, 2); - EXPECT_EQ(ref.size(), 2); - EXPECT_EQ(ref.data(), str); -} - -TEST(string_ref, StdStringConstructor) -{ - std::string str = "Test"; - StringRef ref(str); - EXPECT_EQ(ref.size(), 4); - EXPECT_EQ(ref.data(), str.data()); -} - -TEST(string_ref, SubscriptOperator) -{ - StringRef ref("hello"); - EXPECT_EQ(ref.size(), 5); - EXPECT_EQ(ref[0], 'h'); - EXPECT_EQ(ref[1], 'e'); - EXPECT_EQ(ref[2], 'l'); - EXPECT_EQ(ref[3], 'l'); - EXPECT_EQ(ref[4], 'o'); -} - -TEST(string_ref, ToStdString) -{ - StringRef ref("test"); - std::string str = ref; - EXPECT_EQ(str.size(), 4); - EXPECT_EQ(str, "test"); -} - -TEST(string_ref, Print) -{ - StringRef ref("test"); - std::stringstream ss; - ss << ref; - ss << ref; - std::string str = ss.str(); - EXPECT_EQ(str.size(), 8); - EXPECT_EQ(str, "testtest"); -} - -TEST(string_ref, Add) -{ - StringRef a("qwe"); - StringRef b("asd"); - std::string result = a + b; - EXPECT_EQ(result, "qweasd"); -} - -TEST(string_ref, AddCharPtr1) -{ - StringRef ref("test"); - std::string result = ref + "qwe"; - EXPECT_EQ(result, "testqwe"); -} - -TEST(string_ref, AddCharPtr2) -{ - StringRef ref("test"); - std::string result = "qwe" + ref; - EXPECT_EQ(result, "qwetest"); -} - -TEST(string_ref, AddString1) -{ - StringRef ref("test"); - std::string result = ref + std::string("asd"); - EXPECT_EQ(result, "testasd"); -} - -TEST(string_ref, AddString2) -{ - StringRef ref("test"); - std::string result = std::string("asd") + ref; - EXPECT_EQ(result, "asdtest"); -} - -TEST(string_ref, CompareEqual) -{ - StringRef ref1("test"); - StringRef ref2("test"); - StringRef ref3("other"); - EXPECT_TRUE(ref1 == ref2); - EXPECT_FALSE(ref1 == ref3); - EXPECT_TRUE(ref1 != ref3); - EXPECT_FALSE(ref1 != ref2); -} - -TEST(string_ref, CompareEqualCharPtr1) -{ - StringRef ref("test"); - EXPECT_TRUE(ref == "test"); - EXPECT_FALSE(ref == "other"); - EXPECT_TRUE(ref != "other"); - EXPECT_FALSE(ref != "test"); -} - -TEST(string_ref, CompareEqualCharPtr2) -{ - StringRef ref("test"); - EXPECT_TRUE("test" == ref); - EXPECT_FALSE("other" == ref); - EXPECT_TRUE(ref != "other"); - EXPECT_FALSE(ref != "test"); -} - -TEST(string_ref, CompareEqualString1) -{ - StringRef ref("test"); - EXPECT_TRUE(ref == std::string("test")); - EXPECT_FALSE(ref == std::string("other")); - EXPECT_TRUE(ref != std::string("other")); - EXPECT_FALSE(ref != std::string("test")); -} - -TEST(string_ref, CompareEqualString2) -{ - StringRef ref("test"); - EXPECT_TRUE(std::string("test") == ref); - EXPECT_FALSE(std::string("other") == ref); - EXPECT_TRUE(std::string("other") != ref); - EXPECT_FALSE(std::string("test") != ref); -} - -TEST(string_ref, Iterate) -{ - StringRef ref("test"); - Vector chars; - for (char c : ref) { - chars.append(c); - } - EXPECT_EQ(chars.size(), 4); - EXPECT_EQ(chars[0], 't'); - EXPECT_EQ(chars[1], 'e'); - EXPECT_EQ(chars[2], 's'); - EXPECT_EQ(chars[3], 't'); -} - -TEST(string_ref, StartsWith) -{ - StringRef ref("test"); - EXPECT_TRUE(ref.startswith("")); - EXPECT_TRUE(ref.startswith("t")); - EXPECT_TRUE(ref.startswith("te")); - EXPECT_TRUE(ref.startswith("tes")); - EXPECT_TRUE(ref.startswith("test")); - EXPECT_FALSE(ref.startswith("test ")); - EXPECT_FALSE(ref.startswith("a")); -} - -TEST(string_ref, EndsWith) -{ - StringRef ref("test"); - EXPECT_TRUE(ref.endswith("")); - EXPECT_TRUE(ref.endswith("t")); - EXPECT_TRUE(ref.endswith("st")); - EXPECT_TRUE(ref.endswith("est")); - EXPECT_TRUE(ref.endswith("test")); - EXPECT_FALSE(ref.endswith(" test")); - EXPECT_FALSE(ref.endswith("a")); -} - -TEST(string_ref, DropPrefixN) -{ - StringRef ref("test"); - StringRef ref2 = ref.drop_prefix(2); - StringRef ref3 = ref2.drop_prefix(2); - EXPECT_EQ(ref2.size(), 2); - EXPECT_EQ(ref3.size(), 0); - EXPECT_EQ(ref2, "st"); - EXPECT_EQ(ref3, ""); -} - -TEST(string_ref, DropPrefix) -{ - StringRef ref("test"); - StringRef ref2 = ref.drop_prefix("tes"); - EXPECT_EQ(ref2.size(), 1); - EXPECT_EQ(ref2, "t"); -} - -TEST(string_ref, Substr) -{ - StringRef ref("hello world"); - EXPECT_EQ(ref.substr(0, 5), "hello"); - EXPECT_EQ(ref.substr(4, 0), ""); - EXPECT_EQ(ref.substr(3, 4), "lo w"); - EXPECT_EQ(ref.substr(6, 5), "world"); -} - -TEST(string_ref, Copy) -{ - StringRef ref("hello"); - char dst[10]; - memset(dst, 0xFF, 10); - ref.copy(dst); - EXPECT_EQ(dst[5], '\0'); - EXPECT_EQ(dst[6], 0xFF); - EXPECT_EQ(ref, dst); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_vector_set_test.cc b/tests/gtests/blenlib/BLI_vector_set_test.cc deleted file mode 100644 index 116c4747c5a..00000000000 --- a/tests/gtests/blenlib/BLI_vector_set_test.cc +++ /dev/null @@ -1,164 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_strict_flags.h" -#include "BLI_vector_set.hh" -#include "testing/testing.h" - -namespace blender { - -TEST(vector_set, DefaultConstructor) -{ - VectorSet set; - EXPECT_EQ(set.size(), 0); - EXPECT_TRUE(set.is_empty()); -} - -TEST(vector_set, InitializerListConstructor_WithoutDuplicates) -{ - VectorSet set = {1, 4, 5}; - EXPECT_EQ(set.size(), 3); - EXPECT_EQ(set[0], 1); - EXPECT_EQ(set[1], 4); - EXPECT_EQ(set[2], 5); -} - -TEST(vector_set, InitializerListConstructor_WithDuplicates) -{ - VectorSet set = {1, 3, 3, 2, 1, 5}; - EXPECT_EQ(set.size(), 4); - EXPECT_EQ(set[0], 1); - EXPECT_EQ(set[1], 3); - EXPECT_EQ(set[2], 2); - EXPECT_EQ(set[3], 5); -} - -TEST(vector_set, Copy) -{ - VectorSet set1 = {1, 2, 3}; - VectorSet set2 = set1; - EXPECT_EQ(set1.size(), 3); - EXPECT_EQ(set2.size(), 3); - EXPECT_EQ(set1.index_of(2), 1); - EXPECT_EQ(set2.index_of(2), 1); -} - -TEST(vector_set, CopyAssignment) -{ - VectorSet set1 = {1, 2, 3}; - VectorSet set2 = {}; - set2 = set1; - EXPECT_EQ(set1.size(), 3); - EXPECT_EQ(set2.size(), 3); - EXPECT_EQ(set1.index_of(2), 1); - EXPECT_EQ(set2.index_of(2), 1); -} - -TEST(vector_set, Move) -{ - VectorSet set1 = {1, 2, 3}; - VectorSet set2 = std::move(set1); - EXPECT_EQ(set1.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(vector_set, MoveAssignment) -{ - VectorSet set1 = {1, 2, 3}; - VectorSet set2 = {}; - set2 = std::move(set1); - EXPECT_EQ(set1.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(vector_set, AddNewIncreasesSize) -{ - VectorSet set; - EXPECT_TRUE(set.is_empty()); - EXPECT_EQ(set.size(), 0); - set.add(5); - EXPECT_FALSE(set.is_empty()); - EXPECT_EQ(set.size(), 1); -} - -TEST(vector_set, AddExistingDoesNotIncreaseSize) -{ - VectorSet set; - EXPECT_EQ(set.size(), 0); - EXPECT_TRUE(set.add(5)); - EXPECT_EQ(set.size(), 1); - EXPECT_FALSE(set.add(5)); - EXPECT_EQ(set.size(), 1); -} - -TEST(vector_set, Index) -{ - VectorSet set = {3, 6, 4}; - EXPECT_EQ(set.index_of(6), 1); - EXPECT_EQ(set.index_of(3), 0); - EXPECT_EQ(set.index_of(4), 2); -} - -TEST(vector_set, IndexTry) -{ - VectorSet set = {3, 6, 4}; - EXPECT_EQ(set.index_of_try(5), -1); - EXPECT_EQ(set.index_of_try(3), 0); - EXPECT_EQ(set.index_of_try(6), 1); - EXPECT_EQ(set.index_of_try(2), -1); -} - -TEST(vector_set, RemoveContained) -{ - VectorSet set = {4, 5, 6, 7}; - EXPECT_EQ(set.size(), 4); - set.remove_contained(5); - EXPECT_EQ(set.size(), 3); - EXPECT_EQ(set[0], 4); - EXPECT_EQ(set[1], 7); - EXPECT_EQ(set[2], 6); - set.remove_contained(6); - EXPECT_EQ(set.size(), 2); - EXPECT_EQ(set[0], 4); - EXPECT_EQ(set[1], 7); - set.remove_contained(4); - EXPECT_EQ(set.size(), 1); - EXPECT_EQ(set[0], 7); - set.remove_contained(7); - EXPECT_EQ(set.size(), 0); -} - -TEST(vector_set, AddMultipleTimes) -{ - VectorSet set; - for (int i = 0; i < 100; i++) { - EXPECT_FALSE(set.contains(i * 13)); - set.add(i * 12); - set.add(i * 13); - EXPECT_TRUE(set.contains(i * 13)); - } -} - -TEST(vector_set, UniquePtrValue) -{ - VectorSet> set; - set.add_new(std::unique_ptr(new int())); - set.add(std::unique_ptr(new int())); - set.index_of_try(std::unique_ptr(new int())); - std::unique_ptr value = set.pop(); - UNUSED_VARS(value); -} - -TEST(vector_set, Remove) -{ - VectorSet set; - EXPECT_TRUE(set.add(5)); - EXPECT_TRUE(set.contains(5)); - EXPECT_FALSE(set.remove(6)); - EXPECT_TRUE(set.contains(5)); - EXPECT_TRUE(set.remove(5)); - EXPECT_FALSE(set.contains(5)); - EXPECT_FALSE(set.remove(5)); - EXPECT_FALSE(set.contains(5)); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/BLI_vector_test.cc b/tests/gtests/blenlib/BLI_vector_test.cc deleted file mode 100644 index f581626d1ad..00000000000 --- a/tests/gtests/blenlib/BLI_vector_test.cc +++ /dev/null @@ -1,639 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_strict_flags.h" -#include "BLI_vector.hh" -#include "testing/testing.h" -#include - -namespace blender { - -TEST(vector, DefaultConstructor) -{ - Vector vec; - EXPECT_EQ(vec.size(), 0); -} - -TEST(vector, SizeConstructor) -{ - Vector vec(3); - EXPECT_EQ(vec.size(), 3); -} - -/** - * Tests that the trivially constructible types are not zero-initialized. We do not want that for - * performance reasons. - */ -TEST(vector, TrivialTypeSizeConstructor) -{ - Vector *vec = new Vector(1); - char *ptr = &(*vec)[0]; - vec->~Vector(); - - const char magic = 42; - *ptr = magic; - EXPECT_EQ(*ptr, magic); - - new (vec) Vector(1); - EXPECT_EQ((*vec)[0], magic); - EXPECT_EQ(*ptr, magic); - delete vec; -} - -TEST(vector, SizeValueConstructor) -{ - Vector vec(4, 10); - EXPECT_EQ(vec.size(), 4); - EXPECT_EQ(vec[0], 10); - EXPECT_EQ(vec[1], 10); - EXPECT_EQ(vec[2], 10); - EXPECT_EQ(vec[3], 10); -} - -TEST(vector, InitializerListConstructor) -{ - Vector vec = {1, 3, 4, 6}; - EXPECT_EQ(vec.size(), 4); - EXPECT_EQ(vec[0], 1); - EXPECT_EQ(vec[1], 3); - EXPECT_EQ(vec[2], 4); - EXPECT_EQ(vec[3], 6); -} - -TEST(vector, ConvertingConstructor) -{ - std::array values = {5.4f, 7.3f, -8.1f, 5.0f, 0.0f}; - Vector vec = values; - EXPECT_EQ(vec.size(), 5); - EXPECT_EQ(vec[0], 5); - EXPECT_EQ(vec[1], 7); - EXPECT_EQ(vec[2], -8); - EXPECT_EQ(vec[3], 5); - EXPECT_EQ(vec[4], 0); -} - -struct TestListValue { - TestListValue *next, *prev; - int value; -}; - -TEST(vector, ListBaseConstructor) -{ - TestListValue *value1 = new TestListValue{0, 0, 4}; - TestListValue *value2 = new TestListValue{0, 0, 5}; - TestListValue *value3 = new TestListValue{0, 0, 6}; - - ListBase list = {NULL, NULL}; - BLI_addtail(&list, value1); - BLI_addtail(&list, value2); - BLI_addtail(&list, value3); - Vector vec(list); - - EXPECT_EQ(vec.size(), 3); - EXPECT_EQ(vec[0]->value, 4); - EXPECT_EQ(vec[1]->value, 5); - EXPECT_EQ(vec[2]->value, 6); - - delete value1; - delete value2; - delete value3; -} - -TEST(vector, ContainerConstructor) -{ - std::forward_list list; - list.push_front(3); - list.push_front(1); - list.push_front(5); - - Vector vec = Vector::FromContainer(list); - EXPECT_EQ(vec.size(), 3); - EXPECT_EQ(vec[0], 5); - EXPECT_EQ(vec[1], 1); - EXPECT_EQ(vec[2], 3); -} - -TEST(vector, CopyConstructor) -{ - Vector vec1 = {1, 2, 3}; - Vector vec2(vec1); - EXPECT_EQ(vec2.size(), 3); - EXPECT_EQ(vec2[0], 1); - EXPECT_EQ(vec2[1], 2); - EXPECT_EQ(vec2[2], 3); - - vec1[1] = 5; - EXPECT_EQ(vec1[1], 5); - EXPECT_EQ(vec2[1], 2); -} - -TEST(vector, CopyConstructor2) -{ - Vector vec1 = {1, 2, 3, 4}; - Vector vec2(vec1); - - EXPECT_EQ(vec1.size(), 4); - EXPECT_EQ(vec2.size(), 4); - EXPECT_NE(vec1.data(), vec2.data()); - EXPECT_EQ(vec2[0], 1); - EXPECT_EQ(vec2[1], 2); - EXPECT_EQ(vec2[2], 3); - EXPECT_EQ(vec2[3], 4); -} - -TEST(vector, CopyConstructor3) -{ - Vector vec1 = {1, 2, 3, 4}; - Vector vec2(vec1); - - EXPECT_EQ(vec1.size(), 4); - EXPECT_EQ(vec2.size(), 4); - EXPECT_NE(vec1.data(), vec2.data()); - EXPECT_EQ(vec2[2], 3); -} - -TEST(vector, CopyConstructor4) -{ - Vector vec1 = {1, 2, 3, 4}; - Vector vec2(vec1); - - EXPECT_EQ(vec1.size(), 4); - EXPECT_EQ(vec2.size(), 4); - EXPECT_NE(vec1.data(), vec2.data()); - EXPECT_EQ(vec2[3], 4); -} - -TEST(vector, MoveConstructor) -{ - Vector vec1 = {1, 2, 3, 4}; - Vector vec2(std::move(vec1)); - - EXPECT_EQ(vec1.size(), 0); - EXPECT_EQ(vec2.size(), 4); - EXPECT_EQ(vec2[0], 1); - EXPECT_EQ(vec2[1], 2); - EXPECT_EQ(vec2[2], 3); - EXPECT_EQ(vec2[3], 4); -} - -TEST(vector, MoveConstructor2) -{ - Vector vec1 = {1, 2, 3, 4}; - Vector vec2(std::move(vec1)); - - EXPECT_EQ(vec1.size(), 0); - EXPECT_EQ(vec2.size(), 4); - EXPECT_EQ(vec2[0], 1); - EXPECT_EQ(vec2[1], 2); - EXPECT_EQ(vec2[2], 3); - EXPECT_EQ(vec2[3], 4); -} - -TEST(vector, MoveConstructor3) -{ - Vector vec1 = {1, 2, 3, 4}; - Vector vec2(std::move(vec1)); - - EXPECT_EQ(vec1.size(), 0); - EXPECT_EQ(vec2.size(), 4); - EXPECT_EQ(vec2[2], 3); -} - -TEST(vector, MoveConstructor4) -{ - Vector vec1 = {1, 2, 3, 4}; - Vector vec2(std::move(vec1)); - - EXPECT_EQ(vec1.size(), 0); - EXPECT_EQ(vec2.size(), 4); - EXPECT_EQ(vec2[3], 4); -} - -TEST(vector, MoveAssignment) -{ - Vector vec = {1, 2}; - EXPECT_EQ(vec.size(), 2); - EXPECT_EQ(vec[0], 1); - EXPECT_EQ(vec[1], 2); - - vec = Vector({5}); - EXPECT_EQ(vec.size(), 1); - EXPECT_EQ(vec[0], 5); -} - -TEST(vector, CopyAssignment) -{ - Vector vec1 = {1, 2, 3}; - Vector vec2 = {4, 5}; - EXPECT_EQ(vec1.size(), 3); - EXPECT_EQ(vec2.size(), 2); - - vec2 = vec1; - EXPECT_EQ(vec2.size(), 3); - - vec1[0] = 7; - EXPECT_EQ(vec1[0], 7); - EXPECT_EQ(vec2[0], 1); -} - -TEST(vector, Append) -{ - Vector vec; - vec.append(3); - vec.append(6); - vec.append(7); - EXPECT_EQ(vec.size(), 3); - EXPECT_EQ(vec[0], 3); - EXPECT_EQ(vec[1], 6); - EXPECT_EQ(vec[2], 7); -} - -TEST(vector, AppendAndGetIndex) -{ - Vector vec; - EXPECT_EQ(vec.append_and_get_index(10), 0); - EXPECT_EQ(vec.append_and_get_index(10), 1); - EXPECT_EQ(vec.append_and_get_index(10), 2); - vec.append(10); - EXPECT_EQ(vec.append_and_get_index(10), 4); -} - -TEST(vector, AppendNonDuplicates) -{ - Vector vec; - vec.append_non_duplicates(4); - EXPECT_EQ(vec.size(), 1); - vec.append_non_duplicates(5); - EXPECT_EQ(vec.size(), 2); - vec.append_non_duplicates(4); - EXPECT_EQ(vec.size(), 2); -} - -TEST(vector, ExtendNonDuplicates) -{ - Vector vec; - vec.extend_non_duplicates({1, 2}); - EXPECT_EQ(vec.size(), 2); - vec.extend_non_duplicates({3, 4}); - EXPECT_EQ(vec.size(), 4); - vec.extend_non_duplicates({0, 1, 2, 3}); - EXPECT_EQ(vec.size(), 5); -} - -TEST(vector, Iterator) -{ - Vector vec({1, 4, 9, 16}); - int i = 1; - for (int value : vec) { - EXPECT_EQ(value, i * i); - i++; - } -} - -TEST(vector, BecomeLarge) -{ - Vector vec; - for (int i = 0; i < 100; i++) { - vec.append(i * 5); - } - EXPECT_EQ(vec.size(), 100); - for (int i = 0; i < 100; i++) { - EXPECT_EQ(vec[i], static_cast(i * 5)); - } -} - -static Vector return_by_value_helper() -{ - return Vector({3, 5, 1}); -} - -TEST(vector, ReturnByValue) -{ - Vector vec = return_by_value_helper(); - EXPECT_EQ(vec.size(), 3); - EXPECT_EQ(vec[0], 3); - EXPECT_EQ(vec[1], 5); - EXPECT_EQ(vec[2], 1); -} - -TEST(vector, VectorOfVectors_Append) -{ - Vector> vec; - EXPECT_EQ(vec.size(), 0); - - Vector v({1, 2}); - vec.append(v); - vec.append({7, 8}); - EXPECT_EQ(vec.size(), 2); - EXPECT_EQ(vec[0][0], 1); - EXPECT_EQ(vec[0][1], 2); - EXPECT_EQ(vec[1][0], 7); - EXPECT_EQ(vec[1][1], 8); -} - -TEST(vector, RemoveLast) -{ - Vector vec = {5, 6}; - EXPECT_EQ(vec.size(), 2); - vec.remove_last(); - EXPECT_EQ(vec.size(), 1); - vec.remove_last(); - EXPECT_EQ(vec.size(), 0); -} - -TEST(vector, IsEmpty) -{ - Vector vec; - EXPECT_TRUE(vec.is_empty()); - vec.append(1); - EXPECT_FALSE(vec.is_empty()); - vec.remove_last(); - EXPECT_TRUE(vec.is_empty()); -} - -TEST(vector, RemoveReorder) -{ - Vector vec = {4, 5, 6, 7}; - vec.remove_and_reorder(1); - EXPECT_EQ(vec[0], 4); - EXPECT_EQ(vec[1], 7); - EXPECT_EQ(vec[2], 6); - vec.remove_and_reorder(2); - EXPECT_EQ(vec[0], 4); - EXPECT_EQ(vec[1], 7); - vec.remove_and_reorder(0); - EXPECT_EQ(vec[0], 7); - vec.remove_and_reorder(0); - EXPECT_TRUE(vec.is_empty()); -} - -TEST(vector, RemoveFirstOccurrenceAndReorder) -{ - Vector vec = {4, 5, 6, 7}; - vec.remove_first_occurrence_and_reorder(5); - EXPECT_EQ(vec[0], 4); - EXPECT_EQ(vec[1], 7); - EXPECT_EQ(vec[2], 6); - vec.remove_first_occurrence_and_reorder(6); - EXPECT_EQ(vec[0], 4); - EXPECT_EQ(vec[1], 7); - vec.remove_first_occurrence_and_reorder(4); - EXPECT_EQ(vec[0], 7); - vec.remove_first_occurrence_and_reorder(7); - EXPECT_EQ(vec.size(), 0); -} - -TEST(vector, Remove) -{ - Vector vec = {1, 2, 3, 4, 5, 6}; - vec.remove(3); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span({1, 2, 3, 5, 6}).begin())); - vec.remove(0); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span({2, 3, 5, 6}).begin())); - vec.remove(3); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span({2, 3, 5}).begin())); - vec.remove(1); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span({2, 5}).begin())); - vec.remove(1); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span({2}).begin())); - vec.remove(0); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span({}).begin())); -} - -TEST(vector, ExtendSmallVector) -{ - Vector a = {2, 3, 4}; - Vector b = {11, 12}; - b.extend(a); - EXPECT_EQ(b.size(), 5); - EXPECT_EQ(b[0], 11); - EXPECT_EQ(b[1], 12); - EXPECT_EQ(b[2], 2); - EXPECT_EQ(b[3], 3); - EXPECT_EQ(b[4], 4); -} - -TEST(vector, ExtendArray) -{ - int array[] = {3, 4, 5, 6}; - - Vector a; - a.extend(array, 2); - - EXPECT_EQ(a.size(), 2); - EXPECT_EQ(a[0], 3); - EXPECT_EQ(a[1], 4); -} - -TEST(vector, Last) -{ - Vector a{3, 5, 7}; - EXPECT_EQ(a.last(), 7); -} - -TEST(vector, AppendNTimes) -{ - Vector a; - a.append_n_times(5, 3); - a.append_n_times(2, 2); - EXPECT_EQ(a.size(), 5); - EXPECT_EQ(a[0], 5); - EXPECT_EQ(a[1], 5); - EXPECT_EQ(a[2], 5); - EXPECT_EQ(a[3], 2); - EXPECT_EQ(a[4], 2); -} - -TEST(vector, UniquePtrValue) -{ - Vector> vec; - vec.append(std::unique_ptr(new int())); - vec.append(std::unique_ptr(new int())); - vec.append(std::unique_ptr(new int())); - vec.append(std::unique_ptr(new int())); - EXPECT_EQ(vec.size(), 4); - - std::unique_ptr &a = vec.last(); - std::unique_ptr b = vec.pop_last(); - vec.remove_and_reorder(0); - vec.remove(0); - EXPECT_EQ(vec.size(), 1); - - UNUSED_VARS(a, b); -} - -class TypeConstructMock { - public: - bool default_constructed = false; - bool copy_constructed = false; - bool move_constructed = false; - bool copy_assigned = false; - bool move_assigned = false; - - TypeConstructMock() : default_constructed(true) - { - } - - TypeConstructMock(const TypeConstructMock &other) : copy_constructed(true) - { - } - - TypeConstructMock(TypeConstructMock &&other) noexcept : move_constructed(true) - { - } - - TypeConstructMock &operator=(const TypeConstructMock &other) - { - if (this == &other) { - return *this; - } - - copy_assigned = true; - return *this; - } - - TypeConstructMock &operator=(TypeConstructMock &&other) noexcept - { - if (this == &other) { - return *this; - } - - move_assigned = true; - return *this; - } -}; - -TEST(vector, SizeConstructorCallsDefaultConstructor) -{ - Vector vec(3); - EXPECT_TRUE(vec[0].default_constructed); - EXPECT_TRUE(vec[1].default_constructed); - EXPECT_TRUE(vec[2].default_constructed); -} - -TEST(vector, SizeValueConstructorCallsCopyConstructor) -{ - Vector vec(3, TypeConstructMock()); - EXPECT_TRUE(vec[0].copy_constructed); - EXPECT_TRUE(vec[1].copy_constructed); - EXPECT_TRUE(vec[2].copy_constructed); -} - -TEST(vector, AppendCallsCopyConstructor) -{ - Vector vec; - TypeConstructMock value; - vec.append(value); - EXPECT_TRUE(vec[0].copy_constructed); -} - -TEST(vector, AppendCallsMoveConstructor) -{ - Vector vec; - vec.append(TypeConstructMock()); - EXPECT_TRUE(vec[0].move_constructed); -} - -TEST(vector, SmallVectorCopyCallsCopyConstructor) -{ - Vector src(2); - Vector dst(src); - EXPECT_TRUE(dst[0].copy_constructed); - EXPECT_TRUE(dst[1].copy_constructed); -} - -TEST(vector, LargeVectorCopyCallsCopyConstructor) -{ - Vector src(5); - Vector dst(src); - EXPECT_TRUE(dst[0].copy_constructed); - EXPECT_TRUE(dst[1].copy_constructed); -} - -TEST(vector, SmallVectorMoveCallsMoveConstructor) -{ - Vector src(2); - Vector dst(std::move(src)); - EXPECT_TRUE(dst[0].move_constructed); - EXPECT_TRUE(dst[1].move_constructed); -} - -TEST(vector, LargeVectorMoveCallsNoConstructor) -{ - Vector src(5); - Vector dst(std::move(src)); - - EXPECT_TRUE(dst[0].default_constructed); - EXPECT_FALSE(dst[0].move_constructed); - EXPECT_FALSE(dst[0].copy_constructed); -} - -TEST(vector, Resize) -{ - std::string long_string = "012345678901234567890123456789"; - Vector vec; - EXPECT_EQ(vec.size(), 0); - vec.resize(2); - EXPECT_EQ(vec.size(), 2); - EXPECT_EQ(vec[0], ""); - EXPECT_EQ(vec[1], ""); - vec.resize(5, long_string); - EXPECT_EQ(vec.size(), 5); - EXPECT_EQ(vec[0], ""); - EXPECT_EQ(vec[1], ""); - EXPECT_EQ(vec[2], long_string); - EXPECT_EQ(vec[3], long_string); - EXPECT_EQ(vec[4], long_string); - vec.resize(1); - EXPECT_EQ(vec.size(), 1); - EXPECT_EQ(vec[0], ""); -} - -TEST(vector, FirstIndexOf) -{ - Vector vec = {2, 3, 5, 7, 5, 9}; - EXPECT_EQ(vec.first_index_of(2), 0); - EXPECT_EQ(vec.first_index_of(5), 2); - EXPECT_EQ(vec.first_index_of(9), 5); -} - -TEST(vector, FirstIndexTryOf) -{ - Vector vec = {2, 3, 5, 7, 5, 9}; - EXPECT_EQ(vec.first_index_of_try(2), 0); - EXPECT_EQ(vec.first_index_of_try(4), -1); - EXPECT_EQ(vec.first_index_of_try(5), 2); - EXPECT_EQ(vec.first_index_of_try(9), 5); - EXPECT_EQ(vec.first_index_of_try(1), -1); -} - -TEST(vector, OveralignedValues) -{ - Vector, 2> vec; - for (int i = 0; i < 100; i++) { - vec.append({}); - EXPECT_EQ((uintptr_t)&vec.last() % 512, 0); - } -} - -TEST(vector, ConstructVoidPointerVector) -{ - int a; - float b; - double c; - Vector vec = {&a, &b, &c}; - EXPECT_EQ(vec.size(), 3); -} - -TEST(vector, Fill) -{ - Vector vec(5); - vec.fill(3); - EXPECT_EQ(vec.size(), 5u); - EXPECT_EQ(vec[0], 3); - EXPECT_EQ(vec[1], 3); - EXPECT_EQ(vec[2], 3); - EXPECT_EQ(vec[3], 3); - EXPECT_EQ(vec[4], 3); -} - -} // namespace blender diff --git a/tests/gtests/blenlib/CMakeLists.txt b/tests/gtests/blenlib/CMakeLists.txt index d151dacd7a4..0727d317eaa 100644 --- a/tests/gtests/blenlib/CMakeLists.txt +++ b/tests/gtests/blenlib/CMakeLists.txt @@ -39,46 +39,31 @@ else() set(BLI_path_util_extra_libs "bf_blenlib;extern_wcwidth;${ZLIB_LIBRARIES}") endif() -BLENDER_TEST(BLI_array "bf_blenlib") BLENDER_TEST(BLI_array_store "bf_blenlib") BLENDER_TEST(BLI_array_utils "bf_blenlib") BLENDER_TEST(BLI_delaunay_2d "bf_blenlib") -BLENDER_TEST(BLI_disjoint_set "bf_blenlib") -BLENDER_TEST(BLI_edgehash "bf_blenlib") BLENDER_TEST(BLI_expr_pylike_eval "bf_blenlib") BLENDER_TEST(BLI_ghash "bf_blenlib") BLENDER_TEST(BLI_hash_mm2a "bf_blenlib") BLENDER_TEST(BLI_heap "bf_blenlib") BLENDER_TEST(BLI_heap_simple "bf_blenlib") -BLENDER_TEST(BLI_index_mask "bf_blenlib") -BLENDER_TEST(BLI_index_range "bf_blenlib") BLENDER_TEST(BLI_kdopbvh "bf_blenlib;bf_intern_numaapi") -BLENDER_TEST(BLI_linear_allocator "bf_blenlib") BLENDER_TEST(BLI_linklist_lockfree "bf_blenlib;bf_intern_numaapi") BLENDER_TEST(BLI_listbase "bf_blenlib") -BLENDER_TEST(BLI_map "bf_blenlib") BLENDER_TEST(BLI_math_base "bf_blenlib") -BLENDER_TEST(BLI_math_base_safe "bf_blenlib") BLENDER_TEST(BLI_math_bits "bf_blenlib") BLENDER_TEST(BLI_math_color "bf_blenlib") BLENDER_TEST(BLI_math_geom "bf_blenlib") BLENDER_TEST(BLI_math_matrix "bf_blenlib") BLENDER_TEST(BLI_math_vector "bf_blenlib") BLENDER_TEST(BLI_memiter "bf_blenlib") -BLENDER_TEST(BLI_memory_utils "bf_blenlib") BLENDER_TEST(BLI_path_util "${BLI_path_util_extra_libs}") BLENDER_TEST(BLI_polyfill_2d "bf_blenlib") -BLENDER_TEST(BLI_set "bf_blenlib") -BLENDER_TEST(BLI_span "bf_blenlib") BLENDER_TEST(BLI_stack "bf_blenlib") -BLENDER_TEST(BLI_stack_cxx "bf_blenlib") BLENDER_TEST(BLI_string "bf_blenlib") -BLENDER_TEST(BLI_string_ref "bf_blenlib") BLENDER_TEST(BLI_string_utf8 "bf_blenlib") BLENDER_TEST(BLI_task "bf_blenlib;bf_intern_numaapi") BLENDER_TEST(BLI_task_graph "bf_blenlib;bf_intern_numaapi") -BLENDER_TEST(BLI_vector "bf_blenlib") -BLENDER_TEST(BLI_vector_set "bf_blenlib") BLENDER_TEST_PERFORMANCE(BLI_ghash_performance "bf_blenlib") BLENDER_TEST_PERFORMANCE(BLI_task_performance "bf_blenlib") -- cgit v1.2.3