Add a runtime-disabled dialog element skeleton
[WebKit-https.git] / LayoutTests / webgpu / whlsl / return-spec-tests.html
1 <!DOCTYPE html>
2 <html>
3 <meta charset=utf-8>
4 <meta name="timeout" content="long">
5 <title>Test the WHLSL test harness.</title>
6 <script src="js/test-harness.js"></script>
7 <script src="../js/webgpu-functions.js"></script>
8 <script src="../../resources/testharness.js"></script>
9 <script src="../../resources/testharnessreport.js"></script>
10 <script>
11 const whlslTests = {};
12
13 whlslTests.returnIf = async () => {
14     await checkFail(
15         `
16             int foo(int x)
17             {
18                 int y = 6;
19                 if (x == 7) {
20                     return y;
21                 }
22             }
23         `);
24
25     await checkFail(
26         `
27             int foo(int x)
28             {
29                 int y = 6;
30                 if (x == 7) {
31                     return y;
32                 } else {
33                     y = 8;
34                 }
35             }
36         `);
37
38     await checkFail(
39         `
40             int foo(int x)
41             {
42                 int y = 6;
43                 if (x == 7) {
44                     y = 8;
45                 } else {
46                     return y;
47                 }
48             }
49         `);
50
51     let program = `
52         int foo(int x)
53         {
54             int y = 6;
55             if (x == 7) {
56                 return 8;
57             } else {
58                 return 10;
59             }
60         }
61     `;
62     assert_equals(await callIntFunction(program, "foo", [makeInt(3)]), 10);
63     assert_equals(await callIntFunction(program, "foo", [makeInt(4)]), 10);
64     assert_equals(await callIntFunction(program, "foo", [makeInt(5)]), 10);
65     assert_equals(await callIntFunction(program, "foo", [makeInt(6)]), 10);
66     assert_equals(await callIntFunction(program, "foo", [makeInt(7)]), 8);
67     assert_equals(await callIntFunction(program, "foo", [makeInt(8)]), 10);
68     assert_equals(await callIntFunction(program, "foo", [makeInt(9)]), 10);
69
70     await checkFail(
71         `
72             int foo(int x)
73             {
74                 int y = 6;
75                 if (x == 7) {
76                     return 8;
77                 } else if (x == 9) {
78                     return 10;
79                 }
80             }
81         `);
82     program = `
83         int foo(int x)
84         {
85             int y = 6;
86             if (x == 7) {
87                 return 8;
88             } else {
89                 y = 9;
90             }
91             return y;
92         }
93     `;
94     assert_equals(await callIntFunction(program, "foo", [makeInt(3)]), 9);
95     assert_equals(await callIntFunction(program, "foo", [makeInt(4)]), 9);
96     assert_equals(await callIntFunction(program, "foo", [makeInt(5)]), 9);
97     assert_equals(await callIntFunction(program, "foo", [makeInt(6)]), 9);
98     assert_equals(await callIntFunction(program, "foo", [makeInt(7)]), 8);
99     assert_equals(await callIntFunction(program, "foo", [makeInt(8)]), 9);
100     assert_equals(await callIntFunction(program, "foo", [makeInt(9)]), 9);
101     await checkFail(
102         `
103             int foo(int x)
104             {
105                 int y = 6;
106                 if (x == 7) {
107                     return 8;
108                 } else {
109                     return 10;
110                 }
111                 return 11;
112             }
113         `);
114
115     program = `
116         int foo(int x)
117         {
118             int y = 6;
119             if (x == 7)
120                 int y = 8;
121             return y;
122         }
123     `;
124     assert_equals(await callIntFunction(program, "foo", [makeInt(7)]), 6);
125 };
126
127 whlslTests.returnReferenceToSameParameter = async () => {
128     let program = `
129         int foo()
130         {
131             return plus(bar(5), bar(7));
132         }
133
134         int plus(thread int* x, thread int* y)
135         {
136             return *x + *y;
137         }
138
139         thread int* bar(int x)
140         {
141             return &x;
142         }
143     `;
144
145     assert_equals(await callIntFunction(program, "foo", []), 14);
146 };
147
148 whlslTests.returnReferenceToParameterWithDifferentFunctions = async () => {
149     let program = `
150         int foo()
151         {
152             return *bar(10) + *baz(20);
153         }
154
155         thread int* bar(int x)
156         {
157             return &x;
158         }
159
160         thread int* baz(int y)
161         {
162             return &y;
163         }
164     `;
165
166     assert_equals(await callIntFunction(program, "foo", []), 30);
167 };
168
169 whlslTests.returnReferenceToParameter = async () => {
170     let program = `
171         int foo(bool condition)
172         {
173             return *bar(condition, 1, 2);
174         }
175
176         thread int* bar(bool condition, int a, int b)
177         {
178             return condition ? &a : &b;
179         }
180     `;
181
182     assert_equals(await callIntFunction(program, "foo", [makeBool(true)]), 1);
183     assert_equals(await callIntFunction(program, "foo", [makeBool(false)]), 2);
184 };
185
186 whlslTests.returnReferenceToLocalVariableWithNesting = async () => {
187     let program = `
188         int foo()
189         {
190             return *bar() + *baz();
191         }
192
193         thread int* bar()
194         {
195             int a = 20;
196             return &a;
197         }
198
199         thread int* baz()
200         {
201             int a = 22;
202             return &a;
203         }
204     `;
205
206     assert_equals(await callIntFunction(program, "foo", []), 42);
207 };
208
209 whlslTests.returnReferenceToLocalVariable = async () => {
210     let program = `
211         int foo()
212         {
213             return *bar();
214         }
215
216         thread int* bar()
217         {
218             int a = 42;
219             return &a;
220         }
221     `;
222
223     assert_equals(await callIntFunction(program, "foo", []), 42);
224 };
225
226 whlslTests.returnIntLiteralUint = async () => {
227     let program = "uint foo() { return 42; }";
228     assert_equals(await callUintFunction(program, "foo", []), 42);
229 };
230
231 whlslTests.returnIntLiteralFloat = async () => {
232     let program = "float foo() { return 42; }";
233     assert_equals(await callFloatFunction(program, "foo", []), 42);
234 };
235
236 runTests(whlslTests);
237 </script>
238 </html>