diff options
author | Jacques Lucke <jacques@blender.org> | 2020-07-20 13:16:20 +0300 |
---|---|---|
committer | Jacques Lucke <jacques@blender.org> | 2020-07-20 13:16:20 +0300 |
commit | 8cbbdedaf4dfec9e320e7e2be58b75d256950df1 (patch) | |
tree | 496b9620e11ac44e515b0bb4ca52c05834d557f9 /tests/gtests/blenlib | |
parent | 686ab4c9401a90b22fb17e46c992eb513fe4f693 (diff) |
Refactor: Update integer type usage
This updates the usage of integer types in code I wrote according to our new style guides.
Major changes:
* Use signed instead of unsigned integers in many places.
* C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`).
* Hash values for C++ containers are 64 bit wide now (instead of 32 bit).
I do hope that I broke no builds, but it is quite likely that some compiler reports
slightly different errors. Please let me know when there are any errors. If the fix
is small, feel free to commit it yourself.
I compiled successfully on linux with gcc and on windows.
Diffstat (limited to 'tests/gtests/blenlib')
-rw-r--r-- | tests/gtests/blenlib/BLI_array_test.cc | 32 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_disjoint_set_test.cc | 2 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_index_mask_test.cc | 2 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_index_range_test.cc | 86 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_linear_allocator_test.cc | 12 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_map_test.cc | 84 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_set_test.cc | 54 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_span_test.cc | 64 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_stack_cxx_test.cc | 32 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_string_ref_test.cc | 32 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_vector_set_test.cc | 56 | ||||
-rw-r--r-- | tests/gtests/blenlib/BLI_vector_test.cc | 156 |
12 files changed, 288 insertions, 324 deletions
diff --git a/tests/gtests/blenlib/BLI_array_test.cc b/tests/gtests/blenlib/BLI_array_test.cc index 3ff5baf1d94..4e03321454c 100644 --- a/tests/gtests/blenlib/BLI_array_test.cc +++ b/tests/gtests/blenlib/BLI_array_test.cc @@ -9,21 +9,21 @@ namespace blender { TEST(array, DefaultConstructor) { Array<int> array; - EXPECT_EQ(array.size(), 0u); + EXPECT_EQ(array.size(), 0); EXPECT_TRUE(array.is_empty()); } TEST(array, SizeConstructor) { Array<int> array(5); - EXPECT_EQ(array.size(), 5u); + EXPECT_EQ(array.size(), 5); EXPECT_FALSE(array.is_empty()); } TEST(array, FillConstructor) { Array<int> array(5, 8); - EXPECT_EQ(array.size(), 5u); + EXPECT_EQ(array.size(), 5); EXPECT_EQ(array[0], 8); EXPECT_EQ(array[1], 8); EXPECT_EQ(array[2], 8); @@ -34,7 +34,7 @@ TEST(array, FillConstructor) TEST(array, InitializerListConstructor) { Array<int> array = {4, 5, 6, 7}; - EXPECT_EQ(array.size(), 4u); + EXPECT_EQ(array.size(), 4); EXPECT_EQ(array[0], 4); EXPECT_EQ(array[1], 5); EXPECT_EQ(array[2], 6); @@ -46,7 +46,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(), 4u); + EXPECT_EQ(array.size(), 4); EXPECT_EQ(array[0], 6); EXPECT_EQ(array[1], 7); EXPECT_EQ(array[2], 8); @@ -58,8 +58,8 @@ TEST(array, CopyConstructor) Array<int> array = {5, 6, 7, 8}; Array<int> new_array(array); - EXPECT_EQ(array.size(), 4u); - EXPECT_EQ(new_array.size(), 4u); + 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); @@ -72,8 +72,8 @@ TEST(array, MoveConstructor) Array<int> array = {5, 6, 7, 8}; Array<int> new_array(std::move(array)); - EXPECT_EQ(array.size(), 0u); - EXPECT_EQ(new_array.size(), 4u); + 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); @@ -84,10 +84,10 @@ TEST(array, CopyAssignment) { Array<int> array = {1, 2, 3}; Array<int> new_array = {4}; - EXPECT_EQ(new_array.size(), 1u); + EXPECT_EQ(new_array.size(), 1); new_array = array; - EXPECT_EQ(new_array.size(), 3u); - EXPECT_EQ(array.size(), 3u); + 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); @@ -98,10 +98,10 @@ TEST(array, MoveAssignment) { Array<int> array = {1, 2, 3}; Array<int> new_array = {4}; - EXPECT_EQ(new_array.size(), 1u); + EXPECT_EQ(new_array.size(), 1); new_array = std::move(array); - EXPECT_EQ(new_array.size(), 3u); - EXPECT_EQ(array.size(), 0u); + 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); @@ -144,7 +144,7 @@ TEST(array, NoInitializationSizeConstructor) memset(buffer, 100, sizeof(MyArray)); /* Doing this to avoid some compiler optimization. */ - for (uint i : IndexRange(sizeof(MyArray))) { + for (int64_t i : IndexRange(sizeof(MyArray))) { EXPECT_EQ(((char *)buffer.ptr())[i], 100); } diff --git a/tests/gtests/blenlib/BLI_disjoint_set_test.cc b/tests/gtests/blenlib/BLI_disjoint_set_test.cc index 30503954c62..22663b936d9 100644 --- a/tests/gtests/blenlib/BLI_disjoint_set_test.cc +++ b/tests/gtests/blenlib/BLI_disjoint_set_test.cc @@ -13,7 +13,7 @@ TEST(disjoint_set, Test) 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), 3u); + EXPECT_EQ(disjoint_set.find_root(3), 3); disjoint_set.join(1, 2); diff --git a/tests/gtests/blenlib/BLI_index_mask_test.cc b/tests/gtests/blenlib/BLI_index_mask_test.cc index 6d9b7c70ab2..bce467cadd9 100644 --- a/tests/gtests/blenlib/BLI_index_mask_test.cc +++ b/tests/gtests/blenlib/BLI_index_mask_test.cc @@ -34,7 +34,7 @@ TEST(index_mask, RangeConstructor) EXPECT_TRUE(mask.is_range()); EXPECT_EQ(mask.as_range().first(), 3); EXPECT_EQ(mask.as_range().last(), 7); - Span<uint> indices = mask.indices(); + Span<int64_t> indices = mask.indices(); EXPECT_EQ(indices[0], 3); EXPECT_EQ(indices[1], 4); EXPECT_EQ(indices[2], 5); diff --git a/tests/gtests/blenlib/BLI_index_range_test.cc b/tests/gtests/blenlib/BLI_index_range_test.cc index 0f4fb7ef03b..1c4d4a1a1f3 100644 --- a/tests/gtests/blenlib/BLI_index_range_test.cc +++ b/tests/gtests/blenlib/BLI_index_range_test.cc @@ -10,42 +10,42 @@ namespace blender { TEST(index_range, DefaultConstructor) { IndexRange range; - EXPECT_EQ(range.size(), 0u); + EXPECT_EQ(range.size(), 0); - Vector<uint> vector; - for (uint value : range) { + Vector<int64_t> vector; + for (int64_t value : range) { vector.append(value); } - EXPECT_EQ(vector.size(), 0u); + EXPECT_EQ(vector.size(), 0); } TEST(index_range, SingleElementRange) { IndexRange range(4, 1); - EXPECT_EQ(range.size(), 1u); - EXPECT_EQ(*range.begin(), 4u); + EXPECT_EQ(range.size(), 1); + EXPECT_EQ(*range.begin(), 4); - Vector<uint> vector; - for (uint value : range) { + Vector<int64_t> vector; + for (int64_t value : range) { vector.append(value); } - EXPECT_EQ(vector.size(), 1u); - EXPECT_EQ(vector[0], 4u); + EXPECT_EQ(vector.size(), 1); + EXPECT_EQ(vector[0], 4); } TEST(index_range, MultipleElementRange) { IndexRange range(6, 4); - EXPECT_EQ(range.size(), 4u); + EXPECT_EQ(range.size(), 4); - Vector<uint> vector; - for (uint value : range) { + Vector<int64_t> vector; + for (int64_t value : range) { vector.append(value); } - EXPECT_EQ(vector.size(), 4u); - for (uint i = 0; i < 4; i++) { + EXPECT_EQ(vector.size(), 4); + for (int i = 0; i < 4; i++) { EXPECT_EQ(vector[i], i + 6); } } @@ -53,28 +53,28 @@ TEST(index_range, MultipleElementRange) TEST(index_range, SubscriptOperator) { IndexRange range(5, 5); - EXPECT_EQ(range[0], 5u); - EXPECT_EQ(range[1], 6u); - EXPECT_EQ(range[2], 7u); + 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], 2u); - EXPECT_EQ(range[1], 3u); - EXPECT_EQ(range[2], 4u); - EXPECT_EQ(range.size(), 3u); + 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], 10u); - EXPECT_EQ(range[1], 11u); - EXPECT_EQ(range[2], 12u); - EXPECT_EQ(range[3], 13u); - EXPECT_EQ(range.size(), 4u); + 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) @@ -90,54 +90,54 @@ TEST(index_range, Contains) TEST(index_range, First) { IndexRange range = IndexRange(5, 3); - EXPECT_EQ(range.first(), 5u); + EXPECT_EQ(range.first(), 5); } TEST(index_range, Last) { IndexRange range = IndexRange(5, 3); - EXPECT_EQ(range.last(), 7u); + EXPECT_EQ(range.last(), 7); } TEST(index_range, OneAfterEnd) { IndexRange range = IndexRange(5, 3); - EXPECT_EQ(range.one_after_last(), 8u); + EXPECT_EQ(range.one_after_last(), 8); } TEST(index_range, Start) { IndexRange range = IndexRange(6, 2); - EXPECT_EQ(range.start(), 6u); + EXPECT_EQ(range.start(), 6); } TEST(index_range, Slice) { IndexRange range = IndexRange(5, 15); IndexRange slice = range.slice(2, 6); - EXPECT_EQ(slice.size(), 6u); - EXPECT_EQ(slice.first(), 7u); - EXPECT_EQ(slice.last(), 12u); + 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(), 5u); - EXPECT_EQ(slice.first(), 8u); - EXPECT_EQ(slice.last(), 12u); + 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<uint> span = range.as_span(); - EXPECT_EQ(span.size(), 6u); - EXPECT_EQ(span[0], 4u); - EXPECT_EQ(span[1], 5u); - EXPECT_EQ(span[2], 6u); - EXPECT_EQ(span[3], 7u); + 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 index 7ef9d433a4d..9c2dcdc7457 100644 --- a/tests/gtests/blenlib/BLI_linear_allocator_test.cc +++ b/tests/gtests/blenlib/BLI_linear_allocator_test.cc @@ -70,7 +70,7 @@ TEST(linear_allocator, AllocateArray) LinearAllocator<> allocator; MutableSpan<int> span = allocator.allocate_array<int>(5); - EXPECT_EQ(span.size(), 5u); + EXPECT_EQ(span.size(), 5); } TEST(linear_allocator, Construct) @@ -79,7 +79,7 @@ TEST(linear_allocator, Construct) std::array<int, 5> values = {1, 2, 3, 4, 5}; Vector<int> *vector = allocator.construct<Vector<int>>(values); - EXPECT_EQ(vector->size(), 5u); + EXPECT_EQ(vector->size(), 5); EXPECT_EQ((*vector)[3], 4); vector->~Vector(); } @@ -92,8 +92,8 @@ TEST(linear_allocator, ConstructElementsAndPointerArray) Span<Vector<int> *> vectors = allocator.construct_elements_and_pointer_array<Vector<int>>( 5, values); - EXPECT_EQ(vectors.size(), 5u); - EXPECT_EQ(vectors[3]->size(), 7u); + EXPECT_EQ(vectors.size(), 5); + EXPECT_EQ(vectors[3]->size(), 7); EXPECT_EQ((*vectors[2])[5], 6); for (Vector<int> *vector : vectors) { @@ -109,8 +109,8 @@ TEST(linear_allocator, ConstructArrayCopy) 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(), 3u); - EXPECT_EQ(span2.size(), 3u); + EXPECT_EQ(span1.size(), 3); + EXPECT_EQ(span2.size(), 3); EXPECT_EQ(span1[1], 2); EXPECT_EQ(span2[2], 3); } diff --git a/tests/gtests/blenlib/BLI_map_test.cc b/tests/gtests/blenlib/BLI_map_test.cc index 4fb97c40e86..cebce218112 100644 --- a/tests/gtests/blenlib/BLI_map_test.cc +++ b/tests/gtests/blenlib/BLI_map_test.cc @@ -13,20 +13,20 @@ namespace blender { TEST(map, DefaultConstructor) { Map<int, float> map; - EXPECT_EQ(map.size(), 0u); + EXPECT_EQ(map.size(), 0); EXPECT_TRUE(map.is_empty()); } TEST(map, AddIncreasesSize) { Map<int, float> map; - EXPECT_EQ(map.size(), 0u); + EXPECT_EQ(map.size(), 0); EXPECT_TRUE(map.is_empty()); map.add(2, 5.0f); - EXPECT_EQ(map.size(), 1u); + EXPECT_EQ(map.size(), 1); EXPECT_FALSE(map.is_empty()); map.add(6, 2.0f); - EXPECT_EQ(map.size(), 2u); + EXPECT_EQ(map.size(), 2); EXPECT_FALSE(map.is_empty()); } @@ -89,16 +89,16 @@ TEST(map, PopTry) Map<int, int> map; map.add(1, 5); map.add(2, 7); - EXPECT_EQ(map.size(), 2u); + EXPECT_EQ(map.size(), 2); std::optional<int> value = map.pop_try(4); - EXPECT_EQ(map.size(), 2u); + EXPECT_EQ(map.size(), 2); EXPECT_FALSE(value.has_value()); value = map.pop_try(2); - EXPECT_EQ(map.size(), 1u); + 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(), 0u); + EXPECT_EQ(map.size(), 0); } TEST(map, PopDefault) @@ -107,17 +107,17 @@ TEST(map, PopDefault) map.add(1, 4); map.add(2, 7); map.add(3, 8); - EXPECT_EQ(map.size(), 3u); + EXPECT_EQ(map.size(), 3); EXPECT_EQ(map.pop_default(4, 10), 10); - EXPECT_EQ(map.size(), 3u); + EXPECT_EQ(map.size(), 3); EXPECT_EQ(map.pop_default(1, 10), 4); - EXPECT_EQ(map.size(), 2u); + EXPECT_EQ(map.size(), 2); EXPECT_EQ(map.pop_default(2, 20), 7); - EXPECT_EQ(map.size(), 1u); + EXPECT_EQ(map.size(), 1); EXPECT_EQ(map.pop_default(2, 20), 20); - EXPECT_EQ(map.size(), 1u); + EXPECT_EQ(map.size(), 1); EXPECT_EQ(map.pop_default(3, 0), 8); - EXPECT_EQ(map.size(), 0u); + EXPECT_EQ(map.size(), 0); } TEST(map, PopItemMany) @@ -143,13 +143,13 @@ TEST(map, ValueIterator) blender::Set<float> values; - uint iterations = 0; + int iterations = 0; for (float value : map.values()) { values.add(value); iterations++; } - EXPECT_EQ(iterations, 3u); + EXPECT_EQ(iterations, 3); EXPECT_TRUE(values.contains(5.0f)); EXPECT_TRUE(values.contains(-2.0f)); EXPECT_TRUE(values.contains(2.0f)); @@ -164,13 +164,13 @@ TEST(map, KeyIterator) blender::Set<int> keys; - uint iterations = 0; + int iterations = 0; for (int key : map.keys()) { keys.add(key); iterations++; } - EXPECT_EQ(iterations, 3u); + EXPECT_EQ(iterations, 3); EXPECT_TRUE(keys.contains(1)); EXPECT_TRUE(keys.contains(2)); EXPECT_TRUE(keys.contains(6)); @@ -186,7 +186,7 @@ TEST(map, ItemIterator) blender::Set<int> keys; blender::Set<float> values; - uint iterations = 0; + int iterations = 0; const Map<int, float> &const_map = map; for (auto item : const_map.items()) { keys.add(item.key); @@ -194,7 +194,7 @@ TEST(map, ItemIterator) iterations++; } - EXPECT_EQ(iterations, 3u); + EXPECT_EQ(iterations, 3); EXPECT_TRUE(keys.contains(5)); EXPECT_TRUE(keys.contains(2)); EXPECT_TRUE(keys.contains(1)); @@ -243,8 +243,8 @@ TEST(map, MutableItemToItemConversion) values.append(item.value); } - EXPECT_EQ(keys.size(), 2u); - EXPECT_EQ(values.size(), 2u); + 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)); @@ -332,10 +332,10 @@ TEST(map, MoveConstructorSmall) map1.add(1, 2.0f); map1.add(4, 1.0f); Map<int, float> map2(std::move(map1)); - EXPECT_EQ(map2.size(), 2u); + EXPECT_EQ(map2.size(), 2); EXPECT_EQ(map2.lookup(1), 2.0f); EXPECT_EQ(map2.lookup(4), 1.0f); - EXPECT_EQ(map1.size(), 0u); + EXPECT_EQ(map1.size(), 0); EXPECT_EQ(map1.lookup_ptr(4), nullptr); } @@ -346,10 +346,10 @@ TEST(map, MoveConstructorLarge) map1.add_new(i, i); } Map<int, int> map2(std::move(map1)); - EXPECT_EQ(map2.size(), 100u); + EXPECT_EQ(map2.size(), 100); EXPECT_EQ(map2.lookup(1), 1); EXPECT_EQ(map2.lookup(4), 4); - EXPECT_EQ(map1.size(), 0u); + EXPECT_EQ(map1.size(), 0); EXPECT_EQ(map1.lookup_ptr(4), nullptr); } @@ -360,10 +360,10 @@ TEST(map, MoveAssignment) map1.add(4, 1.0f); Map<int, float> map2; map2 = std::move(map1); - EXPECT_EQ(map2.size(), 2u); + EXPECT_EQ(map2.size(), 2); EXPECT_EQ(map2.lookup(1), 2.0f); EXPECT_EQ(map2.lookup(4), 1.0f); - EXPECT_EQ(map1.size(), 0u); + EXPECT_EQ(map1.size(), 0); EXPECT_EQ(map1.lookup_ptr(4), nullptr); } @@ -374,10 +374,10 @@ TEST(map, CopyAssignment) map1.add(4, 1.0f); Map<int, float> map2; map2 = map1; - EXPECT_EQ(map2.size(), 2u); + EXPECT_EQ(map2.size(), 2); EXPECT_EQ(map2.lookup(1), 2.0f); EXPECT_EQ(map2.lookup(4), 1.0f); - EXPECT_EQ(map1.size(), 2u); + EXPECT_EQ(map1.size(), 2); EXPECT_EQ(*map1.lookup_ptr(4), 1.0f); } @@ -387,13 +387,13 @@ TEST(map, Clear) map.add(1, 1.0f); map.add(2, 5.0f); - EXPECT_EQ(map.size(), 2u); + EXPECT_EQ(map.size(), 2); EXPECT_TRUE(map.contains(1)); EXPECT_TRUE(map.contains(2)); map.clear(); - EXPECT_EQ(map.size(), 0u); + EXPECT_EQ(map.size(), 0); EXPECT_FALSE(map.contains(1)); EXPECT_FALSE(map.contains(2)); } @@ -425,11 +425,11 @@ TEST(map, Remove) { Map<int, int> map; map.add(2, 4); - EXPECT_EQ(map.size(), 1u); + EXPECT_EQ(map.size(), 1); EXPECT_FALSE(map.remove(3)); - EXPECT_EQ(map.size(), 1u); + EXPECT_EQ(map.size(), 1); EXPECT_TRUE(map.remove(2)); - EXPECT_EQ(map.size(), 0u); + EXPECT_EQ(map.size(), 0); } TEST(map, PointerKeys) @@ -441,7 +441,7 @@ TEST(map, PointerKeys) EXPECT_FALSE(map.add(&a, 4)); map.add_new(&b, 1); map.add_new(&c, 1); - EXPECT_EQ(map.size(), 3u); + EXPECT_EQ(map.size(), 3); EXPECT_TRUE(map.remove(&b)); EXPECT_TRUE(map.add(&b, 8)); EXPECT_FALSE(map.remove(&d)); @@ -473,8 +473,8 @@ TEST(map, ForeachItem) values.append(value); }); - EXPECT_EQ(keys.size(), 2u); - EXPECT_EQ(values.size(), 2u); + 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)); } @@ -484,11 +484,11 @@ TEST(map, ForeachItem) */ #if 0 template<typename MapT> -BLI_NOINLINE void benchmark_random_ints(StringRef name, uint amount, uint factor) +BLI_NOINLINE void benchmark_random_ints(StringRef name, int amount, int factor) { RNG *rng = BLI_rng_new(0); Vector<int> values; - for (uint i = 0; i < amount; i++) { + for (int i = 0; i < amount; i++) { values.append(BLI_rng_get_int(rng) * factor); } BLI_rng_free(rng); @@ -520,12 +520,12 @@ BLI_NOINLINE void benchmark_random_ints(StringRef name, uint amount, uint factor TEST(map, Benchmark) { - for (uint i = 0; i < 3; i++) { + 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 (uint i = 0; i < 3; i++) { + 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>>( diff --git a/tests/gtests/blenlib/BLI_set_test.cc b/tests/gtests/blenlib/BLI_set_test.cc index 189f0c1b134..fcd958dc2f1 100644 --- a/tests/gtests/blenlib/BLI_set_test.cc +++ b/tests/gtests/blenlib/BLI_set_test.cc @@ -16,7 +16,7 @@ namespace blender { TEST(set, DefaultConstructor) { Set<int> set; - EXPECT_EQ(set.size(), 0u); + EXPECT_EQ(set.size(), 0); EXPECT_TRUE(set.is_empty()); } @@ -54,7 +54,7 @@ TEST(set, AddMany) TEST(set, InitializerListConstructor) { Set<int> set = {4, 5, 6}; - EXPECT_EQ(set.size(), 3u); + EXPECT_EQ(set.size(), 3); EXPECT_TRUE(set.contains(4)); EXPECT_TRUE(set.contains(5)); EXPECT_TRUE(set.contains(6)); @@ -79,10 +79,10 @@ TEST(set, CopyConstructor) TEST(set, MoveConstructor) { Set<int> set = {1, 2, 3}; - EXPECT_EQ(set.size(), 3u); + EXPECT_EQ(set.size(), 3); Set<int> set2(std::move(set)); - EXPECT_EQ(set.size(), 0u); - EXPECT_EQ(set2.size(), 3u); + EXPECT_EQ(set.size(), 0); + EXPECT_EQ(set2.size(), 3); } TEST(set, CopyAssignment) @@ -103,11 +103,11 @@ TEST(set, CopyAssignment) TEST(set, MoveAssignment) { Set<int> set = {1, 2, 3}; - EXPECT_EQ(set.size(), 3u); + EXPECT_EQ(set.size(), 3); Set<int> set2; set2 = std::move(set); - EXPECT_EQ(set.size(), 0u); - EXPECT_EQ(set2.size(), 3u); + EXPECT_EQ(set.size(), 0); + EXPECT_EQ(set2.size(), 3); } TEST(set, RemoveContained) @@ -179,7 +179,7 @@ TEST(set, AddMultiple) a.add_multiple({2, 4, 7}); EXPECT_TRUE(a.contains(4)); EXPECT_TRUE(a.contains(2)); - EXPECT_EQ(a.size(), 4u); + EXPECT_EQ(a.size(), 4); } TEST(set, AddMultipleNew) @@ -197,7 +197,7 @@ TEST(set, Iterator) for (int value : set) { vec.append(value); } - EXPECT_EQ(vec.size(), 5u); + EXPECT_EQ(vec.size(), 5); EXPECT_TRUE(vec.contains(1)); EXPECT_TRUE(vec.contains(3)); EXPECT_TRUE(vec.contains(2)); @@ -210,9 +210,9 @@ TEST(set, OftenAddRemoveContained) Set<int> set; for (int i = 0; i < 100; i++) { set.add(42); - EXPECT_EQ(set.size(), 1u); + EXPECT_EQ(set.size(), 1); set.remove_contained(42); - EXPECT_EQ(set.size(), 0u); + EXPECT_EQ(set.size(), 0); } } @@ -224,15 +224,15 @@ TEST(set, UniquePtrValues) set.add_new(std::move(value1)); set.add(std::unique_ptr<int>(new int())); - EXPECT_EQ(set.size(), 3u); + EXPECT_EQ(set.size(), 3); } TEST(set, Clear) { Set<int> set = {3, 4, 6, 7}; - EXPECT_EQ(set.size(), 4u); + EXPECT_EQ(set.size(), 4); set.clear(); - EXPECT_EQ(set.size(), 0u); + EXPECT_EQ(set.size(), 0); } TEST(set, StringSet) @@ -240,7 +240,7 @@ TEST(set, StringSet) Set<std::string> set; set.add("hello"); set.add("world"); - EXPECT_EQ(set.size(), 2u); + EXPECT_EQ(set.size(), 2); EXPECT_TRUE(set.contains("hello")); EXPECT_TRUE(set.contains("world")); EXPECT_FALSE(set.contains("world2")); @@ -252,7 +252,7 @@ TEST(set, PointerSet) Set<int *> set; set.add(&a); set.add(&b); - EXPECT_EQ(set.size(), 2u); + EXPECT_EQ(set.size(), 2); EXPECT_TRUE(set.contains(&a)); EXPECT_TRUE(set.contains(&b)); EXPECT_FALSE(set.contains(&c)); @@ -261,14 +261,14 @@ TEST(set, PointerSet) TEST(set, Remove) { Set<int> set = {1, 2, 3, 4, 5, 6}; - EXPECT_EQ(set.size(), 6u); + EXPECT_EQ(set.size(), 6); EXPECT_TRUE(set.remove(2)); - EXPECT_EQ(set.size(), 5u); + EXPECT_EQ(set.size(), 5); EXPECT_FALSE(set.contains(2)); EXPECT_FALSE(set.remove(2)); - EXPECT_EQ(set.size(), 5u); + EXPECT_EQ(set.size(), 5); EXPECT_TRUE(set.remove(5)); - EXPECT_EQ(set.size(), 4u); + EXPECT_EQ(set.size(), 4); } struct Type1 { @@ -363,7 +363,7 @@ template<uint N> struct EqualityIntModN { }; template<uint N> struct HashIntModN { - uint32_t operator()(uint value) const + uint64_t operator()(uint value) const { return value % N; } @@ -409,7 +409,7 @@ struct MyKeyType { uint32_t key; int32_t attached_data; - uint32_t hash() const + uint64_t hash() const { return key; } @@ -455,11 +455,11 @@ TEST(set, LookupKeyPtr) */ #if 0 template<typename SetT> -BLI_NOINLINE void benchmark_random_ints(StringRef name, uint amount, uint factor) +BLI_NOINLINE void benchmark_random_ints(StringRef name, int amount, int factor) { RNG *rng = BLI_rng_new(0); Vector<int> values; - for (uint i = 0; i < amount; i++) { + for (int i = 0; i < amount; i++) { values.append(BLI_rng_get_int(rng) * factor); } BLI_rng_free(rng); @@ -491,12 +491,12 @@ BLI_NOINLINE void benchmark_random_ints(StringRef name, uint amount, uint factor TEST(set, Benchmark) { - for (uint i = 0; i < 3; i++) { + 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 (uint i = 0; i < 3; i++) { + 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); diff --git a/tests/gtests/blenlib/BLI_span_test.cc b/tests/gtests/blenlib/BLI_span_test.cc index ccc63fd80eb..9c2e7cf26fb 100644 --- a/tests/gtests/blenlib/BLI_span_test.cc +++ b/tests/gtests/blenlib/BLI_span_test.cc @@ -11,7 +11,7 @@ TEST(span, FromSmallVector) { Vector<int> a = {1, 2, 3}; Span<int> a_span = a; - EXPECT_EQ(a_span.size(), 3u); + EXPECT_EQ(a_span.size(), 3); EXPECT_EQ(a_span[0], 1); EXPECT_EQ(a_span[1], 2); EXPECT_EQ(a_span[2], 3); @@ -23,14 +23,14 @@ TEST(span, AddConstToPointer) std::vector<int *> vec = {&a}; Span<int *> span = vec; Span<const int *> const_span = span; - EXPECT_EQ(const_span.size(), 1u); + 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(), 3u); + EXPECT_EQ(span.size(), 3); EXPECT_EQ(span[1], 5); array[1] = 10; EXPECT_EQ(span[1], 10); @@ -40,7 +40,7 @@ TEST(span, DropBack) { Vector<int> a = {4, 5, 6, 7}; auto slice = Span<int>(a).drop_back(2); - EXPECT_EQ(slice.size(), 2u); + EXPECT_EQ(slice.size(), 2); EXPECT_EQ(slice[0], 4); EXPECT_EQ(slice[1], 5); } @@ -49,14 +49,14 @@ TEST(span, DropBackAll) { Vector<int> a = {4, 5, 6, 7}; auto slice = Span<int>(a).drop_back(a.size()); - EXPECT_EQ(slice.size(), 0u); + 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(), 3u); + EXPECT_EQ(slice.size(), 3); EXPECT_EQ(slice[0], 5); EXPECT_EQ(slice[1], 6); EXPECT_EQ(slice[2], 7); @@ -66,14 +66,14 @@ TEST(span, DropFrontAll) { Vector<int> a = {4, 5, 6, 7}; auto slice = Span<int>(a).drop_front(a.size()); - EXPECT_EQ(slice.size(), 0u); + 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(), 2u); + EXPECT_EQ(slice.size(), 2); EXPECT_EQ(slice[0], 4); EXPECT_EQ(slice[1], 5); } @@ -82,7 +82,7 @@ TEST(span, TakeBack) { Vector<int> a = {5, 6, 7, 8}; auto slice = Span<int>(a).take_back(2); - EXPECT_EQ(slice.size(), 2u); + EXPECT_EQ(slice.size(), 2); EXPECT_EQ(slice[0], 7); EXPECT_EQ(slice[1], 8); } @@ -91,7 +91,7 @@ TEST(span, Slice) { Vector<int> a = {4, 5, 6, 7}; auto slice = Span<int>(a).slice(1, 2); - EXPECT_EQ(slice.size(), 2u); + EXPECT_EQ(slice.size(), 2); EXPECT_EQ(slice[0], 5); EXPECT_EQ(slice[1], 6); } @@ -100,14 +100,14 @@ TEST(span, SliceEmpty) { Vector<int> a = {4, 5, 6, 7}; auto slice = Span<int>(a).slice(2, 0); - EXPECT_EQ(slice.size(), 0u); + 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(), 2u); + EXPECT_EQ(slice.size(), 2); EXPECT_EQ(slice[0], 3); EXPECT_EQ(slice[1], 4); } @@ -128,16 +128,16 @@ 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), 0u); - EXPECT_EQ(a_span.count(2), 5u); - EXPECT_EQ(a_span.count(3), 3u); - EXPECT_EQ(a_span.count(4), 1u); - EXPECT_EQ(a_span.count(5), 0u); + 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(), 4u); + EXPECT_EQ(span.size(), 4); EXPECT_EQ(span[0], 3); EXPECT_EQ(span[1], 6); EXPECT_EQ(span[2], 8); @@ -153,7 +153,7 @@ TEST(span, FromVector) { std::vector<int> a = {1, 2, 3, 4}; Span<int> a_span(a); - EXPECT_EQ(a_span.size(), 4u); + EXPECT_EQ(a_span.size(), 4); EXPECT_EQ(a_span[0], 1); EXPECT_EQ(a_span[1], 2); EXPECT_EQ(a_span[2], 3); @@ -164,7 +164,7 @@ TEST(span, FromArray) { std::array<int, 2> a = {5, 6}; Span<int> a_span(a); - EXPECT_EQ(a_span.size(), 2u); + EXPECT_EQ(a_span.size(), 2); EXPECT_EQ(a_span[0], 5); EXPECT_EQ(a_span[1], 6); } @@ -197,8 +197,8 @@ TEST(span, SizeInBytes) { std::array<int, 10> a; Span<int> a_span(a); - EXPECT_EQ(a_span.size_in_bytes(), sizeof(a)); - EXPECT_EQ(a_span.size_in_bytes(), 40u); + EXPECT_EQ(a_span.size_in_bytes(), (int64_t)sizeof(a)); + EXPECT_EQ(a_span.size_in_bytes(), 40); } TEST(span, FirstLast) @@ -246,9 +246,9 @@ 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), 0u); - EXPECT_EQ(a_span.first_index(5), 1u); - EXPECT_EQ(a_span.first_index(2), 3u); + 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) @@ -258,8 +258,8 @@ TEST(span, CastSameSize) Span<int *> a_span = a; Span<float *> new_a_span = a_span.cast<float *>(); - EXPECT_EQ(a_span.size(), 4u); - EXPECT_EQ(new_a_span.size(), 4u); + 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); @@ -271,8 +271,8 @@ TEST(span, CastSmallerSize) Span<uint32_t> a_span = a; Span<uint16_t> new_a_span = a_span.cast<uint16_t>(); - EXPECT_EQ(a_span.size(), 4u); - EXPECT_EQ(new_a_span.size(), 8u); + EXPECT_EQ(a_span.size(), 4); + EXPECT_EQ(new_a_span.size(), 8); } TEST(span, CastLargerSize) @@ -281,8 +281,8 @@ TEST(span, CastLargerSize) Span<uint16_t> a_span = a; Span<uint32_t> new_a_span = a_span.cast<uint32_t>(); - EXPECT_EQ(a_span.size(), 4u); - EXPECT_EQ(new_a_span.size(), 2u); + EXPECT_EQ(a_span.size(), 4); + EXPECT_EQ(new_a_span.size(), 2); } TEST(span, VoidPointerSpan) @@ -291,7 +291,7 @@ TEST(span, VoidPointerSpan) float b; double c; - auto func1 = [](Span<void *> span) { EXPECT_EQ(span.size(), 3u); }; + auto func1 = [](Span<void *> span) { EXPECT_EQ(span.size(), 3); }; func1({&a, &b, &c}); } diff --git a/tests/gtests/blenlib/BLI_stack_cxx_test.cc b/tests/gtests/blenlib/BLI_stack_cxx_test.cc index c8433b4fd87..43b3dd8b3ae 100644 --- a/tests/gtests/blenlib/BLI_stack_cxx_test.cc +++ b/tests/gtests/blenlib/BLI_stack_cxx_test.cc @@ -10,7 +10,7 @@ namespace blender { TEST(stack, DefaultConstructor) { Stack<int> stack; - EXPECT_EQ(stack.size(), 0u); + EXPECT_EQ(stack.size(), 0); EXPECT_TRUE(stack.is_empty()); } @@ -18,7 +18,7 @@ TEST(stack, SpanConstructor) { std::array<int, 3> array = {4, 7, 2}; Stack<int> stack(array); - EXPECT_EQ(stack.size(), 3u); + EXPECT_EQ(stack.size(), 3); EXPECT_EQ(stack.pop(), 2); EXPECT_EQ(stack.pop(), 7); EXPECT_EQ(stack.pop(), 4); @@ -29,8 +29,8 @@ TEST(stack, CopyConstructor) { Stack<int> stack1 = {1, 2, 3, 4, 5, 6, 7}; Stack<int> stack2 = stack1; - EXPECT_EQ(stack1.size(), 7u); - EXPECT_EQ(stack2.size(), 7u); + 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()); @@ -45,8 +45,8 @@ TEST(stack, MoveConstructor) { Stack<int> stack1 = {1, 2, 3, 4, 5, 6, 7}; Stack<int> stack2 = std::move(stack1); - EXPECT_EQ(stack1.size(), 0u); - EXPECT_EQ(stack2.size(), 7u); + EXPECT_EQ(stack1.size(), 0); + EXPECT_EQ(stack2.size(), 7); for (int i = 7; i >= 1; i--) { EXPECT_EQ(stack2.pop(), i); } @@ -58,8 +58,8 @@ TEST(stack, CopyAssignment) Stack<int> stack2 = {2, 3, 4, 5, 6, 7}; stack2 = stack1; - EXPECT_EQ(stack1.size(), 7u); - EXPECT_EQ(stack2.size(), 7u); + 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()); @@ -75,8 +75,8 @@ 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(), 0u); - EXPECT_EQ(stack2.size(), 7u); + EXPECT_EQ(stack1.size(), 0); + EXPECT_EQ(stack2.size(), 7); for (int i = 7; i >= 1; i--) { EXPECT_EQ(stack2.pop(), i); } @@ -85,19 +85,19 @@ TEST(stack, MoveAssignment) TEST(stack, Push) { Stack<int> stack; - EXPECT_EQ(stack.size(), 0u); + EXPECT_EQ(stack.size(), 0); stack.push(3); - EXPECT_EQ(stack.size(), 1u); + EXPECT_EQ(stack.size(), 1); stack.push(5); - EXPECT_EQ(stack.size(), 2u); + EXPECT_EQ(stack.size(), 2); } TEST(stack, PushMultiple) { Stack<int> stack; - EXPECT_EQ(stack.size(), 0u); + EXPECT_EQ(stack.size(), 0); stack.push_multiple({1, 2, 3}); - EXPECT_EQ(stack.size(), 3u); + EXPECT_EQ(stack.size(), 3); EXPECT_EQ(stack.pop(), 3); EXPECT_EQ(stack.pop(), 2); EXPECT_EQ(stack.pop(), 1); @@ -139,7 +139,7 @@ TEST(stack, PushMultipleAfterPop) values.append(i); } stack.push_multiple(values); - EXPECT_EQ(stack.size(), 5000u); + EXPECT_EQ(stack.size(), 5000); for (int i = 4999; i >= 0; i--) { EXPECT_EQ(stack.pop(), i); diff --git a/tests/gtests/blenlib/BLI_string_ref_test.cc b/tests/gtests/blenlib/BLI_string_ref_test.cc index 0d1880229c7..83099741c29 100644 --- a/tests/gtests/blenlib/BLI_string_ref_test.cc +++ b/tests/gtests/blenlib/BLI_string_ref_test.cc @@ -10,7 +10,7 @@ namespace blender { TEST(string_ref_null, DefaultConstructor) { StringRefNull ref; - EXPECT_EQ(ref.size(), 0u); + EXPECT_EQ(ref.size(), 0); EXPECT_EQ(ref[0], '\0'); } @@ -18,7 +18,7 @@ TEST(string_ref_null, CStringConstructor) { const char *str = "Hello"; StringRefNull ref(str); - EXPECT_EQ(ref.size(), 5u); + EXPECT_EQ(ref.size(), 5); EXPECT_EQ(ref.data(), str); } @@ -26,21 +26,21 @@ TEST(string_ref_null, CStringLengthConstructor) { const char *str = "Hello"; StringRefNull ref(str, 5); - EXPECT_EQ(ref.size(), 5u); + EXPECT_EQ(ref.size(), 5); EXPECT_EQ(ref.data(), str); } TEST(string_ref, DefaultConstructor) { StringRef ref; - EXPECT_EQ(ref.size(), 0u); + EXPECT_EQ(ref.size(), 0); } TEST(string_ref, StartEndConstructor) { const char *text = "hello world"; StringRef ref(text, text + 5); - EXPECT_EQ(ref.size(), 5u); + EXPECT_EQ(ref.size(), 5); EXPECT_TRUE(ref == "hello"); EXPECT_FALSE(ref == "hello "); } @@ -48,7 +48,7 @@ TEST(string_ref, StartEndConstructor) TEST(string_ref, StartEndConstructorNullptr) { StringRef ref(nullptr, nullptr); - EXPECT_EQ(ref.size(), 0u); + EXPECT_EQ(ref.size(), 0); EXPECT_TRUE(ref == ""); } @@ -56,7 +56,7 @@ TEST(string_ref, StartEndConstructorSame) { const char *text = "hello world"; StringRef ref(text, text); - EXPECT_EQ(ref.size(), 0u); + EXPECT_EQ(ref.size(), 0); EXPECT_TRUE(ref == ""); } @@ -64,7 +64,7 @@ TEST(string_ref, CStringConstructor) { const char *str = "Test"; StringRef ref(str); - EXPECT_EQ(ref.size(), 4u); + EXPECT_EQ(ref.size(), 4); EXPECT_EQ(ref.data(), str); } @@ -72,7 +72,7 @@ TEST(string_ref, PointerWithLengthConstructor) { const char *str = "Test"; StringRef ref(str, 2); - EXPECT_EQ(ref.size(), 2u); + EXPECT_EQ(ref.size(), 2); EXPECT_EQ(ref.data(), str); } @@ -80,14 +80,14 @@ TEST(string_ref, StdStringConstructor) { std::string str = "Test"; StringRef ref(str); - EXPECT_EQ(ref.size(), 4u); + EXPECT_EQ(ref.size(), 4); EXPECT_EQ(ref.data(), str.data()); } TEST(string_ref, SubscriptOperator) { StringRef ref("hello"); - EXPECT_EQ(ref.size(), 5u); + EXPECT_EQ(ref.size(), 5); EXPECT_EQ(ref[0], 'h'); EXPECT_EQ(ref[1], 'e'); EXPECT_EQ(ref[2], 'l'); @@ -99,7 +99,7 @@ TEST(string_ref, ToStdString) { StringRef ref("test"); std::string str = ref; - EXPECT_EQ(str.size(), 4u); + EXPECT_EQ(str.size(), 4); EXPECT_EQ(str, "test"); } @@ -204,7 +204,7 @@ TEST(string_ref, Iterate) for (char c : ref) { chars.append(c); } - EXPECT_EQ(chars.size(), 4u); + EXPECT_EQ(chars.size(), 4); EXPECT_EQ(chars[0], 't'); EXPECT_EQ(chars[1], 'e'); EXPECT_EQ(chars[2], 's'); @@ -240,8 +240,8 @@ TEST(string_ref, DropPrefixN) StringRef ref("test"); StringRef ref2 = ref.drop_prefix(2); StringRef ref3 = ref2.drop_prefix(2); - EXPECT_EQ(ref2.size(), 2u); - EXPECT_EQ(ref3.size(), 0u); + EXPECT_EQ(ref2.size(), 2); + EXPECT_EQ(ref3.size(), 0); EXPECT_EQ(ref2, "st"); EXPECT_EQ(ref3, ""); } @@ -250,7 +250,7 @@ TEST(string_ref, DropPrefix) { StringRef ref("test"); StringRef ref2 = ref.drop_prefix("tes"); - EXPECT_EQ(ref2.size(), 1u); + EXPECT_EQ(ref2.size(), 1); EXPECT_EQ(ref2, "t"); } diff --git a/tests/gtests/blenlib/BLI_vector_set_test.cc b/tests/gtests/blenlib/BLI_vector_set_test.cc index 3c3b4d55959..116c4747c5a 100644 --- a/tests/gtests/blenlib/BLI_vector_set_test.cc +++ b/tests/gtests/blenlib/BLI_vector_set_test.cc @@ -9,14 +9,14 @@ namespace blender { TEST(vector_set, DefaultConstructor) { VectorSet<int> set; - EXPECT_EQ(set.size(), 0u); + 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(), 3u); + EXPECT_EQ(set.size(), 3); EXPECT_EQ(set[0], 1); EXPECT_EQ(set[1], 4); EXPECT_EQ(set[2], 5); @@ -25,7 +25,7 @@ TEST(vector_set, InitializerListConstructor_WithoutDuplicates) TEST(vector_set, InitializerListConstructor_WithDuplicates) { VectorSet<int> set = {1, 3, 3, 2, 1, 5}; - EXPECT_EQ(set.size(), 4u); + EXPECT_EQ(set.size(), 4); EXPECT_EQ(set[0], 1); EXPECT_EQ(set[1], 3); EXPECT_EQ(set[2], 2); @@ -36,10 +36,10 @@ TEST(vector_set, Copy) { VectorSet<int> set1 = {1, 2, 3}; VectorSet<int> set2 = set1; - EXPECT_EQ(set1.size(), 3u); - EXPECT_EQ(set2.size(), 3u); - EXPECT_EQ(set1.index_of(2), 1u); - EXPECT_EQ(set2.index_of(2), 1u); + 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) @@ -47,18 +47,18 @@ TEST(vector_set, CopyAssignment) VectorSet<int> set1 = {1, 2, 3}; VectorSet<int> set2 = {}; set2 = set1; - EXPECT_EQ(set1.size(), 3u); - EXPECT_EQ(set2.size(), 3u); - EXPECT_EQ(set1.index_of(2), 1u); - EXPECT_EQ(set2.index_of(2), 1u); + 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(), 0u); - EXPECT_EQ(set2.size(), 3u); + EXPECT_EQ(set1.size(), 0); + EXPECT_EQ(set2.size(), 3); } TEST(vector_set, MoveAssignment) @@ -66,36 +66,36 @@ TEST(vector_set, MoveAssignment) VectorSet<int> set1 = {1, 2, 3}; VectorSet<int> set2 = {}; set2 = std::move(set1); - EXPECT_EQ(set1.size(), 0u); - EXPECT_EQ(set2.size(), 3u); + 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(), 0u); + EXPECT_EQ(set.size(), 0); set.add(5); EXPECT_FALSE(set.is_empty()); - EXPECT_EQ(set.size(), 1u); + EXPECT_EQ(set.size(), 1); } TEST(vector_set, AddExistingDoesNotIncreaseSize) { VectorSet<int> set; - EXPECT_EQ(set.size(), 0u); + EXPECT_EQ(set.size(), 0); EXPECT_TRUE(set.add(5)); - EXPECT_EQ(set.size(), 1u); + EXPECT_EQ(set.size(), 1); EXPECT_FALSE(set.add(5)); - EXPECT_EQ(set.size(), 1u); + EXPECT_EQ(set.size(), 1); } TEST(vector_set, Index) { VectorSet<int> set = {3, 6, 4}; - EXPECT_EQ(set.index_of(6), 1u); - EXPECT_EQ(set.index_of(3), 0u); - EXPECT_EQ(set.index_of(4), 2u); + 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) @@ -110,21 +110,21 @@ TEST(vector_set, IndexTry) TEST(vector_set, RemoveContained) { VectorSet<int> set = {4, 5, 6, 7}; - EXPECT_EQ(set.size(), 4u); + EXPECT_EQ(set.size(), 4); set.remove_contained(5); - EXPECT_EQ(set.size(), 3u); + 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(), 2u); + EXPECT_EQ(set.size(), 2); EXPECT_EQ(set[0], 4); EXPECT_EQ(set[1], 7); set.remove_contained(4); - EXPECT_EQ(set.size(), 1u); + EXPECT_EQ(set.size(), 1); EXPECT_EQ(set[0], 7); set.remove_contained(7); - EXPECT_EQ(set.size(), 0u); + EXPECT_EQ(set.size(), 0); } TEST(vector_set, AddMultipleTimes) diff --git a/tests/gtests/blenlib/BLI_vector_test.cc b/tests/gtests/blenlib/BLI_vector_test.cc index 25435739a43..b203970ff8e 100644 --- a/tests/gtests/blenlib/BLI_vector_test.cc +++ b/tests/gtests/blenlib/BLI_vector_test.cc @@ -10,13 +10,13 @@ namespace blender { TEST(vector, DefaultConstructor) { Vector<int> vec; - EXPECT_EQ(vec.size(), 0u); + EXPECT_EQ(vec.size(), 0); } TEST(vector, SizeConstructor) { Vector<int> vec(3); - EXPECT_EQ(vec.size(), 3u); + EXPECT_EQ(vec.size(), 3); } /** @@ -42,7 +42,7 @@ TEST(vector, TrivialTypeSizeConstructor) TEST(vector, SizeValueConstructor) { Vector<int> vec(4, 10); - EXPECT_EQ(vec.size(), 4u); + EXPECT_EQ(vec.size(), 4); EXPECT_EQ(vec[0], 10); EXPECT_EQ(vec[1], 10); EXPECT_EQ(vec[2], 10); @@ -52,7 +52,7 @@ TEST(vector, SizeValueConstructor) TEST(vector, InitializerListConstructor) { Vector<int> vec = {1, 3, 4, 6}; - EXPECT_EQ(vec.size(), 4u); + EXPECT_EQ(vec.size(), 4); EXPECT_EQ(vec[0], 1); EXPECT_EQ(vec[1], 3); EXPECT_EQ(vec[2], 4); @@ -63,7 +63,7 @@ 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(), 5u); + EXPECT_EQ(vec.size(), 5); EXPECT_EQ(vec[0], 5); EXPECT_EQ(vec[1], 7); EXPECT_EQ(vec[2], -8); @@ -88,7 +88,7 @@ TEST(vector, ListBaseConstructor) BLI_addtail(&list, value3); Vector<TestListValue *> vec(list); - EXPECT_EQ(vec.size(), 3u); + EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec[0]->value, 4); EXPECT_EQ(vec[1]->value, 5); EXPECT_EQ(vec[2]->value, 6); @@ -106,7 +106,7 @@ TEST(vector, ContainerConstructor) list.push_front(5); Vector<int> vec = Vector<int>::FromContainer(list); - EXPECT_EQ(vec.size(), 3u); + EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec[0], 5); EXPECT_EQ(vec[1], 1); EXPECT_EQ(vec[2], 3); @@ -116,7 +116,7 @@ TEST(vector, CopyConstructor) { Vector<int> vec1 = {1, 2, 3}; Vector<int> vec2(vec1); - EXPECT_EQ(vec2.size(), 3u); + EXPECT_EQ(vec2.size(), 3); EXPECT_EQ(vec2[0], 1); EXPECT_EQ(vec2[1], 2); EXPECT_EQ(vec2[2], 3); @@ -131,8 +131,8 @@ TEST(vector, CopyConstructor2) Vector<int, 2> vec1 = {1, 2, 3, 4}; Vector<int, 3> vec2(vec1); - EXPECT_EQ(vec1.size(), 4u); - EXPECT_EQ(vec2.size(), 4u); + 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); @@ -145,8 +145,8 @@ TEST(vector, CopyConstructor3) Vector<int, 20> vec1 = {1, 2, 3, 4}; Vector<int, 1> vec2(vec1); - EXPECT_EQ(vec1.size(), 4u); - EXPECT_EQ(vec2.size(), 4u); + EXPECT_EQ(vec1.size(), 4); + EXPECT_EQ(vec2.size(), 4); EXPECT_NE(vec1.data(), vec2.data()); EXPECT_EQ(vec2[2], 3); } @@ -156,8 +156,8 @@ TEST(vector, CopyConstructor4) Vector<int, 5> vec1 = {1, 2, 3, 4}; Vector<int, 6> vec2(vec1); - EXPECT_EQ(vec1.size(), 4u); - EXPECT_EQ(vec2.size(), 4u); + EXPECT_EQ(vec1.size(), 4); + EXPECT_EQ(vec2.size(), 4); EXPECT_NE(vec1.data(), vec2.data()); EXPECT_EQ(vec2[3], 4); } @@ -167,8 +167,8 @@ TEST(vector, MoveConstructor) Vector<int> vec1 = {1, 2, 3, 4}; Vector<int> vec2(std::move(vec1)); - EXPECT_EQ(vec1.size(), 0u); - EXPECT_EQ(vec2.size(), 4u); + 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); @@ -180,8 +180,8 @@ TEST(vector, MoveConstructor2) Vector<int, 2> vec1 = {1, 2, 3, 4}; Vector<int, 3> vec2(std::move(vec1)); - EXPECT_EQ(vec1.size(), 0u); - EXPECT_EQ(vec2.size(), 4u); + 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); @@ -193,8 +193,8 @@ TEST(vector, MoveConstructor3) Vector<int, 20> vec1 = {1, 2, 3, 4}; Vector<int, 1> vec2(std::move(vec1)); - EXPECT_EQ(vec1.size(), 0u); - EXPECT_EQ(vec2.size(), 4u); + EXPECT_EQ(vec1.size(), 0); + EXPECT_EQ(vec2.size(), 4); EXPECT_EQ(vec2[2], 3); } @@ -203,20 +203,20 @@ TEST(vector, MoveConstructor4) Vector<int, 5> vec1 = {1, 2, 3, 4}; Vector<int, 6> vec2(std::move(vec1)); - EXPECT_EQ(vec1.size(), 0u); - EXPECT_EQ(vec2.size(), 4u); + 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(), 2u); + EXPECT_EQ(vec.size(), 2); EXPECT_EQ(vec[0], 1); EXPECT_EQ(vec[1], 2); vec = Vector<int>({5}); - EXPECT_EQ(vec.size(), 1u); + EXPECT_EQ(vec.size(), 1); EXPECT_EQ(vec[0], 5); } @@ -224,11 +224,11 @@ TEST(vector, CopyAssignment) { Vector<int> vec1 = {1, 2, 3}; Vector<int> vec2 = {4, 5}; - EXPECT_EQ(vec1.size(), 3u); - EXPECT_EQ(vec2.size(), 2u); + EXPECT_EQ(vec1.size(), 3); + EXPECT_EQ(vec2.size(), 2); vec2 = vec1; - EXPECT_EQ(vec2.size(), 3u); + EXPECT_EQ(vec2.size(), 3); vec1[0] = 7; EXPECT_EQ(vec1[0], 7); @@ -241,7 +241,7 @@ TEST(vector, Append) vec.append(3); vec.append(6); vec.append(7); - EXPECT_EQ(vec.size(), 3u); + EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec[0], 3); EXPECT_EQ(vec[1], 6); EXPECT_EQ(vec[2], 7); @@ -250,56 +250,33 @@ TEST(vector, Append) TEST(vector, AppendAndGetIndex) { Vector<int> vec; - EXPECT_EQ(vec.append_and_get_index(10), 0u); - EXPECT_EQ(vec.append_and_get_index(10), 1u); - EXPECT_EQ(vec.append_and_get_index(10), 2u); + 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), 4u); + EXPECT_EQ(vec.append_and_get_index(10), 4); } TEST(vector, AppendNonDuplicates) { Vector<int> vec; vec.append_non_duplicates(4); - EXPECT_EQ(vec.size(), 1u); + EXPECT_EQ(vec.size(), 1); vec.append_non_duplicates(5); - EXPECT_EQ(vec.size(), 2u); + EXPECT_EQ(vec.size(), 2); vec.append_non_duplicates(4); - EXPECT_EQ(vec.size(), 2u); + EXPECT_EQ(vec.size(), 2); } TEST(vector, ExtendNonDuplicates) { Vector<int> vec; vec.extend_non_duplicates({1, 2}); - EXPECT_EQ(vec.size(), 2u); + EXPECT_EQ(vec.size(), 2); vec.extend_non_duplicates({3, 4}); - EXPECT_EQ(vec.size(), 4u); + EXPECT_EQ(vec.size(), 4); vec.extend_non_duplicates({0, 1, 2, 3}); - EXPECT_EQ(vec.size(), 5u); -} - -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); -} - -TEST(vector, FillIndices) -{ - Vector<int> vec(5, 0); - vec.fill_indices({1, 2}, 4); - EXPECT_EQ(vec[0], 0); - EXPECT_EQ(vec[1], 4); - EXPECT_EQ(vec[2], 4); - EXPECT_EQ(vec[3], 0); - EXPECT_EQ(vec[4], 0); + EXPECT_EQ(vec.size(), 5); } TEST(vector, Iterator) @@ -318,8 +295,8 @@ TEST(vector, BecomeLarge) for (int i = 0; i < 100; i++) { vec.append(i * 5); } - EXPECT_EQ(vec.size(), 100u); - for (uint i = 0; i < 100; i++) { + EXPECT_EQ(vec.size(), 100); + for (int i = 0; i < 100; i++) { EXPECT_EQ(vec[i], static_cast<int>(i * 5)); } } @@ -332,7 +309,7 @@ static Vector<int> return_by_value_helper() TEST(vector, ReturnByValue) { Vector<int> vec = return_by_value_helper(); - EXPECT_EQ(vec.size(), 3u); + EXPECT_EQ(vec.size(), 3); EXPECT_EQ(vec[0], 3); EXPECT_EQ(vec[1], 5); EXPECT_EQ(vec[2], 1); @@ -341,39 +318,26 @@ TEST(vector, ReturnByValue) TEST(vector, VectorOfVectors_Append) { Vector<Vector<int>> vec; - EXPECT_EQ(vec.size(), 0u); + EXPECT_EQ(vec.size(), 0); Vector<int> v({1, 2}); vec.append(v); vec.append({7, 8}); - EXPECT_EQ(vec.size(), 2u); + 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, VectorOfVectors_Fill) -{ - Vector<Vector<int>> vec(3); - vec.fill({4, 5}); - - EXPECT_EQ(vec[0][0], 4); - EXPECT_EQ(vec[0][1], 5); - EXPECT_EQ(vec[1][0], 4); - EXPECT_EQ(vec[1][1], 5); - EXPECT_EQ(vec[2][0], 4); - EXPECT_EQ(vec[2][1], 5); -} - TEST(vector, RemoveLast) { Vector<int> vec = {5, 6}; - EXPECT_EQ(vec.size(), 2u); + EXPECT_EQ(vec.size(), 2); vec.remove_last(); - EXPECT_EQ(vec.size(), 1u); + EXPECT_EQ(vec.size(), 1); vec.remove_last(); - EXPECT_EQ(vec.size(), 0u); + EXPECT_EQ(vec.size(), 0); } TEST(vector, IsEmpty) @@ -415,7 +379,7 @@ TEST(vector, RemoveFirstOccurrenceAndReorder) vec.remove_first_occurrence_and_reorder(4); EXPECT_EQ(vec[0], 7); vec.remove_first_occurrence_and_reorder(7); - EXPECT_EQ(vec.size(), 0u); + EXPECT_EQ(vec.size(), 0); } TEST(vector, Remove) @@ -440,7 +404,7 @@ TEST(vector, ExtendSmallVector) Vector<int> a = {2, 3, 4}; Vector<int> b = {11, 12}; b.extend(a); - EXPECT_EQ(b.size(), 5u); + EXPECT_EQ(b.size(), 5); EXPECT_EQ(b[0], 11); EXPECT_EQ(b[1], 12); EXPECT_EQ(b[2], 2); @@ -455,7 +419,7 @@ TEST(vector, ExtendArray) Vector<int> a; a.extend(array, 2); - EXPECT_EQ(a.size(), 2u); + EXPECT_EQ(a.size(), 2); EXPECT_EQ(a[0], 3); EXPECT_EQ(a[1], 4); } @@ -471,7 +435,7 @@ TEST(vector, AppendNTimes) Vector<int> a; a.append_n_times(5, 3); a.append_n_times(2, 2); - EXPECT_EQ(a.size(), 5u); + EXPECT_EQ(a.size(), 5); EXPECT_EQ(a[0], 5); EXPECT_EQ(a[1], 5); EXPECT_EQ(a[2], 5); @@ -486,13 +450,13 @@ TEST(vector, UniquePtrValue) 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(), 4u); + 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(), 1u); + EXPECT_EQ(vec.size(), 1); UNUSED_VARS(a, b); } @@ -607,29 +571,29 @@ TEST(vector, Resize) { std::string long_string = "012345678901234567890123456789"; Vector<std::string> vec; - EXPECT_EQ(vec.size(), 0u); + EXPECT_EQ(vec.size(), 0); vec.resize(2); - EXPECT_EQ(vec.size(), 2u); + EXPECT_EQ(vec.size(), 2); EXPECT_EQ(vec[0], ""); EXPECT_EQ(vec[1], ""); vec.resize(5, long_string); - EXPECT_EQ(vec.size(), 5u); + 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(), 1u); + 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), 0u); - EXPECT_EQ(vec.first_index_of(5), 2u); - EXPECT_EQ(vec.first_index_of(9), 5u); + 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) @@ -657,7 +621,7 @@ TEST(vector, ConstructVoidPointerVector) float b; double c; Vector<void *> vec = {&a, &b, &c}; - EXPECT_EQ(vec.size(), 3u); + EXPECT_EQ(vec.size(), 3); } } // namespace blender |