How to use ShouldWorkWithUndefinedNullAndEmpty method of Microsoft.Playwright.Tests.JSHandlePropertiesTests class

1/*
2 * MIT License
3 *
4 * Copyright (c) Microsoft Corporation.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25using System.Threading.Tasks;
26using Microsoft.Playwright.Helpers;
27using Microsoft.Playwright.NUnit;
28using NUnit.Framework;
29
30namespace Microsoft.Playwright.Tests
31{
32    public class JSHandlePropertiesTests : PageTestEx
33    {
34        [PlaywrightTest("jshandle-properties.spec.ts", "getProperties should work")]
35        public async Task GetPropertiesShouldWork()
36        {
37            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
38                foo: 'bar'
39            })");
40            var properties = await aHandle.GetPropertiesAsync();
41            Assert.True(properties.TryGetValue("foo", out var foo));
42            Assert.AreEqual("bar", await foo.JsonValueAsync<string>());
43        }
44
45        [PlaywrightTest("jshandle-properties.spec.ts", "should return empty map for non-objects")]
46        public async Task ShouldReturnEmptyMapForNonObjects()
47        {
48            var aHandle = await Page.EvaluateHandleAsync("() => 123");
49            var properties = await aHandle.GetPropertiesAsync();
50            Assert.IsEmpty(properties);
51        }
52
53        [PlaywrightTest("jshandle-properties.spec.ts", "should return even non-own properties")]
54        public async Task ShouldReturnEvenNonOwnProperties()
55        {
56            var aHandle = await Page.EvaluateHandleAsync(@"() => {
57                class A
58                {
59                    constructor()
60                    {
61                        this.a = '1';
62                    }
63                }
64                class B extends A
65                {
66                    constructor() {
67                        super();
68                        this.b = '2';
69                    }
70                }
71                return new B();
72            }");
73            var properties = await aHandle.GetPropertiesAsync();
74            Assert.AreEqual("1", await properties["a"].JsonValueAsync<string>());
75            Assert.AreEqual("2", await properties["b"].JsonValueAsync<string>());
76        }
77
78        [PlaywrightTest("jshandle-properties.spec.ts", "should work")]
79        public async Task ShouldWork()
80        {
81            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
82                one: 1,
83                two: 2,
84                three: 3
85            })");
86            var twoHandle = await aHandle.GetPropertyAsync("two");
87            Assert.AreEqual(2, await twoHandle.JsonValueAsync<int>());
88        }
89
90        [PlaywrightTest("jshandle-properties.spec.ts", "should work with undefined, null, and empty")]
91        public async Task ShouldWorkWithUndefinedNullAndEmpty()
92        {
93            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
94                undefined: undefined,
95                null: null,
96            })");
97            var undefinedHandle = await aHandle.GetPropertyAsync("undefined");
98            Assert.Null(await undefinedHandle.JsonValueAsync<string>());
99            var nullHandle = await aHandle.GetPropertyAsync("null");
100            Assert.Null(await nullHandle.JsonValueAsync<string>());
101            var emptyHandle = await aHandle.GetPropertyAsync("emptyHandle");
102            Assert.Null(await emptyHandle.JsonValueAsync<string>());
103        }
104
105        [PlaywrightTest("jshandle-properties.spec.ts", "should work with unserializable values")]
106        public async Task ShouldWorkWithUnserializableValues()
107        {
108            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
109                infinity: Infinity,
110                nInfinity: -Infinity,
111                nan: NaN,
112                nzero: -0
113            })");
114
115            var infinityHandle = await aHandle.GetPropertyAsync("infinity");
116            Assert.AreEqual(double.PositiveInfinity, await infinityHandle.JsonValueAsync<double>());
117            var ninfinityHandle = await aHandle.GetPropertyAsync("nInfinity");
118            Assert.AreEqual(double.NegativeInfinity, await ninfinityHandle.JsonValueAsync<double>());
119            var nanHandle = await aHandle.GetPropertyAsync("nan");
120            Assert.AreEqual(double.NaN, await nanHandle.JsonValueAsync<double>());
121            var nzeroHandle = await aHandle.GetPropertyAsync("nzero");
122            Assert.True((await nzeroHandle.JsonValueAsync<double>()).IsNegativeZero());
123        }
124    }
125}
126

Source: JSHandlePropertiesTests.cs

/*
 * MIT License
 *
 * Copyright (c) Microsoft Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

using System.Threading.Tasks;
using Microsoft.Playwright.Helpers;
using Microsoft.Playwright.NUnit;
using NUnit.Framework;

namespace Microsoft.Playwright.Tests
{
    public class JSHandlePropertiesTests : PageTestEx
    {
        [PlaywrightTest("jshandle-properties.spec.ts", "getProperties should work")]
        public async Task GetPropertiesShouldWork()
        {
            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
                foo: 'bar'
            })");
            var properties = await aHandle.GetPropertiesAsync();
            Assert.True(properties.TryGetValue("foo", out var foo));
            Assert.AreEqual("bar", await foo.JsonValueAsync<string>());
        }

        [PlaywrightTest("jshandle-properties.spec.ts", "should return empty map for non-objects")]
        public async Task ShouldReturnEmptyMapForNonObjects()
        {
            var aHandle = await Page.EvaluateHandleAsync("() => 123");
            var properties = await aHandle.GetPropertiesAsync();
            Assert.IsEmpty(properties);
        }

        [PlaywrightTest("jshandle-properties.spec.ts", "should return even non-own properties")]
        public async Task ShouldReturnEvenNonOwnProperties()
        {
            var aHandle = await Page.EvaluateHandleAsync(@"() => {
                class A
                {
                    constructor()
                    {
                        this.a = '1';
                    }
                }
                class B extends A
                {
                    constructor() {
                        super();
                        this.b = '2';
                    }
                }
                return new B();
            }");
            var properties = await aHandle.GetPropertiesAsync();
            Assert.AreEqual("1", await properties["a"].JsonValueAsync<string>());
            Assert.AreEqual("2", await properties["b"].JsonValueAsync<string>());
        }

        [PlaywrightTest("jshandle-properties.spec.ts", "should work")]
        public async Task ShouldWork()
        {
            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
                one: 1,
                two: 2,
                three: 3
            })");
            var twoHandle = await aHandle.GetPropertyAsync("two");
            Assert.AreEqual(2, await twoHandle.JsonValueAsync<int>());
        }

        [PlaywrightTest("jshandle-properties.spec.ts", "should work with undefined, null, and empty")]
        public async Task ShouldWorkWithUndefinedNullAndEmpty()
        {
            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
                undefined: undefined,
                null: null,
            })");
            var undefinedHandle = await aHandle.GetPropertyAsync("undefined");
            Assert.Null(await undefinedHandle.JsonValueAsync<string>());
            var nullHandle = await aHandle.GetPropertyAsync("null");
            Assert.Null(await nullHandle.JsonValueAsync<string>());
            var emptyHandle = await aHandle.GetPropertyAsync("emptyHandle");
            Assert.Null(await emptyHandle.JsonValueAsync<string>());
        }

        [PlaywrightTest("jshandle-properties.spec.ts", "should work with unserializable values")]
        public async Task ShouldWorkWithUnserializableValues()
        {
            var aHandle = await Page.EvaluateHandleAsync(@"() => ({
                infinity: Infinity,
                nInfinity: -Infinity,
                nan: NaN,
                nzero: -0
            })");

            var infinityHandle = await aHandle.GetPropertyAsync("infinity");
            Assert.AreEqual(double.PositiveInfinity, await infinityHandle.JsonValueAsync<double>());
            var ninfinityHandle = await aHandle.GetPropertyAsync("nInfinity");
            Assert.AreEqual(double.NegativeInfinity, await ninfinityHandle.JsonValueAsync<double>());
            var nanHandle = await aHandle.GetPropertyAsync("nan");
            Assert.AreEqual(double.NaN, await nanHandle.JsonValueAsync<double>());
            var nzeroHandle = await aHandle.GetPropertyAsync("nzero");
            Assert.True((await nzeroHandle.JsonValueAsync<double>()).IsNegativeZero());
        }
    }
}