1 files changed, 139 insertions, 0 deletions
diff --git a/tools/slang-unit-test/unit-test-byte-encode.cpp b/tools/slang-unit-test/unit-test-byte-encode.cpp
new file mode 100644
index 000000000..38bd5561d
--- /dev/null
+++ b/tools/slang-unit-test/unit-test-byte-encode.cpp
@@ -0,0 +1,139 @@
+// unit-test-byte-encode.cpp
+
+#include "../../source/core/slang-byte-encode-util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "tools/unit-test/slang-unit-test.h"
+
+#include "../../source/core/slang-random-generator.h"
+#include "../../source/core/slang-list.h"
+
+using namespace Slang;
+
+static void checkUInt32(uint32_t value)
+{
+    uint8_t buffer[ByteEncodeUtil::kMaxLiteEncodeUInt32 + 1];
+
+    int writeLen = ByteEncodeUtil::encodeLiteUInt32(value, buffer);
+    buffer[writeLen] = 0xcd;
+
+    uint32_t decode;
+    int readLen = ByteEncodeUtil::decodeLiteUInt32(buffer, &decode);
+
+    SLANG_CHECK(readLen == writeLen && decode == value);
+}
+
+SLANG_UNIT_TEST(byteEncode)
+{
+    DefaultRandomGenerator randGen(0x5346536a);
+
+    {
+        SLANG_CHECK(ByteEncodeUtil::calcMsb8(0) == -1);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb8(1) == 0);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb8(0x81) == 7);
+    }
+
+    {
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0) == -1);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x81) == 7);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000001) == 0);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000081) == 7);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000181) == 8);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00008181) == 15);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00018181) == 16);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00818181) == 23);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x01818181) == 24);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x81818181) == 31);
+        SLANG_CHECK(ByteEncodeUtil::calcMsb32(0xffffffff) == 31);
+    }
+
+    {
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000000) == -1);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000001) == 0);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000081) == 0);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000181) == 1);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00008181) == 1);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00018181) == 2);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00818181) == 2);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x01818181) == 3);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x81818181) == 3);
+        SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0xffffffff) == 3);
+    }
+
+    {
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000001) == 0);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000081) == 0);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000181) == 1);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00008181) == 1);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00018181) == 2);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00818181) == 2);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x01818181) == 3);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x81818181) == 3);
+        SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0xffffffff) == 3);
+    }
+
+    {
+        const int blockSize = 1024;
+
+        List<uint8_t> encodedBuffer;
+        encodedBuffer.setCount(ByteEncodeUtil::kMaxLiteEncodeUInt32 * blockSize);
+
+        List<uint32_t> initialBuffer;
+        initialBuffer.setCount(blockSize);
+        List<uint32_t> decodeBuffer;
+        decodeBuffer.setCount(blockSize);
+        // Put in cache?
+        memset(decodeBuffer.begin(), 0, blockSize * sizeof(uint32_t));
+
+        for (int i = 0; i < blockSize; i++)
+        {
+            const int v = ByteEncodeUtil::calcMsb8(uint32_t((randGen.nextInt32() & 0xf) | 1));
+
+            // Make the commonality of different numbers that bytes are most common, then shorts etc..
+            uint32_t mask;
+            switch (v)
+            {
+                case 0: mask = 0xffffffff; break;
+                case 1: mask = 0x00ffffff; break;
+                case 2: mask = 0x0000ffff; break;
+                case 3: mask = 0x000000ff; break;
+            }
+
+            initialBuffer[i] = randGen.nextInt32() & mask;
+        }
+        
+        size_t numEncodeBytes = ByteEncodeUtil::encodeLiteUInt32(initialBuffer.begin(), blockSize, encodedBuffer.begin());
+
+        SLANG_CHECK(ByteEncodeUtil::calcEncodeLiteSizeUInt32(initialBuffer.begin(), blockSize) == numEncodeBytes);
+
+        size_t numEncodeBytes2 = ByteEncodeUtil::decodeLiteUInt32(encodedBuffer.begin(), blockSize, decodeBuffer.begin());
+       
+        SLANG_CHECK(numEncodeBytes2 == numEncodeBytes);
+        
+        SLANG_CHECK(memcmp(decodeBuffer.begin(), initialBuffer.begin(), sizeof(uint32_t) * blockSize) == 0);
+    }
+
+    {
+        checkUInt32(uint32_t(0));
+        checkUInt32(uint32_t(0x7fffff));
+        checkUInt32(uint32_t(0x7fff));
+        checkUInt32(uint32_t(0x7f));
+        checkUInt32(uint32_t(0x7fffffff));
+        checkUInt32(uint32_t(0xffffffff));
+
+#if 1
+        for (int64_t i = 0; i < SLANG_INT64(0x100000000); i += 371)
+        {
+            checkUInt32(uint32_t(i));
+        }
+#else
+        for (int64_t i = 0; i < SLANG_INT64(0x100000000); i += 1)
+        {
+            checkUInt32(uint32_t(i));
+        }
+#endif
+    } 
+
+}