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.

17 files changed, 301 insertions, 337 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
diff --git a/tests/gtests/functions/FN_array_spans_test.cc b/tests/gtests/functions/FN_array_spans_test.cc
index 6912a62ff17..6b7bb8429ff 100644
--- a/tests/gtests/functions/FN_array_spans_test.cc
+++ b/tests/gtests/functions/FN_array_spans_test.cc
@@ -50,7 +50,7 @@ TEST(virtual_array_span, MultipleArrayConstructor)
   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<uint, 3> sizes{values0.size(), values1.size(), values2.size()};
+  std::array<int64_t, 3> sizes{values0.size(), values1.size(), values2.size()};
 
   VArraySpan<int> span{starts, sizes};
   EXPECT_EQ(span.size(), 3);
diff --git a/tests/gtests/functions/FN_attributes_ref_test.cc b/tests/gtests/functions/FN_attributes_ref_test.cc
index 0b0afdc210f..9c7cce83493 100644
--- a/tests/gtests/functions/FN_attributes_ref_test.cc
+++ b/tests/gtests/functions/FN_attributes_ref_test.cc
@@ -58,7 +58,7 @@ TEST(mutable_attributes_ref, ComplexTest)
   info_builder.add<std::string>("Name", "<no name>");
   AttributesInfo info{info_builder};
 
-  uint amount = 5;
+  int amount = 5;
   Array<float3> positions(amount);
   Array<uint> ids(amount, 0);
   Array<float> sizes(amount);
diff --git a/tests/gtests/functions/FN_cpp_type_test.cc b/tests/gtests/functions/FN_cpp_type_test.cc
index 78731f9c987..85fc1105c25 100644
--- a/tests/gtests/functions/FN_cpp_type_test.cc
+++ b/tests/gtests/functions/FN_cpp_type_test.cc
@@ -67,7 +67,7 @@ struct TestType {
     return false;
   }
 
-  uint32_t hash() const
+  uint64_t hash() const
   {
     return 0;
   }
diff --git a/tests/gtests/functions/FN_multi_function_network_test.cc b/tests/gtests/functions/FN_multi_function_network_test.cc
index 35af8300cfa..9f16b71bb10 100644
--- a/tests/gtests/functions/FN_multi_function_network_test.cc
+++ b/tests/gtests/functions/FN_multi_function_network_test.cc
@@ -78,7 +78,7 @@ class ConcatVectorsFunction : public MultiFunction {
     GVectorArrayRef<int> a = params.vector_mutable<int>(0);
     VArraySpan<int> b = params.readonly_vector_input<int>(1);
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       a.extend(i, b[i]);
     }
   }
@@ -98,7 +98,7 @@ class AppendFunction : public MultiFunction {
     GVectorArrayRef<int> vectors = params.vector_mutable<int>(0);
     VSpan<int> values = params.readonly_single_input<int>(1);
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       vectors.append(i, values[i]);
     }
   }
@@ -118,10 +118,10 @@ class SumVectorFunction : public MultiFunction {
     VArraySpan<int> vectors = params.readonly_vector_input<int>(0);
     MutableSpan<int> sums = params.uninitialized_single_output<int>(1);
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       int sum = 0;
       VSpan<int> vector = vectors[i];
-      for (uint j = 0; j < vector.size(); j++) {
+      for (int j = 0; j < vector.size(); j++) {
         sum += vector[j];
       }
       sums[i] = sum;
@@ -143,7 +143,7 @@ class CreateRangeFunction : public MultiFunction {
     VSpan<int> sizes = params.readonly_single_input<int>(0, "Size");
     GVectorArrayRef<int> ranges = params.vector_output<int>(1, "Range");
 
-    for (int i : mask) {
+    for (int64_t i : mask) {
       int size = sizes[i];
       for (int j : IndexRange(size)) {
         ranges.append(i, j);
diff --git a/tests/gtests/functions/FN_multi_function_test.cc b/tests/gtests/functions/FN_multi_function_test.cc
index 66039e463ed..8b5fb060c36 100644
--- a/tests/gtests/functions/FN_multi_function_test.cc
+++ b/tests/gtests/functions/FN_multi_function_test.cc
@@ -23,7 +23,7 @@ class AddFunction : public MultiFunction {
     VSpan<int> b = params.readonly_single_input<int>(1, "B");
     MutableSpan<int> result = params.uninitialized_single_output<int>(2, "Result");
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       result[i] = a[i] + b[i];
     }
   }
@@ -65,7 +65,7 @@ class AddPrefixFunction : public MultiFunction {
     VSpan<std::string> prefixes = params.readonly_single_input<std::string>(0, "Prefix");
     MutableSpan<std::string> strings = params.single_mutable<std::string>(1, "Strings");
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       strings[i] = prefixes[i] + strings[i];
     }
   }
@@ -112,7 +112,7 @@ class CreateRangeFunction : public MultiFunction {
     VSpan<uint> sizes = params.readonly_single_input<uint>(0, "Size");
     GVectorArrayRef<uint> ranges = params.vector_output<uint>(1, "Range");
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       uint size = sizes[i];
       for (uint j : IndexRange(size)) {
         ranges.append(i, j);
@@ -164,7 +164,7 @@ class GenericAppendFunction : public MultiFunction {
     GVectorArray &vectors = params.vector_mutable(0, "Vector");
     GVSpan values = params.readonly_single_input(1, "Value");
 
-    for (uint i : mask) {
+    for (int64_t i : mask) {
       vectors.append(i, values[i]);
     }
   }
@@ -355,7 +355,7 @@ TEST(multi_function, CustomMF_GenericConstantArray)
   EXPECT_EQ(vector_array[1].size(), 4);
   EXPECT_EQ(vector_array[2].size(), 4);
   EXPECT_EQ(vector_array[3].size(), 4);
-  for (uint i = 1; i < 4; i++) {
+  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);