yum-mirror/slang

Making it easier to work with shaders

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

jarcherNVAdd static functions to create blobs from data (#8179)af27de015

master
branchesmasterall refs →
5.1 KiB169 linesraw
1// unit-test-create-blob.cpp
2
3#include "slang-com-ptr.h"
4#include "slang.h"
5#include "unit-test/slang-unit-test.h"
6
7#include <stdio.h>
8#include <stdlib.h>
9#include <string.h>
10
11using namespace Slang;
12
13// Test the slang_createBlob function
14SLANG_UNIT_TEST(createBlob)
15{
16    // Test 1: Basic functionality with valid string data
17    {
18        const char* testData = "Hello, World!";
19        size_t dataSize = strlen(testData);
20
21        ComPtr<ISlangBlob> blob;
22        blob = slang_createBlob((const void*)testData, dataSize);
23
24        SLANG_CHECK(blob != nullptr);
25
26        if (blob)
27        {
28            SLANG_CHECK(blob->getBufferSize() == dataSize);
29            SLANG_CHECK(memcmp(blob->getBufferPointer(), testData, dataSize) == 0);
30        }
31    }
32
33    // Test 2: Test with binary data (non-string)
34    {
35        const uint8_t binaryData[] = {0x00, 0x01, 0x02, 0x03, 0xFF, 0xFE, 0xFD, 0xFC};
36        size_t dataSize = sizeof(binaryData);
37
38        ComPtr<ISlangBlob> blob;
39        blob = slang_createBlob((const void*)binaryData, dataSize);
40
41        SLANG_CHECK(blob != nullptr);
42
43        if (blob)
44        {
45            SLANG_CHECK(blob->getBufferSize() == dataSize);
46            SLANG_CHECK(memcmp(blob->getBufferPointer(), binaryData, dataSize) == 0);
47        }
48    }
49
50    // Test 3: Test with large data
51    {
52        const size_t largeSize = 1024 * 1024; // 1MB
53        char* largeData = new char[largeSize];
54
55        // Fill with pattern
56        for (size_t i = 0; i < largeSize; i++)
57        {
58            largeData[i] = (char)(i % 256);
59        }
60
61        ComPtr<ISlangBlob> blob;
62        blob = slang_createBlob((const void*)largeData, largeSize);
63
64        SLANG_CHECK(blob != nullptr);
65
66        if (blob)
67        {
68            SLANG_CHECK(blob->getBufferSize() == largeSize);
69            SLANG_CHECK(memcmp(blob->getBufferPointer(), largeData, largeSize) == 0);
70        }
71
72        delete[] largeData;
73    }
74
75    // Test 4: Test with null pointer and non-zero size (should fail)
76    {
77        char* testData = nullptr;
78        ComPtr<ISlangBlob> blob;
79        blob = slang_createBlob((const void*)testData, 10);
80
81        SLANG_CHECK(blob == nullptr);
82    }
83
84    // Test 5: Test with null pointer and zero size (should fail)
85    {
86        char* testData = nullptr;
87        ComPtr<ISlangBlob> blob;
88        blob = slang_createBlob((const void*)testData, 0);
89
90        SLANG_CHECK(blob == nullptr);
91    }
92
93    // Test 6: Test with valid pointer and zero size (should fail)
94    {
95        const char* testData = "test";
96
97        ComPtr<ISlangBlob> blob;
98        blob = slang_createBlob((const void*)testData, 0);
99
100        SLANG_CHECK(blob == nullptr);
101    }
102
103    // Test 7: Test with void* version of the function
104    {
105        const char* testData = "Test void* version";
106        size_t dataSize = strlen(testData);
107
108        ComPtr<ISlangBlob> blob;
109        blob = slang_createBlob((const void*)testData, dataSize);
110
111        SLANG_CHECK(blob != nullptr);
112
113        if (blob)
114        {
115            SLANG_CHECK(blob->getBufferSize() == dataSize);
116            SLANG_CHECK(memcmp(blob->getBufferPointer(), testData, dataSize) == 0);
117        }
118    }
119
120    // Test 8: Test multiple blobs with same data
121    {
122        const char* testData = "Shared data";
123        size_t dataSize = strlen(testData);
124
125        ComPtr<ISlangBlob> blob1;
126        ComPtr<ISlangBlob> blob2;
127        ComPtr<ISlangBlob> blob3;
128        blob1 = slang_createBlob((const void*)testData, dataSize);
129        blob2 = slang_createBlob((const void*)testData, dataSize);
130        blob3 = slang_createBlob((const void*)testData, dataSize);
131
132        SLANG_CHECK(blob1 != nullptr);
133        SLANG_CHECK(blob2 != nullptr);
134        SLANG_CHECK(blob3 != nullptr);
135
136        // All should have same content
137        SLANG_CHECK(blob1->getBufferSize() == dataSize);
138        SLANG_CHECK(blob2->getBufferSize() == dataSize);
139        SLANG_CHECK(blob3->getBufferSize() == dataSize);
140
141        SLANG_CHECK(memcmp(blob1->getBufferPointer(), testData, dataSize) == 0);
142        SLANG_CHECK(memcmp(blob2->getBufferPointer(), testData, dataSize) == 0);
143        SLANG_CHECK(memcmp(blob3->getBufferPointer(), testData, dataSize) == 0);
144    }
145
146    // Test 9: Test memory management (blob should be independent)
147    {
148        const char* testData = "Memory test";
149        size_t dataSize = strlen(testData);
150
151        ComPtr<ISlangBlob> blob;
152        blob = slang_createBlob((const void*)testData, dataSize);
153
154        // Modify original data - blob should remain unchanged
155        char* mutableData = new char[dataSize + 1];
156        memcpy(mutableData, testData, dataSize + 1);
157        mutableData[0] = 'X'; // Change first character
158
159        SLANG_CHECK(blob->getBufferSize() == dataSize);
160        SLANG_CHECK(
161            memcmp(blob->getBufferPointer(), testData, dataSize) ==
162            0); // Should still match original
163        SLANG_CHECK(
164            memcmp(blob->getBufferPointer(), mutableData, dataSize) !=
165            0); // Should not match modified
166
167        delete[] mutableData;
168    }
169}