forked from Shell4026/ShellEngine
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathReflectionTest.hpp
More file actions
130 lines (109 loc) · 3.75 KB
/
Copy pathReflectionTest.hpp
File metadata and controls
130 lines (109 loc) · 3.75 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#pragma once
#include "../include/Core/SObject.h"
#include "../include/Core/Reflection.hpp"
#include "../include/Core/SContainer.hpp"
#include <gtest/gtest.h>
#include <string_view>
class Base : public sh::core::SObject
{
SCLASS(Base)
};
class Derived : public Base
{
SCLASS(Derived)
public:
PROPERTY(number, sh::core::PropertyOption::constant)
int number;
PROPERTY(numbers)
std::vector<int> numbers;
PROPERTY(set)
sh::core::SSet<int> set;
PROPERTY(ptr)
int* ptr;
PROPERTY(sobjectPtr)
Derived* sobjectPtr;
PROPERTY(sobjectArr)
std::array<Derived*, 2> sobjectArr;
PROPERTY(map)
sh::core::SMap<std::string, int> map;
};
TEST(ReflectionTest, TypeInfoTest)
{
Base base;
Derived derived;
EXPECT_EQ(Base::GetStaticType().name, "Base");
EXPECT_EQ(Derived::GetStaticType().name, "Derived");
EXPECT_TRUE(derived.GetType().IsA(Derived::GetStaticType()));
EXPECT_TRUE(derived.GetType().IsChildOf(Base::GetStaticType()));
}
TEST(ReflectionTest, PropertyTest)
{
Derived derived;
derived.number = 42;
derived.numbers = { 1, 2, 3 };
auto* numberProperty = Derived::GetStaticType().GetProperty("number");
auto* numbersProperty = Derived::GetStaticType().GetProperty("numbers");
ASSERT_NE(numberProperty, nullptr);
ASSERT_NE(numbersProperty, nullptr);
EXPECT_EQ(*numberProperty->Get<int>(&derived), 42);
EXPECT_EQ(numbersProperty->type.name, sh::core::reflection::GetTypeName<std::vector<int>>());
auto begin = numbersProperty->Begin(&derived);
auto end = numbersProperty->End(&derived);
std::vector<int> expected = { 1, 2, 3 };
for (size_t i = 0; begin != end; ++begin, ++i)
{
EXPECT_FALSE(begin.IsConst());
EXPECT_EQ(*begin.Get<int>(), expected[i]);
}
// set테스트
for(int i = 0; i < 3; ++i)
derived.set.insert(i);
auto setProp = derived.GetType().GetProperty("set");
EXPECT_TRUE(setProp->isContainer);
auto setIterator = setProp->Begin(&derived);
EXPECT_TRUE(setIterator.IsConst());
const int* ptr = setIterator.Get<const int>();
EXPECT_EQ(*ptr, 0);
// 포인터 테스트
auto ptrProp = derived.GetType().GetProperty("ptr");
EXPECT_TRUE(ptrProp->isPointer);
EXPECT_FALSE(ptrProp->isSObjectPointer);
ptrProp = derived.GetType().GetProperty("sobjectPtr");
EXPECT_TRUE(ptrProp->isPointer);
EXPECT_TRUE(ptrProp->isSObjectPointer);
// Array 테스트
{
auto prop = derived.GetType().GetProperty("sobjectArr");
EXPECT_EQ(prop->isContainer, true);
auto arrIterator = prop->Begin(&derived);
EXPECT_FALSE(arrIterator.IsConst());
}
// map 요소 변경 테스트
{
derived.map.insert({ "test0", 0 });
derived.map.insert({ "test1", 1 });
auto prop = derived.GetType().GetProperty("map");
EXPECT_TRUE(prop->isContainer);
for (auto it = prop->Begin(&derived); it != prop->End(&derived); ++it)
{
EXPECT_TRUE(it.IsPair());
EXPECT_TRUE(it.GetPairType()->first.isConst);
EXPECT_TRUE(it.GetPairType()->first == sh::core::reflection::GetType<std::string>());
EXPECT_TRUE(it.GetPairType()->second == sh::core::reflection::GetType<int>());
auto pair = it.Get<std::pair<const std::string, int>>();
pair->second++;
}
EXPECT_EQ(derived.map["test0"], 1);
EXPECT_EQ(derived.map["test1"], 2);
}
}
TEST(ReflectionTest, SafePropertyTest)
{
Derived derived;
derived.number = 123;
auto prop = Derived::GetStaticType().GetProperty("number");
int number = *prop->GetSafe<int>(&derived);
EXPECT_EQ(number, 123);
float* floatPtr = prop->GetSafe<float>(&derived);
EXPECT_EQ(floatPtr, nullptr);
}