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 →
5.2 KiB154 linesraw
1// unit-test-byte-encode.cpp
2
3#include "../../source/core/slang-byte-encode-util.h"
4#include "../../source/core/slang-list.h"
5#include "../../source/core/slang-random-generator.h"
6#include "unit-test/slang-unit-test.h"
7
8#include <stdio.h>
9#include <stdlib.h>
10
11using namespace Slang;
12
13static void checkUInt32(uint32_t value)
14{
15    uint8_t buffer[ByteEncodeUtil::kMaxLiteEncodeUInt32 + 1];
16
17    int writeLen = ByteEncodeUtil::encodeLiteUInt32(value, buffer);
18    buffer[writeLen] = 0xcd;
19
20    uint32_t decode;
21    int readLen = ByteEncodeUtil::decodeLiteUInt32(buffer, &decode);
22
23    SLANG_CHECK(readLen == writeLen && decode == value);
24}
25
26SLANG_UNIT_TEST(byteEncode)
27{
28    DefaultRandomGenerator randGen(0x5346536a);
29
30    {
31        SLANG_CHECK(ByteEncodeUtil::calcMsb8(0) == -1);
32        SLANG_CHECK(ByteEncodeUtil::calcMsb8(1) == 0);
33        SLANG_CHECK(ByteEncodeUtil::calcMsb8(0x81) == 7);
34    }
35
36    {
37        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0) == -1);
38        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x81) == 7);
39        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000001) == 0);
40        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000081) == 7);
41        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000181) == 8);
42        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00008181) == 15);
43        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00018181) == 16);
44        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00818181) == 23);
45        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x01818181) == 24);
46        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x81818181) == 31);
47        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0xffffffff) == 31);
48    }
49
50    {
51        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000000) == -1);
52        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000001) == 0);
53        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000081) == 0);
54        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000181) == 1);
55        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00008181) == 1);
56        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00018181) == 2);
57        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00818181) == 2);
58        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x01818181) == 3);
59        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x81818181) == 3);
60        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0xffffffff) == 3);
61    }
62
63    {
64        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000001) == 0);
65        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000081) == 0);
66        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000181) == 1);
67        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00008181) == 1);
68        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00018181) == 2);
69        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00818181) == 2);
70        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x01818181) == 3);
71        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x81818181) == 3);
72        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0xffffffff) == 3);
73    }
74
75    {
76        const int blockSize = 1024;
77
78        List<uint8_t> encodedBuffer;
79        encodedBuffer.setCount(ByteEncodeUtil::kMaxLiteEncodeUInt32 * blockSize);
80
81        List<uint32_t> initialBuffer;
82        initialBuffer.setCount(blockSize);
83        List<uint32_t> decodeBuffer;
84        decodeBuffer.setCount(blockSize);
85        // Put in cache?
86        memset(decodeBuffer.begin(), 0, blockSize * sizeof(uint32_t));
87
88        for (int i = 0; i < blockSize; i++)
89        {
90            const int v = ByteEncodeUtil::calcMsb8(uint32_t((randGen.nextInt32() & 0xf) | 1));
91
92            // Make the commonality of different numbers that bytes are most common, then shorts
93            // etc..
94            uint32_t mask;
95            switch (v)
96            {
97            case 0:
98                mask = 0xffffffff;
99                break;
100            case 1:
101                mask = 0x00ffffff;
102                break;
103            case 2:
104                mask = 0x0000ffff;
105                break;
106            case 3:
107                mask = 0x000000ff;
108                break;
109            }
110
111            initialBuffer[i] = randGen.nextInt32() & mask;
112        }
113
114        size_t numEncodeBytes = ByteEncodeUtil::encodeLiteUInt32(
115            initialBuffer.begin(),
116            blockSize,
117            encodedBuffer.begin());
118
119        SLANG_CHECK(
120            ByteEncodeUtil::calcEncodeLiteSizeUInt32(initialBuffer.begin(), blockSize) ==
121            numEncodeBytes);
122
123        size_t numEncodeBytes2 = ByteEncodeUtil::decodeLiteUInt32(
124            encodedBuffer.begin(),
125            blockSize,
126            decodeBuffer.begin());
127
128        SLANG_CHECK(numEncodeBytes2 == numEncodeBytes);
129
130        SLANG_CHECK(
131            memcmp(decodeBuffer.begin(), initialBuffer.begin(), sizeof(uint32_t) * blockSize) == 0);
132    }
133
134    {
135        checkUInt32(uint32_t(0));
136        checkUInt32(uint32_t(0x7fffff));
137        checkUInt32(uint32_t(0x7fff));
138        checkUInt32(uint32_t(0x7f));
139        checkUInt32(uint32_t(0x7fffffff));
140        checkUInt32(uint32_t(0xffffffff));
141
142#if 1
143        for (int64_t i = 0; i < SLANG_INT64(0x100000000); i += 371)
144        {
145            checkUInt32(uint32_t(i));
146        }
147#else
148        for (int64_t i = 0; i < SLANG_INT64(0x100000000); i += 1)
149        {
150            checkUInt32(uint32_t(i));
151        }
152#endif
153    }
154}