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 →
7.5 KiB268 linesraw
1// unit-test-load-module-from-source.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
10using namespace Slang;
11
12// Test the loadModuleFromSource method and slang_loadModuleFromSource function
13SLANG_UNIT_TEST(loadModuleFromSource)
14{
15    // Test source code with various content
16    const char* testSource = R"(
17        [shader("compute")]
18        [numthreads(1,1,1)]
19        void computeMain(uint3 workGroup : SV_GroupID)
20        {
21            // Simple compute shader
22        }
23    )";
24
25    size_t sourceSize = strlen(testSource);
26
27    ComPtr<slang::IGlobalSession> globalSession;
28    SLANG_CHECK(slang_createGlobalSession(SLANG_API_VERSION, globalSession.writeRef()) == SLANG_OK);
29
30    slang::SessionDesc sessionDesc = {};
31    sessionDesc.targetCount = 1;
32    slang::TargetDesc targetDesc = {};
33    targetDesc.format = SLANG_HLSL;
34    targetDesc.profile = globalSession->findProfile("sm_5_0");
35    sessionDesc.targets = &targetDesc;
36
37    ComPtr<slang::ISession> session;
38    SLANG_CHECK(globalSession->createSession(sessionDesc, session.writeRef()) == SLANG_OK);
39
40    // Test 1: Test the method version (existing functionality)
41    {
42        ComPtr<slang::IModule> module;
43        ComPtr<ISlangBlob> diagnostics;
44
45        // Use loadModuleFromSourceString which takes a string directly
46        module = session->loadModuleFromSourceString(
47            "testModule",
48            "test.slang",
49            testSource,
50            diagnostics.writeRef());
51
52        SLANG_CHECK(module != nullptr);
53        if (diagnostics)
54        {
55            // If there are diagnostics, they should be warnings or errors
56            SLANG_CHECK(diagnostics->getBufferSize() > 0);
57        }
58    }
59
60    // Test 2: Test the new slang_loadModuleFromSource function
61    {
62        ComPtr<slang::IModule> module;
63        ComPtr<ISlangBlob> diagnostics;
64
65        module = slang_loadModuleFromSource(
66            session,
67            "testModule2",
68            "test2.slang",
69            testSource,
70            sourceSize,
71            diagnostics.writeRef());
72
73        SLANG_CHECK(module != nullptr);
74        if (diagnostics)
75        {
76            // If there are diagnostics, they should be warnings or errors
77            SLANG_CHECK(diagnostics->getBufferSize() > 0);
78        }
79    }
80
81    // Test 3: Test with invalid parameters
82    {
83        ComPtr<slang::IModule> module;
84        ComPtr<ISlangBlob> diagnostics;
85
86        // Test with null session
87        module = slang_loadModuleFromSource(
88            nullptr,
89            "testModule",
90            "test.slang",
91            testSource,
92            sourceSize,
93            diagnostics.writeRef());
94
95        SLANG_CHECK(module == nullptr);
96
97        // Test with null moduleName
98        module = slang_loadModuleFromSource(
99            session,
100            nullptr,
101            "test.slang",
102            testSource,
103            sourceSize,
104            diagnostics.writeRef());
105
106        SLANG_CHECK(module == nullptr);
107
108        // Test with null path
109        module = slang_loadModuleFromSource(
110            session,
111            "testModule",
112            nullptr,
113            testSource,
114            sourceSize,
115            diagnostics.writeRef());
116
117        SLANG_CHECK(module == nullptr);
118    }
119
120    // Test 4: Test with null source and non-zero size (should fail)
121    {
122        ComPtr<slang::IModule> module;
123        ComPtr<ISlangBlob> diagnostics;
124
125        module = slang_loadModuleFromSource(
126            session,
127            "testModule",
128            "test.slang",
129            nullptr,
130            10,
131            diagnostics.writeRef());
132
133        SLANG_CHECK(module == nullptr);
134    }
135
136    // Test 5: Test with complex source code
137    {
138        const char* complexSource = R"(
139            [shader("compute")]
140            [numthreads(8,8,1)]
141            void computeMain(uint3 workGroup : SV_GroupID, uint3 localID : SV_GroupThreadID)
142            {
143                uint2 pixelPos = workGroup.xy * uint2(8,8) + localID.xy;
144                
145                // Simple computation
146                float result = sin(pixelPos.x * 0.1f) * cos(pixelPos.y * 0.1f);
147                
148                // Store result (in a real shader, this would go to a buffer)
149                // outputBuffer[pixelPos] = result;
150            }
151        )";
152
153        size_t complexSourceSize = strlen(complexSource);
154
155        ComPtr<slang::IModule> module;
156        ComPtr<ISlangBlob> diagnostics;
157
158        module = slang_loadModuleFromSource(
159            session,
160            "complexModule",
161            "complex.slang",
162            complexSource,
163            complexSourceSize,
164            diagnostics.writeRef());
165
166        SLANG_CHECK(module != nullptr);
167    }
168
169    // Test 6: Test IR blob functions with invalid parameters
170    {
171        ComPtr<slang::IModule> module;
172        ComPtr<ISlangBlob> diagnostics;
173        const char* testData = "test data";
174        size_t testDataSize = strlen(testData);
175
176        // Test with null session
177        module = slang_loadModuleFromIRBlob(
178            nullptr,
179            "testModule",
180            "test.slang",
181            testData,
182            testDataSize,
183            diagnostics.writeRef());
184
185        SLANG_CHECK(module == nullptr);
186
187        // Test with null moduleName
188        module = slang_loadModuleFromIRBlob(
189            session,
190            nullptr,
191            "test.slang",
192            testData,
193            testDataSize,
194            diagnostics.writeRef());
195
196        SLANG_CHECK(module == nullptr);
197
198        // Test with null path
199        module = slang_loadModuleFromIRBlob(
200            session,
201            "testModule",
202            nullptr,
203            testData,
204            testDataSize,
205            diagnostics.writeRef());
206
207        SLANG_CHECK(module == nullptr);
208
209        // Test with null source
210        module = slang_loadModuleFromIRBlob(
211            session,
212            "testModule",
213            "test.slang",
214            nullptr,
215            testDataSize,
216            diagnostics.writeRef());
217
218        SLANG_CHECK(module == nullptr);
219
220        // Test with zero size
221        module = slang_loadModuleFromIRBlob(
222            session,
223            "testModule",
224            "test.slang",
225            testData,
226            0,
227            diagnostics.writeRef());
228
229        SLANG_CHECK(module == nullptr);
230
231        // Test loadModuleInfoFromIRBlob with null session
232        SlangInt moduleVersion;
233        const char* moduleCompilerVersion;
234        const char* moduleName;
235
236        SlangResult infoResult = slang_loadModuleInfoFromIRBlob(
237            nullptr,
238            testData,
239            testDataSize,
240            moduleVersion,
241            moduleCompilerVersion,
242            moduleName);
243
244        SLANG_CHECK(infoResult == SLANG_E_INVALID_ARG);
245
246        // Test loadModuleInfoFromIRBlob with null source
247        infoResult = slang_loadModuleInfoFromIRBlob(
248            session,
249            nullptr,
250            testDataSize,
251            moduleVersion,
252            moduleCompilerVersion,
253            moduleName);
254
255        SLANG_CHECK(infoResult == SLANG_E_INVALID_ARG);
256
257        // Test loadModuleInfoFromIRBlob with zero size
258        infoResult = slang_loadModuleInfoFromIRBlob(
259            session,
260            testData,
261            0,
262            moduleVersion,
263            moduleCompilerVersion,
264            moduleName);
265
266        SLANG_CHECK(infoResult == SLANG_E_INVALID_ARG);
267    }
268}