How to use SkipAttribute method of Microsoft.Playwright.NUnit.SkipAttribute 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.AspNetCore.Http;
27using Microsoft.Playwright.NUnit;
28using NUnit.Framework;
29
30namespace Microsoft.Playwright.Tests
31{
32    ///<playwright-file>capabilities.spec.ts</playwright-file>
33    public class CapabilitiesTests : PageTestEx
34    {
35        [PlaywrightTest("capabilities.spec.ts", "Web Assembly should work")]
36        [Skip(SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Windows)]
37        public async Task WebAssemblyShouldWork()
38        {
39            await Page.GotoAsync(Server.Prefix + "/wasm/table2.html");
40            Assert.AreEqual("42, 83", await Page.EvaluateAsync<string>("() => loadTable()"));
41        }
42
43#if NETCOREAPP
44        [PlaywrightTest("capabilities.spec.ts", "WebSocket should work")]
45        [Skip(SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Windows)]
46        public async Task WebSocketShouldWork()
47        {
48            Server.SendOnWebSocketConnection("incoming");
49            string value = await Page.EvaluateAsync<string>(
50                [email protected]"(port) => {{
51                    let cb;
52                    const result = new Promise(f => cb = f);
53                    const ws = new WebSocket('ws://localhost:' + port + '/ws');
54                    ws.addEventListener('message', data => {{ ws.close(); cb(data.data); console.log(data); console.log(data.data) }});
55                    ws.addEventListener('error', error => cb('Error'));
56                    return result;
57                }}",
58                Server.Port);
59            Assert.AreEqual("incoming", value);
60        }
61#endif
62
63        [PlaywrightTest("capabilities.spec.ts", "should respect CSP")]
64        public async Task ShouldRespectCSP()
65        {
66            Server.SetRoute("/empty.html", context =>
67            {
68                const string message = @"
69                    <script>
70                      window.testStatus = 'SUCCESS';
71                      window.testStatus = eval(""'FAILED'"");
72                    </script>
73                ";
74
75                context.Response.Headers["Content-Length"] = message.Length.ToString();
76                context.Response.Headers["Content-Security-Policy"] = "script-src 'unsafe-inline';";
77                return context.Response.WriteAsync(message);
78            });
79
80            await Page.GotoAsync(Server.EmptyPage);
81            Assert.AreEqual("SUCCESS", await Page.EvaluateAsync<string>("() => window.testStatus"));
82        }
83
84        [PlaywrightTest("capabilities.spec.ts", "should play video")]
85        [Skip(SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Linux, SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Windows, SkipAttribute.Targets.Firefox)]
86        public async Task ShouldPlayVideo()
87        {
88            await Page.GotoAsync(Server.Prefix + (TestConstants.IsWebKit ? "/video_mp4.html" : "/video.html"));
89            await Page.EvalOnSelectorAsync("video", "v => v.play()");
90            await Page.EvalOnSelectorAsync("video", "v => v.pause()");
91        }
92    }
93}
94

Source: CapabilitiesTests.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.AspNetCore.Http;
using Microsoft.Playwright.NUnit;
using NUnit.Framework;

namespace Microsoft.Playwright.Tests
{
    ///<playwright-file>capabilities.spec.ts</playwright-file>
    public class CapabilitiesTests : PageTestEx
    {
        [PlaywrightTest("capabilities.spec.ts", "Web Assembly should work")]
        [Skip(SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Windows)]
        public async Task WebAssemblyShouldWork()
        {
            await Page.GotoAsync(Server.Prefix + "/wasm/table2.html");
            Assert.AreEqual("42, 83", await Page.EvaluateAsync<string>("() => loadTable()"));
        }

#if NETCOREAPP
        [PlaywrightTest("capabilities.spec.ts", "WebSocket should work")]
        [Skip(SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Windows)]
        public async Task WebSocketShouldWork()
        {
            Server.SendOnWebSocketConnection("incoming");
            string value = await Page.EvaluateAsync<string>(
                [email protected]"(port) => {{
                    let cb;
                    const result = new Promise(f => cb = f);
                    const ws = new WebSocket('ws://localhost:' + port + '/ws');
                    ws.addEventListener('message', data => {{ ws.close(); cb(data.data); console.log(data); console.log(data.data) }});
                    ws.addEventListener('error', error => cb('Error'));
                    return result;
                }}",
                Server.Port);
            Assert.AreEqual("incoming", value);
        }
#endif

        [PlaywrightTest("capabilities.spec.ts", "should respect CSP")]
        public async Task ShouldRespectCSP()
        {
            Server.SetRoute("/empty.html", context =>
            {
                const string message = @"
                    <script>
                      window.testStatus = 'SUCCESS';
                      window.testStatus = eval(""'FAILED'"");
                    </script>
                ";

                context.Response.Headers["Content-Length"] = message.Length.ToString();
                context.Response.Headers["Content-Security-Policy"] = "script-src 'unsafe-inline';";
                return context.Response.WriteAsync(message);
            });

            await Page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual("SUCCESS", await Page.EvaluateAsync<string>("() => window.testStatus"));
        }

        [PlaywrightTest("capabilities.spec.ts", "should play video")]
        [Skip(SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Linux, SkipAttribute.Targets.Webkit | SkipAttribute.Targets.Windows, SkipAttribute.Targets.Firefox)]
        public async Task ShouldPlayVideo()
        {
            await Page.GotoAsync(Server.Prefix + (TestConstants.IsWebKit ? "/video_mp4.html" : "/video.html"));
            await Page.EvalOnSelectorAsync("video", "v => v.play()");
            await Page.EvalOnSelectorAsync("video", "v => v.pause()");
        }
    }
}

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 PageEventCrashTests : PageTestEx
32    {
33        // We skip all browser because crash uses internals.
34        [PlaywrightTest("page-event-crash.spec.ts", "should emit crash event when page crashes")]
35        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
36        public async Task ShouldEmitCrashEventWhenPageCrashes()
37        {
38            await Page.SetContentAsync("<div>This page should crash</div>");
39            var crashEvent = new TaskCompletionSource<bool>();
40            Page.Crash += (_, _) => crashEvent.TrySetResult(true);
41
42            await CrashAsync(Page);
43            await crashEvent.Task;
44        }
45
46        // We skip all browser because crash uses internals.
47        [PlaywrightTest("page-event-crash.spec.ts", "should throw on any action after page crashes")]
48        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
49        public async Task ShouldThrowOnAnyActionAfterPageCrashes()
50        {
51            await Page.SetContentAsync("<div>This page should crash</div>");
52            var crashEvent = new TaskCompletionSource<bool>();
53            Page.Crash += (_, _) => crashEvent.TrySetResult(true);
54
55            await CrashAsync(Page);
56            await crashEvent.Task;
57            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => Page.EvaluateAsync("() => {}"));
58            StringAssert.Contains("Target crashed", exception.Message);
59        }
60
61        // We skip all browser because crash uses internals.
62        [PlaywrightTest("page-event-crash.spec.ts", "should cancel waitForEvent when page crashes")]
63        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
64        public async Task ShouldCancelWaitForEventWhenPageCrashes()
65        {
66            await Page.SetContentAsync("<div>This page should crash</div>");
67            var responseTask = Page.WaitForResponseAsync("**/*");
68            await CrashAsync(Page);
69            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => responseTask);
70            StringAssert.Contains("Page crashed", exception.Message);
71        }
72
73        // We skip all browser because crash uses internals.
74        [PlaywrightTest("page-event-crash.spec.ts", "should cancel navigation when page crashes")]
75        [Ignore("Not relevant downstream")]
76        public void ShouldCancelNavigationWhenPageCrashes()
77        {
78        }
79
80        // We skip all browser because crash uses internals.
81        [PlaywrightTest("page-event-crash.spec.ts", "should be able to close context when page crashes")]
82        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
83        public async Task ShouldBeAbleToCloseContextWhenPageCrashes()
84        {
85            await Page.SetContentAsync("<div>This page should crash</div>");
86
87            var crashEvent = new TaskCompletionSource<bool>();
88            Page.Crash += (_, _) => crashEvent.TrySetResult(true);
89
90            await CrashAsync(Page);
91            await crashEvent.Task;
92            await Page.Context.CloseAsync();
93        }
94
95        private async Task CrashAsync(IPage page)
96        {
97            try
98            {
99                await page.GotoAsync("chrome://crash");
100            }
101            catch
102            {
103            }
104        }
105    }
106}
107

Source: PageEventCrashTests.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 PageEventCrashTests : PageTestEx
    {
        // We skip all browser because crash uses internals.
        [PlaywrightTest("page-event-crash.spec.ts", "should emit crash event when page crashes")]
        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
        public async Task ShouldEmitCrashEventWhenPageCrashes()
        {
            await Page.SetContentAsync("<div>This page should crash</div>");
            var crashEvent = new TaskCompletionSource<bool>();
            Page.Crash += (_, _) => crashEvent.TrySetResult(true);

            await CrashAsync(Page);
            await crashEvent.Task;
        }

        // We skip all browser because crash uses internals.
        [PlaywrightTest("page-event-crash.spec.ts", "should throw on any action after page crashes")]
        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
        public async Task ShouldThrowOnAnyActionAfterPageCrashes()
        {
            await Page.SetContentAsync("<div>This page should crash</div>");
            var crashEvent = new TaskCompletionSource<bool>();
            Page.Crash += (_, _) => crashEvent.TrySetResult(true);

            await CrashAsync(Page);
            await crashEvent.Task;
            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => Page.EvaluateAsync("() => {}"));
            StringAssert.Contains("Target crashed", exception.Message);
        }

        // We skip all browser because crash uses internals.
        [PlaywrightTest("page-event-crash.spec.ts", "should cancel waitForEvent when page crashes")]
        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
        public async Task ShouldCancelWaitForEventWhenPageCrashes()
        {
            await Page.SetContentAsync("<div>This page should crash</div>");
            var responseTask = Page.WaitForResponseAsync("**/*");
            await CrashAsync(Page);
            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => responseTask);
            StringAssert.Contains("Page crashed", exception.Message);
        }

        // We skip all browser because crash uses internals.
        [PlaywrightTest("page-event-crash.spec.ts", "should cancel navigation when page crashes")]
        [Ignore("Not relevant downstream")]
        public void ShouldCancelNavigationWhenPageCrashes()
        {
        }

        // We skip all browser because crash uses internals.
        [PlaywrightTest("page-event-crash.spec.ts", "should be able to close context when page crashes")]
        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
        public async Task ShouldBeAbleToCloseContextWhenPageCrashes()
        {
            await Page.SetContentAsync("<div>This page should crash</div>");

            var crashEvent = new TaskCompletionSource<bool>();
            Page.Crash += (_, _) => crashEvent.TrySetResult(true);

            await CrashAsync(Page);
            await crashEvent.Task;
            await Page.Context.CloseAsync();
        }

        private async Task CrashAsync(IPage page)
        {
            try
            {
                await page.GotoAsync("chrome://crash");
            }
            catch
            {
            }
        }
    }
}

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.Collections.Generic;
26using System.Threading.Tasks;
27using Microsoft.Playwright.Helpers;
28using Microsoft.Playwright.NUnit;
29using NUnit.Framework;
30
31namespace Microsoft.Playwright.Tests
32{
33    ///<playwright-file>chromium/chromium.spec.ts</playwright-file>
34    public class BrowserTypeConnectOverCDPTests : PlaywrightTestEx
35    {
36        [PlaywrightTest("chromium/chromium.spec.ts", "should connect to an existing cdp session")]
37        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
38        public async Task ShouldConnectToAnExistingCDPSession()
39        {
40            int port = 9393 + WorkerIndex;
41            IBrowser browserServer = await BrowserType.LaunchAsync(new() { Args = new[] { $"--remote-debugging-port={port}" } });
42            try
43            {
44                IBrowser cdpBrowser = await BrowserType.ConnectOverCDPAsync($"http://localhost:{port}/");
45                var contexts = cdpBrowser.Contexts;
46                Assert.AreEqual(1, cdpBrowser.Contexts.Count);
47                var page = await cdpBrowser.Contexts[0].NewPageAsync();
48                Assert.AreEqual(2, await page.EvaluateAsync<int>("1 + 1"));
49                await cdpBrowser.CloseAsync();
50            }
51            finally
52            {
53
54                await browserServer.CloseAsync();
55            }
56        }
57
58        [PlaywrightTest("chromium/chromium.spec.ts", "should send extra headers with connect request")]
59        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
60        public async Task ShouldSendExtraHeadersWithConnectRequest()
61        {
62            var waitForRequest = Server.WaitForWebSocketConnectionRequest();
63            BrowserType.ConnectOverCDPAsync($"ws://localhost:{Server.Port}/ws", new()
64            {
65                Headers = new Dictionary<string, string> {
66                    { "x-foo-bar", "fookek" }
67                },
68            }).IgnoreException();
69            var req = await waitForRequest;
70            Assert.AreEqual("fookek", req.Headers["x-foo-bar"]);
71            StringAssert.Contains("Playwright", req.Headers["user-agent"]);
72        }
73    }
74}
75

Source: BrowserTypeConnectOverCDPTests.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.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Playwright.Helpers;
using Microsoft.Playwright.NUnit;
using NUnit.Framework;

namespace Microsoft.Playwright.Tests
{
    ///<playwright-file>chromium/chromium.spec.ts</playwright-file>
    public class BrowserTypeConnectOverCDPTests : PlaywrightTestEx
    {
        [PlaywrightTest("chromium/chromium.spec.ts", "should connect to an existing cdp session")]
        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
        public async Task ShouldConnectToAnExistingCDPSession()
        {
            int port = 9393 + WorkerIndex;
            IBrowser browserServer = await BrowserType.LaunchAsync(new() { Args = new[] { $"--remote-debugging-port={port}" } });
            try
            {
                IBrowser cdpBrowser = await BrowserType.ConnectOverCDPAsync($"http://localhost:{port}/");
                var contexts = cdpBrowser.Contexts;
                Assert.AreEqual(1, cdpBrowser.Contexts.Count);
                var page = await cdpBrowser.Contexts[0].NewPageAsync();
                Assert.AreEqual(2, await page.EvaluateAsync<int>("1 + 1"));
                await cdpBrowser.CloseAsync();
            }
            finally
            {

                await browserServer.CloseAsync();
            }
        }

        [PlaywrightTest("chromium/chromium.spec.ts", "should send extra headers with connect request")]
        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
        public async Task ShouldSendExtraHeadersWithConnectRequest()
        {
            var waitForRequest = Server.WaitForWebSocketConnectionRequest();
            BrowserType.ConnectOverCDPAsync($"ws://localhost:{Server.Port}/ws", new()
            {
                Headers = new Dictionary<string, string> {
                    { "x-foo-bar", "fookek" }
                },
            }).IgnoreException();
            var req = await waitForRequest;
            Assert.AreEqual("fookek", req.Headers["x-foo-bar"]);
            StringAssert.Contains("Playwright", req.Headers["user-agent"]);
        }
    }
}