mirror
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test: Add unit tests for simple array alignment

This commit is contained in:
kd-11 2025-11-21 02:32:31 +03:00 committed by Elad
parent d6a36f4b60
commit ea7183b6bd
3 changed files with 185 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
rpcs3/tests/test_pair.cpp
View File

@ -3,44 +3,47 @@
#include "util/types.hpp"
#include "util/pair.hpp"
struct some_struct
namespace utils
{
u64 v {};
char s[12] = "Hello World";
bool operator == (const some_struct& r) const
struct some_struct
{
return v == r.v && std::memcmp(s, r.s, sizeof(s)) == 0;
u64 v{};
char s[12] = "Hello World";
bool operator == (const some_struct& r) const
{
return v == r.v && std::memcmp(s, r.s, sizeof(s)) == 0;
}
};
TEST(Pair, General)
{
some_struct s{};
s.v = 1234;
utils::pair<int, some_struct> p;
EXPECT_EQ(sizeof(p), 32);
EXPECT_EQ(p.first, 0);
EXPECT_EQ(p.second, some_struct{});
p = { 666, s };
EXPECT_EQ(p.first, 666);
EXPECT_EQ(p.second, s);
const utils::pair<int, some_struct> p1 = p;
EXPECT_EQ(p.first, 666);
EXPECT_EQ(p.second, s);
EXPECT_EQ(p1.first, 666);
EXPECT_EQ(p1.second, s);
utils::pair<int, some_struct> p2 = p1;
EXPECT_EQ(p1.first, 666);
EXPECT_EQ(p1.second, s);
EXPECT_EQ(p2.first, 666);
EXPECT_EQ(p2.second, s);
utils::pair<int, some_struct> p3 = std::move(p);
EXPECT_EQ(p3.first, 666);
EXPECT_EQ(p3.second, s);
}
};
TEST(Utils, Pair)
{
some_struct s {};
s.v = 1234;
utils::pair<int, some_struct> p;
EXPECT_EQ(sizeof(p), 32);
EXPECT_EQ(p.first, 0);
EXPECT_EQ(p.second, some_struct{});
p = { 666, s };
EXPECT_EQ(p.first, 666);
EXPECT_EQ(p.second, s);
const utils::pair<int, some_struct> p1 = p;
EXPECT_EQ(p.first, 666);
EXPECT_EQ(p.second, s);
EXPECT_EQ(p1.first, 666);
EXPECT_EQ(p1.second, s);
utils::pair<int, some_struct> p2 = p1;
EXPECT_EQ(p1.first, 666);
EXPECT_EQ(p1.second, s);
EXPECT_EQ(p2.first, 666);
EXPECT_EQ(p2.second, s);
utils::pair<int, some_struct> p3 = std::move(p);
EXPECT_EQ(p3.first, 666);
EXPECT_EQ(p3.second, s);
}

36
rpcs3/tests/test_simple_array.cpp
View File

@ -267,4 +267,40 @@ namespace rsx
EXPECT_EQ(std::memcmp(arr[i].second.s, "Hello World", sizeof(arr[i].second.s)), 0);
}
}
TEST(SimpleArray, DataAlignment_SmallVector)
{
struct alignas(16) some_struct {
char data[16];
};
rsx::simple_array<some_struct> arr(2);
const auto data_ptr = reinterpret_cast<uintptr_t>(arr.data());
EXPECT_EQ(data_ptr & 15, 0);
}
TEST(SimpleArray, DataAlignment_HeapAlloc)
{
struct alignas(16) some_struct {
char data[16];
};
rsx::simple_array<some_struct> arr(128);
const auto data_ptr = reinterpret_cast<uintptr_t>(arr.data());
EXPECT_EQ(data_ptr & 15, 0);
}
TEST(SimpleArray, DataAlignment_Overrides)
{
rsx::simple_array<std::byte, 16> arr(4);
rsx::simple_array<std::byte, 128> arr2(4);
const auto data_ptr1 = reinterpret_cast<uintptr_t>(arr.data());
const auto data_ptr2 = reinterpret_cast<uintptr_t>(arr2.data());
EXPECT_EQ(data_ptr1 & 15, 0);
EXPECT_EQ(data_ptr2 & 127, 0);
}
}

215
rpcs3/tests/test_tuple.cpp
View File

@ -2,113 +2,116 @@
#include "util/tuple.hpp"
struct some_struct
namespace utils
{
u64 v {};
char s[12] = "Hello World";
bool operator == (const some_struct& r) const
struct some_struct
{
return v == r.v && std::memcmp(s, r.s, sizeof(s)) == 0;
u64 v{};
char s[12] = "Hello World";
bool operator == (const some_struct& r) const
{
return v == r.v && std::memcmp(s, r.s, sizeof(s)) == 0;
}
};
TEST(Tuple, General)
{
some_struct s{};
s.v = 1234;
utils::tuple t0 = {};
EXPECT_EQ(t0.size(), 0);
utils::tuple<int> t;
EXPECT_EQ(sizeof(t), sizeof(int));
EXPECT_TRUE((std::is_same_v<decltype(t.get<0>()), int&>));
EXPECT_EQ(t.size(), 1);
EXPECT_EQ(t.get<0>(), 0);
utils::tuple<int> t1 = 2;
EXPECT_EQ(sizeof(t1), sizeof(int));
EXPECT_TRUE((std::is_same_v<decltype(t1.get<0>()), int&>));
EXPECT_EQ(t1.size(), 1);
EXPECT_EQ(t1.get<0>(), 2);
t1 = {};
EXPECT_EQ(t1.size(), 1);
EXPECT_EQ(t1.get<0>(), 0);
utils::tuple<int, some_struct> t2 = { 2, s };
EXPECT_EQ(sizeof(t2), 32);
EXPECT_EQ(t2.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(t2.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(t2.get<1>()), some_struct&>));
EXPECT_EQ(t2.get<0>(), 2);
EXPECT_EQ(t2.get<1>(), s);
t2 = {};
EXPECT_EQ(t2.size(), 2);
EXPECT_EQ(t2.get<0>(), 0);
EXPECT_EQ(t2.get<1>(), some_struct{});
t2.get<0>() = 666;
t2.get<1>() = s;
EXPECT_EQ(t2.get<0>(), 666);
EXPECT_EQ(t2.get<1>(), s);
utils::tuple<int, some_struct, double> t3 = { 2, s, 1234.0 };
EXPECT_EQ(sizeof(t3), 40);
EXPECT_EQ(t3.size(), 3);
EXPECT_TRUE((std::is_same_v<decltype(t3.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(t3.get<1>()), some_struct&>));
EXPECT_TRUE((std::is_same_v<decltype(t3.get<2>()), double&>));
EXPECT_EQ(t3.get<0>(), 2);
EXPECT_EQ(t3.get<1>(), s);
EXPECT_EQ(t3.get<2>(), 1234.0);
t3 = {};
EXPECT_EQ(t3.size(), 3);
EXPECT_EQ(t3.get<0>(), 0);
EXPECT_EQ(t3.get<1>(), some_struct{});
EXPECT_EQ(t3.get<2>(), 0.0);
t3.get<0>() = 666;
t3.get<1>() = s;
t3.get<2>() = 7.0;
EXPECT_EQ(t3.get<0>(), 666);
EXPECT_EQ(t3.get<1>(), s);
EXPECT_EQ(t3.get<2>(), 7.0);
// const
const utils::tuple<int, some_struct> tc = { 2, s };
EXPECT_EQ(tc.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(tc.get<0>()), const int&>));
EXPECT_TRUE((std::is_same_v<decltype(tc.get<1>()), const some_struct&>));
EXPECT_EQ(tc.get<0>(), 2);
EXPECT_EQ(tc.get<1>(), s);
// assignment
const utils::tuple<int, some_struct> ta1 = { 2, s };
utils::tuple<int, some_struct> ta = ta1;
EXPECT_EQ(ta.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta.get<1>()), some_struct&>));
EXPECT_EQ(ta.get<0>(), 2);
EXPECT_EQ(ta.get<1>(), s);
utils::tuple<int, some_struct> ta2 = { 2, s };
ta = ta2;
EXPECT_EQ(ta.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta.get<1>()), some_struct&>));
EXPECT_EQ(ta.get<0>(), 2);
EXPECT_EQ(ta.get<1>(), s);
EXPECT_EQ(ta2.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta2.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta2.get<1>()), some_struct&>));
EXPECT_EQ(ta2.get<0>(), 2);
EXPECT_EQ(ta2.get<1>(), s);
ta = std::move(ta2);
EXPECT_EQ(ta.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta.get<1>()), some_struct&>));
EXPECT_EQ(ta.get<0>(), 2);
EXPECT_EQ(ta.get<1>(), s);
}
};
TEST(Utils, Tuple)
{
some_struct s {};
s.v = 1234;
utils::tuple t0 = {};
EXPECT_EQ(t0.size(), 0);
utils::tuple<int> t;
EXPECT_EQ(sizeof(t), sizeof(int));
EXPECT_TRUE((std::is_same_v<decltype(t.get<0>()), int&>));
EXPECT_EQ(t.size(), 1);
EXPECT_EQ(t.get<0>(), 0);
utils::tuple<int> t1 = 2;
EXPECT_EQ(sizeof(t1), sizeof(int));
EXPECT_TRUE((std::is_same_v<decltype(t1.get<0>()), int&>));
EXPECT_EQ(t1.size(), 1);
EXPECT_EQ(t1.get<0>(), 2);
t1 = {};
EXPECT_EQ(t1.size(), 1);
EXPECT_EQ(t1.get<0>(), 0);
utils::tuple<int, some_struct> t2 = { 2, s };
EXPECT_EQ(sizeof(t2), 32);
EXPECT_EQ(t2.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(t2.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(t2.get<1>()), some_struct&>));
EXPECT_EQ(t2.get<0>(), 2);
EXPECT_EQ(t2.get<1>(), s);
t2 = {};
EXPECT_EQ(t2.size(), 2);
EXPECT_EQ(t2.get<0>(), 0);
EXPECT_EQ(t2.get<1>(), some_struct{});
t2.get<0>() = 666;
t2.get<1>() = s;
EXPECT_EQ(t2.get<0>(), 666);
EXPECT_EQ(t2.get<1>(), s);
utils::tuple<int, some_struct, double> t3 = { 2, s, 1234.0 };
EXPECT_EQ(sizeof(t3), 40);
EXPECT_EQ(t3.size(), 3);
EXPECT_TRUE((std::is_same_v<decltype(t3.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(t3.get<1>()), some_struct&>));
EXPECT_TRUE((std::is_same_v<decltype(t3.get<2>()), double&>));
EXPECT_EQ(t3.get<0>(), 2);
EXPECT_EQ(t3.get<1>(), s);
EXPECT_EQ(t3.get<2>(), 1234.0);
t3 = {};
EXPECT_EQ(t3.size(), 3);
EXPECT_EQ(t3.get<0>(), 0);
EXPECT_EQ(t3.get<1>(), some_struct{});
EXPECT_EQ(t3.get<2>(), 0.0);
t3.get<0>() = 666;
t3.get<1>() = s;
t3.get<2>() = 7.0;
EXPECT_EQ(t3.get<0>(), 666);
EXPECT_EQ(t3.get<1>(), s);
EXPECT_EQ(t3.get<2>(), 7.0);
// const
const utils::tuple<int, some_struct> tc = { 2, s };
EXPECT_EQ(tc.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(tc.get<0>()), const int&>));
EXPECT_TRUE((std::is_same_v<decltype(tc.get<1>()), const some_struct&>));
EXPECT_EQ(tc.get<0>(), 2);
EXPECT_EQ(tc.get<1>(), s);
// assignment
const utils::tuple<int, some_struct> ta1 = { 2, s };
utils::tuple<int, some_struct> ta = ta1;
EXPECT_EQ(ta.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta.get<1>()), some_struct&>));
EXPECT_EQ(ta.get<0>(), 2);
EXPECT_EQ(ta.get<1>(), s);
utils::tuple<int, some_struct> ta2 = { 2, s };
ta = ta2;
EXPECT_EQ(ta.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta.get<1>()), some_struct&>));
EXPECT_EQ(ta.get<0>(), 2);
EXPECT_EQ(ta.get<1>(), s);
EXPECT_EQ(ta2.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta2.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta2.get<1>()), some_struct&>));
EXPECT_EQ(ta2.get<0>(), 2);
EXPECT_EQ(ta2.get<1>(), s);
ta = std::move(ta2);
EXPECT_EQ(ta.size(), 2);
EXPECT_TRUE((std::is_same_v<decltype(ta.get<0>()), int&>));
EXPECT_TRUE((std::is_same_v<decltype(ta.get<1>()), some_struct&>));
EXPECT_EQ(ta.get<0>(), 2);
EXPECT_EQ(ta.get<1>(), s);
}