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
131
132
133
134
135
|
#include "Globals.h"
#include "../TestHelpers.h"
#include "ChunkData.h"
/** Performs the entire cChunkData coordinates test. */
static void test()
{
class cMockAllocationPool
: public cAllocationPool<cChunkData::sChunkSection>
{
virtual cChunkData::sChunkSection * Allocate() override
{
return new cChunkData::sChunkSection();
}
virtual void Free(cChunkData::sChunkSection * a_Ptr) override
{
delete a_Ptr;
}
virtual bool DoIsEqual(const cAllocationPool<cChunkData::sChunkSection> &) const noexcept override
{
return false;
}
} Pool;
{
cChunkData buffer(Pool);
// Empty chunks
buffer.SetBlock({ 0, 0, 0 }, 0xAB);
TEST_EQUAL(buffer.GetBlock({ 0, 0, 0 }), 0xAB);
buffer.SetMeta({ 0, 16, 0 }, 0xC);
TEST_EQUAL(buffer.GetMeta({ 0, 16, 0 }), 0xC);
// loaded but not written segments
TEST_EQUAL(buffer.GetBlock({ 1, 0, 0 }), 0x0);
TEST_EQUAL(buffer.GetMeta({ 1, 16, 0 }), 0x0);
// Notloaded segments
TEST_EQUAL(buffer.GetBlock({ 0, 32, 0 }), 0x0);
TEST_EQUAL(buffer.GetMeta({ 0, 48, 0 }), 0x0);
// Out of range SetBlock
TEST_ASSERTS(
buffer.SetBlock({ -1, 0, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetBlock({ 0, -1, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetBlock({ 0, 0, -1 }, 0)
);
TEST_ASSERTS(
buffer.SetBlock({ 256, 0, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetBlock({ 0, 256, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetBlock({ 0, 0, 256 }, 0)
);
// Out of range SetMeta
TEST_ASSERTS(
buffer.SetMeta({ -1, 0, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetMeta({ 0, -1, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetMeta({ 0, 0, -1 }, 0)
);
TEST_ASSERTS(
buffer.SetMeta({ 256, 0, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetMeta({ 0, 256, 0 }, 0)
);
TEST_ASSERTS(
buffer.SetMeta({ 0, 0, 256 }, 0)
);
// Reading out of range blocks should return air
TEST_EQUAL(buffer.GetBlock({ -1, 0, 0 }), 0);
TEST_EQUAL(buffer.GetBlock({ 0, -1, 0 }), 0);
TEST_EQUAL(buffer.GetBlock({ 0, 0, -1 }), 0);
TEST_EQUAL(buffer.GetBlock({ 256, 0, 0 }), 0);
TEST_EQUAL(buffer.GetBlock({ 0, 256, 0 }), 0);
TEST_EQUAL(buffer.GetBlock({ 0, 0, 256 }), 0);
// Reading out of range metas should return 0
TEST_EQUAL(buffer.GetMeta({ -1, 0, 0 }), 0);
TEST_EQUAL(buffer.GetMeta({ 0, -1, 0 }), 0);
TEST_EQUAL(buffer.GetMeta({ 0, 0, -1 }), 0);
TEST_EQUAL(buffer.GetMeta({ 256, 0, 0 }), 0);
TEST_EQUAL(buffer.GetMeta({ 0, 256, 0 }), 0);
TEST_EQUAL(buffer.GetMeta({ 0, 0, 256 }), 0);
}
{
cChunkData buffer(Pool);
// Zero's
buffer.SetBlock({ 0, 0, 0 }, 0x0);
buffer.SetBlock({ 0, 0, 1 }, 0xab);
TEST_EQUAL(buffer.GetBlock({ 0, 0, 0 }), 0x0);
TEST_EQUAL(buffer.GetBlock({ 0, 0, 1 }), 0xab);
buffer.SetMeta({ 0, 16, 0 }, 0x0);
buffer.SetMeta({ 0, 16, 1 }, 0xc);
TEST_EQUAL(buffer.GetMeta({ 0, 16, 0 }), 0x0);
TEST_EQUAL(buffer.GetMeta({ 0, 16, 1 }), 0xc);
}
{
// Operator =
cChunkData buffer(Pool);
buffer.SetBlock({ 0, 0, 0 }, 0x42);
cChunkData copy(Pool);
copy = std::move(buffer);
TEST_EQUAL(copy.GetBlock({ 0, 0, 0 }), 0x42);
}
}
IMPLEMENT_TEST_MAIN("ChunkData Coordinates",
test();
)
|
