How to use ShouldCheckTheBox method of Microsoft.Playwright.Tests.ElementHandleMiscTests 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.NUnit;
27using NUnit.Framework;
28
29namespace Microsoft.Playwright.Tests
30{
31    public class ElementHandleMiscTests : PageTestEx
32    {
33        [PlaywrightTest("elementhandle-misc.spec.ts", "should hover")]
34        public async Task ShouldHover()
35        {
36            await Page.GotoAsync(Server.Prefix + "/input/scrollable.html");
37            var button = await Page.QuerySelectorAsync("#button-6");
38            await button.HoverAsync();
39            Assert.AreEqual("button-6", await Page.EvaluateAsync<string>("() => document.querySelector('button:hover').id"));
40        }
41
42        [PlaywrightTest("elementhandle-misc.spec.ts", "should hover when Node is removed")]
43        public async Task ShouldHoverWhenNodeIsRemoved()
44        {
45            await Page.GotoAsync(Server.Prefix + "/input/scrollable.html");
46            await Page.EvaluateAsync("() => delete window['Node']");
47            var button = await Page.QuerySelectorAsync("#button-6");
48            await button.HoverAsync();
49            Assert.AreEqual("button-6", await Page.EvaluateAsync<string>("() => document.querySelector('button:hover').id"));
50        }
51
52        [PlaywrightTest("elementhandle-misc.spec.ts", "should fill input")]
53        public async Task ShouldFillInput()
54        {
55            await Page.GotoAsync(Server.Prefix + "/input/textarea.html");
56            var handle = await Page.QuerySelectorAsync("input");
57            await handle.FillAsync("some value");
58            Assert.AreEqual("some value", await Page.EvaluateAsync<string>("() => result"));
59        }
60
61        [PlaywrightTest("elementhandle-misc.spec.ts", "should fill input when Node is removed")]
62        public async Task ShouldFillInputWhenNodeIsRemoved()
63        {
64            await Page.GotoAsync(Server.Prefix + "/input/textarea.html");
65            await Page.EvaluateAsync("() => delete window['Node']");
66            var handle = await Page.QuerySelectorAsync("input");
67            await handle.FillAsync("some value");
68            Assert.AreEqual("some value", await Page.EvaluateAsync<string>("() => result"));
69        }
70
71        [PlaywrightTest("elementhandle-misc.spec.ts", "should check the box")]
72        public async Task ShouldCheckTheBox()
73        {
74            await Page.SetContentAsync("<input id='checkbox' type='checkbox'></input>");
75            var input = await Page.QuerySelectorAsync("input");
76            await input.CheckAsync();
77            Assert.True(await Page.EvaluateAsync<bool>("() => checkbox.checked"));
78        }
79
80        [PlaywrightTest("elementhandle-misc.spec.ts", "should uncheck the box")]
81        public async Task ShouldUncheckTheBox()
82        {
83            await Page.SetContentAsync("<input id='checkbox' type='checkbox'></input>");
84            var input = await Page.QuerySelectorAsync("input");
85            await input.UncheckAsync();
86            Assert.False(await Page.EvaluateAsync<bool>("() => checkbox.checked"));
87        }
88
89        [PlaywrightTest("elementhandle-misc.spec.ts", "should focus a button")]
90        public async Task ShouldFocusAButton()
91        {
92            await Page.GotoAsync(Server.Prefix + "/input/button.html");
93            var button = await Page.QuerySelectorAsync("button");
94
95            Assert.False(await button.EvaluateAsync<bool?>("button => document.activeElement === button"));
96            await button.FocusAsync();
97            Assert.True(await button.EvaluateAsync<bool?>("button => document.activeElement === button"));
98        }
99
100        [PlaywrightTest("elementhandle-misc.spec.ts", "should select single option")]
101        public async Task ShouldSelectSingleOption()
102        {
103            await Page.GotoAsync(Server.Prefix + "/input/select.html");
104            var select = await Page.QuerySelectorAsync("select");
105            await select.SelectOptionAsync("blue");
106
107            Assert.AreEqual(new[] { "blue" }, await Page.EvaluateAsync<string[]>("() => result.onInput"));
108            Assert.AreEqual(new[] { "blue" }, await Page.EvaluateAsync<string[]>("() => result.onChange"));
109        }
110
111        [PlaywrightTest("elementhandle-misc.spec.ts", "should check the box using setChecked")]
112        public async Task ShouldCheckTheBoxUsingSetChecked()
113        {
114            await Page.SetContentAsync("<input id='checkbox' type='checkbox'></input>");
115            var input = await Page.QuerySelectorAsync("input");
116            await input.SetCheckedAsync(true);
117            Assert.IsTrue(await Page.EvaluateAsync<bool>("checkbox.checked"));
118            await input.SetCheckedAsync(false);
119            Assert.IsFalse(await Page.EvaluateAsync<bool>("checkbox.checked"));
120        }
121
122    }
123}
124

Source: ElementHandleMiscTests.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.NUnit;
using NUnit.Framework;

namespace Microsoft.Playwright.Tests
{
    public class ElementHandleMiscTests : PageTestEx
    {
        [PlaywrightTest("elementhandle-misc.spec.ts", "should hover")]
        public async Task ShouldHover()
        {
            await Page.GotoAsync(Server.Prefix + "/input/scrollable.html");
            var button = await Page.QuerySelectorAsync("#button-6");
            await button.HoverAsync();
            Assert.AreEqual("button-6", await Page.EvaluateAsync<string>("() => document.querySelector('button:hover').id"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should hover when Node is removed")]
        public async Task ShouldHoverWhenNodeIsRemoved()
        {
            await Page.GotoAsync(Server.Prefix + "/input/scrollable.html");
            await Page.EvaluateAsync("() => delete window['Node']");
            var button = await Page.QuerySelectorAsync("#button-6");
            await button.HoverAsync();
            Assert.AreEqual("button-6", await Page.EvaluateAsync<string>("() => document.querySelector('button:hover').id"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should fill input")]
        public async Task ShouldFillInput()
        {
            await Page.GotoAsync(Server.Prefix + "/input/textarea.html");
            var handle = await Page.QuerySelectorAsync("input");
            await handle.FillAsync("some value");
            Assert.AreEqual("some value", await Page.EvaluateAsync<string>("() => result"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should fill input when Node is removed")]
        public async Task ShouldFillInputWhenNodeIsRemoved()
        {
            await Page.GotoAsync(Server.Prefix + "/input/textarea.html");
            await Page.EvaluateAsync("() => delete window['Node']");
            var handle = await Page.QuerySelectorAsync("input");
            await handle.FillAsync("some value");
            Assert.AreEqual("some value", await Page.EvaluateAsync<string>("() => result"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should check the box")]
        public async Task ShouldCheckTheBox()
        {
            await Page.SetContentAsync("<input id='checkbox' type='checkbox'></input>");
            var input = await Page.QuerySelectorAsync("input");
            await input.CheckAsync();
            Assert.True(await Page.EvaluateAsync<bool>("() => checkbox.checked"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should uncheck the box")]
        public async Task ShouldUncheckTheBox()
        {
            await Page.SetContentAsync("<input id='checkbox' type='checkbox'></input>");
            var input = await Page.QuerySelectorAsync("input");
            await input.UncheckAsync();
            Assert.False(await Page.EvaluateAsync<bool>("() => checkbox.checked"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should focus a button")]
        public async Task ShouldFocusAButton()
        {
            await Page.GotoAsync(Server.Prefix + "/input/button.html");
            var button = await Page.QuerySelectorAsync("button");

            Assert.False(await button.EvaluateAsync<bool?>("button => document.activeElement === button"));
            await button.FocusAsync();
            Assert.True(await button.EvaluateAsync<bool?>("button => document.activeElement === button"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should select single option")]
        public async Task ShouldSelectSingleOption()
        {
            await Page.GotoAsync(Server.Prefix + "/input/select.html");
            var select = await Page.QuerySelectorAsync("select");
            await select.SelectOptionAsync("blue");

            Assert.AreEqual(new[] { "blue" }, await Page.EvaluateAsync<string[]>("() => result.onInput"));
            Assert.AreEqual(new[] { "blue" }, await Page.EvaluateAsync<string[]>("() => result.onChange"));
        }

        [PlaywrightTest("elementhandle-misc.spec.ts", "should check the box using setChecked")]
        public async Task ShouldCheckTheBoxUsingSetChecked()
        {
            await Page.SetContentAsync("<input id='checkbox' type='checkbox'></input>");
            var input = await Page.QuerySelectorAsync("input");
            await input.SetCheckedAsync(true);
            Assert.IsTrue(await Page.EvaluateAsync<bool>("checkbox.checked"));
            await input.SetCheckedAsync(false);
            Assert.IsFalse(await Page.EvaluateAsync<bool>("checkbox.checked"));
        }

    }
}