Attachment 373777 Details for Bug 199642 – patch

[patch] patch

a-backup.diff (text/plain), 29.39 KB, created by Saam Barati on 2019-07-09 15:18:52 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Saam Barati

Created: 2019-07-09 15:18:52 PDT

Size: 29.39 KB

patch

obsolete

>Index: LayoutTests/ChangeLog
>===================================================================
>--- LayoutTests/ChangeLog	(revision 247282)
>+++ LayoutTests/ChangeLog	(working copy)
>@@ -1,3 +1,25 @@
>+2019-07-09  Saam Barati  <sbarati@apple.com>
>+
>+        [WHLSL] Add another group of WHLSL JS reference spec tests
>+        https://bugs.webkit.org/show_bug.cgi?id=199642
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * webgpu/whlsl-array-spec-tests-expected.txt: Added.
>+        * webgpu/whlsl-array-spec-tests.html: Added.
>+        * webgpu/whlsl-enum-spec-tests-expected.txt: Added.
>+        * webgpu/whlsl-enum-spec-tests.html: Added.
>+        * webgpu/whlsl-equality-expected.txt: Added.
>+        * webgpu/whlsl-equality.html: Added.
>+        * webgpu/whlsl-matrices-spec-tests-expected.txt: Added.
>+        * webgpu/whlsl-matrices-spec-tests.html: Added.
>+        * webgpu/whlsl-return-spec-tests-expected.txt: Added.
>+        * webgpu/whlsl-return-spec-tests.html: Added.
>+        * webgpu/whlsl-simple-getter-setter-expected.txt: Added.
>+        * webgpu/whlsl-simple-getter-setter.html: Added.
>+        * webgpu/whlsl-simple-while-loop-expected.txt: Added.
>+        * webgpu/whlsl-simple-while-loop.html: Added.
>+
> 2019-07-09  Youenn Fablet  <youenn@apple.com>
> 
>         XHR CORS requests logged twice in the server
>Index: LayoutTests/webgpu/whlsl-array-spec-tests-expected.txt
>===================================================================
>--- LayoutTests/webgpu/whlsl-array-spec-tests-expected.txt	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-array-spec-tests-expected.txt	(working copy)
>@@ -0,0 +1,7 @@
>+
>+PASS arrayRefToArrayRef 
>+PASS assignLength 
>+PASS assignLengthHelper 
>+PASS buildArrayThenSumIt 
>+PASS buildArrayThenSumItUsingArrayReference 
>+
>Index: LayoutTests/webgpu/whlsl-array-spec-tests.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-array-spec-tests.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-array-spec-tests.html	(working copy)
>@@ -0,0 +1,100 @@
>+<!DOCTYPE html>
>+<html>
>+<meta charset=utf-8>
>+<meta name="timeout" content="long">
>+<title>Test the WHLSL test harness.</title>
>+<script src="js/whlsl-test-harness.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+<script src="../resources/testharness.js"></script>
>+<script src="../resources/testharnessreport.js"></script>
>+<script>
>+const whlslTests = {};
>+
>+whlslTests.arrayRefToArrayRef = async () => {
>+    let program = `
>+        int foo()
>+        {
>+            int x;
>+            thread int[] p = @x;
>+            thread int[][] pp = @p;
>+            int[]thread[]thread qq = pp;
>+            int result = 0;
>+            x = 42;
>+            p[0] = 76;
>+            result += x;
>+            pp[0][0] = 39;
>+            result += x;
>+            qq[0][0] = 83;
>+            result += x;
>+            return result;
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", []), 76 + 39 + 83);
>+}
>+
>+whlslTests.assignLength = async () => {
>+    await checkFail(
>+        `
>+            void foo()
>+            {
>+                float[754] array;
>+                (@array).length = 42;
>+            }
>+        `);
>+        
>+}
>+
>+whlslTests.assignLengthHelper = async () => {
>+    await checkFail(
>+        `
>+            void bar(thread float[] array)
>+            {
>+                array.length = 42;
>+            }
>+            void foo()
>+            {
>+                float[754] array;
>+                bar(@array);
>+            }
>+        `);
>+}
>+
>+whlslTests.buildArrayThenSumIt = async () => {
>+    let program = `
>+        int foo()
>+        {
>+            int[42] array;
>+            for (uint i = 0; i < 42; i = i + 1)
>+                array[i] = int(i + 5);
>+            int result;
>+            for (uint i = 0; i < 42; i = i + 1)
>+                result = result + array[i];
>+            return result;
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", []), 42 * 5 + 42 * 41 / 2);
>+}
>+
>+whlslTests.buildArrayThenSumItUsingArrayReference = async () => {
>+    let program = `
>+        int bar(thread int[] array)
>+        {
>+            for (uint i = 0; i < 42; i = i + 1)
>+                array[i] = int(i + 5);
>+            int result;
>+            for (uint i = 0; i < 42; i = i + 1)
>+                result = result + array[i];
>+            return result;
>+        }
>+        int foo()
>+        {
>+            int[42] array;
>+            return bar(@array);
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", []), 42 * 5 + 42 * 41 / 2);
>+}
>+
>+runTests(whlslTests);
>+</script>
>+</html>
>Index: LayoutTests/webgpu/whlsl-enum-spec-tests-expected.txt
>===================================================================
>--- LayoutTests/webgpu/whlsl-enum-spec-tests-expected.txt	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-enum-spec-tests-expected.txt	(working copy)
>@@ -0,0 +1,9 @@
>+
>+PASS enumDuplicates 
>+PASS defaultEnumConstructor 
>+PASS enumArrayRefBase 
>+PASS enumFloatBase 
>+PASS enumPtrBase 
>+PASS enumStructBase 
>+PASS enumNoMembers 
>+
>Index: LayoutTests/webgpu/whlsl-enum-spec-tests.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-enum-spec-tests.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-enum-spec-tests.html	(working copy)
>@@ -0,0 +1,89 @@
>+<!DOCTYPE html>
>+<html>
>+<meta charset=utf-8>
>+<meta name="timeout" content="long">
>+<title>Test the WHLSL test harness.</title>
>+<script src="js/whlsl-test-harness.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+<script src="../resources/testharness.js"></script>
>+<script src="../resources/testharnessreport.js"></script>
>+<script>
>+const whlslTests = {};
>+
>+whlslTests.enumDuplicates = async () => {
>+    await checkFail(`
>+            enum Foo {
>+                War = 42,
>+                Famine = 0,
>+                Pestilence = 23,
>+                Death = 42
>+            }
>+        `);
>+};
>+
>+whlslTests.defaultEnumConstructor = async () => {
>+    const program = `
>+        enum Weekday {
>+            Monday,
>+            Tuesday,
>+            Wednesday,
>+            Thursday,
>+            Pizzaday
>+        }
>+        int foo()
>+        {
>+            Weekday x = Weekday();
>+            return 42;
>+        }
>+    `;
>+
>+    assert_equals(await callIntFunction(program, "foo", []), 42);
>+};
>+
>+whlslTests.enumArrayRefBase = async () => {
>+    await checkFail(
>+        `
>+            enum Foo : thread int[] {
>+                Bar
>+            }
>+        `);
>+}
>+
>+whlslTests.enumFloatBase = async () => {
>+    await checkFail(
>+        `
>+            enum Foo : float {
>+                Bar
>+            }
>+        `);
>+}
>+
>+whlslTests.enumPtrBase = async () => {
>+    await checkFail(
>+        `
>+            enum Foo : thread int* {
>+                Bar
>+            }
>+        `);
>+}
>+
>+whlslTests.enumStructBase = async () => {
>+    await checkFail(
>+        `
>+            struct Thingy { }
>+            enum Foo : Thingy {
>+                Bar
>+            }
>+        `);
>+};
>+
>+whlslTests.enumNoMembers = async () => {
>+    await checkFail(
>+        `
>+            enum Foo { }
>+        `);
>+};
>+
>+runTests(whlslTests);
>+</script>
>+</html>
>Index: LayoutTests/webgpu/whlsl-equality-expected.txt
>===================================================================
>--- LayoutTests/webgpu/whlsl-equality-expected.txt	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-equality-expected.txt	(working copy)
>@@ -0,0 +1,11 @@
>+
>+PASS equality 
>+PASS notEquality 
>+PASS equalityTypeFailure 
>+PASS equalsWrongArgumentLength 
>+PASS equalsWrongReturnType 
>+PASS lessEqualWrongArgumentLength 
>+PASS lessEqualWrongReturnType 
>+PASS lessThanWrongArgumentLength 
>+PASS lessThanWrongReturnType 
>+
>Index: LayoutTests/webgpu/whlsl-equality.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-equality.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-equality.html	(working copy)
>@@ -0,0 +1,119 @@
>+<!DOCTYPE html>
>+<html>
>+<meta charset=utf-8>
>+<meta name="timeout" content="long">
>+<title>Test the WHLSL test harness.</title>
>+<script src="js/whlsl-test-harness.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+<script src="../resources/testharness.js"></script>
>+<script src="../resources/testharnessreport.js"></script>
>+<script>
>+const whlslTests = {};
>+
>+whlslTests.equality = async () => {
>+    let program = "bool foo(uint x, uint y) { return x == y; }";
>+    assert_equals(await callBoolFunction(program, "foo", [makeUint(7), makeUint(5)]), false);
>+    assert_equals(await callBoolFunction(program, "foo", [makeUint(7), makeUint(7)]), true);
>+    program = "bool foo(int x, int y) { return x == y; }";
>+    assert_equals(await callBoolFunction(program, "foo", [makeInt(7), makeInt(5)]), false);
>+    assert_equals(await callBoolFunction(program, "foo", [makeInt(7), makeInt(7)]), true);
>+    program = "bool foo(bool x, bool y) { return x == y; }";
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(false), makeBool(true)]), false);
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(true), makeBool(false)]), false);
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(false), makeBool(false)]), true);
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(true), makeBool(true)]), true);
>+}
>+
>+whlslTests.notEquality = async () => {
>+    let program = "bool foo(uint x, uint y) { return x != y; }";
>+    assert_equals(await callBoolFunction(program, "foo", [makeUint(7), makeUint(5)]), true);
>+    assert_equals(await callBoolFunction(program, "foo", [makeUint(7), makeUint(7)]), false);
>+    program = "bool foo(int x, int y) { return x != y; }";
>+    assert_equals(await callBoolFunction(program, "foo", [makeInt(7), makeInt(5)]), true);
>+    assert_equals(await callBoolFunction(program, "foo", [makeInt(7), makeInt(7)]), false);
>+    program = "bool foo(bool x, bool y) { return x != y; }";
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(false), makeBool(true)]), true);
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(true), makeBool(false)]), true);
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(false), makeBool(false)]), false);
>+    assert_equals(await callBoolFunction(program, "foo", [makeBool(true), makeBool(true)]), false);
>+};
>+
>+whlslTests.equalityTypeFailure = async () => {
>+    await checkFail("bool foo(int x, uint y) { return x == y; }");
>+};
>+
>+whlslTests.equalsWrongArgumentLength = async () => {
>+    await checkFail(
>+        `
>+            bool operator==() { return true; }
>+        `);
>+
>+    await checkFail(
>+        `
>+            bool operator==(int) { return true; }
>+        `);
>+
>+    await checkFail(
>+        `
>+            bool operator==(int, int, int) { return true; }
>+        `);
>+};
>+
>+whlslTests.equalsWrongReturnType = async () => {
>+    await checkFail(
>+        `
>+            struct Foo { }
>+            int operator==(Foo, Foo) { return 42; }
>+        `);
>+}
>+
>+whlslTests.lessEqualWrongArgumentLength = async () => {
>+    await checkFail(
>+        `
>+            bool operator<=() { return true; }
>+        `);
>+    await checkFail(
>+        `
>+            bool operator<=(int) { return true; }
>+        `);
>+
>+    await checkFail(
>+        `
>+            bool operator<=(int, int, int) { return true; }
>+        `);
>+}
>+
>+whlslTests.lessEqualWrongReturnType = async () => {
>+    checkFail(
>+        `
>+            struct Foo { }
>+            int operator<=(Foo, Foo) { return 42; }
>+        `);
>+}
>+
>+whlslTests.lessThanWrongArgumentLength = async () => {
>+    await checkFail(
>+        `
>+            bool operator<() { return true; }
>+        `);
>+    await checkFail(
>+        `
>+            bool operator<(int) { return true; }
>+        `);
>+    await checkFail(
>+        `
>+            bool operator<(int, int, int) { return true; }
>+        `);
>+}
>+
>+whlslTests.lessThanWrongReturnType = async () => {
>+    await checkFail(
>+        `
>+            struct Foo { }
>+            int operator<(Foo, Foo) { return 42; }
>+        `);
>+}
>+
>+runTests(whlslTests);
>+</script>
>+</html>
>Index: LayoutTests/webgpu/whlsl-matrices-spec-tests-expected.txt
>===================================================================
>--- LayoutTests/webgpu/whlsl-matrices-spec-tests-expected.txt	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-matrices-spec-tests-expected.txt	(working copy)
>@@ -0,0 +1,4 @@
>+
>+PASS builtinMatrices 
>+PASS matrixMultiplication 
>+
>Index: LayoutTests/webgpu/whlsl-matrices-spec-tests.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-matrices-spec-tests.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-matrices-spec-tests.html	(working copy)
>@@ -0,0 +1,204 @@
>+<!DOCTYPE html>
>+<html>
>+<meta charset=utf-8>
>+<meta name="timeout" content="long">
>+<title>Test the WHLSL test harness.</title>
>+<script src="js/whlsl-test-harness.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+<script src="../resources/testharness.js"></script>
>+<script src="../resources/testharnessreport.js"></script>
>+<script>
>+const whlslTests = {};
>+
>+whlslTests.builtinMatrices = async () => {
>+    let program = `
>+        float foo()
>+        {
>+            float2x2 a;
>+            a[0][0] = 1;
>+            a[0][1] = 2;
>+            a[1][0] = 3;
>+            a[1][1] = 4;
>+            return a[0][0];
>+        }
>+        float foo2()
>+        {
>+            float2x3 a;
>+            a[0][0] = 1;
>+            a[0][1] = 2;
>+            a[0][2] = 3;
>+            a[1][0] = 4;
>+            a[1][1] = 5;
>+            a[1][2] = 6;
>+            return a[1][2];
>+        }
>+        float foo3()
>+        {
>+            float2x2 a;
>+            return a[0][0];
>+        }
>+        bool foo4()
>+        {
>+            float2x2 a;
>+            a[0][0] = 1;
>+            a[0][1] = 2;
>+            a[1][0] = 3;
>+            a[1][1] = 4;
>+            float2x2 b;
>+            b[0][0] = 5;
>+            b[0][1] = 6;
>+            b[1][0] = 7;
>+            b[1][1] = 8;
>+            for (uint i = 0; i < 2; ++i) {
>+                for (uint j = 0; j < 2; ++j) {
>+                    a[i][j] += 4;
>+                }
>+            }
>+            return a == b;
>+        }
>+        bool foo5()
>+        {
>+            float2x2 a;
>+            a[0] = float2(1, 2);
>+            a[1] = float2(3, 4);
>+            float2x2 b;
>+            b[0][0] = 1;
>+            b[0][1] = 2;
>+            b[1][0] = 3;
>+            b[1][1] = 4;
>+            return a == b;
>+        }
>+        bool foo6()
>+        {
>+            float2x2 a;
>+            a[0][0] = 1;
>+            a[0][1] = 2;
>+            a[1][0] = 3;
>+            a[1][1] = 4;
>+            float2x2 b;
>+            b[0][0] = 5;
>+            b[0][1] = 10;
>+            b[1][0] = 18;
>+            b[1][1] = 24;
>+            a[0] *= 5;
>+            a[1] *= 6;
>+            return a == b;
>+        }
>+        float foo7()
>+        {
>+            float2x3 a = float2x3(float3(3, 4, 5), float3(6, 7, 8));
>+            return a[0][2];
>+        }
>+    `;
>+    assert_equals(await callFloatFunction(program, "foo", []), 1);
>+    assert_equals(await callFloatFunction(program, "foo2", []), 6);
>+    assert_equals(await callFloatFunction(program, "foo3", []), 0);
>+    assert_equals(await callBoolFunction(program,  "foo4", []), true);
>+    assert_equals(await callBoolFunction(program,  "foo5", []), true);
>+    assert_equals(await callBoolFunction(program,  "foo6", []), true);
>+    assert_equals(await callFloatFunction(program, "foo7", []), 5);
>+};
>+
>+whlslTests.matrixMultiplication = async () => {
>+    let program = `
>+        float2x4 multiply(float2x3 x, float3x4 y) {
>+            // Copied and pasted from the standard library
>+            float2x4 result;
>+            result[0][0] = 0;
>+            result[0][0] += x[0][0] * y[0][0];
>+            result[0][0] += x[0][1] * y[1][0];
>+            result[0][0] += x[0][2] * y[2][0];
>+            result[0][1] = 0;
>+            result[0][1] += x[0][0] * y[0][1];
>+            result[0][1] += x[0][1] * y[1][1];
>+            result[0][1] += x[0][2] * y[2][1];
>+            result[0][2] = 0;
>+            result[0][2] += x[0][0] * y[0][2];
>+            result[0][2] += x[0][1] * y[1][2];
>+            result[0][2] += x[0][2] * y[2][2];
>+            result[0][3] = 0;
>+            result[0][3] += x[0][0] * y[0][3];
>+            result[0][3] += x[0][1] * y[1][3];
>+            result[0][3] += x[0][2] * y[2][3];
>+            result[1][0] = 0;
>+            result[1][0] += x[1][0] * y[0][0];
>+            result[1][0] += x[1][1] * y[1][0];
>+            result[1][0] += x[1][2] * y[2][0];
>+            result[1][1] = 0;
>+            result[1][1] += x[1][0] * y[0][1];
>+            result[1][1] += x[1][1] * y[1][1];
>+            result[1][1] += x[1][2] * y[2][1];
>+            result[1][2] = 0;
>+            result[1][2] += x[1][0] * y[0][2];
>+            result[1][2] += x[1][1] * y[1][2];
>+            result[1][2] += x[1][2] * y[2][2];
>+            result[1][3] = 0;
>+            result[1][3] += x[1][0] * y[0][3];
>+            result[1][3] += x[1][1] * y[1][3];
>+            result[1][3] += x[1][2] * y[2][3];
>+            return result;
>+        }
>+        float2x3 matrix1() {
>+            float2x3 x;
>+            x[0][0] = 2;
>+            x[0][1] = 3;
>+            x[0][2] = 5;
>+            x[1][0] = 7;
>+            x[1][1] = 11;
>+            x[1][2] = 13;
>+            return x;
>+        }
>+        float3x4 matrix2() {
>+            float3x4 y;
>+            y[0][0] = 17;
>+            y[0][1] = 19;
>+            y[0][2] = 23;
>+            y[0][3] = 29;
>+            y[1][0] = 31;
>+            y[1][1] = 37;
>+            y[1][2] = 41;
>+            y[1][3] = 43;
>+            y[2][0] = 47;
>+            y[2][1] = 53;
>+            y[2][2] = 59;
>+            y[2][3] = 61;
>+            return y;
>+        }
>+        float foo00() {
>+            return multiply(matrix1(), matrix2())[0][0];
>+        }
>+        float foo01() {
>+            return multiply(matrix1(), matrix2())[0][1];
>+        }
>+        float foo02() {
>+            return multiply(matrix1(), matrix2())[0][2];
>+        }
>+        float foo03() {
>+            return multiply(matrix1(), matrix2())[0][3];
>+        }
>+        float foo10() {
>+            return multiply(matrix1(), matrix2())[1][0];
>+        }
>+        float foo11() {
>+            return multiply(matrix1(), matrix2())[1][1];
>+        }
>+        float foo12() {
>+            return multiply(matrix1(), matrix2())[1][2];
>+        }
>+        float foo13() {
>+            return multiply(matrix1(), matrix2())[1][3];
>+        }
>+    `;
>+    assert_equals(await callFloatFunction(program, "foo00", []), 17 * 2 + 31 * 3 + 47 * 5);
>+    assert_equals(await callFloatFunction(program, "foo01", []), 19 * 2 + 37 * 3 + 53 * 5);
>+    assert_equals(await callFloatFunction(program, "foo02", []), 23 * 2 + 41 * 3 + 59 * 5);
>+    assert_equals(await callFloatFunction(program, "foo03", []), 29 * 2 + 43 * 3 + 61 * 5);
>+    assert_equals(await callFloatFunction(program, "foo10", []), 17 * 7 + 31 * 11 + 47 * 13);
>+    assert_equals(await callFloatFunction(program, "foo11", []), 19 * 7 + 37 * 11 + 53 * 13);
>+    assert_equals(await callFloatFunction(program, "foo12", []), 23 * 7 + 41 * 11 + 59 * 13);
>+    assert_equals(await callFloatFunction(program, "foo13", []), 29 * 7 + 43 * 11 + 61 * 13);
>+};
>+
>+runTests(whlslTests);
>+</script>
>+</html>
>Index: LayoutTests/webgpu/whlsl-return-spec-tests-expected.txt
>===================================================================
>--- LayoutTests/webgpu/whlsl-return-spec-tests-expected.txt	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-return-spec-tests-expected.txt	(working copy)
>@@ -0,0 +1,10 @@
>+
>+PASS returnIf 
>+PASS returnReferenceToSameParameter 
>+PASS returnReferenceToParameterWithDifferentFunctions 
>+PASS returnReferenceToParameter 
>+PASS returnReferenceToLocalVariableWithNesting 
>+PASS returnReferenceToLocalVariable 
>+PASS returnIntLiteralUint 
>+PASS returnIntLiteralFloat 
>+
>Index: LayoutTests/webgpu/whlsl-return-spec-tests.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-return-spec-tests.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-return-spec-tests.html	(working copy)
>@@ -0,0 +1,238 @@
>+<!DOCTYPE html>
>+<html>
>+<meta charset=utf-8>
>+<meta name="timeout" content="long">
>+<title>Test the WHLSL test harness.</title>
>+<script src="js/whlsl-test-harness.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+<script src="../resources/testharness.js"></script>
>+<script src="../resources/testharnessreport.js"></script>
>+<script>
>+const whlslTests = {};
>+
>+whlslTests.returnIf = async () => {
>+    await checkFail(
>+        `
>+            int foo(int x)
>+            {
>+                int y = 6;
>+                if (x == 7) {
>+                    return y;
>+                }
>+            }
>+        `);
>+
>+    await checkFail(
>+        `
>+            int foo(int x)
>+            {
>+                int y = 6;
>+                if (x == 7) {
>+                    return y;
>+                } else {
>+                    y = 8;
>+                }
>+            }
>+        `);
>+
>+    await checkFail(
>+        `
>+            int foo(int x)
>+            {
>+                int y = 6;
>+                if (x == 7) {
>+                    y = 8;
>+                } else {
>+                    return y;
>+                }
>+            }
>+        `);
>+
>+    let program = `
>+        int foo(int x)
>+        {
>+            int y = 6;
>+            if (x == 7) {
>+                return 8;
>+            } else {
>+                return 10;
>+            }
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(3)]), 10);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(4)]), 10);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(5)]), 10);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(6)]), 10);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(7)]), 8);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(8)]), 10);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(9)]), 10);
>+
>+    await checkFail(
>+        `
>+            int foo(int x)
>+            {
>+                int y = 6;
>+                if (x == 7) {
>+                    return 8;
>+                } else if (x == 9) {
>+                    return 10;
>+                }
>+            }
>+        `);
>+    program = `
>+        int foo(int x)
>+        {
>+            int y = 6;
>+            if (x == 7) {
>+                return 8;
>+            } else {
>+                y = 9;
>+            }
>+            return y;
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(3)]), 9);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(4)]), 9);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(5)]), 9);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(6)]), 9);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(7)]), 8);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(8)]), 9);
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(9)]), 9);
>+    await checkFail(
>+        `
>+            int foo(int x)
>+            {
>+                int y = 6;
>+                if (x == 7) {
>+                    return 8;
>+                } else {
>+                    return 10;
>+                }
>+                return 11;
>+            }
>+        `);
>+
>+    program = `
>+        int foo(int x)
>+        {
>+            int y = 6;
>+            if (x == 7)
>+                int y = 8;
>+            return y;
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(7)]), 6);
>+};
>+
>+whlslTests.returnReferenceToSameParameter = async () => {
>+    let program = `
>+        int foo()
>+        {
>+            return plus(bar(5), bar(7));
>+        }
>+
>+        int plus(thread int* x, thread int* y)
>+        {
>+            return *x + *y;
>+        }
>+
>+        thread int* bar(int x)
>+        {
>+            return &x;
>+        }
>+    `;
>+
>+    assert_equals(await callIntFunction(program, "foo", []), 14);
>+};
>+
>+whlslTests.returnReferenceToParameterWithDifferentFunctions = async () => {
>+    let program = `
>+        int foo()
>+        {
>+            return *bar(10) + *baz(20);
>+        }
>+
>+        thread int* bar(int x)
>+        {
>+            return &x;
>+        }
>+
>+        thread int* baz(int y)
>+        {
>+            return &y;
>+        }
>+    `;
>+
>+    assert_equals(await callIntFunction(program, "foo", []), 30);
>+};
>+
>+whlslTests.returnReferenceToParameter = async () => {
>+    let program = `
>+        int foo(bool condition)
>+        {
>+            return *bar(condition, 1, 2);
>+        }
>+
>+        thread int* bar(bool condition, int a, int b)
>+        {
>+            return condition ? &a : &b;
>+        }
>+    `;
>+
>+    assert_equals(await callIntFunction(program, "foo", [makeBool(true)]), 1);
>+    assert_equals(await callIntFunction(program, "foo", [makeBool(false)]), 2);
>+};
>+
>+whlslTests.returnReferenceToLocalVariableWithNesting = async () => {
>+    let program = `
>+        int foo()
>+        {
>+            return *bar() + *baz();
>+        }
>+
>+        thread int* bar()
>+        {
>+            int a = 20;
>+            return &a;
>+        }
>+
>+        thread int* baz()
>+        {
>+            int a = 22;
>+            return &a;
>+        }
>+    `;
>+
>+    assert_equals(await callIntFunction(program, "foo", []), 42);
>+};
>+
>+whlslTests.returnReferenceToLocalVariable = async () => {
>+    let program = `
>+        int foo()
>+        {
>+            return *bar();
>+        }
>+
>+        thread int* bar()
>+        {
>+            int a = 42;
>+            return &a;
>+        }
>+    `;
>+
>+    assert_equals(await callIntFunction(program, "foo", []), 42);
>+};
>+
>+whlslTests.returnIntLiteralUint = async () => {
>+    let program = "uint foo() { return 42; }";
>+    assert_equals(await callUintFunction(program, "foo", []), 42);
>+};
>+
>+whlslTests.returnIntLiteralFloat = async () => {
>+    let program = "float foo() { return 42; }";
>+    assert_equals(await callFloatFunction(program, "foo", []), 42);
>+};
>+
>+runTests(whlslTests);
>+</script>
>+</html>
>Index: LayoutTests/webgpu/whlsl-simple-getter-setter-expected.txt
>===================================================================
>--- LayoutTests/webgpu/whlsl-simple-getter-setter-expected.txt	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-simple-getter-setter-expected.txt	(working copy)
>@@ -0,0 +1,4 @@
>+
>+PASS simpleGetter 
>+PASS simpleSetter 
>+
>Index: LayoutTests/webgpu/whlsl-simple-getter-setter.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-simple-getter-setter.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-simple-getter-setter.html	(working copy)
>@@ -0,0 +1,58 @@
>+<!DOCTYPE html>
>+<html>
>+<meta charset=utf-8>
>+<meta name="timeout" content="long">
>+<title>Test the WHLSL test harness.</title>
>+<script src="js/whlsl-test-harness.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+<script src="../resources/testharness.js"></script>
>+<script src="../resources/testharnessreport.js"></script>
>+<script>
>+const whlslTests = {};
>+
>+whlslTests.simpleGetter = async () => {
>+    let program = `
>+        struct Foo {
>+            int x;
>+        }
>+        int operator.y(Foo foo)
>+        {
>+            return foo.x;
>+        }
>+        int foo()
>+        {
>+            Foo foo;
>+            foo.x = 7804;
>+            return foo.y;
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", []), 7804);
>+};
>+
>+whlslTests.simpleSetter = async () => {
>+    let program = `
>+        struct Foo {
>+            int x;
>+        }
>+        int operator.y(Foo foo)
>+        {
>+            return foo.x;
>+        }
>+        Foo operator.y=(Foo foo, int value)
>+        {
>+            foo.x = value;
>+            return foo;
>+        }
>+        int foo()
>+        {
>+            Foo foo;
>+            foo.y = 7804;
>+            return foo.x;
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", []), 7804);
>+};
>+
>+runTests(whlslTests);
>+</script>
>+</html>
>Index: LayoutTests/webgpu/whlsl-simple-while-loop-expected.txt
>===================================================================
>--- LayoutTests/webgpu/whlsl-simple-while-loop-expected.txt	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-simple-while-loop-expected.txt	(working copy)
>@@ -0,0 +1,3 @@
>+
>+PASS simpleWhile 
>+
>Index: LayoutTests/webgpu/whlsl-simple-while-loop.html
>===================================================================
>--- LayoutTests/webgpu/whlsl-simple-while-loop.html	(nonexistent)
>+++ LayoutTests/webgpu/whlsl-simple-while-loop.html	(working copy)
>@@ -0,0 +1,27 @@
>+<!DOCTYPE html>
>+<html>
>+<meta charset=utf-8>
>+<meta name="timeout" content="long">
>+<title>Test the WHLSL test harness.</title>
>+<script src="js/whlsl-test-harness.js"></script>
>+<script src="js/webgpu-functions.js"></script>
>+<script src="../resources/testharness.js"></script>
>+<script src="../resources/testharnessreport.js"></script>
>+<script>
>+const whlslTests = {};
>+
>+whlslTests.simpleWhile = async () => {
>+    let program = `
>+        int foo(int x)
>+        {
>+            while (x < 13)
>+                x = x * 2;
>+            return x;
>+        }
>+    `;
>+    assert_equals(await callIntFunction(program, "foo", [makeInt(1)]), 16);
>+}
>+
>+runTests(whlslTests);
>+</script>
>+</html>

Actions: View | Formatted Diff | Diff

Attachments on bug 199642: 373777