Skip to content

Commit b25276d

Browse files
kd-11kd-11
committed
tests: Fix failing test and improve msvc setup
1 parent 947c6ec commit b25276d

File tree

4 files changed

+194
-165
lines changed

4 files changed

+194
-165
lines changed

‎rpcs3/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -201,6 +201,7 @@ elseif(BUILD_RPCS3_TESTS)
201201
PRIVATE
202202
tests/test.cpp
203203
tests/test_fmt.cpp
204+
tests/test_simple_array.cpp
204205
)
205206

206207
target_link_libraries(rpcs3_test

‎rpcs3/Emu/RSX/Common/simple_array.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -23,9 +23,9 @@ namespace rsx
2323
Ty* _data = _local_capacity ? reinterpret_cast<Ty*>(_local_storage) : nullptr;
2424
u32 _size = 0;
2525

26-
inline u64 offset(const_iterator pos)
26+
inline u32 offset(const_iterator pos)
2727
{
28-
return (_data) ? u64(pos - _data) : 0ull;
28+
return (_data) ? u32(pos - _data) : 0u;
2929
}
3030

3131
bool is_local_storage() const

‎rpcs3/tests/rpcs3_test.vcxproj‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -88,6 +88,7 @@
8888
<ItemGroup>
8989
<ClCompile Include="test.cpp" />
9090
<ClCompile Include="test_fmt.cpp" />
91+
<ClCompile Include="test_simple_array.cpp" />
9192
</ItemGroup>
9293
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
9394
<ImportGroup Label="ExtensionTargets" Condition="'$(GTestInstalled)' == 'true'">
@@ -100,4 +101,4 @@
100101
</PropertyGroup>
101102
<Warning Condition="!Exists('$(GTestPath)')" Text="$([System.String]::Format('$(ErrorText)', '$(GTestPath)'))" />
102103
</Target>
103-
</Project>
104+
</Project>

‎rpcs3/tests/test_simple_array.cpp‎

Lines changed: 189 additions & 162 deletions
Original file line numberDiff line numberDiff line change
@@ -1,165 +1,192 @@
11
#include <gtest/gtest.h>
2-
#include "Emu/RSX/Common/simple_array.hpp"
3-
4-
using namespace rsx;
5-
6-
TEST(SimpleArray, DefaultConstructor)
7-
{
8-
simple_array<int> arr;
9-
EXPECT_TRUE(arr.empty());
10-
EXPECT_EQ(arr.size(), 0);
11-
EXPECT_GE(arr.capacity(), 1);
12-
}
13-
14-
TEST(SimpleArray, InitialSizeConstructor)
15-
{
16-
simple_array<int> arr(5);
17-
EXPECT_FALSE(arr.empty());
18-
EXPECT_EQ(arr.size(), 5);
19-
EXPECT_GE(arr.capacity(), 5);
20-
}
21-
22-
TEST(SimpleArray, InitialSizeValueConstructor)
23-
{
24-
simple_array<int> arr(3, 42);
25-
EXPECT_EQ(arr.size(), 3);
26-
for (int i = 0; i < 3; ++i) {
27-
EXPECT_EQ(arr[i], 42);
28-
}
29-
}
30-
31-
TEST(SimpleArray, InitializerListConstructor)
32-
{
33-
simple_array<int> arr{1, 2, 3, 4, 5};
34-
EXPECT_EQ(arr.size(), 5);
35-
for (int i = 0; i < 5; ++i) {
36-
EXPECT_EQ(arr[i], i + 1);
37-
}
38-
}
39-
40-
TEST(SimpleArray, CopyConstructor)
41-
{
42-
simple_array<int> arr1{1, 2, 3};
43-
simple_array<int> arr2(arr1);
44-
EXPECT_EQ(arr1.size(), arr2.size());
45-
for (u32 i = 0; i < arr1.size(); ++i) {
46-
EXPECT_EQ(arr1[i], arr2[i]);
47-
}
48-
}
49-
50-
TEST(SimpleArray, MoveConstructor)
51-
{
52-
simple_array<int> arr1{1, 2, 3};
53-
u32 original_size = arr1.size();
54-
simple_array<int> arr2(std::move(arr1));
55-
EXPECT_EQ(arr2.size(), original_size);
56-
EXPECT_TRUE(arr1.empty());
57-
}
58-
59-
TEST(SimpleArray, PushBackAndAccess)
60-
{
61-
simple_array<int> arr;
62-
arr.push_back(1);
63-
arr.push_back(2);
64-
arr.push_back(3);
65-
66-
EXPECT_EQ(arr.size(), 3);
67-
EXPECT_EQ(arr[0], 1);
68-
EXPECT_EQ(arr[1], 2);
69-
EXPECT_EQ(arr[2], 3);
70-
EXPECT_EQ(arr.front(), 1);
71-
EXPECT_EQ(arr.back(), 3);
72-
}
73-
74-
TEST(SimpleArray, PopBack)
75-
{
76-
simple_array<int> arr{1, 2, 3};
77-
EXPECT_EQ(arr.pop_back(), 3);
78-
EXPECT_EQ(arr.size(), 2);
79-
EXPECT_EQ(arr.back(), 2);
80-
}
812

82-
TEST(SimpleArray, Insert)
83-
{
84-
simple_array<int> arr{1, 3, 4};
85-
auto it = arr.insert(arr.begin() + 1, 2);
86-
EXPECT_EQ(*it, 2);
87-
EXPECT_EQ(arr.size(), 4);
88-
for (int i = 0; i < 4; ++i) {
89-
EXPECT_EQ(arr[i], i + 1);
90-
}
91-
}
92-
93-
TEST(SimpleArray, Clear)
94-
{
95-
simple_array<int> arr{1, 2, 3};
96-
arr.clear();
97-
EXPECT_TRUE(arr.empty());
98-
EXPECT_EQ(arr.size(), 0);
99-
}
100-
101-
TEST(SimpleArray, SmallBufferOptimization)
102-
{
103-
// Test with a small type that should use stack storage
104-
simple_array<char> small_arr(3, 'a');
105-
EXPECT_TRUE(small_arr.is_local_storage());
106-
107-
// Test with a larger type or more elements that should use heap storage
108-
struct LargeType { char data[128]; };
109-
simple_array<LargeType> large_arr(10);
110-
EXPECT_FALSE(large_arr.is_local_storage());
111-
}
112-
113-
TEST(SimpleArray, Iterator)
114-
{
115-
simple_array<int> arr{1, 2, 3, 4, 5};
116-
int sum = 0;
117-
for (const auto& val : arr) {
118-
sum += val;
119-
}
120-
EXPECT_EQ(sum, 15);
121-
}
122-
123-
TEST(SimpleArray, EraseIf)
124-
{
125-
simple_array<int> arr{1, 2, 3, 4, 5};
126-
bool modified = arr.erase_if([](const int& val) { return val % 2 == 0; });
127-
EXPECT_TRUE(modified);
128-
EXPECT_EQ(arr.size(), 3);
129-
EXPECT_EQ(arr[0], 1);
130-
EXPECT_EQ(arr[1], 3);
131-
EXPECT_EQ(arr[2], 5);
132-
}
133-
134-
TEST(SimpleArray, Map)
135-
{
136-
simple_array<int> arr{1, 2, 3};
137-
auto result = arr.map([](const int& val) { return val * 2; });
138-
EXPECT_EQ(result.size(), 3);
139-
EXPECT_EQ(result[0], 2);
140-
EXPECT_EQ(result[1], 4);
141-
EXPECT_EQ(result[2], 6);
142-
}
143-
144-
TEST(SimpleArray, Reduce)
145-
{
146-
simple_array<int> arr{1, 2, 3, 4, 5};
147-
int sum = arr.reduce(0, [](const int& acc, const int& val) { return acc + val; });
148-
EXPECT_EQ(sum, 15);
149-
}
150-
151-
TEST(SimpleArray, Any)
152-
{
153-
simple_array<int> arr{1, 2, 3, 4, 5};
154-
EXPECT_TRUE(arr.any([](const int& val) { return val > 3; }));
155-
EXPECT_FALSE(arr.any([](const int& val) { return val > 5; }));
156-
}
157-
158-
TEST(SimpleArray, Sort)
159-
{
160-
simple_array<int> arr{5, 3, 1, 4, 2};
161-
arr.sort([](const int& a, const int& b) { return a < b; });
162-
for (u32 i = 0; i < arr.size(); ++i) {
163-
EXPECT_EQ(arr[i], i + 1);
164-
}
3+
#define private public
4+
#include "Emu/RSX/Common/simple_array.hpp"
5+
#undef private
6+
7+
namespace rsx
8+
{
9+
TEST(SimpleArray, DefaultConstructor)
10+
{
11+
rsx::simple_array<int> arr;
12+
13+
EXPECT_TRUE(arr.empty());
14+
EXPECT_EQ(arr.size(), 0);
15+
EXPECT_GE(arr.capacity(), 1u);
16+
}
17+
18+
TEST(SimpleArray, InitialSizeConstructor)
19+
{
20+
rsx::simple_array<int> arr(5);
21+
22+
EXPECT_FALSE(arr.empty());
23+
EXPECT_EQ(arr.size(), 5);
24+
EXPECT_GE(arr.capacity(), 5u);
25+
}
26+
27+
TEST(SimpleArray, InitialSizeValueConstructor)
28+
{
29+
rsx::simple_array<int> arr(3, 42);
30+
31+
EXPECT_EQ(arr.size(), 3);
32+
for (int i = 0; i < 3; ++i)
33+
{
34+
EXPECT_EQ(arr[i], 42);
35+
}
36+
}
37+
38+
TEST(SimpleArray, InitializerListConstructor)
39+
{
40+
rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
41+
42+
EXPECT_EQ(arr.size(), 5);
43+
for (int i = 0; i < 5; ++i)
44+
{
45+
EXPECT_EQ(arr[i], i + 1);
46+
}
47+
}
48+
49+
TEST(SimpleArray, CopyConstructor)
50+
{
51+
rsx::simple_array<int> arr1{ 1, 2, 3 };
52+
rsx::simple_array<int> arr2(arr1);
53+
54+
EXPECT_EQ(arr1.size(), arr2.size());
55+
for (u32 i = 0; i < arr1.size(); ++i)
56+
{
57+
EXPECT_EQ(arr1[i], arr2[i]);
58+
}
59+
}
60+
61+
TEST(SimpleArray, MoveConstructor)
62+
{
63+
rsx::simple_array<int> arr1{ 1, 2, 3 };
64+
u32 original_size = arr1.size();
65+
rsx::simple_array<int> arr2(std::move(arr1));
66+
67+
EXPECT_EQ(arr2.size(), original_size);
68+
EXPECT_TRUE(arr1.empty());
69+
}
70+
71+
TEST(SimpleArray, PushBackAndAccess)
72+
{
73+
rsx::simple_array<int> arr;
74+
arr.push_back(1);
75+
arr.push_back(2);
76+
arr.push_back(3);
77+
78+
EXPECT_EQ(arr.size(), 3);
79+
EXPECT_EQ(arr[0], 1);
80+
EXPECT_EQ(arr[1], 2);
81+
EXPECT_EQ(arr[2], 3);
82+
EXPECT_EQ(arr.front(), 1);
83+
EXPECT_EQ(arr.back(), 3);
84+
}
85+
86+
TEST(SimpleArray, PopBack)
87+
{
88+
rsx::simple_array<int> arr{ 1, 2, 3 };
89+
90+
EXPECT_EQ(arr.pop_back(), 3);
91+
EXPECT_EQ(arr.size(), 2);
92+
EXPECT_EQ(arr.back(), 2);
93+
}
94+
95+
TEST(SimpleArray, Insert)
96+
{
97+
rsx::simple_array<int> arr{ 1, 3, 4 };
98+
auto it = arr.insert(arr.begin() + 1, 2);
99+
100+
EXPECT_EQ(*it, 2);
101+
EXPECT_EQ(arr.size(), 4);
102+
103+
for (int i = 0; i < 4; ++i)
104+
{
105+
EXPECT_EQ(arr[i], i + 1);
106+
}
107+
}
108+
109+
TEST(SimpleArray, Clear)
110+
{
111+
rsx::simple_array<int> arr{ 1, 2, 3 };
112+
arr.clear();
113+
114+
EXPECT_TRUE(arr.empty());
115+
EXPECT_EQ(arr.size(), 0);
116+
}
117+
118+
TEST(SimpleArray, SmallBufferOptimization)
119+
{
120+
// Test with a small type that should use stack storage
121+
rsx::simple_array<char> small_arr(3, 'a');
122+
EXPECT_TRUE(small_arr.is_local_storage());
123+
124+
// Test with a larger type or more elements that should use heap storage
125+
struct LargeType { char data[128]; };
126+
rsx::simple_array<LargeType> large_arr(10);
127+
EXPECT_FALSE(large_arr.is_local_storage());
128+
}
129+
130+
TEST(SimpleArray, Iterator)
131+
{
132+
rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
133+
int sum = 0;
134+
for (const auto& val : arr)
135+
{
136+
sum += val;
137+
}
138+
139+
EXPECT_EQ(sum, 15);
140+
}
141+
142+
TEST(SimpleArray, EraseIf)
143+
{
144+
rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
145+
bool modified = arr.erase_if([](const int& val) { return val % 2 == 0; });
146+
arr.sort(FN(x < y));
147+
148+
EXPECT_TRUE(modified);
149+
EXPECT_EQ(arr.size(), 3);
150+
EXPECT_EQ(arr[0], 1);
151+
EXPECT_EQ(arr[1], 3);
152+
EXPECT_EQ(arr[2], 5);
153+
}
154+
155+
TEST(SimpleArray, Map)
156+
{
157+
rsx::simple_array<int> arr{ 1, 2, 3 };
158+
auto result = arr.map([](const int& val) { return val * 2; });
159+
160+
EXPECT_EQ(result.size(), 3);
161+
EXPECT_EQ(result[0], 2);
162+
EXPECT_EQ(result[1], 4);
163+
EXPECT_EQ(result[2], 6);
164+
}
165+
166+
TEST(SimpleArray, Reduce)
167+
{
168+
rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
169+
int sum = arr.reduce(0, [](const int& acc, const int& val) { return acc + val; });
170+
171+
EXPECT_EQ(sum, 15);
172+
}
173+
174+
TEST(SimpleArray, Any)
175+
{
176+
rsx::simple_array<int> arr{ 1, 2, 3, 4, 5 };
177+
178+
EXPECT_TRUE(arr.any([](const int& val) { return val > 3; }));
179+
EXPECT_FALSE(arr.any([](const int& val) { return val > 5; }));
180+
}
181+
182+
TEST(SimpleArray, Sort)
183+
{
184+
rsx::simple_array<int> arr{ 5, 3, 1, 4, 2 };
185+
arr.sort([](const int& a, const int& b) { return a < b; });
186+
187+
for (u32 i = 0; i < arr.size(); ++i)
188+
{
189+
EXPECT_EQ(arr[i], i + 1);
190+
}
191+
}
165192
}

0 commit comments

Comments
 (0)