How to use ShouldPressTheMetaKey method of PuppeteerSharp.Tests.KeyboardTests.KeyboardTests class

1using System;
2using System.Collections.Generic;
3using System.Threading.Tasks;
4using PuppeteerSharp.Input;
5using PuppeteerSharp.Tests.Attributes;
6using PuppeteerSharp.Xunit;
7using Xunit;
8using Xunit.Abstractions;
9
10namespace PuppeteerSharp.Tests.KeyboardTests
11{
12    [Collection(TestConstants.TestFixtureCollectionName)]
13    public class KeyboardTests : PuppeteerPageBaseTest
14    {
15        public KeyboardTests(ITestOutputHelper output) : base(output)
16        {
17        }
18
19        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type into a textarea")]
20        [PuppeteerFact]
21        public async Task ShouldTypeIntoTheTextarea()
22        {
23            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
24
25            var textarea = await Page.QuerySelectorAsync("textarea");
26            await textarea.TypeAsync("Type in this text!");
27            Assert.Equal("Type in this text!", await Page.EvaluateExpressionAsync<string>("result"));
28        }
29
30        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should move with the arrow keys")]
31        [PuppeteerFact]
32        public async Task ShouldMoveWithTheArrowKeys()
33        {
34            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
35            await Page.TypeAsync("textarea", "Hello World!");
36            Assert.Equal("Hello World!", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
37            for (var i = 0; i < "World!".Length; i++)
38            {
39                _ = Page.Keyboard.PressAsync("ArrowLeft");
40            }
41
42            await Page.Keyboard.TypeAsync("inserted ");
43            Assert.Equal("Hello inserted World!", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
44            _ = Page.Keyboard.DownAsync("Shift");
45            for (var i = 0; i < "inserted ".Length; i++)
46            {
47                _ = Page.Keyboard.PressAsync("ArrowLeft");
48            }
49
50            _ = Page.Keyboard.UpAsync("Shift");
51            await Page.Keyboard.PressAsync("Backspace");
52            Assert.Equal("Hello World!", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
53        }
54
55        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send a character with ElementHandle.press")]
56        [PuppeteerFact]
57        public async Task ShouldSendACharacterWithElementHandlePress()
58        {
59            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
60            var textarea = await Page.QuerySelectorAsync("textarea");
61            await textarea.PressAsync("a");
62            Assert.Equal("a", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
63
64            await Page.EvaluateExpressionAsync("window.addEventListener('keydown', e => e.preventDefault(), true)");
65
66            await textarea.PressAsync("b");
67            Assert.Equal("a", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
68        }
69
70        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "ElementHandle.press should support |text| option")]
71        [SkipBrowserFact(skipFirefox: true)]
72        public async Task ElementHandlePressShouldSupportTextOption()
73        {
74            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
75            var textarea = await Page.QuerySelectorAsync("textarea");
76            await textarea.PressAsync("a", new PressOptions { Text = "ё" });
77            Assert.Equal("ё", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
78        }
79
80        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send a character with sendCharacter")]
81        [SkipBrowserFact(skipFirefox: true)]
82        public async Task ShouldSendACharacterWithSendCharacter()
83        {
84            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
85            await Page.FocusAsync("textarea");
86            await Page.Keyboard.SendCharacterAsync("嗨");
87            Assert.Equal("嗨", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
88            await Page.EvaluateExpressionAsync("window.addEventListener('keydown', e => e.preventDefault(), true)");
89            await Page.Keyboard.SendCharacterAsync("a");
90            Assert.Equal("嗨a", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
91        }
92
93        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should report shiftKey")]
94        [SkipBrowserFact(skipFirefox: true)]
95        public async Task ShouldReportShiftKey()
96        {
97            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
98            var keyboard = Page.Keyboard;
99            var codeForKey = new Dictionary<string, int> { ["Shift"] = 16, ["Alt"] = 18, ["Control"] = 17 };
100            foreach (var modifier in codeForKey)
101            {
102                await keyboard.DownAsync(modifier.Key);
103                Assert.Equal($"Keydown: {modifier.Key} {modifier.Key}Left {modifier.Value} [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
104                await keyboard.DownAsync("!");
105                // Shift+! will generate a keypress
106                if (modifier.Key == "Shift")
107                {
108                    Assert.Equal($"Keydown: ! Digit1 49 [{modifier.Key}]\nKeypress: ! Digit1 33 33 [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
109                }
110                else
111                {
112                    Assert.Equal($"Keydown: ! Digit1 49 [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
113                }
114
115                await keyboard.UpAsync("!");
116                Assert.Equal($"Keyup: ! Digit1 49 [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
117                await keyboard.UpAsync(modifier.Key);
118                Assert.Equal($"Keyup: {modifier.Key} {modifier.Key}Left {modifier.Value} []", await Page.EvaluateExpressionAsync<string>("getResult()"));
119            }
120        }
121
122        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should report multiple modifiers")]
123        [PuppeteerFact]
124        public async Task ShouldReportMultipleModifiers()
125        {
126            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
127            var keyboard = Page.Keyboard;
128            await keyboard.DownAsync("Control");
129            Assert.Equal("Keydown: Control ControlLeft 17 [Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
130            await keyboard.DownAsync("Alt");
131            Assert.Equal("Keydown: Alt AltLeft 18 [Alt Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
132            await keyboard.DownAsync(";");
133            Assert.Equal("Keydown: ; Semicolon 186 [Alt Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
134            await keyboard.UpAsync(";");
135            Assert.Equal("Keyup: ; Semicolon 186 [Alt Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
136            await keyboard.UpAsync("Control");
137            Assert.Equal("Keyup: Control ControlLeft 17 [Alt]", await Page.EvaluateExpressionAsync<string>("getResult()"));
138            await keyboard.UpAsync("Alt");
139            Assert.Equal("Keyup: Alt AltLeft 18 []", await Page.EvaluateExpressionAsync<string>("getResult()"));
140        }
141
142        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send proper codes while typing")]
143        [PuppeteerFact]
144        public async Task ShouldSendProperCodesWhileTyping()
145        {
146            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
147            await Page.Keyboard.TypeAsync("!");
148            Assert.Equal(string.Join("\n", new[] {
149                "Keydown: ! Digit1 49 []",
150                "Keypress: ! Digit1 33 33 []",
151                "Keyup: ! Digit1 49 []" }), await Page.EvaluateExpressionAsync<string>("getResult()"));
152            await Page.Keyboard.TypeAsync("^");
153            Assert.Equal(string.Join("\n", new[] {
154                "Keydown: ^ Digit6 54 []",
155                "Keypress: ^ Digit6 94 94 []",
156                "Keyup: ^ Digit6 54 []" }), await Page.EvaluateExpressionAsync<string>("getResult()"));
157        }
158
159        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send proper codes while typing with shift")]
160        [PuppeteerFact]
161        public async Task ShouldSendProperCodesWhileTypingWithShift()
162        {
163            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
164            var keyboard = Page.Keyboard;
165            await keyboard.DownAsync("Shift");
166            await Page.Keyboard.TypeAsync("~");
167            Assert.Equal(string.Join("\n", new[] {
168                "Keydown: Shift ShiftLeft 16 [Shift]",
169                "Keydown: ~ Backquote 192 [Shift]", // 192 is ` keyCode
170                "Keypress: ~ Backquote 126 126 [Shift]", // 126 is ~ charCode
171                "Keyup: ~ Backquote 192 [Shift]" }), await Page.EvaluateExpressionAsync<string>("getResult()"));
172            await keyboard.UpAsync("Shift");
173        }
174
175        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should not type canceled events")]
176        [PuppeteerFact]
177        public async Task ShouldNotTypeCanceledEvents()
178        {
179            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
180            await Page.FocusAsync("textarea");
181            await Page.EvaluateExpressionAsync(@"{
182              window.addEventListener('keydown', event => {
183                event.stopPropagation();
184                event.stopImmediatePropagation();
185                if (event.key === 'l')
186                  event.preventDefault();
187                if (event.key === 'o')
188                  event.preventDefault();
189              }, false);
190            }");
191            await Page.Keyboard.TypeAsync("Hello World!");
192            Assert.Equal("He Wrd!", await Page.EvaluateExpressionAsync<string>("textarea.value"));
193        }
194
195        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should specify repeat property")]
196        [SkipBrowserFact(skipFirefox: true)]
197        public async Task ShouldSpecifyRepeatProperty()
198        {
199            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
200            await Page.FocusAsync("textarea");
201            await Page.EvaluateExpressionAsync("document.querySelector('textarea').addEventListener('keydown', e => window.lastEvent = e, true)");
202            await Page.Keyboard.DownAsync("a");
203            Assert.False(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
204            await Page.Keyboard.PressAsync("a");
205            Assert.True(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
206
207            await Page.Keyboard.DownAsync("b");
208            Assert.False(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
209            await Page.Keyboard.DownAsync("b");
210            Assert.True(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
211
212            await Page.Keyboard.UpAsync("a");
213            await Page.Keyboard.DownAsync("a");
214            Assert.False(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
215        }
216
217        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type all kinds of characters")]
218        [SkipBrowserFact(skipFirefox: true)]
219        public async Task ShouldTypeAllKindsOfCharacters()
220        {
221            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
222            await Page.FocusAsync("textarea");
223            const string text = "This text goes onto two lines.\nThis character is 嗨.";
224            await Page.Keyboard.TypeAsync(text);
225            Assert.Equal(text, await Page.EvaluateExpressionAsync<string>("result"));
226        }
227
228        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should specify location")]
229        [SkipBrowserFact(skipFirefox: true)]
230        public async Task ShouldSpecifyLocation()
231        {
232            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
233            await Page.EvaluateExpressionAsync(@"{
234              window.addEventListener('keydown', event => window.keyLocation = event.location, true);
235            }");
236            var textarea = await Page.QuerySelectorAsync("textarea");
237
238            await textarea.PressAsync("Digit5");
239            Assert.Equal(0, await Page.EvaluateExpressionAsync<int>("keyLocation"));
240
241            await textarea.PressAsync("ControlLeft");
242            Assert.Equal(1, await Page.EvaluateExpressionAsync<int>("keyLocation"));
243
244            await textarea.PressAsync("ControlRight");
245            Assert.Equal(2, await Page.EvaluateExpressionAsync<int>("keyLocation"));
246
247            await textarea.PressAsync("NumpadSubtract");
248            Assert.Equal(3, await Page.EvaluateExpressionAsync<int>("keyLocation"));
249        }
250
251        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should throw on unknown keys")]
252        [PuppeteerFact]
253        public async Task ShouldThrowOnUnknownKeys()
254        {
255            await Assert.ThrowsAsync<KeyNotFoundException>(() => Page.Keyboard.PressAsync("NotARealKey"));
256
257            await Assert.ThrowsAsync<KeyNotFoundException>(() => Page.Keyboard.PressAsync("ё"));
258
259            await Assert.ThrowsAsync<KeyNotFoundException>(() => Page.Keyboard.PressAsync("😊"));
260        }
261
262        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type emoji")]
263        [SkipBrowserFact(skipFirefox: true)]
264        public async Task ShouldTypeEmoji()
265        {
266            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
267            await Page.TypeAsync("textarea", "👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5");
268            Assert.Equal(
269                "👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5",
270                await Page.QuerySelectorAsync("textarea").EvaluateFunctionAsync<string>("t => t.value"));
271        }
272
273        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type emoji into an iframe")]
274        [SkipBrowserFact(skipFirefox: true)]
275        public async Task ShouldTypeEmojiIntoAniframe()
276        {
277            await Page.GoToAsync(TestConstants.EmptyPage);
278            await FrameUtils.AttachFrameAsync(Page, "emoji-test", TestConstants.ServerUrl + "/input/textarea.html");
279            var frame = Page.FirstChildFrame();
280            var textarea = await frame.QuerySelectorAsync("textarea");
281            await textarea.TypeAsync("👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5");
282            Assert.Equal(
283                "👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5",
284                await frame.QuerySelectorAsync("textarea").EvaluateFunctionAsync<string>("t => t.value"));
285        }
286
287        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should press the metaKey")]
288        [SkipBrowserFact(skipFirefox: true)]
289        public async Task ShouldPressTheMetaKey()
290        {
291            await Page.EvaluateFunctionAsync(@"() =>
292            {
293                window.result = null;
294                document.addEventListener('keydown', event => {
295                    window.result = [event.key, event.code, event.metaKey];
296                });
297            }");
298            await Page.Keyboard.PressAsync("Meta");
299            const int key = 0;
300            const int code = 1;
301            const int metaKey = 2;
302            var result = await Page.EvaluateExpressionAsync<object[]>("result");
303            Assert.Equal("Meta", result[key]);
304            Assert.Equal("MetaLeft", result[code]);
305            Assert.Equal(true, result[metaKey]);
306        }
307    }
308}
309

Source: KeyboardTests.cs

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

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

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type into a textarea")]
        [PuppeteerFact]
        public async Task ShouldTypeIntoTheTextarea()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");

            var textarea = await Page.QuerySelectorAsync("textarea");
            await textarea.TypeAsync("Type in this text!");
            Assert.Equal("Type in this text!", await Page.EvaluateExpressionAsync<string>("result"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should move with the arrow keys")]
        [PuppeteerFact]
        public async Task ShouldMoveWithTheArrowKeys()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.TypeAsync("textarea", "Hello World!");
            Assert.Equal("Hello World!", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
            for (var i = 0; i < "World!".Length; i++)
            {
                _ = Page.Keyboard.PressAsync("ArrowLeft");
            }

            await Page.Keyboard.TypeAsync("inserted ");
            Assert.Equal("Hello inserted World!", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
            _ = Page.Keyboard.DownAsync("Shift");
            for (var i = 0; i < "inserted ".Length; i++)
            {
                _ = Page.Keyboard.PressAsync("ArrowLeft");
            }

            _ = Page.Keyboard.UpAsync("Shift");
            await Page.Keyboard.PressAsync("Backspace");
            Assert.Equal("Hello World!", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send a character with ElementHandle.press")]
        [PuppeteerFact]
        public async Task ShouldSendACharacterWithElementHandlePress()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            var textarea = await Page.QuerySelectorAsync("textarea");
            await textarea.PressAsync("a");
            Assert.Equal("a", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));

            await Page.EvaluateExpressionAsync("window.addEventListener('keydown', e => e.preventDefault(), true)");

            await textarea.PressAsync("b");
            Assert.Equal("a", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "ElementHandle.press should support |text| option")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ElementHandlePressShouldSupportTextOption()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            var textarea = await Page.QuerySelectorAsync("textarea");
            await textarea.PressAsync("a", new PressOptions { Text = "ё" });
            Assert.Equal("ё", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send a character with sendCharacter")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldSendACharacterWithSendCharacter()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.FocusAsync("textarea");
            await Page.Keyboard.SendCharacterAsync("嗨");
            Assert.Equal("嗨", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
            await Page.EvaluateExpressionAsync("window.addEventListener('keydown', e => e.preventDefault(), true)");
            await Page.Keyboard.SendCharacterAsync("a");
            Assert.Equal("嗨a", await Page.EvaluateExpressionAsync<string>("document.querySelector('textarea').value"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should report shiftKey")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldReportShiftKey()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
            var keyboard = Page.Keyboard;
            var codeForKey = new Dictionary<string, int> { ["Shift"] = 16, ["Alt"] = 18, ["Control"] = 17 };
            foreach (var modifier in codeForKey)
            {
                await keyboard.DownAsync(modifier.Key);
                Assert.Equal($"Keydown: {modifier.Key} {modifier.Key}Left {modifier.Value} [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
                await keyboard.DownAsync("!");
                // Shift+! will generate a keypress
                if (modifier.Key == "Shift")
                {
                    Assert.Equal($"Keydown: ! Digit1 49 [{modifier.Key}]\nKeypress: ! Digit1 33 33 [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
                }
                else
                {
                    Assert.Equal($"Keydown: ! Digit1 49 [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
                }

                await keyboard.UpAsync("!");
                Assert.Equal($"Keyup: ! Digit1 49 [{modifier.Key}]", await Page.EvaluateExpressionAsync<string>("getResult()"));
                await keyboard.UpAsync(modifier.Key);
                Assert.Equal($"Keyup: {modifier.Key} {modifier.Key}Left {modifier.Value} []", await Page.EvaluateExpressionAsync<string>("getResult()"));
            }
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should report multiple modifiers")]
        [PuppeteerFact]
        public async Task ShouldReportMultipleModifiers()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
            var keyboard = Page.Keyboard;
            await keyboard.DownAsync("Control");
            Assert.Equal("Keydown: Control ControlLeft 17 [Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
            await keyboard.DownAsync("Alt");
            Assert.Equal("Keydown: Alt AltLeft 18 [Alt Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
            await keyboard.DownAsync(";");
            Assert.Equal("Keydown: ; Semicolon 186 [Alt Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
            await keyboard.UpAsync(";");
            Assert.Equal("Keyup: ; Semicolon 186 [Alt Control]", await Page.EvaluateExpressionAsync<string>("getResult()"));
            await keyboard.UpAsync("Control");
            Assert.Equal("Keyup: Control ControlLeft 17 [Alt]", await Page.EvaluateExpressionAsync<string>("getResult()"));
            await keyboard.UpAsync("Alt");
            Assert.Equal("Keyup: Alt AltLeft 18 []", await Page.EvaluateExpressionAsync<string>("getResult()"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send proper codes while typing")]
        [PuppeteerFact]
        public async Task ShouldSendProperCodesWhileTyping()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
            await Page.Keyboard.TypeAsync("!");
            Assert.Equal(string.Join("\n", new[] {
                "Keydown: ! Digit1 49 []",
                "Keypress: ! Digit1 33 33 []",
                "Keyup: ! Digit1 49 []" }), await Page.EvaluateExpressionAsync<string>("getResult()"));
            await Page.Keyboard.TypeAsync("^");
            Assert.Equal(string.Join("\n", new[] {
                "Keydown: ^ Digit6 54 []",
                "Keypress: ^ Digit6 94 94 []",
                "Keyup: ^ Digit6 54 []" }), await Page.EvaluateExpressionAsync<string>("getResult()"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should send proper codes while typing with shift")]
        [PuppeteerFact]
        public async Task ShouldSendProperCodesWhileTypingWithShift()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/keyboard.html");
            var keyboard = Page.Keyboard;
            await keyboard.DownAsync("Shift");
            await Page.Keyboard.TypeAsync("~");
            Assert.Equal(string.Join("\n", new[] {
                "Keydown: Shift ShiftLeft 16 [Shift]",
                "Keydown: ~ Backquote 192 [Shift]", // 192 is ` keyCode
                "Keypress: ~ Backquote 126 126 [Shift]", // 126 is ~ charCode
                "Keyup: ~ Backquote 192 [Shift]" }), await Page.EvaluateExpressionAsync<string>("getResult()"));
            await keyboard.UpAsync("Shift");
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should not type canceled events")]
        [PuppeteerFact]
        public async Task ShouldNotTypeCanceledEvents()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.FocusAsync("textarea");
            await Page.EvaluateExpressionAsync(@"{
              window.addEventListener('keydown', event => {
                event.stopPropagation();
                event.stopImmediatePropagation();
                if (event.key === 'l')
                  event.preventDefault();
                if (event.key === 'o')
                  event.preventDefault();
              }, false);
            }");
            await Page.Keyboard.TypeAsync("Hello World!");
            Assert.Equal("He Wrd!", await Page.EvaluateExpressionAsync<string>("textarea.value"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should specify repeat property")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldSpecifyRepeatProperty()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.FocusAsync("textarea");
            await Page.EvaluateExpressionAsync("document.querySelector('textarea').addEventListener('keydown', e => window.lastEvent = e, true)");
            await Page.Keyboard.DownAsync("a");
            Assert.False(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
            await Page.Keyboard.PressAsync("a");
            Assert.True(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));

            await Page.Keyboard.DownAsync("b");
            Assert.False(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
            await Page.Keyboard.DownAsync("b");
            Assert.True(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));

            await Page.Keyboard.UpAsync("a");
            await Page.Keyboard.DownAsync("a");
            Assert.False(await Page.EvaluateExpressionAsync<bool>("window.lastEvent.repeat"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type all kinds of characters")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldTypeAllKindsOfCharacters()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.FocusAsync("textarea");
            const string text = "This text goes onto two lines.\nThis character is 嗨.";
            await Page.Keyboard.TypeAsync(text);
            Assert.Equal(text, await Page.EvaluateExpressionAsync<string>("result"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should specify location")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldSpecifyLocation()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.EvaluateExpressionAsync(@"{
              window.addEventListener('keydown', event => window.keyLocation = event.location, true);
            }");
            var textarea = await Page.QuerySelectorAsync("textarea");

            await textarea.PressAsync("Digit5");
            Assert.Equal(0, await Page.EvaluateExpressionAsync<int>("keyLocation"));

            await textarea.PressAsync("ControlLeft");
            Assert.Equal(1, await Page.EvaluateExpressionAsync<int>("keyLocation"));

            await textarea.PressAsync("ControlRight");
            Assert.Equal(2, await Page.EvaluateExpressionAsync<int>("keyLocation"));

            await textarea.PressAsync("NumpadSubtract");
            Assert.Equal(3, await Page.EvaluateExpressionAsync<int>("keyLocation"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should throw on unknown keys")]
        [PuppeteerFact]
        public async Task ShouldThrowOnUnknownKeys()
        {
            await Assert.ThrowsAsync<KeyNotFoundException>(() => Page.Keyboard.PressAsync("NotARealKey"));

            await Assert.ThrowsAsync<KeyNotFoundException>(() => Page.Keyboard.PressAsync("ё"));

            await Assert.ThrowsAsync<KeyNotFoundException>(() => Page.Keyboard.PressAsync("😊"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type emoji")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldTypeEmoji()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/input/textarea.html");
            await Page.TypeAsync("textarea", "👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5");
            Assert.Equal(
                "👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5",
                await Page.QuerySelectorAsync("textarea").EvaluateFunctionAsync<string>("t => t.value"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should type emoji into an iframe")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldTypeEmojiIntoAniframe()
        {
            await Page.GoToAsync(TestConstants.EmptyPage);
            await FrameUtils.AttachFrameAsync(Page, "emoji-test", TestConstants.ServerUrl + "/input/textarea.html");
            var frame = Page.FirstChildFrame();
            var textarea = await frame.QuerySelectorAsync("textarea");
            await textarea.TypeAsync("👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5");
            Assert.Equal(
                "👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5",
                await frame.QuerySelectorAsync("textarea").EvaluateFunctionAsync<string>("t => t.value"));
        }

        [PuppeteerTest("keyboard.spec.ts", "Keyboard", "should press the metaKey")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldPressTheMetaKey()
        {
            await Page.EvaluateFunctionAsync(@"() =>
            {
                window.result = null;
                document.addEventListener('keydown', event => {
                    window.result = [event.key, event.code, event.metaKey];
                });
            }");
            await Page.Keyboard.PressAsync("Meta");
            const int key = 0;
            const int code = 1;
            const int metaKey = 2;
            var result = await Page.EvaluateExpressionAsync<object[]>("result");
            Assert.Equal("Meta", result[key]);
            Assert.Equal("MetaLeft", result[code]);
            Assert.Equal(true, result[metaKey]);
        }
    }
}