diff options
Diffstat (limited to 'tests')
29 files changed, 40 insertions, 5416 deletions
diff --git a/tests/gtests/CMakeLists.txt b/tests/gtests/CMakeLists.txt index 282eb9080f5..9a7509f81f3 100644 --- a/tests/gtests/CMakeLists.txt +++ b/tests/gtests/CMakeLists.txt @@ -12,7 +12,6 @@ if(WITH_GTESTS) add_subdirectory(blenloader) add_subdirectory(guardedalloc) add_subdirectory(bmesh) - add_subdirectory(functions) if(WITH_CODEC_FFMPEG) add_subdirectory(ffmpeg) endif() 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<int> array; - EXPECT_EQ(array.size(), 0); - EXPECT_TRUE(array.is_empty()); -} - -TEST(array, SizeConstructor) -{ - Array<int> array(5); - EXPECT_EQ(array.size(), 5); - EXPECT_FALSE(array.is_empty()); -} - -TEST(array, FillConstructor) -{ - Array<int> 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<int> 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<int> span(stackarray, ARRAY_SIZE(stackarray)); - Array<int> 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<int> array = {5, 6, 7, 8}; - Array<int> 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<int> array = {5, 6, 7, 8}; - Array<int> 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<int> array = {1, 2, 3}; - Array<int> 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<int> array = {1, 2, 3}; - Array<int> 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<char, 1> *array = new Array<char, 1>(1); - char *ptr = &(*array)[0]; - array->~Array(); - - const char magic = 42; - *ptr = magic; - EXPECT_EQ(*ptr, magic); - - new (array) Array<char, 1>(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<ConstructibleType>; - - TypedBuffer<MyArray> 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<int> 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 <algorithm> -#include <random> -#include <vector> - -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<Edge> 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<Edge> 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<int64_t> 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<int64_t> 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<int64_t> 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<int64_t> 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<int64_t> 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<int> span = allocator.allocate_array<int>(5); - EXPECT_EQ(span.size(), 5); -} - -TEST(linear_allocator, Construct) -{ - LinearAllocator<> allocator; - - std::array<int, 5> values = {1, 2, 3, 4, 5}; - Vector<int> *vector = allocator.construct<Vector<int>>(values); - EXPECT_EQ(vector->size(), 5); - EXPECT_EQ((*vector)[3], 4); - vector->~Vector(); -} - -TEST(linear_allocator, ConstructElementsAndPointerArray) -{ - LinearAllocator<> allocator; - - std::array<int, 7> values = {1, 2, 3, 4, 5, 6, 7}; - Span<Vector<int> *> vectors = allocator.construct_elements_and_pointer_array<Vector<int>>( - 5, values); - - EXPECT_EQ(vectors.size(), 5); - EXPECT_EQ(vectors[3]->size(), 7); - EXPECT_EQ((*vectors[2])[5], 6); - - for (Vector<int> *vector : vectors) { - vector->~Vector(); - } -} - -TEST(linear_allocator, ConstructArrayCopy) -{ - LinearAllocator<> allocator; - - Vector<int> values = {1, 2, 3}; - MutableSpan<int> span1 = allocator.construct_array_copy(values.as_span()); - MutableSpan<int> 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<int, float> map; - EXPECT_EQ(map.size(), 0); - EXPECT_TRUE(map.is_empty()); -} - -TEST(map, AddIncreasesSize) -{ - Map<int, float> 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<int, float> 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<int, float> 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<int, float> 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<int, int> map; - for (int i = 0; i < 100; i++) { - map.add(i * 30, i); - map.add(i * 31, i); - } -} - -TEST(map, PopItem) -{ - Map<int, float> 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<int, int> map; - map.add(1, 5); - map.add(2, 7); - EXPECT_EQ(map.size(), 2); - std::optional<int> 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<int, int> 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<int, int> 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<int, float> map; - map.add(3, 5.0f); - map.add(1, 2.0f); - map.add(7, -2.0f); - - blender::Set<float> 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<int, float> map; - map.add(6, 3.0f); - map.add(2, 4.0f); - map.add(1, 3.0f); - - blender::Set<int> 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<int, float> map; - map.add(5, 3.0f); - map.add(2, 9.0f); - map.add(1, 0.0f); - - blender::Set<int> keys; - blender::Set<float> values; - - int iterations = 0; - const Map<int, float> &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<int, int> 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<int, int> 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<int, int> map; - map.add(3, 6); - map.add(2, 1); - - Vector<int> keys, values; - for (Map<int, int>::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<int, float> 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<int, float> 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<int, float> 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<int, float> 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<int, float> 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<int, int> 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<int, float> map1; - map1.add(1, 2.0f); - map1.add(4, 1.0f); - Map<int, float> 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<int, int> map1; - for (int i = 0; i < 100; i++) { - map1.add_new(i, i); - } - Map<int, int> 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<int, float> map1; - map1.add(1, 2.0f); - map1.add(4, 1.0f); - Map<int, float> 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<int, float> map1; - map1.add(1, 2.0f); - map1.add(4, 1.0f); - Map<int, float> 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<int, float> 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<int>(new int()); - auto value2 = std::unique_ptr<int>(new int()); - auto value3 = std::unique_ptr<int>(new int()); - - int *value1_ptr = value1.get(); - - Map<int, std::unique_ptr<int>> 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<int>(new int()); }); - map.add_new(5, std::unique_ptr<int>(new int())); - map.add(6, std::unique_ptr<int>(new int())); - map.add_overwrite(7, std::unique_ptr<int>(new int())); - map.lookup_or_add(8, std::unique_ptr<int>(new int())); - map.pop_default(9, std::unique_ptr<int>(new int())); - - EXPECT_EQ(map.lookup(1).get(), value1_ptr); - EXPECT_EQ(map.lookup_ptr(100), nullptr); -} - -TEST(map, Remove) -{ - Map<int, int> 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<char *, int> 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<const std::string, const std::string> map; - map.reserve(10); - map.add("45", "643"); - EXPECT_TRUE(map.contains("45")); - EXPECT_FALSE(map.contains("54")); -} - -TEST(map, ForeachItem) -{ - Map<int, int> map; - map.add(3, 4); - map.add(1, 8); - - Vector<int> keys; - Vector<int> 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<typename MapT> -BLI_NOINLINE void benchmark_random_ints(StringRef name, int amount, int factor) -{ - RNG *rng = BLI_rng_new(0); - Vector<int> 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<int, int>>("blender::Map ", 1000000, 1); - benchmark_random_ints<blender::StdUnorderedMapWrapper<int, int>>("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<int, int>>("blender::Map ", 1000000, factor); - benchmark_random_ints<blender::StdUnorderedMapWrapper<int, int>>( - "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<MyValue, amount> 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<MyValue, amount> 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<MyValue, amount> buffer1; - TypedBuffer<MyValue, amount> 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<MyValue, amount> buffer1; - TypedBuffer<MyValue, amount> 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<MyValue, amount> 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<MyValue, amount> 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<int *, int *>); -static_assert(is_convertible_pointer_v<int *, const int *>); -static_assert(is_convertible_pointer_v<int *, int *const>); -static_assert(is_convertible_pointer_v<int *, const int *const>); -static_assert(!is_convertible_pointer_v<const int *, int *>); -static_assert(!is_convertible_pointer_v<int, int *>); -static_assert(!is_convertible_pointer_v<int *, int>); -static_assert(is_convertible_pointer_v<TestBaseClass *, const TestBaseClass *>); -static_assert(!is_convertible_pointer_v<const TestBaseClass *, TestBaseClass *>); -static_assert(is_convertible_pointer_v<TestChildClass *, TestBaseClass *>); -static_assert(!is_convertible_pointer_v<TestBaseClass *, TestChildClass *>); -static_assert(is_convertible_pointer_v<const TestChildClass *, const TestBaseClass *>); -static_assert(!is_convertible_pointer_v<TestBaseClass, const TestChildClass *>); -static_assert(!is_convertible_pointer_v<float3, float *>); -static_assert(!is_convertible_pointer_v<float *, float3>); -static_assert(!is_convertible_pointer_v<int **, int *>); -static_assert(!is_convertible_pointer_v<int *, int **>); -static_assert(is_convertible_pointer_v<int **, int **>); -static_assert(is_convertible_pointer_v<const int **, const int **>); -static_assert(!is_convertible_pointer_v<const int **, int **>); -static_assert(!is_convertible_pointer_v<int *const *, int **>); -static_assert(!is_convertible_pointer_v<int *const *const, int **>); -static_assert(is_convertible_pointer_v<int **, int **const>); -static_assert(is_convertible_pointer_v<int **, int *const *>); -static_assert(is_convertible_pointer_v<int **, int const *const *>); - -} // 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 <set> -#include <unordered_set> - -#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<int> set; - EXPECT_EQ(set.size(), 0); - EXPECT_TRUE(set.is_empty()); -} - -TEST(set, ContainsNotExistant) -{ - Set<int> set; - EXPECT_FALSE(set.contains(3)); -} - -TEST(set, ContainsExistant) -{ - Set<int> 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<int> 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<int> 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<int> set = {3}; - EXPECT_TRUE(set.contains(3)); - EXPECT_FALSE(set.contains(4)); - - Set<int> set2(set); - set2.add(4); - EXPECT_TRUE(set2.contains(3)); - EXPECT_TRUE(set2.contains(4)); - - EXPECT_FALSE(set.contains(4)); -} - -TEST(set, MoveConstructor) -{ - Set<int> set = {1, 2, 3}; - EXPECT_EQ(set.size(), 3); - Set<int> set2(std::move(set)); - EXPECT_EQ(set.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(set, CopyAssignment) -{ - Set<int> set = {3}; - EXPECT_TRUE(set.contains(3)); - EXPECT_FALSE(set.contains(4)); - - Set<int> 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<int> set = {1, 2, 3}; - EXPECT_EQ(set.size(), 3); - Set<int> set2; - set2 = std::move(set); - EXPECT_EQ(set.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(set, RemoveContained) -{ - Set<int> 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<int> 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<int> a = {3, 4, 5, 6}; - Set<int> b = {1, 2, 5}; - EXPECT_TRUE(Set<int>::Intersects(a, b)); - EXPECT_FALSE(Set<int>::Disjoint(a, b)); -} - -TEST(set, Disjoint) -{ - Set<int> a = {5, 6, 7, 8}; - Set<int> b = {2, 3, 4, 9}; - EXPECT_FALSE(Set<int>::Intersects(a, b)); - EXPECT_TRUE(Set<int>::Disjoint(a, b)); -} - -TEST(set, AddMultiple) -{ - Set<int> 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<int> a; - a.add_multiple_new({5, 6}); - EXPECT_TRUE(a.contains(5)); - EXPECT_TRUE(a.contains(6)); -} - -TEST(set, Iterator) -{ - Set<int> set = {1, 3, 2, 5, 4}; - blender::Vector<int> 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<int> 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<std::unique_ptr<int>> set; - set.add_new(std::unique_ptr<int>(new int())); - auto value1 = std::unique_ptr<int>(new int()); - set.add_new(std::move(value1)); - set.add(std::unique_ptr<int>(new int())); - - EXPECT_EQ(set.size(), 3); -} - -TEST(set, Clear) -{ - Set<int> set = {3, 4, 6, 7}; - EXPECT_EQ(set.size(), 4); - set.clear(); - EXPECT_EQ(set.size(), 0); -} - -TEST(set, StringSet) -{ - Set<std::string> 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<int *> 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<int> 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<Type1> { - uint32_t operator()(const Type1 &value) const - { - return value.value; - } - - uint32_t operator()(const Type2 &value) const - { - return value.value; - } -}; - -TEST(set, ContainsAs) -{ - Set<Type1> 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<std::string> 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<Type1> 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<Type1> 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<std::string> 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<uint N> struct EqualityIntModN { - bool operator()(uint a, uint b) const - { - return (a % N) == (b % N); - } -}; - -template<uint N> struct HashIntModN { - uint64_t operator()(uint value) const - { - return value % N; - } -}; - -TEST(set, CustomizeHashAndEquality) -{ - Set<uint, 0, DefaultProbingStrategy, HashIntModN<10>, 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<int, - 2, - DefaultProbingStrategy, - DefaultHash<int>, - DefaultEquality, - IntegerSetSlot<int, 100, 200>> - 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<MyKeyType> 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<MyKeyType> 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<MyKeyType> 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<typename SetT> -BLI_NOINLINE void benchmark_random_ints(StringRef name, int amount, int factor) -{ - RNG *rng = BLI_rng_new(0); - Vector<int> 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<int>>("blender::Set ", 100000, 1); - benchmark_random_ints<blender::StdUnorderedSetWrapper<int>>("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<int>>("blender::Set ", 100000, factor); - benchmark_random_ints<blender::StdUnorderedSetWrapper<int>>("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<int> a = {1, 2, 3}; - Span<int> 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<int *> vec = {&a}; - Span<int *> span = vec; - Span<const int *> const_span = span; - EXPECT_EQ(const_span.size(), 1); -} - -TEST(span, IsReferencing) -{ - int array[] = {3, 5, 8}; - MutableSpan<int> 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<int> a = {4, 5, 6, 7}; - auto slice = Span<int>(a).drop_back(2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 4); - EXPECT_EQ(slice[1], 5); -} - -TEST(span, DropBackAll) -{ - Vector<int> a = {4, 5, 6, 7}; - auto slice = Span<int>(a).drop_back(a.size()); - EXPECT_EQ(slice.size(), 0); -} - -TEST(span, DropFront) -{ - Vector<int> a = {4, 5, 6, 7}; - auto slice = Span<int>(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<int> a = {4, 5, 6, 7}; - auto slice = Span<int>(a).drop_front(a.size()); - EXPECT_EQ(slice.size(), 0); -} - -TEST(span, TakeFront) -{ - Vector<int> a = {4, 5, 6, 7}; - auto slice = Span<int>(a).take_front(2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 4); - EXPECT_EQ(slice[1], 5); -} - -TEST(span, TakeBack) -{ - Vector<int> a = {5, 6, 7, 8}; - auto slice = Span<int>(a).take_back(2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 7); - EXPECT_EQ(slice[1], 8); -} - -TEST(span, Slice) -{ - Vector<int> a = {4, 5, 6, 7}; - auto slice = Span<int>(a).slice(1, 2); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 5); - EXPECT_EQ(slice[1], 6); -} - -TEST(span, SliceEmpty) -{ - Vector<int> a = {4, 5, 6, 7}; - auto slice = Span<int>(a).slice(2, 0); - EXPECT_EQ(slice.size(), 0); -} - -TEST(span, SliceRange) -{ - Vector<int> a = {1, 2, 3, 4, 5}; - auto slice = Span<int>(a).slice(IndexRange(2, 2)); - EXPECT_EQ(slice.size(), 2); - EXPECT_EQ(slice[0], 3); - EXPECT_EQ(slice[1], 4); -} - -TEST(span, Contains) -{ - Vector<int> a = {4, 5, 6, 7}; - Span<int> 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<int> a = {2, 3, 4, 3, 3, 2, 2, 2, 2}; - Span<int> 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<int> 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<int> a = {1, 2, 3, 4}; - Span<int> 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<int, 2> a = {5, 6}; - Span<int> 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<int, 5> a = {4, 5, 6, 7, 8}; - MutableSpan<int> 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<int, 5> a = {0, 0, 0, 0, 0}; - MutableSpan<int> 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<int, 10> a; - Span<int> 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<int, 4> a = {6, 7, 8, 9}; - Span<int> a_span(a); - EXPECT_EQ(a_span.first(), 6); - EXPECT_EQ(a_span.last(), 9); -} - -TEST(span, FirstLast_OneElement) -{ - int a = 3; - Span<int> a_span(&a, 1); - EXPECT_EQ(a_span.first(), 3); - EXPECT_EQ(a_span.last(), 3); -} - -TEST(span, Get) -{ - std::array<int, 3> a = {5, 6, 7}; - Span<int> 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<int, 3> a = {5, 6, 7}; - int other = 10; - Span<int> 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<int, 5> a = {4, 5, 4, 2, 5}; - Span<int> 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<int *, 4> a = {&value, nullptr, nullptr, nullptr}; - Span<int *> a_span = a; - Span<float *> new_a_span = a_span.cast<float *>(); - - 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<uint32_t, 4> a = {3, 4, 5, 6}; - Span<uint32_t> a_span = a; - Span<uint16_t> new_a_span = a_span.cast<uint16_t>(); - - EXPECT_EQ(a_span.size(), 4); - EXPECT_EQ(new_a_span.size(), 8); -} - -TEST(span, CastLargerSize) -{ - std::array<uint16_t, 4> a = {4, 5, 6, 7}; - Span<uint16_t> a_span = a; - Span<uint32_t> new_a_span = a_span.cast<uint32_t>(); - - 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<void *> 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<int> stack; - EXPECT_EQ(stack.size(), 0); - EXPECT_TRUE(stack.is_empty()); -} - -TEST(stack, SpanConstructor) -{ - std::array<int, 3> array = {4, 7, 2}; - Stack<int> 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<int> stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack<int> 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<int> stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack<int> 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<int> stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack<int> 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<int> stack1 = {1, 2, 3, 4, 5, 6, 7}; - Stack<int> 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<int> 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<int> 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<int> stack; - for (int i = 0; i < 1000; i++) { - stack.push(i); - EXPECT_EQ(stack.size(), static_cast<unsigned int>(i + 1)); - } - for (int i = 999; i > 50; i--) { - EXPECT_EQ(stack.pop(), i); - EXPECT_EQ(stack.size(), static_cast<unsigned int>(i)); - } - for (int i = 51; i < 5000; i++) { - stack.push(i); - EXPECT_EQ(stack.size(), static_cast<unsigned int>(i + 1)); - } - for (int i = 4999; i >= 0; i--) { - EXPECT_EQ(stack.pop(), i); - EXPECT_EQ(stack.size(), static_cast<unsigned int>(i)); - } -} - -TEST(stack, PushMultipleAfterPop) -{ - Stack<int> stack; - for (int i = 0; i < 1000; i++) { - stack.push(i); - } - for (int i = 999; i >= 0; i--) { - EXPECT_EQ(stack.pop(), i); - } - - Vector<int> 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<int> stack; - stack.push(4); - stack.push(6); - EXPECT_EQ(stack.pop(), 6); - EXPECT_EQ(stack.pop(), 4); -} - -TEST(stack, Peek) -{ - Stack<int> 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<std::unique_ptr<int>> stack; - stack.push(std::unique_ptr<int>(new int())); - stack.push(std::unique_ptr<int>(new int())); - std::unique_ptr<int> a = stack.pop(); - std::unique_ptr<int> &b = stack.peek(); - UNUSED_VARS(a, b); -} - -TEST(stack, OveralignedValues) -{ - Stack<AlignedBuffer<1, 512>, 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<char> 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<int> set; - EXPECT_EQ(set.size(), 0); - EXPECT_TRUE(set.is_empty()); -} - -TEST(vector_set, InitializerListConstructor_WithoutDuplicates) -{ - VectorSet<int> 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<int> 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<int> set1 = {1, 2, 3}; - VectorSet<int> 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<int> set1 = {1, 2, 3}; - VectorSet<int> 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<int> set1 = {1, 2, 3}; - VectorSet<int> set2 = std::move(set1); - EXPECT_EQ(set1.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(vector_set, MoveAssignment) -{ - VectorSet<int> set1 = {1, 2, 3}; - VectorSet<int> set2 = {}; - set2 = std::move(set1); - EXPECT_EQ(set1.size(), 0); - EXPECT_EQ(set2.size(), 3); -} - -TEST(vector_set, AddNewIncreasesSize) -{ - VectorSet<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<std::unique_ptr<int>> set; - set.add_new(std::unique_ptr<int>(new int())); - set.add(std::unique_ptr<int>(new int())); - set.index_of_try(std::unique_ptr<int>(new int())); - std::unique_ptr<int> value = set.pop(); - UNUSED_VARS(value); -} - -TEST(vector_set, Remove) -{ - VectorSet<int> 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 <forward_list> - -namespace blender { - -TEST(vector, DefaultConstructor) -{ - Vector<int> vec; - EXPECT_EQ(vec.size(), 0); -} - -TEST(vector, SizeConstructor) -{ - Vector<int> 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<char, 1> *vec = new Vector<char, 1>(1); - char *ptr = &(*vec)[0]; - vec->~Vector(); - - const char magic = 42; - *ptr = magic; - EXPECT_EQ(*ptr, magic); - - new (vec) Vector<char, 1>(1); - EXPECT_EQ((*vec)[0], magic); - EXPECT_EQ(*ptr, magic); - delete vec; -} - -TEST(vector, SizeValueConstructor) -{ - Vector<int> 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<int> 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<float, 5> values = {5.4f, 7.3f, -8.1f, 5.0f, 0.0f}; - Vector<int> 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<TestListValue *> 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<int> list; - list.push_front(3); - list.push_front(1); - list.push_front(5); - - Vector<int> vec = Vector<int>::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<int> vec1 = {1, 2, 3}; - Vector<int> 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<int, 2> vec1 = {1, 2, 3, 4}; - Vector<int, 3> 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<int, 20> vec1 = {1, 2, 3, 4}; - Vector<int, 1> 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<int, 5> vec1 = {1, 2, 3, 4}; - Vector<int, 6> 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<int> vec1 = {1, 2, 3, 4}; - Vector<int> 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<int, 2> vec1 = {1, 2, 3, 4}; - Vector<int, 3> 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<int, 20> vec1 = {1, 2, 3, 4}; - Vector<int, 1> vec2(std::move(vec1)); - - EXPECT_EQ(vec1.size(), 0); - EXPECT_EQ(vec2.size(), 4); - EXPECT_EQ(vec2[2], 3); -} - -TEST(vector, MoveConstructor4) -{ - Vector<int, 5> vec1 = {1, 2, 3, 4}; - Vector<int, 6> vec2(std::move(vec1)); - - EXPECT_EQ(vec1.size(), 0); - EXPECT_EQ(vec2.size(), 4); - EXPECT_EQ(vec2[3], 4); -} - -TEST(vector, MoveAssignment) -{ - Vector<int> vec = {1, 2}; - EXPECT_EQ(vec.size(), 2); - EXPECT_EQ(vec[0], 1); - EXPECT_EQ(vec[1], 2); - - vec = Vector<int>({5}); - EXPECT_EQ(vec.size(), 1); - EXPECT_EQ(vec[0], 5); -} - -TEST(vector, CopyAssignment) -{ - Vector<int> vec1 = {1, 2, 3}; - Vector<int> 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<int> 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<int> 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<int> 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<int> 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<int> vec({1, 4, 9, 16}); - int i = 1; - for (int value : vec) { - EXPECT_EQ(value, i * i); - i++; - } -} - -TEST(vector, BecomeLarge) -{ - Vector<int, 4> 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<int>(i * 5)); - } -} - -static Vector<int> return_by_value_helper() -{ - return Vector<int>({3, 5, 1}); -} - -TEST(vector, ReturnByValue) -{ - Vector<int> 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<Vector<int>> vec; - EXPECT_EQ(vec.size(), 0); - - Vector<int> 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<int> 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<int> 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<int> 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<int> 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<int> vec = {1, 2, 3, 4, 5, 6}; - vec.remove(3); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({1, 2, 3, 5, 6}).begin())); - vec.remove(0); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5, 6}).begin())); - vec.remove(3); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 3, 5}).begin())); - vec.remove(1); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2, 5}).begin())); - vec.remove(1); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({2}).begin())); - vec.remove(0); - EXPECT_TRUE(std::equal(vec.begin(), vec.end(), Span<int>({}).begin())); -} - -TEST(vector, ExtendSmallVector) -{ - Vector<int> a = {2, 3, 4}; - Vector<int> 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<int> a; - a.extend(array, 2); - - EXPECT_EQ(a.size(), 2); - EXPECT_EQ(a[0], 3); - EXPECT_EQ(a[1], 4); -} - -TEST(vector, Last) -{ - Vector<int> a{3, 5, 7}; - EXPECT_EQ(a.last(), 7); -} - -TEST(vector, AppendNTimes) -{ - Vector<int> 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<std::unique_ptr<int>> vec; - vec.append(std::unique_ptr<int>(new int())); - vec.append(std::unique_ptr<int>(new int())); - vec.append(std::unique_ptr<int>(new int())); - vec.append(std::unique_ptr<int>(new int())); - EXPECT_EQ(vec.size(), 4); - - std::unique_ptr<int> &a = vec.last(); - std::unique_ptr<int> 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<TypeConstructMock> vec(3); - EXPECT_TRUE(vec[0].default_constructed); - EXPECT_TRUE(vec[1].default_constructed); - EXPECT_TRUE(vec[2].default_constructed); -} - -TEST(vector, SizeValueConstructorCallsCopyConstructor) -{ - Vector<TypeConstructMock> 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<TypeConstructMock> vec; - TypeConstructMock value; - vec.append(value); - EXPECT_TRUE(vec[0].copy_constructed); -} - -TEST(vector, AppendCallsMoveConstructor) -{ - Vector<TypeConstructMock> vec; - vec.append(TypeConstructMock()); - EXPECT_TRUE(vec[0].move_constructed); -} - -TEST(vector, SmallVectorCopyCallsCopyConstructor) -{ - Vector<TypeConstructMock, 2> src(2); - Vector<TypeConstructMock, 2> dst(src); - EXPECT_TRUE(dst[0].copy_constructed); - EXPECT_TRUE(dst[1].copy_constructed); -} - -TEST(vector, LargeVectorCopyCallsCopyConstructor) -{ - Vector<TypeConstructMock, 2> src(5); - Vector<TypeConstructMock, 2> dst(src); - EXPECT_TRUE(dst[0].copy_constructed); - EXPECT_TRUE(dst[1].copy_constructed); -} - -TEST(vector, SmallVectorMoveCallsMoveConstructor) -{ - Vector<TypeConstructMock, 2> src(2); - Vector<TypeConstructMock, 2> dst(std::move(src)); - EXPECT_TRUE(dst[0].move_constructed); - EXPECT_TRUE(dst[1].move_constructed); -} - -TEST(vector, LargeVectorMoveCallsNoConstructor) -{ - Vector<TypeConstructMock, 2> src(5); - Vector<TypeConstructMock, 2> 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<std::string> 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<int> 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<int> 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<AlignedBuffer<1, 512>, 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<void *> vec = {&a, &b, &c}; - EXPECT_EQ(vec.size(), 3); -} - -TEST(vector, Fill) -{ - Vector<int> 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 937279bceb9..bb0a5b63f71 100644 --- a/tests/gtests/blenlib/CMakeLists.txt +++ b/tests/gtests/blenlib/CMakeLists.txt @@ -39,47 +39,32 @@ 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_session_uuid "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") diff --git a/tests/gtests/blenloader/blendfile_loading_base_test.h b/tests/gtests/blenloader/blendfile_loading_base_test.h index 6ed32168737..a5e75ef6df8 100644 --- a/tests/gtests/blenloader/blendfile_loading_base_test.h +++ b/tests/gtests/blenloader/blendfile_loading_base_test.h @@ -47,7 +47,7 @@ class BlendfileLoadingBaseTest : public testing::Test { * Requires the CLI argument --test-asset-dir to point to ../../lib/tests. * * WARNING: only files saved with Blender 2.80+ can be loaded. Since Blender - * is only partially initialised (most importantly, without window manager), + * is only partially initialized (most importantly, without window manager), * the space types are not registered, so any versioning code that handles * those will SEGFAULT. */ diff --git a/tests/gtests/functions/CMakeLists.txt b/tests/gtests/functions/CMakeLists.txt deleted file mode 100644 index 1246bbd5599..00000000000 --- a/tests/gtests/functions/CMakeLists.txt +++ /dev/null @@ -1,45 +0,0 @@ -# ***** BEGIN GPL LICENSE BLOCK ***** -# -# This program is free software; you can redistribute it and/or -# modify it under the terms of the GNU General Public License -# as published by the Free Software Foundation; either version 2 -# of the License, or (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software Foundation, -# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. -# -# ***** END GPL LICENSE BLOCK ***** - -set(INC - . - .. - ../../../source/blender/blenlib - ../../../source/blender/functions - ../../../source/blender/makesdna - ../../../intern/guardedalloc -) - -setup_libdirs() -include_directories(${INC}) - - -set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${PLATFORM_LINKFLAGS}") -set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${PLATFORM_LINKFLAGS_DEBUG}") - -if(WITH_BUILDINFO) - set(BUILDINFO buildinfoobj) -endif() - -BLENDER_TEST(FN_array_spans "bf_blenlib;bf_functions;${BUILDINFO}") -BLENDER_TEST(FN_attributes_ref "bf_blenlib;bf_functions;${BUILDINFO}") -BLENDER_TEST(FN_cpp_type "bf_blenlib;bf_functions;${BUILDINFO}") -BLENDER_TEST(FN_generic_vector_array "bf_blenlib;bf_functions;${BUILDINFO}") -BLENDER_TEST(FN_multi_function "bf_blenlib;bf_functions;${BUILDINFO}") -BLENDER_TEST(FN_multi_function_network "bf_blenlib;bf_functions;${BUILDINFO}") -BLENDER_TEST(FN_spans "bf_blenlib;bf_functions;${BUILDINFO}") diff --git a/tests/gtests/functions/FN_array_spans_test.cc b/tests/gtests/functions/FN_array_spans_test.cc deleted file mode 100644 index 6b7bb8429ff..00000000000 --- a/tests/gtests/functions/FN_array_spans_test.cc +++ /dev/null @@ -1,132 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "testing/testing.h" - -#include "FN_array_spans.hh" -#include "FN_generic_vector_array.hh" - -#include "BLI_array.hh" - -namespace blender::fn { - -TEST(virtual_array_span, EmptyConstructor) -{ - VArraySpan<int> span; - EXPECT_EQ(span.size(), 0); - EXPECT_TRUE(span.is_empty()); - - GVArraySpan converted(span); - EXPECT_EQ(converted.type(), CPPType::get<int>()); - EXPECT_EQ(converted.size(), 0); -} - -TEST(virtual_array_span, SingleArrayConstructor) -{ - std::array<int, 4> values = {3, 4, 5, 6}; - VArraySpan<int> span{Span<int>(values), 3}; - EXPECT_EQ(span.size(), 3); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span[0].size(), 4); - EXPECT_EQ(span[1].size(), 4); - EXPECT_EQ(span[2].size(), 4); - EXPECT_EQ(span[0][0], 3); - EXPECT_EQ(span[0][1], 4); - EXPECT_EQ(span[0][2], 5); - EXPECT_EQ(span[0][3], 6); - EXPECT_EQ(span[1][3], 6); - EXPECT_EQ(span[2][1], 4); - - GVArraySpan converted(span); - EXPECT_EQ(converted.type(), CPPType::get<int>()); - EXPECT_EQ(converted.size(), 3); - EXPECT_EQ(converted[0].size(), 4); - EXPECT_EQ(converted[1].size(), 4); - EXPECT_EQ(converted[1][2], &values[2]); -} - -TEST(virtual_array_span, MultipleArrayConstructor) -{ - std::array<int, 4> values0 = {1, 2, 3, 4}; - std::array<int, 2> values1 = {6, 7}; - std::array<int, 1> values2 = {8}; - std::array<const int *, 3> starts = {values0.data(), values1.data(), values2.data()}; - std::array<int64_t, 3> sizes{values0.size(), values1.size(), values2.size()}; - - VArraySpan<int> span{starts, sizes}; - EXPECT_EQ(span.size(), 3); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span[0].size(), 4); - EXPECT_EQ(span[1].size(), 2); - EXPECT_EQ(span[2].size(), 1); - EXPECT_EQ(&span[0][0], values0.data()); - EXPECT_EQ(&span[1][0], values1.data()); - EXPECT_EQ(&span[2][0], values2.data()); - EXPECT_EQ(span[2][0], 8); - EXPECT_EQ(span[1][1], 7); - - GVArraySpan converted(span); - EXPECT_EQ(converted.type(), CPPType::get<int>()); - EXPECT_EQ(converted.size(), 3); - EXPECT_EQ(converted[0].size(), 4); - EXPECT_EQ(converted[1].size(), 2); - EXPECT_EQ(converted[2].size(), 1); - EXPECT_EQ(converted[0][0], values0.data()); - EXPECT_EQ(converted[1][1], values1.data() + 1); -} - -TEST(generic_virtual_array_span, TypeConstructor) -{ - GVArraySpan span{CPPType::get<int32_t>()}; - EXPECT_EQ(span.size(), 0); - EXPECT_TRUE(span.is_empty()); - - VArraySpan converted = span.typed<int>(); - EXPECT_EQ(converted.size(), 0); -} - -TEST(generic_virtual_array_span, GSpanConstructor) -{ - std::array<std::string, 3> values = {"hello", "world", "test"}; - GVArraySpan span{GSpan(CPPType::get<std::string>(), values.data(), 3), 5}; - EXPECT_EQ(span.size(), 5); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span[0][0], values.data()); - EXPECT_EQ(span[1][0], values.data()); - EXPECT_EQ(span[4][0], values.data()); - EXPECT_EQ(span[0].size(), 3); - EXPECT_EQ(span[2].size(), 3); - EXPECT_EQ(*(std::string *)span[3][1], "world"); - - VArraySpan converted = span.typed<std::string>(); - EXPECT_EQ(converted.size(), 5); - EXPECT_EQ(converted[0][0], "hello"); - EXPECT_EQ(converted[1][0], "hello"); - EXPECT_EQ(converted[4][0], "hello"); - EXPECT_EQ(converted[0].size(), 3); - EXPECT_EQ(converted[2].size(), 3); -} - -TEST(generic_virtual_array_span, IsSingleArray1) -{ - Array<int> values = {5, 6, 7}; - GVArraySpan span{GSpan(values.as_span()), 4}; - EXPECT_TRUE(span.is_single_array()); - - VArraySpan converted = span.typed<int>(); - EXPECT_TRUE(converted.is_single_array()); -} - -TEST(generic_virtual_array_span, IsSingleArray2) -{ - GVectorArray vectors{CPPType::get<int32_t>(), 3}; - GVectorArrayRef<int> vectors_ref = vectors; - vectors_ref.append(1, 4); - - GVArraySpan span = vectors; - EXPECT_FALSE(span.is_single_array()); - - VArraySpan converted = span.typed<int>(); - EXPECT_FALSE(converted.is_single_array()); -} - -} // namespace blender::fn diff --git a/tests/gtests/functions/FN_attributes_ref_test.cc b/tests/gtests/functions/FN_attributes_ref_test.cc deleted file mode 100644 index 9c7cce83493..00000000000 --- a/tests/gtests/functions/FN_attributes_ref_test.cc +++ /dev/null @@ -1,97 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "BLI_float3.hh" -#include "FN_attributes_ref.hh" - -#include "testing/testing.h" - -namespace blender::fn { - -TEST(attributes_info, BuildEmpty) -{ - AttributesInfoBuilder info_builder; - AttributesInfo info{info_builder}; - - EXPECT_EQ(info.size(), 0); -} - -TEST(attributes_info, AddSameNameTwice) -{ - AttributesInfoBuilder info_builder; - info_builder.add<int>("A", 4); - info_builder.add<int>("A", 5); - AttributesInfo info{info_builder}; - EXPECT_EQ(info.size(), 1); - EXPECT_TRUE(info.has_attribute("A", CPPType::get<int>())); - EXPECT_FALSE(info.has_attribute("B", CPPType::get<int>())); - EXPECT_FALSE(info.has_attribute("A", CPPType::get<float>())); - EXPECT_EQ(info.default_of<int>("A"), 4); - EXPECT_EQ(info.name_of(0), "A"); - EXPECT_EQ(info.index_range().start(), 0); - EXPECT_EQ(info.index_range().one_after_last(), 1); -} - -TEST(attributes_info, BuildWithDefaultString) -{ - AttributesInfoBuilder info_builder; - info_builder.add("A", CPPType::get<std::string>()); - AttributesInfo info{info_builder}; - EXPECT_EQ(info.default_of<std::string>("A"), ""); -} - -TEST(attributes_info, BuildWithGivenDefault) -{ - AttributesInfoBuilder info_builder; - info_builder.add<std::string>("A", "hello world"); - AttributesInfo info{info_builder}; - const void *default_value = info.default_of("A"); - EXPECT_EQ(*(const std::string *)default_value, "hello world"); - EXPECT_EQ(info.type_of("A"), CPPType::get<std::string>()); -} - -TEST(mutable_attributes_ref, ComplexTest) -{ - AttributesInfoBuilder info_builder; - info_builder.add<float3>("Position", {0, 0, 10}); - info_builder.add<uint>("ID", 0); - info_builder.add<float>("Size", 0.5f); - info_builder.add<std::string>("Name", "<no name>"); - AttributesInfo info{info_builder}; - - int amount = 5; - Array<float3> positions(amount); - Array<uint> ids(amount, 0); - Array<float> sizes(amount); - Array<std::string> names(amount); - - Array<void *> buffers = {positions.data(), ids.data(), sizes.data(), names.data()}; - MutableAttributesRef attributes{info, buffers, IndexRange(1, 3)}; - EXPECT_EQ(attributes.size(), 3); - EXPECT_EQ(attributes.info().size(), 4); - EXPECT_EQ(attributes.get("Position").buffer(), positions.data() + 1); - EXPECT_EQ(attributes.get("ID").buffer(), ids.data() + 1); - EXPECT_EQ(attributes.get("Size").buffer(), sizes.data() + 1); - EXPECT_EQ(attributes.get("Name").buffer(), names.data() + 1); - - EXPECT_EQ(attributes.get("ID").size(), 3); - EXPECT_EQ(attributes.get<uint>("ID").size(), 3); - - EXPECT_EQ(ids[2], 0); - MutableSpan<uint> ids_span = attributes.get<uint>("ID"); - ids_span[1] = 42; - EXPECT_EQ(ids[2], 42); - - EXPECT_FALSE(attributes.try_get<int>("not existant").has_value()); - EXPECT_FALSE(attributes.try_get<int>("Position").has_value()); - EXPECT_TRUE(attributes.try_get<float3>("Position").has_value()); - EXPECT_FALSE(attributes.try_get("not existant", CPPType::get<int>()).has_value()); - EXPECT_FALSE(attributes.try_get("Position", CPPType::get<int>()).has_value()); - EXPECT_TRUE(attributes.try_get("Position", CPPType::get<float3>()).has_value()); - - MutableAttributesRef sliced = attributes.slice(IndexRange(1, 2)); - EXPECT_EQ(sliced.size(), 2); - sliced.get<uint>("ID")[0] = 100; - EXPECT_EQ(ids[2], 100); -} - -} // namespace blender::fn diff --git a/tests/gtests/functions/FN_cpp_type_test.cc b/tests/gtests/functions/FN_cpp_type_test.cc deleted file mode 100644 index 85fc1105c25..00000000000 --- a/tests/gtests/functions/FN_cpp_type_test.cc +++ /dev/null @@ -1,321 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "testing/testing.h" - -#include "FN_cpp_type.hh" - -namespace blender::fn { - -static const int default_constructed_value = 1; -static const int copy_constructed_value = 2; -static const int move_constructed_value = 3; -static const int copy_constructed_from_value = 4; -static const int move_constructed_from_value = 5; -static const int copy_assigned_value = 6; -static const int copy_assigned_from_value = 7; -static const int move_assigned_value = 8; -static const int move_assigned_from_value = 9; -static const int destructed_value = 10; - -struct TestType { - mutable volatile int value; - - TestType() - { - value = default_constructed_value; - } - - ~TestType() - { - value = destructed_value; - } - - TestType(const TestType &other) - { - value = copy_constructed_value; - other.value = copy_constructed_from_value; - } - - TestType(TestType &&other) noexcept - { - value = move_constructed_value; - other.value = move_constructed_from_value; - } - - TestType &operator=(const TestType &other) - { - value = copy_assigned_value; - other.value = copy_assigned_from_value; - return *this; - } - - TestType &operator=(TestType &&other) noexcept - { - value = move_assigned_value; - other.value = move_assigned_from_value; - return *this; - } - - friend std::ostream &operator<<(std::ostream &stream, const TestType &value) - { - stream << value.value; - return stream; - } - - friend bool operator==(const TestType &a, const TestType &b) - { - return false; - } - - uint64_t hash() const - { - return 0; - } -}; - -MAKE_CPP_TYPE(TestType, TestType) - -const CPPType &CPPType_TestType = CPPType::get<TestType>(); - -TEST(cpp_type, Size) -{ - EXPECT_EQ(CPPType_TestType.size(), sizeof(TestType)); -} - -TEST(cpp_type, Alignment) -{ - EXPECT_EQ(CPPType_TestType.alignment(), alignof(TestType)); -} - -TEST(cpp_type, Is) -{ - EXPECT_TRUE(CPPType_TestType.is<TestType>()); - EXPECT_FALSE(CPPType_TestType.is<int>()); -} - -TEST(cpp_type, DefaultConstruction) -{ - int buffer[10] = {0}; - CPPType_TestType.construct_default((void *)buffer); - EXPECT_EQ(buffer[0], default_constructed_value); - EXPECT_EQ(buffer[1], 0); - CPPType_TestType.construct_default_n((void *)buffer, 3); - EXPECT_EQ(buffer[0], default_constructed_value); - EXPECT_EQ(buffer[1], default_constructed_value); - EXPECT_EQ(buffer[2], default_constructed_value); - EXPECT_EQ(buffer[3], 0); - CPPType_TestType.construct_default_indices((void *)buffer, {2, 5, 7}); - EXPECT_EQ(buffer[2], default_constructed_value); - EXPECT_EQ(buffer[4], 0); - EXPECT_EQ(buffer[5], default_constructed_value); - EXPECT_EQ(buffer[6], 0); - EXPECT_EQ(buffer[7], default_constructed_value); - EXPECT_EQ(buffer[8], 0); -} - -TEST(cpp_type, Destruct) -{ - int buffer[10] = {0}; - CPPType_TestType.destruct((void *)buffer); - EXPECT_EQ(buffer[0], destructed_value); - EXPECT_EQ(buffer[1], 0); - CPPType_TestType.destruct_n((void *)buffer, 3); - EXPECT_EQ(buffer[0], destructed_value); - EXPECT_EQ(buffer[1], destructed_value); - EXPECT_EQ(buffer[2], destructed_value); - EXPECT_EQ(buffer[3], 0); - CPPType_TestType.destruct_indices((void *)buffer, {2, 5, 7}); - EXPECT_EQ(buffer[2], destructed_value); - EXPECT_EQ(buffer[4], 0); - EXPECT_EQ(buffer[5], destructed_value); - EXPECT_EQ(buffer[6], 0); - EXPECT_EQ(buffer[7], destructed_value); - EXPECT_EQ(buffer[8], 0); -} - -TEST(cpp_type, CopyToUninitialized) -{ - int buffer1[10] = {0}; - int buffer2[10] = {0}; - CPPType_TestType.copy_to_uninitialized((void *)buffer1, (void *)buffer2); - EXPECT_EQ(buffer1[0], copy_constructed_from_value); - EXPECT_EQ(buffer2[0], copy_constructed_value); - CPPType_TestType.copy_to_uninitialized_n((void *)buffer1, (void *)buffer2, 3); - EXPECT_EQ(buffer1[0], copy_constructed_from_value); - EXPECT_EQ(buffer2[0], copy_constructed_value); - EXPECT_EQ(buffer1[1], copy_constructed_from_value); - EXPECT_EQ(buffer2[1], copy_constructed_value); - EXPECT_EQ(buffer1[2], copy_constructed_from_value); - EXPECT_EQ(buffer2[2], copy_constructed_value); - EXPECT_EQ(buffer1[3], 0); - EXPECT_EQ(buffer2[3], 0); - CPPType_TestType.copy_to_uninitialized_indices((void *)buffer1, (void *)buffer2, {2, 5, 7}); - EXPECT_EQ(buffer1[2], copy_constructed_from_value); - EXPECT_EQ(buffer2[2], copy_constructed_value); - EXPECT_EQ(buffer1[4], 0); - EXPECT_EQ(buffer2[4], 0); - EXPECT_EQ(buffer1[5], copy_constructed_from_value); - EXPECT_EQ(buffer2[5], copy_constructed_value); - EXPECT_EQ(buffer1[6], 0); - EXPECT_EQ(buffer2[6], 0); - EXPECT_EQ(buffer1[7], copy_constructed_from_value); - EXPECT_EQ(buffer2[7], copy_constructed_value); - EXPECT_EQ(buffer1[8], 0); - EXPECT_EQ(buffer2[8], 0); -} - -TEST(cpp_type, CopyToInitialized) -{ - int buffer1[10] = {0}; - int buffer2[10] = {0}; - CPPType_TestType.copy_to_initialized((void *)buffer1, (void *)buffer2); - EXPECT_EQ(buffer1[0], copy_assigned_from_value); - EXPECT_EQ(buffer2[0], copy_assigned_value); - CPPType_TestType.copy_to_initialized_n((void *)buffer1, (void *)buffer2, 3); - EXPECT_EQ(buffer1[0], copy_assigned_from_value); - EXPECT_EQ(buffer2[0], copy_assigned_value); - EXPECT_EQ(buffer1[1], copy_assigned_from_value); - EXPECT_EQ(buffer2[1], copy_assigned_value); - EXPECT_EQ(buffer1[2], copy_assigned_from_value); - EXPECT_EQ(buffer2[2], copy_assigned_value); - EXPECT_EQ(buffer1[3], 0); - EXPECT_EQ(buffer2[3], 0); - CPPType_TestType.copy_to_initialized_indices((void *)buffer1, (void *)buffer2, {2, 5, 7}); - EXPECT_EQ(buffer1[2], copy_assigned_from_value); - EXPECT_EQ(buffer2[2], copy_assigned_value); - EXPECT_EQ(buffer1[4], 0); - EXPECT_EQ(buffer2[4], 0); - EXPECT_EQ(buffer1[5], copy_assigned_from_value); - EXPECT_EQ(buffer2[5], copy_assigned_value); - EXPECT_EQ(buffer1[6], 0); - EXPECT_EQ(buffer2[6], 0); - EXPECT_EQ(buffer1[7], copy_assigned_from_value); - EXPECT_EQ(buffer2[7], copy_assigned_value); - EXPECT_EQ(buffer1[8], 0); - EXPECT_EQ(buffer2[8], 0); -} - -TEST(cpp_type, RelocateToUninitialized) -{ - int buffer1[10] = {0}; - int buffer2[10] = {0}; - CPPType_TestType.relocate_to_uninitialized((void *)buffer1, (void *)buffer2); - EXPECT_EQ(buffer1[0], destructed_value); - EXPECT_EQ(buffer2[0], move_constructed_value); - CPPType_TestType.relocate_to_uninitialized_n((void *)buffer1, (void *)buffer2, 3); - EXPECT_EQ(buffer1[0], destructed_value); - EXPECT_EQ(buffer2[0], move_constructed_value); - EXPECT_EQ(buffer1[1], destructed_value); - EXPECT_EQ(buffer2[1], move_constructed_value); - EXPECT_EQ(buffer1[2], destructed_value); - EXPECT_EQ(buffer2[2], move_constructed_value); - EXPECT_EQ(buffer1[3], 0); - EXPECT_EQ(buffer2[3], 0); - CPPType_TestType.relocate_to_uninitialized_indices((void *)buffer1, (void *)buffer2, {2, 5, 7}); - EXPECT_EQ(buffer1[2], destructed_value); - EXPECT_EQ(buffer2[2], move_constructed_value); - EXPECT_EQ(buffer1[4], 0); - EXPECT_EQ(buffer2[4], 0); - EXPECT_EQ(buffer1[5], destructed_value); - EXPECT_EQ(buffer2[5], move_constructed_value); - EXPECT_EQ(buffer1[6], 0); - EXPECT_EQ(buffer2[6], 0); - EXPECT_EQ(buffer1[7], destructed_value); - EXPECT_EQ(buffer2[7], move_constructed_value); - EXPECT_EQ(buffer1[8], 0); - EXPECT_EQ(buffer2[8], 0); -} - -TEST(cpp_type, RelocateToInitialized) -{ - int buffer1[10] = {0}; - int buffer2[10] = {0}; - CPPType_TestType.relocate_to_initialized((void *)buffer1, (void *)buffer2); - EXPECT_EQ(buffer1[0], destructed_value); - EXPECT_EQ(buffer2[0], move_assigned_value); - CPPType_TestType.relocate_to_initialized_n((void *)buffer1, (void *)buffer2, 3); - EXPECT_EQ(buffer1[0], destructed_value); - EXPECT_EQ(buffer2[0], move_assigned_value); - EXPECT_EQ(buffer1[1], destructed_value); - EXPECT_EQ(buffer2[1], move_assigned_value); - EXPECT_EQ(buffer1[2], destructed_value); - EXPECT_EQ(buffer2[2], move_assigned_value); - EXPECT_EQ(buffer1[3], 0); - EXPECT_EQ(buffer2[3], 0); - CPPType_TestType.relocate_to_initialized_indices((void *)buffer1, (void *)buffer2, {2, 5, 7}); - EXPECT_EQ(buffer1[2], destructed_value); - EXPECT_EQ(buffer2[2], move_assigned_value); - EXPECT_EQ(buffer1[4], 0); - EXPECT_EQ(buffer2[4], 0); - EXPECT_EQ(buffer1[5], destructed_value); - EXPECT_EQ(buffer2[5], move_assigned_value); - EXPECT_EQ(buffer1[6], 0); - EXPECT_EQ(buffer2[6], 0); - EXPECT_EQ(buffer1[7], destructed_value); - EXPECT_EQ(buffer2[7], move_assigned_value); - EXPECT_EQ(buffer1[8], 0); - EXPECT_EQ(buffer2[8], 0); -} - -TEST(cpp_type, FillInitialized) -{ - int buffer1 = 0; - int buffer2[10] = {0}; - CPPType_TestType.fill_initialized((void *)&buffer1, (void *)buffer2, 3); - EXPECT_EQ(buffer1, copy_assigned_from_value); - EXPECT_EQ(buffer2[0], copy_assigned_value); - EXPECT_EQ(buffer2[1], copy_assigned_value); - EXPECT_EQ(buffer2[2], copy_assigned_value); - EXPECT_EQ(buffer2[3], 0); - - buffer1 = 0; - CPPType_TestType.fill_initialized_indices((void *)&buffer1, (void *)buffer2, {1, 6, 8}); - EXPECT_EQ(buffer1, copy_assigned_from_value); - EXPECT_EQ(buffer2[0], copy_assigned_value); - EXPECT_EQ(buffer2[1], copy_assigned_value); - EXPECT_EQ(buffer2[2], copy_assigned_value); - EXPECT_EQ(buffer2[3], 0); - EXPECT_EQ(buffer2[4], 0); - EXPECT_EQ(buffer2[5], 0); - EXPECT_EQ(buffer2[6], copy_assigned_value); - EXPECT_EQ(buffer2[7], 0); - EXPECT_EQ(buffer2[8], copy_assigned_value); - EXPECT_EQ(buffer2[9], 0); -} - -TEST(cpp_type, FillUninitialized) -{ - int buffer1 = 0; - int buffer2[10] = {0}; - CPPType_TestType.fill_uninitialized((void *)&buffer1, (void *)buffer2, 3); - EXPECT_EQ(buffer1, copy_constructed_from_value); - EXPECT_EQ(buffer2[0], copy_constructed_value); - EXPECT_EQ(buffer2[1], copy_constructed_value); - EXPECT_EQ(buffer2[2], copy_constructed_value); - EXPECT_EQ(buffer2[3], 0); - - buffer1 = 0; - CPPType_TestType.fill_uninitialized_indices((void *)&buffer1, (void *)buffer2, {1, 6, 8}); - EXPECT_EQ(buffer1, copy_constructed_from_value); - EXPECT_EQ(buffer2[0], copy_constructed_value); - EXPECT_EQ(buffer2[1], copy_constructed_value); - EXPECT_EQ(buffer2[2], copy_constructed_value); - EXPECT_EQ(buffer2[3], 0); - EXPECT_EQ(buffer2[4], 0); - EXPECT_EQ(buffer2[5], 0); - EXPECT_EQ(buffer2[6], copy_constructed_value); - EXPECT_EQ(buffer2[7], 0); - EXPECT_EQ(buffer2[8], copy_constructed_value); - EXPECT_EQ(buffer2[9], 0); -} - -TEST(cpp_type, DebugPrint) -{ - int value = 42; - std::stringstream ss; - CPPType::get<int32_t>().debug_print((void *)&value, ss); - std::string text = ss.str(); - EXPECT_EQ(text, "42"); -} - -} // namespace blender::fn diff --git a/tests/gtests/functions/FN_generic_vector_array_test.cc b/tests/gtests/functions/FN_generic_vector_array_test.cc deleted file mode 100644 index cfca678ad27..00000000000 --- a/tests/gtests/functions/FN_generic_vector_array_test.cc +++ /dev/null @@ -1,101 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "FN_generic_vector_array.hh" - -#include "testing/testing.h" - -namespace blender::fn { - -TEST(generic_vector_array, Constructor) -{ - GVectorArray vectors{CPPType::get<int32_t>(), 3}; - EXPECT_EQ(vectors.size(), 3); - EXPECT_EQ(vectors.lengths().size(), 3); - EXPECT_EQ(vectors.starts().size(), 3); - EXPECT_EQ(vectors.lengths()[0], 0); - EXPECT_EQ(vectors.lengths()[1], 0); - EXPECT_EQ(vectors.lengths()[2], 0); - EXPECT_EQ(vectors.type(), CPPType::get<int32_t>()); -} - -TEST(generic_vector_array, Append) -{ - GVectorArray vectors{CPPType::get<std::string>(), 3}; - std::string value = "hello"; - vectors.append(0, &value); - value = "world"; - vectors.append(0, &value); - vectors.append(2, &value); - - EXPECT_EQ(vectors.lengths()[0], 2); - EXPECT_EQ(vectors.lengths()[1], 0); - EXPECT_EQ(vectors.lengths()[2], 1); - EXPECT_EQ(vectors[0].size(), 2); - EXPECT_EQ(vectors[0].typed<std::string>()[0], "hello"); - EXPECT_EQ(vectors[0].typed<std::string>()[1], "world"); - EXPECT_EQ(vectors[2].typed<std::string>()[0], "world"); -} - -TEST(generic_vector_array, AsArraySpan) -{ - GVectorArray vectors{CPPType::get<int32_t>(), 3}; - int value = 3; - vectors.append(0, &value); - vectors.append(0, &value); - value = 5; - vectors.append(2, &value); - vectors.append(2, &value); - vectors.append(2, &value); - - GVArraySpan span = vectors; - EXPECT_EQ(span.type(), CPPType::get<int32_t>()); - EXPECT_EQ(span.size(), 3); - EXPECT_EQ(span[0].size(), 2); - EXPECT_EQ(span[1].size(), 0); - EXPECT_EQ(span[2].size(), 3); - EXPECT_EQ(span[0].typed<int>()[1], 3); - EXPECT_EQ(span[2].typed<int>()[0], 5); -} - -TEST(generic_vector_array, TypedRef) -{ - GVectorArray vectors{CPPType::get<int32_t>(), 4}; - GVectorArrayRef<int> ref = vectors.typed<int>(); - ref.append(0, 2); - ref.append(0, 6); - ref.append(0, 7); - ref.append(2, 1); - ref.append(2, 1); - ref.append(3, 5); - ref.append(3, 6); - - EXPECT_EQ(ref[0].size(), 3); - EXPECT_EQ(vectors[0].size(), 3); - EXPECT_EQ(ref[0][0], 2); - EXPECT_EQ(ref[0][1], 6); - EXPECT_EQ(ref[0][2], 7); - EXPECT_EQ(ref[1].size(), 0); - EXPECT_EQ(ref[2][0], 1); - EXPECT_EQ(ref[2][1], 1); - EXPECT_EQ(ref[3][0], 5); - EXPECT_EQ(ref[3][1], 6); -} - -TEST(generic_vector_array, Extend) -{ - GVectorArray vectors{CPPType::get<int32_t>(), 3}; - GVectorArrayRef<int> ref = vectors; - - ref.extend(1, {5, 6, 7}); - ref.extend(0, {3}); - - EXPECT_EQ(vectors[0].size(), 1); - EXPECT_EQ(vectors[1].size(), 3); - EXPECT_EQ(vectors[2].size(), 0); - EXPECT_EQ(ref[1][0], 5); - EXPECT_EQ(ref[1][1], 6); - EXPECT_EQ(ref[1][2], 7); - EXPECT_EQ(ref[0][0], 3); -} - -} // namespace blender::fn diff --git a/tests/gtests/functions/FN_multi_function_network_test.cc b/tests/gtests/functions/FN_multi_function_network_test.cc deleted file mode 100644 index 9f16b71bb10..00000000000 --- a/tests/gtests/functions/FN_multi_function_network_test.cc +++ /dev/null @@ -1,253 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "testing/testing.h" - -#include "FN_multi_function_builder.hh" -#include "FN_multi_function_network.hh" -#include "FN_multi_function_network_evaluation.hh" - -namespace blender::fn { - -TEST(multi_function_network, Test1) -{ - CustomMF_SI_SO<int, int> add_10_fn("add 10", [](int value) { return value + 10; }); - CustomMF_SI_SI_SO<int, int, int> multiply_fn("multiply", [](int a, int b) { return a * b; }); - - MFNetwork network; - - MFNode &node1 = network.add_function(add_10_fn); - MFNode &node2 = network.add_function(multiply_fn); - MFOutputSocket &input_socket = network.add_input("Input", MFDataType::ForSingle<int>()); - MFInputSocket &output_socket = network.add_output("Output", MFDataType::ForSingle<int>()); - network.add_link(node1.output(0), node2.input(0)); - network.add_link(node1.output(0), node2.input(1)); - network.add_link(node2.output(0), output_socket); - network.add_link(input_socket, node1.input(0)); - - MFNetworkEvaluator network_fn{{&input_socket}, {&output_socket}}; - - { - Array<int> values = {4, 6, 1, 2, 0}; - Array<int> results(values.size(), 0); - - MFParamsBuilder params(network_fn, values.size()); - params.add_readonly_single_input(values.as_span()); - params.add_uninitialized_single_output(results.as_mutable_span()); - - MFContextBuilder context; - - network_fn.call({0, 2, 3, 4}, params, context); - - EXPECT_EQ(results[0], 14 * 14); - EXPECT_EQ(results[1], 0); - EXPECT_EQ(results[2], 11 * 11); - EXPECT_EQ(results[3], 12 * 12); - EXPECT_EQ(results[4], 10 * 10); - } - { - int value = 3; - Array<int> results(5, 0); - - MFParamsBuilder params(network_fn, results.size()); - params.add_readonly_single_input(&value); - params.add_uninitialized_single_output(results.as_mutable_span()); - - MFContextBuilder context; - - network_fn.call({1, 2, 4}, params, context); - - EXPECT_EQ(results[0], 0); - EXPECT_EQ(results[1], 13 * 13); - EXPECT_EQ(results[2], 13 * 13); - EXPECT_EQ(results[3], 0); - EXPECT_EQ(results[4], 13 * 13); - } -} - -class ConcatVectorsFunction : public MultiFunction { - public: - ConcatVectorsFunction() - { - MFSignatureBuilder signature = this->get_builder("Concat Vectors"); - signature.vector_mutable<int>("A"); - signature.vector_input<int>("B"); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - GVectorArrayRef<int> a = params.vector_mutable<int>(0); - VArraySpan<int> b = params.readonly_vector_input<int>(1); - - for (int64_t i : mask) { - a.extend(i, b[i]); - } - } -}; - -class AppendFunction : public MultiFunction { - public: - AppendFunction() - { - MFSignatureBuilder signature = this->get_builder("Append"); - signature.vector_mutable<int>("Vector"); - signature.single_input<int>("Value"); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - GVectorArrayRef<int> vectors = params.vector_mutable<int>(0); - VSpan<int> values = params.readonly_single_input<int>(1); - - for (int64_t i : mask) { - vectors.append(i, values[i]); - } - } -}; - -class SumVectorFunction : public MultiFunction { - public: - SumVectorFunction() - { - MFSignatureBuilder signature = this->get_builder("Sum Vector"); - signature.vector_input<int>("Vector"); - signature.single_output<int>("Sum"); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - VArraySpan<int> vectors = params.readonly_vector_input<int>(0); - MutableSpan<int> sums = params.uninitialized_single_output<int>(1); - - for (int64_t i : mask) { - int sum = 0; - VSpan<int> vector = vectors[i]; - for (int j = 0; j < vector.size(); j++) { - sum += vector[j]; - } - sums[i] = sum; - } - } -}; - -class CreateRangeFunction : public MultiFunction { - public: - CreateRangeFunction() - { - MFSignatureBuilder builder = this->get_builder("Create Range"); - builder.single_input<int>("Size"); - builder.vector_output<int>("Range"); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - VSpan<int> sizes = params.readonly_single_input<int>(0, "Size"); - GVectorArrayRef<int> ranges = params.vector_output<int>(1, "Range"); - - for (int64_t i : mask) { - int size = sizes[i]; - for (int j : IndexRange(size)) { - ranges.append(i, j); - } - } - } -}; - -TEST(multi_function_network, Test2) -{ - CustomMF_SI_SO<int, int> add_3_fn("add 3", [](int value) { return value + 3; }); - - ConcatVectorsFunction concat_vectors_fn; - AppendFunction append_fn; - SumVectorFunction sum_fn; - CreateRangeFunction create_range_fn; - - MFNetwork network; - - MFOutputSocket &input1 = network.add_input("Input 1", MFDataType::ForVector<int>()); - MFOutputSocket &input2 = network.add_input("Input 2", MFDataType::ForSingle<int>()); - MFInputSocket &output1 = network.add_output("Output 1", MFDataType::ForVector<int>()); - MFInputSocket &output2 = network.add_output("Output 2", MFDataType::ForSingle<int>()); - - MFNode &node1 = network.add_function(add_3_fn); - MFNode &node2 = network.add_function(create_range_fn); - MFNode &node3 = network.add_function(concat_vectors_fn); - MFNode &node4 = network.add_function(sum_fn); - MFNode &node5 = network.add_function(append_fn); - MFNode &node6 = network.add_function(sum_fn); - - network.add_link(input2, node1.input(0)); - network.add_link(node1.output(0), node2.input(0)); - network.add_link(node2.output(0), node3.input(1)); - network.add_link(input1, node3.input(0)); - network.add_link(input1, node4.input(0)); - network.add_link(node4.output(0), node5.input(1)); - network.add_link(node3.output(0), node5.input(0)); - network.add_link(node5.output(0), node6.input(0)); - network.add_link(node3.output(0), output1); - network.add_link(node6.output(0), output2); - - // std::cout << network.to_dot() << "\n\n"; - - MFNetworkEvaluator network_fn{{&input1, &input2}, {&output1, &output2}}; - - { - Array<int> input_value_1 = {3, 6}; - int input_value_2 = 4; - - GVectorArray output_value_1(CPPType::get<int32_t>(), 5); - Array<int> output_value_2(5, -1); - - MFParamsBuilder params(network_fn, 5); - params.add_readonly_vector_input(GVArraySpan(input_value_1.as_span(), 5)); - params.add_readonly_single_input(&input_value_2); - params.add_vector_output(output_value_1); - params.add_uninitialized_single_output(output_value_2.as_mutable_span()); - - MFContextBuilder context; - - network_fn.call({1, 2, 4}, params, context); - - EXPECT_EQ(output_value_1[0].size(), 0); - EXPECT_EQ(output_value_1[1].size(), 9); - EXPECT_EQ(output_value_1[2].size(), 9); - EXPECT_EQ(output_value_1[3].size(), 0); - EXPECT_EQ(output_value_1[4].size(), 9); - - EXPECT_EQ(output_value_2[0], -1); - EXPECT_EQ(output_value_2[1], 39); - EXPECT_EQ(output_value_2[2], 39); - EXPECT_EQ(output_value_2[3], -1); - EXPECT_EQ(output_value_2[4], 39); - } - { - GVectorArray input_value_1(CPPType::get<int32_t>(), 3); - GVectorArrayRef<int> input_value_ref_1 = input_value_1; - input_value_ref_1.extend(0, {3, 4, 5}); - input_value_ref_1.extend(1, {1, 2}); - - Array<int> input_value_2 = {4, 2, 3}; - - GVectorArray output_value_1(CPPType::get<int32_t>(), 3); - Array<int> output_value_2(3, -1); - - MFParamsBuilder params(network_fn, 3); - params.add_readonly_vector_input(input_value_1); - params.add_readonly_single_input(input_value_2.as_span()); - params.add_vector_output(output_value_1); - params.add_uninitialized_single_output(output_value_2.as_mutable_span()); - - MFContextBuilder context; - - network_fn.call({0, 1, 2}, params, context); - - EXPECT_EQ(output_value_1[0].size(), 10); - EXPECT_EQ(output_value_1[1].size(), 7); - EXPECT_EQ(output_value_1[2].size(), 6); - - EXPECT_EQ(output_value_2[0], 45); - EXPECT_EQ(output_value_2[1], 16); - EXPECT_EQ(output_value_2[2], 15); - } -} - -} // namespace blender::fn diff --git a/tests/gtests/functions/FN_multi_function_test.cc b/tests/gtests/functions/FN_multi_function_test.cc deleted file mode 100644 index 8b5fb060c36..00000000000 --- a/tests/gtests/functions/FN_multi_function_test.cc +++ /dev/null @@ -1,385 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "testing/testing.h" - -#include "FN_multi_function.hh" -#include "FN_multi_function_builder.hh" - -namespace blender::fn { - -class AddFunction : public MultiFunction { - public: - AddFunction() - { - MFSignatureBuilder builder = this->get_builder("Add"); - builder.single_input<int>("A"); - builder.single_input<int>("B"); - builder.single_output<int>("Result"); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - VSpan<int> a = params.readonly_single_input<int>(0, "A"); - VSpan<int> b = params.readonly_single_input<int>(1, "B"); - MutableSpan<int> result = params.uninitialized_single_output<int>(2, "Result"); - - for (int64_t i : mask) { - result[i] = a[i] + b[i]; - } - } -}; - -TEST(multi_function, AddFunction) -{ - AddFunction fn; - - Array<int> input1 = {4, 5, 6}; - Array<int> input2 = {10, 20, 30}; - Array<int> output(3, -1); - - MFParamsBuilder params(fn, 3); - params.add_readonly_single_input(input1.as_span()); - params.add_readonly_single_input(input2.as_span()); - params.add_uninitialized_single_output(output.as_mutable_span()); - - MFContextBuilder context; - - fn.call({0, 2}, params, context); - - EXPECT_EQ(output[0], 14); - EXPECT_EQ(output[1], -1); - EXPECT_EQ(output[2], 36); -} - -class AddPrefixFunction : public MultiFunction { - public: - AddPrefixFunction() - { - MFSignatureBuilder builder = this->get_builder("Add Prefix"); - builder.single_input<std::string>("Prefix"); - builder.single_mutable<std::string>("Strings"); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - VSpan<std::string> prefixes = params.readonly_single_input<std::string>(0, "Prefix"); - MutableSpan<std::string> strings = params.single_mutable<std::string>(1, "Strings"); - - for (int64_t i : mask) { - strings[i] = prefixes[i] + strings[i]; - } - } -}; - -TEST(multi_function, AddPrefixFunction) -{ - AddPrefixFunction fn; - - Array<std::string> strings = { - "Hello", - "World", - "This is a test", - "Another much longer string to trigger an allocation", - }; - - std::string prefix = "AB"; - - MFParamsBuilder params(fn, strings.size()); - params.add_readonly_single_input(&prefix); - params.add_single_mutable(strings.as_mutable_span()); - - MFContextBuilder context; - - fn.call({0, 2, 3}, params, context); - - EXPECT_EQ(strings[0], "ABHello"); - EXPECT_EQ(strings[1], "World"); - EXPECT_EQ(strings[2], "ABThis is a test"); - EXPECT_EQ(strings[3], "ABAnother much longer string to trigger an allocation"); -} - -class CreateRangeFunction : public MultiFunction { - public: - CreateRangeFunction() - { - MFSignatureBuilder builder = this->get_builder("Create Range"); - builder.single_input<uint>("Size"); - builder.vector_output<uint>("Range"); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - VSpan<uint> sizes = params.readonly_single_input<uint>(0, "Size"); - GVectorArrayRef<uint> ranges = params.vector_output<uint>(1, "Range"); - - for (int64_t i : mask) { - uint size = sizes[i]; - for (uint j : IndexRange(size)) { - ranges.append(i, j); - } - } - } -}; - -TEST(multi_function, CreateRangeFunction) -{ - CreateRangeFunction fn; - - GVectorArray ranges(CPPType::get<int32_t>(), 5); - GVectorArrayRef<uint> ranges_ref(ranges); - Array<uint> sizes = {3, 0, 6, 1, 4}; - - MFParamsBuilder params(fn, ranges.size()); - params.add_readonly_single_input(sizes.as_span()); - params.add_vector_output(ranges); - - MFContextBuilder context; - - fn.call({0, 1, 2, 3}, params, context); - - EXPECT_EQ(ranges_ref[0].size(), 3); - EXPECT_EQ(ranges_ref[1].size(), 0); - EXPECT_EQ(ranges_ref[2].size(), 6); - EXPECT_EQ(ranges_ref[3].size(), 1); - EXPECT_EQ(ranges_ref[4].size(), 0); - - EXPECT_EQ(ranges_ref[0][0], 0); - EXPECT_EQ(ranges_ref[0][1], 1); - EXPECT_EQ(ranges_ref[0][2], 2); - EXPECT_EQ(ranges_ref[2][0], 0); - EXPECT_EQ(ranges_ref[2][1], 1); -} - -class GenericAppendFunction : public MultiFunction { - public: - GenericAppendFunction(const CPPType &type) - { - MFSignatureBuilder builder = this->get_builder("Append"); - builder.vector_mutable("Vector", type); - builder.single_input("Value", type); - } - - void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override - { - GVectorArray &vectors = params.vector_mutable(0, "Vector"); - GVSpan values = params.readonly_single_input(1, "Value"); - - for (int64_t i : mask) { - vectors.append(i, values[i]); - } - } -}; - -TEST(multi_function, GenericAppendFunction) -{ - GenericAppendFunction fn(CPPType::get<int32_t>()); - - GVectorArray vectors(CPPType::get<int32_t>(), 4); - GVectorArrayRef<int> vectors_ref(vectors); - vectors_ref.append(0, 1); - vectors_ref.append(0, 2); - vectors_ref.append(2, 6); - Array<int> values = {5, 7, 3, 1}; - - MFParamsBuilder params(fn, vectors.size()); - params.add_vector_mutable(vectors); - params.add_readonly_single_input(values.as_span()); - - MFContextBuilder context; - - fn.call(IndexRange(vectors.size()), params, context); - - EXPECT_EQ(vectors_ref[0].size(), 3); - EXPECT_EQ(vectors_ref[1].size(), 1); - EXPECT_EQ(vectors_ref[2].size(), 2); - EXPECT_EQ(vectors_ref[3].size(), 1); - - EXPECT_EQ(vectors_ref[0][0], 1); - EXPECT_EQ(vectors_ref[0][1], 2); - EXPECT_EQ(vectors_ref[0][2], 5); - EXPECT_EQ(vectors_ref[1][0], 7); - EXPECT_EQ(vectors_ref[2][0], 6); - EXPECT_EQ(vectors_ref[2][1], 3); - EXPECT_EQ(vectors_ref[3][0], 1); -} - -TEST(multi_function, CustomMF_SI_SO) -{ - CustomMF_SI_SO<std::string, uint> fn("strlen", - [](const std::string &str) { return str.size(); }); - - Array<std::string> strings = {"hello", "world", "test", "another test"}; - Array<uint> sizes(strings.size(), 0); - - MFParamsBuilder params(fn, strings.size()); - params.add_readonly_single_input(strings.as_span()); - params.add_uninitialized_single_output(sizes.as_mutable_span()); - - MFContextBuilder context; - - fn.call(IndexRange(strings.size()), params, context); - - EXPECT_EQ(sizes[0], 5); - EXPECT_EQ(sizes[1], 5); - EXPECT_EQ(sizes[2], 4); - EXPECT_EQ(sizes[3], 12); -} - -TEST(multi_function, CustomMF_SI_SI_SO) -{ - CustomMF_SI_SI_SO<int, int, int> fn("mul", [](int a, int b) { return a * b; }); - - Array<int> values_a = {4, 6, 8, 9}; - int value_b = 10; - Array<int> outputs(values_a.size(), -1); - - MFParamsBuilder params(fn, values_a.size()); - params.add_readonly_single_input(values_a.as_span()); - params.add_readonly_single_input(&value_b); - params.add_uninitialized_single_output(outputs.as_mutable_span()); - - MFContextBuilder context; - - fn.call({0, 1, 3}, params, context); - - EXPECT_EQ(outputs[0], 40); - EXPECT_EQ(outputs[1], 60); - EXPECT_EQ(outputs[2], -1); - EXPECT_EQ(outputs[3], 90); -} - -TEST(multi_function, CustomMF_SI_SI_SI_SO) -{ - CustomMF_SI_SI_SI_SO<int, std::string, bool, uint> fn{ - "custom", - [](int a, const std::string &b, bool c) { return (uint)((uint)a + b.size() + (uint)c); }}; - - Array<int> values_a = {5, 7, 3, 8}; - Array<std::string> values_b = {"hello", "world", "another", "test"}; - Array<bool> values_c = {true, false, false, true}; - Array<uint> outputs(values_a.size(), 0); - - MFParamsBuilder params(fn, values_a.size()); - params.add_readonly_single_input(values_a.as_span()); - params.add_readonly_single_input(values_b.as_span()); - params.add_readonly_single_input(values_c.as_span()); - params.add_uninitialized_single_output(outputs.as_mutable_span()); - - MFContextBuilder context; - - fn.call({1, 2, 3}, params, context); - - EXPECT_EQ(outputs[0], 0); - EXPECT_EQ(outputs[1], 12); - EXPECT_EQ(outputs[2], 10); - EXPECT_EQ(outputs[3], 13); -} - -TEST(multi_function, CustomMF_SM) -{ - CustomMF_SM<std::string> fn("AddSuffix", [](std::string &value) { value += " test"; }); - - Array<std::string> values = {"a", "b", "c", "d", "e"}; - - MFParamsBuilder params(fn, values.size()); - params.add_single_mutable(values.as_mutable_span()); - - MFContextBuilder context; - - fn.call({1, 2, 3}, params, context); - - EXPECT_EQ(values[0], "a"); - EXPECT_EQ(values[1], "b test"); - EXPECT_EQ(values[2], "c test"); - EXPECT_EQ(values[3], "d test"); - EXPECT_EQ(values[4], "e"); -} - -TEST(multi_function, CustomMF_Constant) -{ - CustomMF_Constant<int> fn{42}; - - Array<int> outputs(4, 0); - - MFParamsBuilder params(fn, outputs.size()); - params.add_uninitialized_single_output(outputs.as_mutable_span()); - - MFContextBuilder context; - - fn.call({0, 2, 3}, params, context); - - EXPECT_EQ(outputs[0], 42); - EXPECT_EQ(outputs[1], 0); - EXPECT_EQ(outputs[2], 42); - EXPECT_EQ(outputs[3], 42); -} - -TEST(multi_function, CustomMF_GenericConstant) -{ - int value = 42; - CustomMF_GenericConstant fn{CPPType::get<int32_t>(), (const void *)&value}; - EXPECT_EQ(fn.param_name(0), "42"); - - Array<int> outputs(4, 0); - - MFParamsBuilder params(fn, outputs.size()); - params.add_uninitialized_single_output(outputs.as_mutable_span()); - - MFContextBuilder context; - - fn.call({0, 1, 2}, params, context); - - EXPECT_EQ(outputs[0], 42); - EXPECT_EQ(outputs[1], 42); - EXPECT_EQ(outputs[2], 42); - EXPECT_EQ(outputs[3], 0); -} - -TEST(multi_function, CustomMF_GenericConstantArray) -{ - std::array<int, 4> values = {3, 4, 5, 6}; - CustomMF_GenericConstantArray fn{GSpan(Span(values))}; - EXPECT_EQ(fn.param_name(0), "[3, 4, 5, 6, ]"); - - GVectorArray g_vector_array{CPPType::get<int32_t>(), 4}; - GVectorArrayRef<int> vector_array = g_vector_array; - - MFParamsBuilder params(fn, g_vector_array.size()); - params.add_vector_output(g_vector_array); - - MFContextBuilder context; - - fn.call({1, 2, 3}, params, context); - - EXPECT_EQ(vector_array[0].size(), 0); - EXPECT_EQ(vector_array[1].size(), 4); - EXPECT_EQ(vector_array[2].size(), 4); - EXPECT_EQ(vector_array[3].size(), 4); - for (int i = 1; i < 4; i++) { - EXPECT_EQ(vector_array[i][0], 3); - EXPECT_EQ(vector_array[i][1], 4); - EXPECT_EQ(vector_array[i][2], 5); - EXPECT_EQ(vector_array[i][3], 6); - } -} - -TEST(multi_function, CustomMF_Convert) -{ - CustomMF_Convert<float, int> fn; - - Array<float> inputs = {5.4f, 7.1f, 9.0f}; - Array<int> outputs(inputs.size(), 0); - - MFParamsBuilder params(fn, inputs.size()); - params.add_readonly_single_input(inputs.as_span()); - params.add_uninitialized_single_output(outputs.as_mutable_span()); - - MFContextBuilder context; - fn.call({0, 2}, params, context); - - EXPECT_EQ(outputs[0], 5); - EXPECT_EQ(outputs[1], 0); - EXPECT_EQ(outputs[2], 9); -} - -} // namespace blender::fn diff --git a/tests/gtests/functions/FN_spans_test.cc b/tests/gtests/functions/FN_spans_test.cc deleted file mode 100644 index 3172cdc7170..00000000000 --- a/tests/gtests/functions/FN_spans_test.cc +++ /dev/null @@ -1,214 +0,0 @@ -/* Apache License, Version 2.0 */ - -#include "testing/testing.h" - -#include "FN_spans.hh" - -namespace blender::fn { - -TEST(generic_span, TypeConstructor) -{ - GSpan span(CPPType::get<float>()); - EXPECT_EQ(span.size(), 0); - EXPECT_EQ(span.typed<float>().size(), 0); - EXPECT_TRUE(span.is_empty()); -} - -TEST(generic_span, BufferAndSizeConstructor) -{ - int values[4] = {6, 7, 3, 2}; - void *buffer = (void *)values; - GSpan span(CPPType::get<int32_t>(), buffer, 4); - EXPECT_EQ(span.size(), 4); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span.typed<int>().size(), 4); - EXPECT_EQ(span[0], &values[0]); - EXPECT_EQ(span[1], &values[1]); - EXPECT_EQ(span[2], &values[2]); - EXPECT_EQ(span[3], &values[3]); -} - -TEST(generic_mutable_span, TypeConstructor) -{ - GMutableSpan span(CPPType::get<int32_t>()); - EXPECT_EQ(span.size(), 0); - EXPECT_TRUE(span.is_empty()); -} - -TEST(generic_mutable_span, BufferAndSizeConstructor) -{ - int values[4] = {4, 7, 3, 5}; - void *buffer = (void *)values; - GMutableSpan span(CPPType::get<int32_t>(), buffer, 4); - EXPECT_EQ(span.size(), 4); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span.typed<int>().size(), 4); - EXPECT_EQ(values[2], 3); - *(int *)span[2] = 10; - EXPECT_EQ(values[2], 10); - span.typed<int>()[2] = 20; - EXPECT_EQ(values[2], 20); -} - -TEST(virtual_span, EmptyConstructor) -{ - VSpan<int> span; - EXPECT_EQ(span.size(), 0); - EXPECT_TRUE(span.is_empty()); - EXPECT_FALSE(span.is_single_element()); - - GVSpan converted(span); - EXPECT_EQ(converted.type(), CPPType::get<int>()); - EXPECT_EQ(converted.size(), 0); -} - -TEST(virtual_span, SpanConstructor) -{ - std::array<int, 5> values = {7, 3, 8, 6, 4}; - Span<int> span = values; - VSpan<int> virtual_span = span; - EXPECT_EQ(virtual_span.size(), 5); - EXPECT_FALSE(virtual_span.is_empty()); - EXPECT_EQ(virtual_span[0], 7); - EXPECT_EQ(virtual_span[2], 8); - EXPECT_EQ(virtual_span[3], 6); - EXPECT_FALSE(virtual_span.is_single_element()); - - GVSpan converted(span); - EXPECT_EQ(converted.type(), CPPType::get<int>()); - EXPECT_EQ(converted.size(), 5); -} - -TEST(virtual_span, PointerSpanConstructor) -{ - int x0 = 3; - int x1 = 6; - int x2 = 7; - std::array<const int *, 3> pointers = {&x0, &x2, &x1}; - VSpan<int> span = Span<const int *>(pointers); - EXPECT_EQ(span.size(), 3); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span[0], 3); - EXPECT_EQ(span[1], 7); - EXPECT_EQ(span[2], 6); - EXPECT_EQ(&span[1], &x2); - EXPECT_FALSE(span.is_single_element()); - - GVSpan converted(span); - EXPECT_EQ(converted.type(), CPPType::get<int>()); - EXPECT_EQ(converted.size(), 3); - EXPECT_EQ(converted[0], &x0); - EXPECT_EQ(converted[1], &x2); - EXPECT_EQ(converted[2], &x1); -} - -TEST(virtual_span, SingleConstructor) -{ - int value = 5; - VSpan<int> span = VSpan<int>::FromSingle(&value, 3); - EXPECT_EQ(span.size(), 3); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span[0], 5); - EXPECT_EQ(span[1], 5); - EXPECT_EQ(span[2], 5); - EXPECT_EQ(&span[0], &value); - EXPECT_EQ(&span[1], &value); - EXPECT_EQ(&span[2], &value); - EXPECT_TRUE(span.is_single_element()); - - GVSpan converted(span); - EXPECT_EQ(converted.type(), CPPType::get<int>()); - EXPECT_EQ(converted.size(), 3); - EXPECT_EQ(converted[0], &value); - EXPECT_EQ(converted[1], &value); - EXPECT_EQ(converted[2], &value); -} - -TEST(generic_virtual_span, TypeConstructor) -{ - GVSpan span(CPPType::get<int32_t>()); - EXPECT_EQ(span.size(), 0); - EXPECT_TRUE(span.is_empty()); - EXPECT_FALSE(span.is_single_element()); - - VSpan<int> converted = span.typed<int>(); - EXPECT_EQ(converted.size(), 0); -} - -TEST(generic_virtual_span, GenericSpanConstructor) -{ - int values[4] = {3, 4, 5, 6}; - GVSpan span{GSpan(CPPType::get<int32_t>(), values, 4)}; - EXPECT_EQ(span.size(), 4); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span[0], &values[0]); - EXPECT_EQ(span[1], &values[1]); - EXPECT_EQ(span[2], &values[2]); - EXPECT_EQ(span[3], &values[3]); - EXPECT_FALSE(span.is_single_element()); - - int materialized[4] = {0}; - span.materialize_to_uninitialized(materialized); - EXPECT_EQ(materialized[0], 3); - EXPECT_EQ(materialized[1], 4); - EXPECT_EQ(materialized[2], 5); - EXPECT_EQ(materialized[3], 6); - - VSpan<int> converted = span.typed<int>(); - EXPECT_EQ(converted.size(), 4); - EXPECT_EQ(converted[0], 3); - EXPECT_EQ(converted[1], 4); - EXPECT_EQ(converted[2], 5); - EXPECT_EQ(converted[3], 6); -} - -TEST(generic_virtual_span, SpanConstructor) -{ - std::array<int, 3> values = {6, 7, 8}; - GVSpan span{Span<int>(values)}; - EXPECT_EQ(span.type(), CPPType::get<int32_t>()); - EXPECT_EQ(span.size(), 3); - EXPECT_EQ(span[0], &values[0]); - EXPECT_EQ(span[1], &values[1]); - EXPECT_EQ(span[2], &values[2]); - EXPECT_FALSE(span.is_single_element()); - - int materialized[3] = {0}; - span.materialize_to_uninitialized(materialized); - EXPECT_EQ(materialized[0], 6); - EXPECT_EQ(materialized[1], 7); - EXPECT_EQ(materialized[2], 8); - - VSpan<int> converted = span.typed<int>(); - EXPECT_EQ(converted.size(), 3); - EXPECT_EQ(converted[0], 6); - EXPECT_EQ(converted[1], 7); - EXPECT_EQ(converted[2], 8); -} - -TEST(generic_virtual_span, SingleConstructor) -{ - int value = 5; - GVSpan span = GVSpan::FromSingle(CPPType::get<int32_t>(), &value, 3); - EXPECT_EQ(span.size(), 3); - EXPECT_FALSE(span.is_empty()); - EXPECT_EQ(span[0], &value); - EXPECT_EQ(span[1], &value); - EXPECT_EQ(span[2], &value); - EXPECT_TRUE(span.is_single_element()); - EXPECT_EQ(span.as_single_element(), &value); - - int materialized[3] = {0}; - span.materialize_to_uninitialized({1, 2}, materialized); - EXPECT_EQ(materialized[0], 0); - EXPECT_EQ(materialized[1], 5); - EXPECT_EQ(materialized[2], 5); - - VSpan<int> converted = span.typed<int>(); - EXPECT_EQ(converted.size(), 3); - EXPECT_EQ(converted[0], 5); - EXPECT_EQ(converted[1], 5); - EXPECT_EQ(converted[2], 5); -} - -} // namespace blender::fn diff --git a/tests/gtests/runner/BlenderAddTests.cmake b/tests/gtests/runner/BlenderAddTests.cmake deleted file mode 100644 index c4f5c8aba8a..00000000000 --- a/tests/gtests/runner/BlenderAddTests.cmake +++ /dev/null @@ -1,3 +0,0 @@ -# Disable ASAN leak detection when trying to discover tests. -set(ENV{ASAN_OPTIONS} "detect_leaks=0") -include(GoogleTestAddTests) diff --git a/tests/gtests/runner/CMakeLists.txt b/tests/gtests/runner/CMakeLists.txt index 18d8f57364f..8b3390e7aec 100644 --- a/tests/gtests/runner/CMakeLists.txt +++ b/tests/gtests/runner/CMakeLists.txt @@ -35,16 +35,13 @@ endif() # Test libraries need to be linked "whole archive", because they're not # directly referenced from other code. get_property(_test_libs GLOBAL PROPERTY BLENDER_TEST_LIBS) -if(WIN32) - list(APPEND TEST_LIBS ${_test_libs}) -elseif(APPLE) - list(APPEND TEST_LIBS "-Wl,-force_load" ${_test_libs}) +if(WIN32 OR APPLE) + # Windows and macOS set target_link_options after target creation. elseif(UNIX) list(APPEND TEST_LIBS "-Wl,--whole-archive" ${_test_libs} "-Wl,--no-whole-archive") else() message(FATAL_ERROR "Unknown how to link whole-archive with your compiler ${CMAKE_CXX_COMPILER_ID}") endif() -unset(_test_libs) # This builds `bin/tests/blender_test`, but does not add it as a single test. setup_libdirs() @@ -56,18 +53,50 @@ BLENDER_SRC_GTEST_EX( ) setup_liblinks(blender_test) +if(WIN32) + foreach(_lib ${_test_libs}) + # Both target_link_libraries and target_link_options are required here + # target_link_libraries will add any dependend libraries, while just setting + # the wholearchive flag in target link options will not. + target_link_libraries(blender_test ${_lib}) + target_link_options(blender_test PRIVATE /wholearchive:$<TARGET_FILE:${_lib}>) + endforeach() +elseif(APPLE) + foreach(_lib ${_test_libs}) + # We need -force_load for every test library and target_link_libraries will + # deduplicate it. So explicitly set as linker option for every test lib. + target_link_libraries(blender_test ${_lib}) + target_link_options(blender_test PRIVATE "LINKER:-force_load,$<TARGET_FILE:${_lib}>") + endforeach() +endif() + +unset(_test_libs) + # This runs the blender_test executable with `--gtest_list_tests`, then # exposes those tests individually to the ctest runner. # See https://cmake.org/cmake/help/v3.18/module/GoogleTest.html -include(GoogleTest) +# +# We have our own modified copy of this CMake module. +include(GTest) set(_GOOGLETEST_DISCOVER_TESTS_SCRIPT - ${CMAKE_CURRENT_LIST_DIR}/BlenderAddTests.cmake + ${CMAKE_SOURCE_DIR}/build_files/cmake/Modules/GTestAddTests.cmake ) +if(APPLE) + set(_test_release_dir ${TEST_INSTALL_DIR}/Blender.app/Contents/Resources/${BLENDER_VERSION}) +else() + set(_test_release_dir ${TEST_INSTALL_DIR}/${BLENDER_VERSION}) +endif() + gtest_discover_tests(blender_test - # So that unit tests know where to find files: + WORKING_DIRECTORY "${TEST_INSTALL_DIR}" +# So that it will run after the install phase that will copy the required libraries + DISCOVERY_MODE PRE_TEST +# So that unit tests know where to find files: EXTRA_ARGS --test-assets-dir "${CMAKE_SOURCE_DIR}/../lib/tests" - --test-release-dir "${CMAKE_INSTALL_PREFIX}/${BLENDER_VERSION}" + --test-release-dir "${_test_release_dir}" ) + +unset(_test_release_dir) diff --git a/tests/gtests/testing/testing_main.cc b/tests/gtests/testing/testing_main.cc index 9816e71526b..36d39a1b3b9 100644 --- a/tests/gtests/testing/testing_main.cc +++ b/tests/gtests/testing/testing_main.cc @@ -48,7 +48,7 @@ const std::string &flags_test_release_dir() int main(int argc, char **argv) { - MEM_initialize_memleak_detection(); + MEM_init_memleak_detection(); testing::InitGoogleTest(&argc, argv); BLENDER_GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true); google::InitGoogleLogging(argv[0]); |