| <!DOCTYPE html> |
| <html> |
| <meta charset=utf-8> |
| <meta name="timeout" content="long"> |
| <title>Enums.</title> |
| <script src="js/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.failTrickyDoubleZero = async () => { |
| const program = ` |
| enum E { |
| F, |
| G = -2, |
| H, |
| I // should get zero, and that's a dupe. |
| } |
| int foo() |
| { |
| E e = E.Foo; |
| return 42; |
| } |
| `; |
| await checkFail(program); |
| }; |
| |
| whlslTests.simpleDeclaration = async () => { |
| const program = ` |
| enum E { |
| Foo, |
| Bar |
| } |
| int foo() |
| { |
| E e = E.Foo; |
| return 42; |
| } |
| `; |
| assert_equals(await callIntFunction(program, "foo", []), 42); |
| }; |
| |
| whlslTests.enumWithUintBase = async () => { |
| let program = ` |
| enum Foo : uint { |
| War, |
| Famine, |
| Pestilence, |
| Death |
| } |
| |
| Foo _war() |
| { |
| return Foo.War; |
| } |
| |
| bool war() |
| { |
| return _war() == Foo.War; |
| } |
| |
| Foo _famine() |
| { |
| return Foo.Famine; |
| } |
| |
| bool famine() |
| { |
| return _famine() == Foo.Famine; |
| } |
| |
| Foo _pestilence() |
| { |
| return Foo.Pestilence; |
| } |
| |
| bool pestilence() |
| { |
| return _pestilence() == Foo.Pestilence; |
| } |
| |
| Foo _death() |
| { |
| return Foo.Death; |
| } |
| |
| bool death() |
| { |
| return _death() == Foo.Death; |
| } |
| |
| bool _equals(Foo a, Foo b) |
| { |
| return a == b; |
| } |
| |
| bool _notEquals(Foo a, Foo b) |
| { |
| return a != b; |
| } |
| |
| bool testSimpleEqual() |
| { |
| return _equals(Foo.War, Foo.War); |
| } |
| |
| bool testAnotherEqual() |
| { |
| return _equals(Foo.Pestilence, Foo.Pestilence); |
| } |
| |
| bool testNotEqual() |
| { |
| return _equals(Foo.Famine, Foo.Death); |
| } |
| |
| bool testSimpleNotEqual() |
| { |
| return _notEquals(Foo.War, Foo.War); |
| } |
| |
| bool testAnotherNotEqual() |
| { |
| return _notEquals(Foo.Pestilence, Foo.Pestilence); |
| } |
| |
| bool testNotNotEqual() |
| { |
| return _notEquals(Foo.Famine, Foo.Death); |
| } |
| |
| uint _uintWar() |
| { |
| return uint(_war()); |
| } |
| |
| uint uintWar() |
| { |
| return _uintWar(); |
| } |
| |
| uint _uintFamine() |
| { |
| return uint(_famine()); |
| } |
| |
| uint uintFamine() |
| { |
| return _uintFamine(); |
| } |
| |
| uint _uintPestilence() |
| { |
| return uint(_pestilence()); |
| } |
| |
| uint uintPestilence() |
| { |
| return _uintPestilence(); |
| } |
| |
| uint _uintDeath() |
| { |
| return uint(_death()); |
| } |
| |
| uint uintDeath() |
| { |
| return _uintDeath(); |
| } |
| |
| bool uintWarBackwards() |
| { |
| return Foo(_uintWar()) == Foo.War; |
| } |
| |
| bool uintFamineBackwards() |
| { |
| return Foo(_uintFamine()) == Foo.Famine; |
| } |
| |
| bool uintPestilenceBackwards() |
| { |
| return Foo(_uintPestilence()) == Foo.Pestilence; |
| } |
| |
| bool uintDeathBackwards() |
| { |
| return Foo(_uintDeath()) == Foo.Death; |
| } |
| `; |
| |
| assert_equals(await callBoolFunction(program, "war", []), true); |
| assert_equals(await callBoolFunction(program, "famine", []), true); |
| assert_equals(await callBoolFunction(program, "pestilence", []), true); |
| assert_equals(await callBoolFunction(program, "death", []), true); |
| |
| assert_equals(await callBoolFunction(program, "testSimpleEqual", []), true); |
| assert_equals(await callBoolFunction(program, "testAnotherEqual", []), true); |
| assert_equals(await callBoolFunction(program, "testNotEqual", []), false); |
| assert_equals(await callBoolFunction(program, "testSimpleNotEqual", []), false); |
| assert_equals(await callBoolFunction(program, "testAnotherNotEqual", []), false); |
| assert_equals(await callBoolFunction(program, "testNotNotEqual", []), true); |
| assert_equals(await callUintFunction(program, "uintWar", []), 0); |
| assert_equals(await callUintFunction(program, "uintFamine", []), 1); |
| assert_equals(await callUintFunction(program, "uintPestilence", []), 2); |
| assert_equals(await callUintFunction(program, "uintDeath", []), 3); |
| |
| assert_equals(await callBoolFunction(program, "uintWarBackwards", []), true); |
| assert_equals(await callBoolFunction(program, "uintFamineBackwards", []), true); |
| assert_equals(await callBoolFunction(program, "uintPestilenceBackwards", []), true); |
| assert_equals(await callBoolFunction(program, "uintDeathBackwards", []), true); |
| }; |
| |
| |
| whlslTests.enumWithoutZero = async () => { |
| await checkFail( |
| ` |
| enum Foo { |
| War = 72, |
| Famine = 64, |
| Pestilence = 23, |
| Death = -42 |
| } |
| `); |
| }; |
| |
| whlslTests.enumNegativeUint = async () => { |
| await checkFail( |
| ` |
| enum Foo : uint { |
| War, |
| Famine, |
| Pestilence, |
| Death = -42 |
| } |
| `); |
| }; |
| |
| whlslTests.pastIntMax = async () => { |
| await checkFail( |
| ` |
| enum Foo : int { |
| War = 2147483647, |
| Famine, |
| Pestilence = 0, |
| Death |
| } |
| `); |
| }; |
| |
| whlslTests.enumWithSomeManualValues = async () => { |
| let program = ` |
| enum Foo { |
| War = 72, |
| Famine, |
| Pestilence = 0, |
| Death |
| } |
| int war() |
| { |
| return int(Foo.War); |
| } |
| int famine() |
| { |
| return int(Foo.Famine); |
| } |
| int pestilence() |
| { |
| return int(Foo.Pestilence); |
| } |
| int death() |
| { |
| return int(Foo.Death); |
| } |
| `; |
| assert_equals(await callIntFunction(program, "war", []), 72); |
| assert_equals(await callIntFunction(program, "famine", []), 73); |
| assert_equals(await callIntFunction(program, "pestilence", []), 0); |
| assert_equals(await callIntFunction(program, "death", []), 1); |
| }; |
| |
| |
| whlslTests.enumSwitchBreakExhaustive = async () => { |
| let program = ` |
| enum Foo { |
| A, B, C |
| } |
| int foo(int x) |
| { |
| int result = 0; |
| switch (Foo(x)) { |
| case Foo.A: |
| result += 27; |
| break; |
| case Foo.B: |
| result += 7624; |
| break; |
| case Foo.C: |
| result += 49; |
| break; |
| } |
| return result; |
| } |
| `; |
| assert_equals(await callIntFunction(program, "foo", [makeInt(0)]), 27); |
| assert_equals(await callIntFunction(program, "foo", [makeInt(1)]), 7624); |
| assert_equals(await callIntFunction(program, "foo", [makeInt(2)]), 49); |
| } |
| |
| |
| whlslTests.enumSwitchBreakNotQuiteExhaustiveWithDefault = async () => { |
| let program = ` |
| enum Foo { |
| A, B, C |
| } |
| int foo(int x) |
| { |
| int result = 0; |
| switch (Foo(x)) { |
| case Foo.A: |
| result += 27; |
| break; |
| case Foo.B: |
| result += 7624; |
| break; |
| default: |
| result += 49; |
| break; |
| } |
| return result; |
| } |
| `; |
| assert_equals(await callIntFunction(program, "foo", [makeInt(0)]), 27); |
| assert_equals(await callIntFunction(program, "foo", [makeInt(1)]), 7624); |
| assert_equals(await callIntFunction(program, "foo", [makeInt(2)]), 49); |
| } |
| |
| whlslTests.enumWithManualValues = async () => { |
| let program = ` |
| enum Foo { |
| War = 72, |
| Famine = 0, |
| Pestilence = 23, |
| Death = -42 |
| } |
| int war() |
| { |
| return int(Foo.War); |
| } |
| int famine() |
| { |
| return int(Foo.Famine); |
| } |
| int pestilence() |
| { |
| return int(Foo.Pestilence); |
| } |
| int death() |
| { |
| return int(Foo.Death); |
| } |
| `; |
| assert_equals(await callIntFunction(program, "war", []), 72); |
| assert_equals(await callIntFunction(program, "famine", []), 0); |
| assert_equals(await callIntFunction(program, "pestilence", []), 23); |
| assert_equals(await callIntFunction(program, "death", []), -42); |
| }; |
| |
| whlslTests.enumSwitchBreakNotQuiteExhaustive = async () => { |
| await checkFail( |
| ` |
| enum Foo { |
| A, B, C, D |
| } |
| int foo(Foo x) |
| { |
| int result = 0; |
| switch (x) { |
| case Foo.A: |
| result += 27; |
| break; |
| case Foo.B: |
| result += 7624; |
| break; |
| case Foo.C: |
| result += 49; |
| break; |
| } |
| return result; |
| } |
| `); |
| }; |
| |
| whlslTests.copyConstructors = async () => { |
| const program = ` |
| enum Weekday { |
| Monday, |
| Tuesday, |
| Wednesday, |
| Thursday, |
| Pizzaday |
| } |
| int foo() |
| { |
| Weekday x = Weekday.Monday; |
| Weekday y = Weekday(x); |
| float4 z = float4(1, 2, 3, 4); |
| float4 w = float4(z); |
| float2x2 p; |
| float2x2 q = float2x2(p); |
| return 42; |
| } |
| `; |
| assert_equals(await callIntFunction(program, "foo", []), 42); |
| }; |
| |
| runTests(whlslTests); |
| </script> |
| </html> |
