How to use ShouldClickTheButtonWithFixedPositionInsideAnIframe method of PuppeteerSharp.Tests.ClickTests.ClickTests class

1using System;
2using System.Collections.Generic;
3using System.Threading.Tasks;
4using PuppeteerSharp.Input;
5using Xunit;
6using Xunit.Abstractions;
7
8namespace PuppeteerSharp.Tests.InputTests
9{
10    [Collection(TestConstants.TestFixtureCollectionName)]
11    public class ClickTests : PuppeteerPageBaseTest
12    {
13        public ClickTests(ITestOutputHelper output) : base(output)
14        {
15        }
16
17        [Fact]
18        public async Task ShouldClickTheButton()
19        {
20            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
21            await Page.ClickAsync("button");
22            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
23        }
24
25        [Fact]
26        public async Task ShouldClickSvg()
27        {
28            await Page.SetContentAsync([email protected]"
29                <svg height=""100"" width=""100"">
30                  <circle onclick=""javascript:window.__CLICKED=42"" cx=""50"" cy=""50"" r=""40"" stroke=""black"" stroke-width=""3"" fill=""red""/>
31                </svg>
32            ");
33            await Page.ClickAsync("circle");
34            Assert.Equal(42, await Page.EvaluateFunctionAsync<int>("() => window.__CLICKED"));
35        }
36
37        [Fact]
38        public async Task ShouldClickTheButtonIfWindowNodeIsRemoved()
39        {
40            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
41            await Page.EvaluateExpressionAsync("delete window.Node");
42            await Page.ClickAsync("button");
43            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync("result"));
44        }
45
46        [Fact(Skip = "See https://github.com/GoogleChrome/puppeteer/issues/4281")]
47        public async Task ShouldClickOnASpanWithAnInlineElementInside()
48        {
49            await Page.SetContentAsync([email protected]"
50                <style>
51                span::before {{
52                    content: 'q';
53                }}
54                </style>
55                <span onclick='javascript:window.CLICKED=42'></span>
56            ");
57            await Page.ClickAsync("span");
58            Assert.Equal(42, await Page.EvaluateFunctionAsync<int>("() => window.CLICKED"));
59        }
60
61        /// <summary>
62        /// This test is called ShouldNotThrowUnhandledPromiseRejectionWhenPageCloses in puppeteer.
63        /// </summary>
64        [Fact]
65        public async Task ShouldGracefullyFailWhenPageCloses()
66        {
67            var newPage = await Browser.NewPageAsync();
68            await Assert.ThrowsAsync<TargetClosedException>(() => Task.WhenAll(
69                newPage.CloseAsync(),
70                newPage.Mouse.ClickAsync(1, 2)
71             ));
72        }
73
74        [Fact]
75        public async Task ShouldClickTheButtonAfterNavigation()
76        {
77            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
78            await Page.ClickAsync("button");
79            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
80            await Page.ClickAsync("button");
81            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
82        }
83
84        [Fact]
85        public async Task ShouldClickWithDisabledJavascript()
86        {
87            await Page.SetJavaScriptEnabledAsync(false);
88            await Page.GoToAsync(TestConstants.ServerUrl + "/wrappedlink.html");
89            await Task.WhenAll(
90                Page.ClickAsync("a"),
91                Page.WaitForNavigationAsync()
92            );
93            Assert.Equal(TestConstants.ServerUrl + "/wrappedlink.html#clicked", Page.Url);
94        }
95
96        [Fact]
97        public async Task ShouldClickWhenOneOfInlineBoxChildrenIsOutsideOfViewport()
98        {
99            await Page.SetContentAsync([email protected]"
100            <style>
101            i {{
102                position: absolute;
103                top: -1000px;
104            }}
105            </style>
106            <span onclick='javascript:window.CLICKED = 42;'><i>woof</i><b>doggo</b></span>
107            ");
108
109            await Page.ClickAsync("span");
110            Assert.Equal(42, await Page.EvaluateFunctionAsync<int>("() => window.CLICKED"));
111        }
112
113        [Fact]
114        public async Task ShouldSelectTheTextByTripleClicking()
115        {
116            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
117            await Page.FocusAsync("textarea");
118            const string text = "This is the text that we are going to try to select. Let's see how it goes.";
119            await Page.Keyboard.TypeAsync(text);
120            await Page.ClickAsync("textarea");
121            await Page.ClickAsync("textarea", new ClickOptions { ClickCount = 2 });
122            await Page.ClickAsync("textarea", new ClickOptions { ClickCount = 3 });
123            Assert.Equal(text, await Page.EvaluateExpressionAsync<string>("window.getSelection().toString()"));
124        }
125
126        [Fact]
127        public async Task ShouldClickOffscreenButtons()
128        {
129            await Page.GoToAsync(TestConstants.ServerUrl + "/offscreenbuttons.html");
130            var messages = new List<string>();
131            Page.Console += (sender, e) => messages.Add(e.Message.Text);
132
133            for (var i = 0; i < 11; ++i)
134            {
135                // We might've scrolled to click a button - reset to (0, 0).
136                await Page.EvaluateFunctionAsync("() => window.scrollTo(0, 0)");
137                await Page.ClickAsync($"#btn{i}");
138            }
139            Assert.Equal(new List<string>
140            {
141                "button #0 clicked",
142                "button #1 clicked",
143                "button #2 clicked",
144                "button #3 clicked",
145                "button #4 clicked",
146                "button #5 clicked",
147                "button #6 clicked",
148                "button #7 clicked",
149                "button #8 clicked",
150                "button #9 clicked",
151                "button #10 clicked"
152            }, messages);
153        }
154
155        [Fact]
156        public async Task ShouldClickWrappedLinks()
157        {
158            await Page.GoToAsync(TestConstants.ServerUrl + "/wrappedlink.html");
159            await Page.ClickAsync("a");
160            Assert.True(await Page.EvaluateExpressionAsync<bool>("window.__clicked"));
161        }
162
163        [Fact]
164        public async Task ShouldClickOnCheckboxInputAndToggle()
165        {
166            await Page.GoToAsync(TestConstants.ServerUrl + "/input/checkbox.html");
167            Assert.Null(await Page.EvaluateExpressionAsync("result.check"));
168            await Page.ClickAsync("input#agree");
169            Assert.True(await Page.EvaluateExpressionAsync<bool>("result.check"));
170            Assert.Equal(new[] {
171                "mouseover",
172                "mouseenter",
173                "mousemove",
174                "mousedown",
175                "mouseup",
176                "click",
177                "input",
178                "change"
179            }, await Page.EvaluateExpressionAsync<string[]>("result.events"));
180            await Page.ClickAsync("input#agree");
181            Assert.False(await Page.EvaluateExpressionAsync<bool>("result.check"));
182        }
183
184        [Fact]
185        public async Task ShouldClickOnCheckboxLabelAndToggle()
186        {
187            await Page.GoToAsync(TestConstants.ServerUrl + "/input/checkbox.html");
188            Assert.Null(await Page.EvaluateExpressionAsync("result.check"));
189            await Page.ClickAsync("label[for=\"agree\"]");
190            Assert.True(await Page.EvaluateExpressionAsync<bool>("result.check"));
191            Assert.Equal(new[] {
192                "click",
193                "input",
194                "change"
195            }, await Page.EvaluateExpressionAsync<string[]>("result.events"));
196            await Page.ClickAsync("label[for=\"agree\"]");
197            Assert.False(await Page.EvaluateExpressionAsync<bool>("result.check"));
198        }
199
200        [Fact]
201        public async Task ShouldFailToClickAMissingButton()
202        {
203            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
204            var exception = await Assert.ThrowsAsync<SelectorException>(()
205                => Page.ClickAsync("button.does-not-exist"));
206            Assert.Equal("No node found for selector: button.does-not-exist", exception.Message);
207            Assert.Equal("button.does-not-exist", exception.Selector);
208        }
209
210        [Fact]
211        public async Task ShouldScrollAndClickTheButton()
212        {
213            await Page.GoToAsync(TestConstants.ServerUrl + "/input/scrollable.html");
214            await Page.ClickAsync("#button-5");
215            Assert.Equal("clicked", await Page.EvaluateExpressionAsync<string>("document.querySelector(\"#button-5\").textContent"));
216            await Page.ClickAsync("#button-80");
217            Assert.Equal("clicked", await Page.EvaluateExpressionAsync<string>("document.querySelector(\"#button-80\").textContent"));
218        }
219
220        [Fact]
221        public async Task ShouldDoubleClickTheButton()
222        {
223            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
224            await Page.EvaluateExpressionAsync(@"{
225               window.double = false;
226               const button = document.querySelector('button');
227               button.addEventListener('dblclick', event => {
228                 window.double = true;
229               });
230            }");
231            var button = await Page.QuerySelectorAsync("button");
232            await button.ClickAsync(new ClickOptions { ClickCount = 2 });
233            Assert.True(await Page.EvaluateExpressionAsync<bool>("double"));
234            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
235        }
236
237        [Fact]
238        public async Task ShouldClickAPartiallyObscuredButton()
239        {
240            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
241            await Page.EvaluateExpressionAsync(@"{
242                const button = document.querySelector('button');
243                button.textContent = 'Some really long text that will go offscreen';
244                button.style.position = 'absolute';
245                button.style.left = '368px';
246            }");
247            await Page.ClickAsync("button");
248            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
249        }
250
251        [Fact]
252        public async Task ShouldClickARotatedButton()
253        {
254            await Page.GoToAsync(TestConstants.ServerUrl + "/input/rotatedButton.html");
255            await Page.ClickAsync("button");
256            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
257        }
258
259        [Fact]
260        public async Task ShouldFireContextmenuEventOnRightClick()
261        {
262            await Page.GoToAsync(TestConstants.ServerUrl + "/input/scrollable.html");
263            await Page.ClickAsync("#button-8", new ClickOptions { Button = MouseButton.Right });
264            Assert.Equal("context menu", await Page.EvaluateExpressionAsync<string>("document.querySelector('#button-8').textContent"));
265        }
266
267        // @see https://github.com/GoogleChrome/puppeteer/issues/206
268        [Fact]
269        public async Task ShouldClickLinksWhichCauseNavigation()
270        {
271            await Page.SetContentAsync($"<a href=\"{TestConstants.EmptyPage}\">empty.html</a>");
272            // This await should not hang.
273            await Page.ClickAsync("a");
274        }
275
276        [Fact]
277        public async Task ShouldClickTheButtonInsideAnIframe()
278        {
279            await Page.GoToAsync(TestConstants.EmptyPage);
280            await Page.SetContentAsync("<div style=\"width:100px;height:100px\">spacer</div>");
281            await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
282            var frame = Page.FirstChildFrame();
283            var button = await frame.QuerySelectorAsync("button");
284            await button.ClickAsync();
285            Assert.Equal("Clicked", await frame.EvaluateExpressionAsync<string>("window.result"));
286        }
287
288        [Fact(Skip = "see https://github.com/GoogleChrome/puppeteer/issues/4110")]
289        public async Task ShouldClickTheButtonWithFixedPositionInsideAnIframe()
290        {
291            await Page.GoToAsync(TestConstants.EmptyPage);
292            await Page.SetViewportAsync(new ViewPortOptions
293            {
294                Width = 500,
295                Height = 500
296            });
297            await Page.SetContentAsync("<div style=\"width:100px;height:2000px\">spacer</div>");
298            await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
299            var frame = Page.FirstChildFrame();
300            await frame.QuerySelectorAsync("button").EvaluateFunctionAsync("button => button.style.setProperty('position', 'fixed')");
301            await frame.ClickAsync("button");
302            Assert.Equal("Clicked", await frame.EvaluateExpressionAsync<string>("window.result"));
303        }
304
305        [Fact]
306        public async Task ShouldClickTheButtonWithDeviceScaleFactorSet()
307        {
308            await Page.SetViewportAsync(new ViewPortOptions { Width = 400, Height = 400, DeviceScaleFactor = 5 });
309            Assert.Equal(5, await Page.EvaluateExpressionAsync<int>("window.devicePixelRatio"));
310            await Page.SetContentAsync("<div style=\"width:100px;height:100px\">spacer</div>");
311            await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
312            var frame = Page.FirstChildFrame();
313            var button = await frame.QuerySelectorAsync("button");
314            await button.ClickAsync();
315            Assert.Equal("Clicked", await frame.EvaluateExpressionAsync<string>("window.result"));
316        }
317    }
318}
319

Source: ClickTests.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using PuppeteerSharp.Input;
using Xunit;
using Xunit.Abstractions;

namespace PuppeteerSharp.Tests.InputTests
{
    [Collection(TestConstants.TestFixtureCollectionName)]
    public class ClickTests : PuppeteerPageBaseTest
    {
        public ClickTests(ITestOutputHelper output) : base(output)
        {
        }

        [Fact]
        public async Task ShouldClickTheButton()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
            await Page.ClickAsync("button");
            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
        }

        [Fact]
        public async Task ShouldClickSvg()
        {
            await Page.SetContentAsync([email protected]"
                <svg height=""100"" width=""100"">
                  <circle onclick=""javascript:window.__CLICKED=42"" cx=""50"" cy=""50"" r=""40"" stroke=""black"" stroke-width=""3"" fill=""red""/>
                </svg>
            ");
            await Page.ClickAsync("circle");
            Assert.Equal(42, await Page.EvaluateFunctionAsync<int>("() => window.__CLICKED"));
        }

        [Fact]
        public async Task ShouldClickTheButtonIfWindowNodeIsRemoved()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
            await Page.EvaluateExpressionAsync("delete window.Node");
            await Page.ClickAsync("button");
            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync("result"));
        }

        [Fact(Skip = "See https://github.com/GoogleChrome/puppeteer/issues/4281")]
        public async Task ShouldClickOnASpanWithAnInlineElementInside()
        {
            await Page.SetContentAsync([email protected]"
                <style>
                span::before {{
                    content: 'q';
                }}
                </style>
                <span onclick='javascript:window.CLICKED=42'></span>
            ");
            await Page.ClickAsync("span");
            Assert.Equal(42, await Page.EvaluateFunctionAsync<int>("() => window.CLICKED"));
        }

        /// <summary>
        /// This test is called ShouldNotThrowUnhandledPromiseRejectionWhenPageCloses in puppeteer.
        /// </summary>
        [Fact]
        public async Task ShouldGracefullyFailWhenPageCloses()
        {
            var newPage = await Browser.NewPageAsync();
            await Assert.ThrowsAsync<TargetClosedException>(() => Task.WhenAll(
                newPage.CloseAsync(),
                newPage.Mouse.ClickAsync(1, 2)
             ));
        }

        [Fact]
        public async Task ShouldClickTheButtonAfterNavigation()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
            await Page.ClickAsync("button");
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
            await Page.ClickAsync("button");
            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
        }

        [Fact]
        public async Task ShouldClickWithDisabledJavascript()
        {
            await Page.SetJavaScriptEnabledAsync(false);
            await Page.GoToAsync(TestConstants.ServerUrl + "/wrappedlink.html");
            await Task.WhenAll(
                Page.ClickAsync("a"),
                Page.WaitForNavigationAsync()
            );
            Assert.Equal(TestConstants.ServerUrl + "/wrappedlink.html#clicked", Page.Url);
        }

        [Fact]
        public async Task ShouldClickWhenOneOfInlineBoxChildrenIsOutsideOfViewport()
        {
            await Page.SetContentAsync([email protected]"
            <style>
            i {{
                position: absolute;
                top: -1000px;
            }}
            </style>
            <span onclick='javascript:window.CLICKED = 42;'><i>woof</i><b>doggo</b></span>
            ");

            await Page.ClickAsync("span");
            Assert.Equal(42, await Page.EvaluateFunctionAsync<int>("() => window.CLICKED"));
        }

        [Fact]
        public async Task ShouldSelectTheTextByTripleClicking()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.FocusAsync("textarea");
            const string text = "This is the text that we are going to try to select. Let's see how it goes.";
            await Page.Keyboard.TypeAsync(text);
            await Page.ClickAsync("textarea");
            await Page.ClickAsync("textarea", new ClickOptions { ClickCount = 2 });
            await Page.ClickAsync("textarea", new ClickOptions { ClickCount = 3 });
            Assert.Equal(text, await Page.EvaluateExpressionAsync<string>("window.getSelection().toString()"));
        }

        [Fact]
        public async Task ShouldClickOffscreenButtons()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/offscreenbuttons.html");
            var messages = new List<string>();
            Page.Console += (sender, e) => messages.Add(e.Message.Text);

            for (var i = 0; i < 11; ++i)
            {
                // We might've scrolled to click a button - reset to (0, 0).
                await Page.EvaluateFunctionAsync("() => window.scrollTo(0, 0)");
                await Page.ClickAsync($"#btn{i}");
            }
            Assert.Equal(new List<string>
            {
                "button #0 clicked",
                "button #1 clicked",
                "button #2 clicked",
                "button #3 clicked",
                "button #4 clicked",
                "button #5 clicked",
                "button #6 clicked",
                "button #7 clicked",
                "button #8 clicked",
                "button #9 clicked",
                "button #10 clicked"
            }, messages);
        }

        [Fact]
        public async Task ShouldClickWrappedLinks()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/wrappedlink.html");
            await Page.ClickAsync("a");
            Assert.True(await Page.EvaluateExpressionAsync<bool>("window.__clicked"));
        }

        [Fact]
        public async Task ShouldClickOnCheckboxInputAndToggle()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/checkbox.html");
            Assert.Null(await Page.EvaluateExpressionAsync("result.check"));
            await Page.ClickAsync("input#agree");
            Assert.True(await Page.EvaluateExpressionAsync<bool>("result.check"));
            Assert.Equal(new[] {
                "mouseover",
                "mouseenter",
                "mousemove",
                "mousedown",
                "mouseup",
                "click",
                "input",
                "change"
            }, await Page.EvaluateExpressionAsync<string[]>("result.events"));
            await Page.ClickAsync("input#agree");
            Assert.False(await Page.EvaluateExpressionAsync<bool>("result.check"));
        }

        [Fact]
        public async Task ShouldClickOnCheckboxLabelAndToggle()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/checkbox.html");
            Assert.Null(await Page.EvaluateExpressionAsync("result.check"));
            await Page.ClickAsync("label[for=\"agree\"]");
            Assert.True(await Page.EvaluateExpressionAsync<bool>("result.check"));
            Assert.Equal(new[] {
                "click",
                "input",
                "change"
            }, await Page.EvaluateExpressionAsync<string[]>("result.events"));
            await Page.ClickAsync("label[for=\"agree\"]");
            Assert.False(await Page.EvaluateExpressionAsync<bool>("result.check"));
        }

        [Fact]
        public async Task ShouldFailToClickAMissingButton()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
            var exception = await Assert.ThrowsAsync<SelectorException>(()
                => Page.ClickAsync("button.does-not-exist"));
            Assert.Equal("No node found for selector: button.does-not-exist", exception.Message);
            Assert.Equal("button.does-not-exist", exception.Selector);
        }

        [Fact]
        public async Task ShouldScrollAndClickTheButton()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/scrollable.html");
            await Page.ClickAsync("#button-5");
            Assert.Equal("clicked", await Page.EvaluateExpressionAsync<string>("document.querySelector(\"#button-5\").textContent"));
            await Page.ClickAsync("#button-80");
            Assert.Equal("clicked", await Page.EvaluateExpressionAsync<string>("document.querySelector(\"#button-80\").textContent"));
        }

        [Fact]
        public async Task ShouldDoubleClickTheButton()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
            await Page.EvaluateExpressionAsync(@"{
               window.double = false;
               const button = document.querySelector('button');
               button.addEventListener('dblclick', event => {
                 window.double = true;
               });
            }");
            var button = await Page.QuerySelectorAsync("button");
            await button.ClickAsync(new ClickOptions { ClickCount = 2 });
            Assert.True(await Page.EvaluateExpressionAsync<bool>("double"));
            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
        }

        [Fact]
        public async Task ShouldClickAPartiallyObscuredButton()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/button.html");
            await Page.EvaluateExpressionAsync(@"{
                const button = document.querySelector('button');
                button.textContent = 'Some really long text that will go offscreen';
                button.style.position = 'absolute';
                button.style.left = '368px';
            }");
            await Page.ClickAsync("button");
            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
        }

        [Fact]
        public async Task ShouldClickARotatedButton()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/rotatedButton.html");
            await Page.ClickAsync("button");
            Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
        }

        [Fact]
        public async Task ShouldFireContextmenuEventOnRightClick()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/scrollable.html");
            await Page.ClickAsync("#button-8", new ClickOptions { Button = MouseButton.Right });
            Assert.Equal("context menu", await Page.EvaluateExpressionAsync<string>("document.querySelector('#button-8').textContent"));
        }

        // @see https://github.com/GoogleChrome/puppeteer/issues/206
        [Fact]
        public async Task ShouldClickLinksWhichCauseNavigation()
        {
            await Page.SetContentAsync($"<a href=\"{TestConstants.EmptyPage}\">empty.html</a>");
            // This await should not hang.
            await Page.ClickAsync("a");
        }

        [Fact]
        public async Task ShouldClickTheButtonInsideAnIframe()
        {
            await Page.GoToAsync(TestConstants.EmptyPage);
            await Page.SetContentAsync("<div style=\"width:100px;height:100px\">spacer</div>");
            await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
            var frame = Page.FirstChildFrame();
            var button = await frame.QuerySelectorAsync("button");
            await button.ClickAsync();
            Assert.Equal("Clicked", await frame.EvaluateExpressionAsync<string>("window.result"));
        }

        [Fact(Skip = "see https://github.com/GoogleChrome/puppeteer/issues/4110")]
        public async Task ShouldClickTheButtonWithFixedPositionInsideAnIframe()
        {
            await Page.GoToAsync(TestConstants.EmptyPage);
            await Page.SetViewportAsync(new ViewPortOptions
            {
                Width = 500,
                Height = 500
            });
            await Page.SetContentAsync("<div style=\"width:100px;height:2000px\">spacer</div>");
            await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
            var frame = Page.FirstChildFrame();
            await frame.QuerySelectorAsync("button").EvaluateFunctionAsync("button => button.style.setProperty('position', 'fixed')");
            await frame.ClickAsync("button");
            Assert.Equal("Clicked", await frame.EvaluateExpressionAsync<string>("window.result"));
        }

        [Fact]
        public async Task ShouldClickTheButtonWithDeviceScaleFactorSet()
        {
            await Page.SetViewportAsync(new ViewPortOptions { Width = 400, Height = 400, DeviceScaleFactor = 5 });
            Assert.Equal(5, await Page.EvaluateExpressionAsync<int>("window.devicePixelRatio"));
            await Page.SetContentAsync("<div style=\"width:100px;height:100px\">spacer</div>");
            await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
            var frame = Page.FirstChildFrame();
            var button = await frame.QuerySelectorAsync("button");
            await button.ClickAsync();
            Assert.Equal("Clicked", await frame.EvaluateExpressionAsync<string>("window.result"));
        }
    }
}