yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

Ellie HermaszewskaCorrect include dir for libslang (#5539)7b570feed

master
branchesmasterall refs →
3.0 KiB116 linesraw
1// unit-test-offset-container.cpp
2
3#include "../../source/core/slang-offset-container.h"
4#include "unit-test/slang-unit-test.h"
5
6using namespace Slang;
7
8static void _checkEncodeDecode(uint32_t size)
9{
10    uint8_t encode[OffsetString::kMaxSizeEncodeSize];
11
12    size_t encodeSize = OffsetString::calcEncodedSize(size, encode);
13
14    size_t decodedSize;
15    const char* chars = OffsetString::decodeSize((const char*)encode, decodedSize);
16
17    SLANG_CHECK(decodedSize == size);
18    SLANG_CHECK(chars - (const char*)encode == encodeSize);
19}
20
21namespace
22{ // anonymous
23
24struct Root
25{
26    Offset32Array<Offset32Ptr<OffsetString>> dirs;
27    Offset32Ptr<OffsetString> name;
28    float value;
29};
30
31} // namespace
32
33SLANG_UNIT_TEST(offsetContainer)
34{
35    _checkEncodeDecode(253);
36
37    for (int64_t i = 0; i < 0x100000000; i += (i / 2) + 1)
38    {
39        _checkEncodeDecode(uint32_t(i));
40    }
41
42    {
43        OffsetContainer container;
44
45        const char* strings[] = {
46            "Hello",
47            "World",
48            nullptr,
49        };
50
51        {
52            auto& base = container.asBase();
53
54            Offset32Ptr<Root> root = container.newObject<Root>();
55
56            auto array = container.newArray<Offset32Ptr<OffsetString>>(SLANG_COUNT_OF(strings));
57            for (Int i = 0; i < SLANG_COUNT_OF(strings); ++i)
58            {
59                base[array[i]] = container.newString(strings[i]);
60            }
61            base[root]->dirs = array;
62        }
63
64        {
65            List<uint8_t> copy;
66            copy.addRange(container.getData(), container.getDataCount());
67
68            MemoryOffsetBase base;
69            base.set(copy.getBuffer(), copy.getCount());
70
71            Root* root = (Root*)(copy.getBuffer() + kStartOffset);
72
73            SLANG_CHECK(root->dirs.getCount() == SLANG_COUNT_OF(strings));
74
75            Int count = root->dirs.getCount();
76            for (Int i = 0; i < count; ++i)
77            {
78                OffsetString* str = base.asRaw(base.asRaw(root->dirs[i]));
79
80                const char* check = strings[i];
81
82                if (check)
83                {
84                    SLANG_CHECK(str != nullptr);
85                    const char* strCstr = str->getCstr();
86                    SLANG_CHECK(strcmp(strCstr, check) == 0);
87                }
88                else
89                {
90                    SLANG_CHECK(str == nullptr);
91                }
92            }
93
94            {
95                Index index = 0;
96                for (const auto v : root->dirs)
97                {
98                    OffsetString* str = base.asRaw(base.asRaw(v));
99                    const char* check = strings[index];
100                    if (check)
101                    {
102                        SLANG_CHECK(str != nullptr);
103                        const char* strCstr = str->getCstr();
104                        SLANG_CHECK(strcmp(strCstr, check) == 0);
105                    }
106                    else
107                    {
108                        SLANG_CHECK(str == nullptr);
109                    }
110
111                    index++;
112                }
113            }
114        }
115    }
116}