[WHLSL] Rewrite all tests to use WHLSL and delete the isWHLSL flag
[WebKit-https.git] / LayoutTests / webgpu / render-pipeline-errors.html
1 <!DOCTYPE html>
2 <meta charset=utf-8>
3 <title>Test Error Scopes.</title>
4 <body>
5 <script src="js/webgpu-functions.js"></script>
6 <script src="../resources/testharness.js"></script>
7 <script src="../resources/testharnessreport.js"></script>
8 <script>
9 const positionLocation = 0;
10 const colorLocation = 1;
11
12 const colorOffset = 4 * 4;
13 const vertexStride = 8 * 4;
14
15 const whlslSource = `
16 struct FragmentData {
17     float4 position : SV_Position;
18     float4 color : attribute(${colorLocation});
19 }
20
21 vertex FragmentData vertexMain(float4 position : attribute(${positionLocation}), float4 color : attribute(${colorLocation}))
22 {
23     FragmentData out;
24
25     out.position = position;
26     out.color = color;
27
28     return out;
29 }
30
31 fragment float4 fragmentMain(float4 color : attribute(${colorLocation})) : SV_Target 0
32 {
33     return color;
34 }
35 `;
36
37 let goodRenderPipelineDescriptor, goodModule;
38
39 let tests = {};
40
41 tests["GPURenderPipeline creation succeeds with no errors."] = async device => {
42     goodModule = device.createShaderModule({ code: whlslSource });
43     
44     goodRenderPipelineDescriptor = {
45         vertexStage: { module: goodModule, entryPoint: "vertexMain" },
46         fragmentStage: { module: goodModule, entryPoint: "fragmentMain" },
47         primitiveTopology: "triangle-list",
48         colorStates: [{
49             format: "bgra8unorm",
50             alphaBlend: {},
51             colorBlend: {}
52         }],
53         vertexInput: {
54             vertexBuffers: [{
55                 stride: vertexStride,
56                 attributeSet: [{
57                     shaderLocation: positionLocation,
58                     format: "float4"
59                 }, {
60                     shaderLocation: colorLocation,
61                     offset: colorOffset,
62                     format: "float4"
63                 }]
64             }]
65         }
66     };
67     Object.freeze(goodRenderPipelineDescriptor);
68
69     device.pushErrorScope("validation");
70     device.createRenderPipeline(goodRenderPipelineDescriptor);
71     return popNullError(device);
72 };
73
74 tests["Invalid GPUShaderModule for vertex stage should fail."] = async device => {
75     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
76     let badShaderModule = device.createShaderModule({ code: "Foo" });
77     badDescriptor.vertexStage = { module: badShaderModule, entryPoint: "vertexMain" };
78
79     return createPipelineAndError(device, badDescriptor);
80 };
81
82 tests["Invalid GPUShaderModule for fragment stage should fail."] = async device => {
83     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
84     let badShaderModule = device.createShaderModule({ code: "Foo"  });
85     badDescriptor.fragmentStage = { module: badShaderModule, entryPoint: "vertexMain" };
86
87     return createPipelineAndError(device, badDescriptor);
88 };
89
90 tests["Empty entry point for vertex stage should fail."] = async device => {
91     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
92     let badShaderModule = device.createShaderModule({ code: "Foo"  });
93     badDescriptor.vertexStage = { module: badShaderModule, entryPoint: "" };
94
95     return createPipelineAndError(device, badDescriptor);
96 };
97
98 tests["Invalid GPUTextureFormat in GPUColorStateDescriptor should fail."] = async device => {
99     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
100     badDescriptor.colorStates = [{
101         format: "depth32float-stencil8",
102         alphaBlend: {},
103         colorBlend: {}
104     }];
105
106     return createPipelineAndError(device, badDescriptor);
107 };
108
109 tests["Too many GPUColorStateDescriptors should fail."] = async device => {
110     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
111     let badColorStates = new Array(100);
112     badColorStates.fill({
113         format: "bgra8unorm",
114         alphaBlend: {},
115         colorBlend: {}
116     });
117     badDescriptor.colorStates = badColorStates;
118
119     return createPipelineAndError(device, badDescriptor);
120 };
121
122 tests["Too many GPUVertexBufferDescriptors should fail."] = async device => {
123     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
124     let badVertexBuffers = new Array(100);
125     badVertexBuffers.fill({
126         stride: vertexStride,
127         attributeSet: [{
128             shaderLocation: positionLocation,
129             format: "float4"
130         }]
131     });
132     badDescriptor.vertexInput = { vertexBuffers: badVertexBuffers };
133
134     return createPipelineAndError(device, badDescriptor);
135 };
136
137 tests["Too many GPUVertexAttributeDescriptors should fail."] = async device => {
138     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
139     let badAttributes = new Array(100);
140     badAttributes.fill({
141         shaderLocation: positionLocation,
142         format: "float4"
143     });
144
145     badDescriptor.vertexInput = {
146         vertexBuffers: [{
147             stride: vertexStride,
148             attributeSet: badAttributes
149         }]
150     };
151
152     return createPipelineAndError(device, badDescriptor);
153 };
154
155 tests["Duplicate shaderLocation for vertex attributes should fail."] = async device => {
156     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
157     badDescriptor.vertexInput = {
158         vertexBuffers: [{
159             stride: vertexStride,
160             attributeSet: [{
161                 shaderLocation: colorLocation,
162                 format: "float4"
163             }, {
164                 shaderLocation: colorLocation,
165                 offset: colorOffset,
166                 format: "float4"
167             }]
168         }]
169     };
170
171     return createPipelineAndError(device, badDescriptor);
172 };
173
174 tests["Invalid entry point string should fail."] = async device => {
175     let badDescriptor = Object.assign({}, goodRenderPipelineDescriptor);
176     badDescriptor.fragmentStage = { module: goodModule, entryPoint: "bar" };
177
178     return createPipelineAndError(device, badDescriptor);
179 };
180
181 runTestsWithDevice(tests);
182
183 const createPipelineAndError = (device, descriptor) => {
184     device.pushErrorScope("validation");
185     device.createRenderPipeline(descriptor);
186     return popValidationError(device);
187 };
188
189 </script>
190 </body>