tests: Fix failing test and improve msvc setup

rpcs3/CMakeLists.txt

@@ -201,6 +201,7 @@ elseif(BUILD_RPCS3_TESTS)
         PRIVATE
             tests/test.cpp
             tests/test_fmt.cpp
+            tests/test_simple_array.cpp
     )
 
     target_link_libraries(rpcs3_test

rpcs3/Emu/RSX/Common/simple_array.hpp

@@ -23,9 +23,9 @@ namespace rsx
 		Ty* _data = _local_capacity ? reinterpret_cast<Ty*>(_local_storage) : nullptr;
 		u32 _size = 0;
 
-		inline u64 offset(const_iterator pos)
+		inline u32 offset(const_iterator pos)
 		{
-			return (_data) ? u64(pos - _data) : 0ull;
+			return (_data) ? u32(pos - _data) : 0u;
 		}
 
 		bool is_local_storage() const

rpcs3/tests/rpcs3_test.vcxproj

@@ -88,6 +88,7 @@
   <ItemGroup>
     <ClCompile Include="test.cpp" />
     <ClCompile Include="test_fmt.cpp" />
+    <ClCompile Include="test_simple_array.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets" Condition="'$(GTestInstalled)' == 'true'">

rpcs3/tests/test_simple_array.cpp

@@ -1,64 +1,76 @@
 #include <gtest/gtest.h>
+
+#define private public
 #include "Emu/RSX/Common/simple_array.hpp"
+#undef private
 
-using namespace rsx;
+namespace rsx
-
-TEST(SimpleArray, DefaultConstructor)
 {
-    simple_array<int> arr;
+	TEST(SimpleArray, DefaultConstructor)
+	{
+		rsx::simple_array<int> arr;
+
 		EXPECT_TRUE(arr.empty());
 		EXPECT_EQ(arr.size(), 0);
-    EXPECT_GE(arr.capacity(), 1);
+		EXPECT_GE(arr.capacity(), 1u);
-}
+	}
+
+	TEST(SimpleArray, InitialSizeConstructor)
+	{
+		rsx::simple_array<int> arr(5);
 
-TEST(SimpleArray, InitialSizeConstructor)
-{
-    simple_array<int> arr(5);
 		EXPECT_FALSE(arr.empty());
 		EXPECT_EQ(arr.size(), 5);
-    EXPECT_GE(arr.capacity(), 5);
+		EXPECT_GE(arr.capacity(), 5u);
-}
+	}
+
+	TEST(SimpleArray, InitialSizeValueConstructor)
+	{
+		rsx::simple_array<int> arr(3, 42);
 
-TEST(SimpleArray, InitialSizeValueConstructor)
-{
-    simple_array<int> arr(3, 42);
 		EXPECT_EQ(arr.size(), 3);
-    for (int i = 0; i < 3; ++i) {
+		for (int i = 0; i < 3; ++i)
+		{
 			EXPECT_EQ(arr[i], 42);
 		}
-}
+	}
+
+	TEST(SimpleArray, InitializerListConstructor)
+	{
+		rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
 
-TEST(SimpleArray, InitializerListConstructor)
-{
-    simple_array<int> arr{1, 2, 3, 4, 5};
 		EXPECT_EQ(arr.size(), 5);
-    for (int i = 0; i < 5; ++i) {
+		for (int i = 0; i < 5; ++i)
+		{
 			EXPECT_EQ(arr[i], i + 1);
 		}
-}
+	}
+
+	TEST(SimpleArray, CopyConstructor)
+	{
+		rsx::simple_array<int> arr1{ 1, 2, 3 };
+		rsx::simple_array<int> arr2(arr1);
 
-TEST(SimpleArray, CopyConstructor)
-{
-    simple_array<int> arr1{1, 2, 3};
-    simple_array<int> arr2(arr1);
 		EXPECT_EQ(arr1.size(), arr2.size());
-    for (u32 i = 0; i < arr1.size(); ++i) {
+		for (u32 i = 0; i < arr1.size(); ++i)
+		{
 			EXPECT_EQ(arr1[i], arr2[i]);
 		}
-}
+	}
 
-TEST(SimpleArray, MoveConstructor)
+	TEST(SimpleArray, MoveConstructor)
-{
+	{
-    simple_array<int> arr1{1, 2, 3};
+		rsx::simple_array<int> arr1{ 1, 2, 3 };
 		u32 original_size = arr1.size();
-    simple_array<int> arr2(std::move(arr1));
+		rsx::simple_array<int> arr2(std::move(arr1));
+
 		EXPECT_EQ(arr2.size(), original_size);
 		EXPECT_TRUE(arr1.empty());
-}
+	}
 
-TEST(SimpleArray, PushBackAndAccess)
+	TEST(SimpleArray, PushBackAndAccess)
-{
+	{
-    simple_array<int> arr;
+		rsx::simple_array<int> arr;
 		arr.push_back(1);
 		arr.push_back(2);
 		arr.push_back(3);
@@ -69,97 +81,112 @@ TEST(SimpleArray, PushBackAndAccess)
 		EXPECT_EQ(arr[2], 3);
 		EXPECT_EQ(arr.front(), 1);
 		EXPECT_EQ(arr.back(), 3);
-}
+	}
+
+	TEST(SimpleArray, PopBack)
+	{
+		rsx::simple_array<int> arr{ 1, 2, 3 };
 
-TEST(SimpleArray, PopBack)
-{
-    simple_array<int> arr{1, 2, 3};
 		EXPECT_EQ(arr.pop_back(), 3);
 		EXPECT_EQ(arr.size(), 2);
 		EXPECT_EQ(arr.back(), 2);
-}
+	}
 
-TEST(SimpleArray, Insert)
+	TEST(SimpleArray, Insert)
-{
+	{
-    simple_array<int> arr{1, 3, 4};
+		rsx::simple_array<int> arr{ 1, 3, 4 };
 		auto it = arr.insert(arr.begin() + 1, 2);
+
 		EXPECT_EQ(*it, 2);
 		EXPECT_EQ(arr.size(), 4);
-    for (int i = 0; i < 4; ++i) {
+
+		for (int i = 0; i < 4; ++i)
+		{
 			EXPECT_EQ(arr[i], i + 1);
 		}
-}
+	}
 
-TEST(SimpleArray, Clear)
+	TEST(SimpleArray, Clear)
-{
+	{
-    simple_array<int> arr{1, 2, 3};
+		rsx::simple_array<int> arr{ 1, 2, 3 };
 		arr.clear();
+
 		EXPECT_TRUE(arr.empty());
 		EXPECT_EQ(arr.size(), 0);
-}
+	}
 
-TEST(SimpleArray, SmallBufferOptimization)
+	TEST(SimpleArray, SmallBufferOptimization)
-{
+	{
 		// Test with a small type that should use stack storage
-    simple_array<char> small_arr(3, 'a');
+		rsx::simple_array<char> small_arr(3, 'a');
 		EXPECT_TRUE(small_arr.is_local_storage());
 
 		// Test with a larger type or more elements that should use heap storage
 		struct LargeType { char data[128]; };
-    simple_array<LargeType> large_arr(10);
+		rsx::simple_array<LargeType> large_arr(10);
 		EXPECT_FALSE(large_arr.is_local_storage());
-}
+	}
 
-TEST(SimpleArray, Iterator)
+	TEST(SimpleArray, Iterator)
-{
+	{
-    simple_array<int> arr{1, 2, 3, 4, 5};
+		rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
 		int sum = 0;
-    for (const auto& val : arr) {
+		for (const auto& val : arr)
+		{
 			sum += val;
 		}
-    EXPECT_EQ(sum, 15);
-}
 
-TEST(SimpleArray, EraseIf)
+		EXPECT_EQ(sum, 15);
-{
+	}
-    simple_array<int> arr{1, 2, 3, 4, 5};
+
+	TEST(SimpleArray, EraseIf)
+	{
+		rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
 		bool modified = arr.erase_if([](const int& val) { return val % 2 == 0; });
+		arr.sort(FN(x < y));
+
 		EXPECT_TRUE(modified);
 		EXPECT_EQ(arr.size(), 3);
 		EXPECT_EQ(arr[0], 1);
 		EXPECT_EQ(arr[1], 3);
 		EXPECT_EQ(arr[2], 5);
-}
+	}
 
-TEST(SimpleArray, Map)
+	TEST(SimpleArray, Map)
-{
+	{
-    simple_array<int> arr{1, 2, 3};
+		rsx::simple_array<int> arr{ 1, 2, 3 };
 		auto result = arr.map([](const int& val) { return val * 2; });
+
 		EXPECT_EQ(result.size(), 3);
 		EXPECT_EQ(result[0], 2);
 		EXPECT_EQ(result[1], 4);
 		EXPECT_EQ(result[2], 6);
-}
+	}
 
-TEST(SimpleArray, Reduce)
+	TEST(SimpleArray, Reduce)
-{
+	{
-    simple_array<int> arr{1, 2, 3, 4, 5};
+		rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
 		int sum = arr.reduce(0, [](const int& acc, const int& val) { return acc + val; });
-    EXPECT_EQ(sum, 15);
-}
 
-TEST(SimpleArray, Any)
+		EXPECT_EQ(sum, 15);
-{
+	}
-    simple_array<int> arr{1, 2, 3, 4, 5};
+
+	TEST(SimpleArray, Any)
+	{
+		rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
+
 		EXPECT_TRUE(arr.any([](const int& val) { return val > 3; }));
 		EXPECT_FALSE(arr.any([](const int& val) { return val > 5; }));
-}
+	}
 
-TEST(SimpleArray, Sort)
+	TEST(SimpleArray, Sort)
-{
+	{
-    simple_array<int> arr{5, 3, 1, 4, 2};
+		rsx::simple_array<int> arr{ 5, 3, 1, 4, 2 };
 		arr.sort([](const int& a, const int& b) { return a < b; });
-    for (u32 i = 0; i < arr.size(); ++i) {
+
+		for (u32 i = 0; i < arr.size(); ++i)
+		{
 			EXPECT_EQ(arr[i], i + 1);
 		}
+	}
 }