Fix wrong test names and tooling (#1731)

kblok · web-flow · commit 713b34d6df5e · 2021-07-03T18:30:12.000-03:00
diff --git a/lib/PuppeteerSharp.Tests/NavigationTests/PageGoBackTests.cs b/lib/PuppeteerSharp.Tests/NavigationTests/PageGoBackTests.cs
@@ -14,7 +14,7 @@ public PageGoBackTests(ITestOutputHelper output) : base(output)
         }
 
         //TODO: This is working in puppeteer. I don't know why is hanging here.
-        [PuppeteerTest("page.spec.ts", "Page.goBack", "should work")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goBack", "should work")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWork()
         {
@@ -33,7 +33,7 @@ public async Task ShouldWork()
             Assert.Null(response);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goBack", "should work with HistoryAPI")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goBack", "should work with HistoryAPI")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWorkWithHistoryAPI()
         {
diff --git a/lib/PuppeteerSharp.Tests/NavigationTests/PageGotoTests.cs b/lib/PuppeteerSharp.Tests/NavigationTests/PageGotoTests.cs
@@ -19,15 +19,15 @@ public PageGotoTests(ITestOutputHelper output) : base(output)
         {
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldWork()
         {
             await Page.GoToAsync(TestConstants.EmptyPage);
             Assert.Equal(TestConstants.EmptyPage, Page.Url);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work with anchor navigation")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with anchor navigation")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWorkWithAnchorNavigation()
         {
@@ -39,7 +39,7 @@ public async Task ShouldWorkWithAnchorNavigation()
             Assert.Equal($"{TestConstants.EmptyPage}#bar", Page.Url);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work with redirects")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with redirects")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldWorkWithRedirects()
         {
@@ -50,23 +50,23 @@ public async Task ShouldWorkWithRedirects()
             await Page.GoToAsync(TestConstants.EmptyPage);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to about:blank")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to about:blank")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldNavigateToAboutBlank()
         {
             var response = await Page.GoToAsync(TestConstants.AboutBlank);
             Assert.Null(response);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should return response when page changes its URL after load")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should return response when page changes its URL after load")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldReturnResponseWhenPageChangesItsURLAfterLoad()
         {
             var response = await Page.GoToAsync(TestConstants.ServerUrl + "/historyapi.html");
             Assert.Equal(HttpStatusCode.OK, response.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work with subframes return 204")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with subframes return 204")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWorkWithSubframesReturn204()
         {
@@ -78,7 +78,7 @@ public async Task ShouldWorkWithSubframesReturn204()
             await Page.GoToAsync(TestConstants.ServerUrl + "/frames/one-frame.html");
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when server returns 204")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when server returns 204")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldFailWhenServerReturns204()
         {
@@ -100,7 +100,7 @@ public async Task ShouldFailWhenServerReturns204()
             }
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to empty page with domcontentloaded")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to empty page with domcontentloaded")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldNavigateToEmptyPageWithDOMContentLoaded()
         {
@@ -112,7 +112,7 @@ public async Task ShouldNavigateToEmptyPageWithDOMContentLoaded()
             Assert.Null(response.SecurityDetails);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work when page calls history API in beforeunload")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when page calls history API in beforeunload")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldWorkWhenPageCallsHistoryAPIInBeforeunload()
         {
@@ -125,23 +125,23 @@ await Page.EvaluateFunctionAsync(@"() =>
             Assert.Equal(HttpStatusCode.OK, response.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to empty page with networkidle0")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to empty page with networkidle0")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldNavigateToEmptyPageWithNetworkidle0()
         {
             var response = await Page.GoToAsync(TestConstants.EmptyPage, new NavigationOptions { WaitUntil = new[] { WaitUntilNavigation.Networkidle0 } });
             Assert.Equal(HttpStatusCode.OK, response.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to empty page with networkidle2")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to empty page with networkidle2")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldNavigateToEmptyPageWithNetworkidle2()
         {
             var response = await Page.GoToAsync(TestConstants.EmptyPage, new NavigationOptions { WaitUntil = new[] { WaitUntilNavigation.Networkidle2 } });
             Assert.Equal(HttpStatusCode.OK, response.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating to bad url")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating to bad url")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldFailWhenNavigatingToBadUrl()
         {
@@ -157,7 +157,7 @@ public async Task ShouldFailWhenNavigatingToBadUrl()
             }
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating to bad SSL")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating to bad SSL")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldFailWhenNavigatingToBadSSL()
         {
@@ -177,7 +177,7 @@ public async Task ShouldFailWhenNavigatingToBadSSL()
             }
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating to bad SSL after redirects")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating to bad SSL after redirects")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldFailWhenNavigatingToBadSSLAfterRedirects()
         {
@@ -193,7 +193,7 @@ public async Task ShouldFailWhenNavigatingToBadSSLAfterRedirects()
             }
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when main resources failed to load")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when main resources failed to load")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldFailWhenMainResourcesFailedToLoad()
         {
@@ -209,7 +209,7 @@ public async Task ShouldFailWhenMainResourcesFailedToLoad()
             }
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when exceeding maximum navigation timeout")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when exceeding maximum navigation timeout")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldFailWhenExceedingMaximumNavigationTimeout()
         {
@@ -220,7 +220,7 @@ public async Task ShouldFailWhenExceedingMaximumNavigationTimeout()
             Assert.Contains("Timeout of 1 ms exceeded", exception.Message);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when exceeding default maximum navigation timeout")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when exceeding default maximum navigation timeout")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldFailWhenExceedingDefaultMaximumNavigationTimeout()
         {
@@ -231,7 +231,7 @@ public async Task ShouldFailWhenExceedingDefaultMaximumNavigationTimeout()
             Assert.Contains("Timeout of 1 ms exceeded", exception.Message);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when exceeding default maximum timeout")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when exceeding default maximum timeout")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldFailWhenExceedingDefaultMaximumTimeout()
         {
@@ -242,7 +242,7 @@ public async Task ShouldFailWhenExceedingDefaultMaximumTimeout()
             Assert.Contains("Timeout of 1 ms exceeded", exception.Message);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should prioritize default navigation timeout over default timeout")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should prioritize default navigation timeout over default timeout")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldPrioritizeDefaultNavigationTimeoutOverDefaultTimeout()
         {
@@ -254,7 +254,7 @@ public async Task ShouldPrioritizeDefaultNavigationTimeoutOverDefaultTimeout()
             Assert.Contains("Timeout of 1 ms exceeded", exception.Message);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should disable timeout when its set to 0")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should disable timeout when its set to 0")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldDisableTimeoutWhenItsSetTo0()
         {
@@ -270,31 +270,31 @@ void OnLoad(object sender, EventArgs e)
             Assert.True(loaded);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work when navigating to valid url")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when navigating to valid url")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldWorkWhenNavigatingToValidUrl()
         {
             var response = await Page.GoToAsync(TestConstants.EmptyPage);
             Assert.Equal(HttpStatusCode.OK, response.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work when navigating to data url")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when navigating to data url")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWorkWhenNavigatingToDataUrl()
         {
             var response = await Page.GoToAsync("data:text/html,hello");
             Assert.Equal(HttpStatusCode.OK, response.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work when navigating to 404")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when navigating to 404")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldWorkWhenNavigatingTo404()
         {
             var response = await Page.GoToAsync(TestConstants.ServerUrl + "/not-found");
             Assert.Equal(HttpStatusCode.NotFound, response.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should return last response in redirect chain")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should return last response in redirect chain")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldReturnLastResponseInRedirectChain()
         {
@@ -307,7 +307,7 @@ public async Task ShouldReturnLastResponseInRedirectChain()
             Assert.Equal(TestConstants.EmptyPage, response.Url);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should wait for network idle to succeed navigation")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should wait for network idle to succeed navigation")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWaitForNetworkIdleToSucceedNavigation()
         {
@@ -397,7 +397,7 @@ await Task.WhenAll(
             Assert.Equal(HttpStatusCode.OK, navigationResponse.Status);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to dataURL and fire dataURL requests")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to dataURL and fire dataURL requests")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldNavigateToDataURLAndFireDataURLRequests()
         {
@@ -416,7 +416,7 @@ public async Task ShouldNavigateToDataURLAndFireDataURLRequests()
             Assert.Equal(dataUrl, requests[0].Url);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to URL with hash and fire requests without hash")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to URL with hash and fire requests without hash")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldNavigateToURLWithHashAndFireRequestsWithoutHash()
         {
@@ -435,7 +435,7 @@ public async Task ShouldNavigateToURLWithHashAndFireRequestsWithoutHash()
             Assert.Equal(TestConstants.EmptyPage, requests[0].Url);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should work with self requesting page")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with self requesting page")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldWorkWithSelfRequestingPage()
         {
@@ -444,7 +444,7 @@ public async Task ShouldWorkWithSelfRequestingPage()
             Assert.Contains("self-request.html", response.Url);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating and show the url at the error message")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating and show the url at the error message")]
         [Fact(Timeout = TestConstants.DefaultTestTimeout)]
         public async Task ShouldFailWhenNavigatingAndShowTheUrlAtTheErrorMessage()
         {
@@ -454,7 +454,7 @@ public async Task ShouldFailWhenNavigatingAndShowTheUrlAtTheErrorMessage()
             Assert.Contains(url, exception.Url);
         }
 
-        [PuppeteerTest("page.spec.ts", "Page.goto", "should send referer")]
+        [PuppeteerTest("navigation.spec.ts", "Page.goto", "should send referer")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldSendReferer()
         {
diff --git a/lib/PuppeteerSharp.Tests/RequestInterceptionTests/RequestRespondTests.cs b/lib/PuppeteerSharp.Tests/RequestInterceptionTests/RequestRespondTests.cs
@@ -7,7 +7,7 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace PuppeteerSharp.Tests.NetworkTests
+namespace PuppeteerSharp.Tests.RequestInterceptionTests
 {
     [Collection(TestConstants.TestFixtureCollectionName)]
     public class RequestRespondTests : PuppeteerPageBaseTest
@@ -16,7 +16,7 @@ public RequestRespondTests(ITestOutputHelper output) : base(output)
         {
         }
 
-        [PuppeteerTest("network.spec.ts", "Request.respond", "should work")]
+        [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should work")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWork()
         {
@@ -45,14 +45,14 @@ await e.Request.RespondAsync(new ResponseData
         /// I found that status 422 is not available in all .NET runtimes (see https://github.com/dotnet/core/blob/4c4642d548074b3fbfd425541a968aadd75fea99/release-notes/2.1/Preview/api-diff/preview2/2.1-preview2_System.Net.md)
         /// As the goal here is testing HTTP codes that are not in Chromium (see https://cs.chromium.org/chromium/src/net/http/http_status_code_list.h?sq=package:chromium&g=0) we will use code 426: Upgrade Required
         /// </summary>
-        [PuppeteerTest("network.spec.ts", "Request.respond", "should work with status code 422")]
+        [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should work with status code 422")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldWorkReturnStatusPhrases()
         {
             await Page.SetRequestInterceptionAsync(true);
             Page.Request += async (_, e) =>
             {
-                await e.Request.RespondAsync(new ResponseData
+                await e.    Request.RespondAsync(new ResponseData
                 {
                     Status = HttpStatusCode.UpgradeRequired,
                     Body = "Yo, page!"
@@ -65,7 +65,7 @@ await e.Request.RespondAsync(new ResponseData
             Assert.Equal("Yo, page!", await Page.EvaluateExpressionAsync<string>("document.body.textContent"));
         }
 
-        [PuppeteerTest("network.spec.ts", "Request.respond", "should redirect")]
+        [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should redirect")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldRedirect()
         {
@@ -96,7 +96,7 @@ await e.Request.RespondAsync(new ResponseData
             Assert.Equal(TestConstants.EmptyPage, response.Url);
         }
 
-        [PuppeteerTest("network.spec.ts", "Request.respond", "should allow mocking binary responses")]
+        [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should allow mocking binary responses")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldAllowMockingBinaryResponses()
         {
@@ -122,7 +122,7 @@ await Page.EvaluateFunctionAsync(@"PREFIX =>
             Assert.True(ScreenshotHelper.PixelMatch("mock-binary-response.png", await img.ScreenshotDataAsync()));
         }
 
-        [PuppeteerTest("network.spec.ts", "Request.respond", "should stringify intercepted request response headers")]
+        [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should stringify intercepted request response headers")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldStringifyInterceptedRequestResponseHeaders()
         {
diff --git a/lib/PuppeteerSharp.Tests/TouchScreenTests/TouchScreenTests.cs b/lib/PuppeteerSharp.Tests/TouchScreenTests/TouchScreenTests.cs
@@ -16,7 +16,7 @@ public TouchScreenTests(ITestOutputHelper output) : base(output)
         {
         }
 
-        [PuppeteerTest("touchescreen.spec.ts", "Touchscreen", "tap the button")]
+        [PuppeteerTest("touchscreen.spec.ts", "Touchscreen", "tap the button")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldTapTheButton()
         {
@@ -26,7 +26,7 @@ public async Task ShouldTapTheButton()
             Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));
         }
 
-        [PuppeteerTest("touchescreen.spec.ts", "Touchscreen", "should report touches")]
+        [PuppeteerTest("touchscreen.spec.ts", "Touchscreen", "should report touches")]
         [SkipBrowserFact(skipFirefox: true)]
         public async Task ShouldReportTouches()
         {
diff --git a/lib/PuppeteerSharp.Tooling/IdentifyMissingTests.cs b/lib/PuppeteerSharp.Tooling/IdentifyMissingTests.cs
diff --git a/lib/PuppeteerSharp.Tooling/PuppeteerSharp.Tooling.csproj b/lib/PuppeteerSharp.Tooling/PuppeteerSharp.Tooling.csproj

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public PageGoBackTests(ITestOutputHelper output) : base(output)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`//TODO: This is working in puppeteer. I don't know why is hanging here.`
`17`		`- [PuppeteerTest("page.spec.ts", "Page.goBack", "should work")]`
	`17`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goBack", "should work")]`
`18`	`18`	`[SkipBrowserFact(skipFirefox: true)]`
`19`	`19`	`public async Task ShouldWork()`
`20`	`20`	`{`
`@@ -33,7 +33,7 @@ public async Task ShouldWork()`
`33`	`33`	`Assert.Null(response);`
`34`	`34`	`}`
`35`	`35`
`36`		`- [PuppeteerTest("page.spec.ts", "Page.goBack", "should work with HistoryAPI")]`
	`36`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goBack", "should work with HistoryAPI")]`
`37`	`37`	`[SkipBrowserFact(skipFirefox: true)]`
`38`	`38`	`public async Task ShouldWorkWithHistoryAPI()`
`39`	`39`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,15 @@ public PageGotoTests(ITestOutputHelper output) : base(output)`
`19`	`19`	`{`
`20`	`20`	`}`
`21`	`21`
`22`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work")]`
	`22`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work")]`
`23`	`23`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`24`	`24`	`public async Task ShouldWork()`
`25`	`25`	`{`
`26`	`26`	`await Page.GoToAsync(TestConstants.EmptyPage);`
`27`	`27`	`Assert.Equal(TestConstants.EmptyPage, Page.Url);`
`28`	`28`	`}`
`29`	`29`
`30`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work with anchor navigation")]`
	`30`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with anchor navigation")]`
`31`	`31`	`[SkipBrowserFact(skipFirefox: true)]`
`32`	`32`	`public async Task ShouldWorkWithAnchorNavigation()`
`33`	`33`	`{`
`@@ -39,7 +39,7 @@ public async Task ShouldWorkWithAnchorNavigation()`
`39`	`39`	`Assert.Equal($"{TestConstants.EmptyPage}#bar", Page.Url);`
`40`	`40`	`}`
`41`	`41`
`42`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work with redirects")]`
	`42`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with redirects")]`
`43`	`43`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`44`	`44`	`public async Task ShouldWorkWithRedirects()`
`45`	`45`	`{`
`@@ -50,23 +50,23 @@ public async Task ShouldWorkWithRedirects()`
`50`	`50`	`await Page.GoToAsync(TestConstants.EmptyPage);`
`51`	`51`	`}`
`52`	`52`
`53`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to about:blank")]`
	`53`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to about:blank")]`
`54`	`54`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`55`	`55`	`public async Task ShouldNavigateToAboutBlank()`
`56`	`56`	`{`
`57`	`57`	`var response = await Page.GoToAsync(TestConstants.AboutBlank);`
`58`	`58`	`Assert.Null(response);`
`59`	`59`	`}`
`60`	`60`
`61`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should return response when page changes its URL after load")]`
	`61`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should return response when page changes its URL after load")]`
`62`	`62`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`63`	`63`	`public async Task ShouldReturnResponseWhenPageChangesItsURLAfterLoad()`
`64`	`64`	`{`
`65`	`65`	`var response = await Page.GoToAsync(TestConstants.ServerUrl + "/historyapi.html");`
`66`	`66`	`Assert.Equal(HttpStatusCode.OK, response.Status);`
`67`	`67`	`}`
`68`	`68`
`69`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work with subframes return 204")]`
	`69`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with subframes return 204")]`
`70`	`70`	`[SkipBrowserFact(skipFirefox: true)]`
`71`	`71`	`public async Task ShouldWorkWithSubframesReturn204()`
`72`	`72`	`{`
`@@ -78,7 +78,7 @@ public async Task ShouldWorkWithSubframesReturn204()`
`78`	`78`	`await Page.GoToAsync(TestConstants.ServerUrl + "/frames/one-frame.html");`
`79`	`79`	`}`
`80`	`80`
`81`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when server returns 204")]`
	`81`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when server returns 204")]`
`82`	`82`	`[SkipBrowserFact(skipFirefox: true)]`
`83`	`83`	`public async Task ShouldFailWhenServerReturns204()`
`84`	`84`	`{`
`@@ -100,7 +100,7 @@ public async Task ShouldFailWhenServerReturns204()`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`103`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to empty page with domcontentloaded")]`
	`103`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to empty page with domcontentloaded")]`
`104`	`104`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`105`	`105`	`public async Task ShouldNavigateToEmptyPageWithDOMContentLoaded()`
`106`	`106`	`{`
`@@ -112,7 +112,7 @@ public async Task ShouldNavigateToEmptyPageWithDOMContentLoaded()`
`112`	`112`	`Assert.Null(response.SecurityDetails);`
`113`	`113`	`}`
`114`	`114`
`115`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work when page calls history API in beforeunload")]`
	`115`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when page calls history API in beforeunload")]`
`116`	`116`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`117`	`117`	`public async Task ShouldWorkWhenPageCallsHistoryAPIInBeforeunload()`
`118`	`118`	`{`
`@@ -125,23 +125,23 @@ await Page.EvaluateFunctionAsync(@"() =>`
`125`	`125`	`Assert.Equal(HttpStatusCode.OK, response.Status);`
`126`	`126`	`}`
`127`	`127`
`128`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to empty page with networkidle0")]`
	`128`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to empty page with networkidle0")]`
`129`	`129`	`[SkipBrowserFact(skipFirefox: true)]`
`130`	`130`	`public async Task ShouldNavigateToEmptyPageWithNetworkidle0()`
`131`	`131`	`{`
`132`	`132`	`var response = await Page.GoToAsync(TestConstants.EmptyPage, new NavigationOptions { WaitUntil = new[] { WaitUntilNavigation.Networkidle0 } });`
`133`	`133`	`Assert.Equal(HttpStatusCode.OK, response.Status);`
`134`	`134`	`}`
`135`	`135`
`136`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to empty page with networkidle2")]`
	`136`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to empty page with networkidle2")]`
`137`	`137`	`[SkipBrowserFact(skipFirefox: true)]`
`138`	`138`	`public async Task ShouldNavigateToEmptyPageWithNetworkidle2()`
`139`	`139`	`{`
`140`	`140`	`var response = await Page.GoToAsync(TestConstants.EmptyPage, new NavigationOptions { WaitUntil = new[] { WaitUntilNavigation.Networkidle2 } });`
`141`	`141`	`Assert.Equal(HttpStatusCode.OK, response.Status);`
`142`	`142`	`}`
`143`	`143`
`144`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating to bad url")]`
	`144`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating to bad url")]`
`145`	`145`	`[SkipBrowserFact(skipFirefox: true)]`
`146`	`146`	`public async Task ShouldFailWhenNavigatingToBadUrl()`
`147`	`147`	`{`
`@@ -157,7 +157,7 @@ public async Task ShouldFailWhenNavigatingToBadUrl()`
`157`	`157`	`}`
`158`	`158`	`}`
`159`	`159`
`160`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating to bad SSL")]`
	`160`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating to bad SSL")]`
`161`	`161`	`[SkipBrowserFact(skipFirefox: true)]`
`162`	`162`	`public async Task ShouldFailWhenNavigatingToBadSSL()`
`163`	`163`	`{`
`@@ -177,7 +177,7 @@ public async Task ShouldFailWhenNavigatingToBadSSL()`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating to bad SSL after redirects")]`
	`180`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating to bad SSL after redirects")]`
`181`	`181`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`182`	`182`	`public async Task ShouldFailWhenNavigatingToBadSSLAfterRedirects()`
`183`	`183`	`{`
`@@ -193,7 +193,7 @@ public async Task ShouldFailWhenNavigatingToBadSSLAfterRedirects()`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`
`196`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when main resources failed to load")]`
	`196`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when main resources failed to load")]`
`197`	`197`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`198`	`198`	`public async Task ShouldFailWhenMainResourcesFailedToLoad()`
`199`	`199`	`{`
`@@ -209,7 +209,7 @@ public async Task ShouldFailWhenMainResourcesFailedToLoad()`
`209`	`209`	`}`
`210`	`210`	`}`
`211`	`211`
`212`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when exceeding maximum navigation timeout")]`
	`212`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when exceeding maximum navigation timeout")]`
`213`	`213`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`214`	`214`	`public async Task ShouldFailWhenExceedingMaximumNavigationTimeout()`
`215`	`215`	`{`
`@@ -220,7 +220,7 @@ public async Task ShouldFailWhenExceedingMaximumNavigationTimeout()`
`220`	`220`	`Assert.Contains("Timeout of 1 ms exceeded", exception.Message);`
`221`	`221`	`}`
`222`	`222`
`223`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when exceeding default maximum navigation timeout")]`
	`223`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when exceeding default maximum navigation timeout")]`
`224`	`224`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`225`	`225`	`public async Task ShouldFailWhenExceedingDefaultMaximumNavigationTimeout()`
`226`	`226`	`{`
`@@ -231,7 +231,7 @@ public async Task ShouldFailWhenExceedingDefaultMaximumNavigationTimeout()`
`231`	`231`	`Assert.Contains("Timeout of 1 ms exceeded", exception.Message);`
`232`	`232`	`}`
`233`	`233`
`234`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when exceeding default maximum timeout")]`
	`234`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when exceeding default maximum timeout")]`
`235`	`235`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`236`	`236`	`public async Task ShouldFailWhenExceedingDefaultMaximumTimeout()`
`237`	`237`	`{`
`@@ -242,7 +242,7 @@ public async Task ShouldFailWhenExceedingDefaultMaximumTimeout()`
`242`	`242`	`Assert.Contains("Timeout of 1 ms exceeded", exception.Message);`
`243`	`243`	`}`
`244`	`244`
`245`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should prioritize default navigation timeout over default timeout")]`
	`245`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should prioritize default navigation timeout over default timeout")]`
`246`	`246`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`247`	`247`	`public async Task ShouldPrioritizeDefaultNavigationTimeoutOverDefaultTimeout()`
`248`	`248`	`{`
`@@ -254,7 +254,7 @@ public async Task ShouldPrioritizeDefaultNavigationTimeoutOverDefaultTimeout()`
`254`	`254`	`Assert.Contains("Timeout of 1 ms exceeded", exception.Message);`
`255`	`255`	`}`
`256`	`256`
`257`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should disable timeout when its set to 0")]`
	`257`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should disable timeout when its set to 0")]`
`258`	`258`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`259`	`259`	`public async Task ShouldDisableTimeoutWhenItsSetTo0()`
`260`	`260`	`{`
`@@ -270,31 +270,31 @@ void OnLoad(object sender, EventArgs e)`
`270`	`270`	`Assert.True(loaded);`
`271`	`271`	`}`
`272`	`272`
`273`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work when navigating to valid url")]`
	`273`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when navigating to valid url")]`
`274`	`274`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`275`	`275`	`public async Task ShouldWorkWhenNavigatingToValidUrl()`
`276`	`276`	`{`
`277`	`277`	`var response = await Page.GoToAsync(TestConstants.EmptyPage);`
`278`	`278`	`Assert.Equal(HttpStatusCode.OK, response.Status);`
`279`	`279`	`}`
`280`	`280`
`281`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work when navigating to data url")]`
	`281`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when navigating to data url")]`
`282`	`282`	`[SkipBrowserFact(skipFirefox: true)]`
`283`	`283`	`public async Task ShouldWorkWhenNavigatingToDataUrl()`
`284`	`284`	`{`
`285`	`285`	`var response = await Page.GoToAsync("data:text/html,hello");`
`286`	`286`	`Assert.Equal(HttpStatusCode.OK, response.Status);`
`287`	`287`	`}`
`288`	`288`
`289`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work when navigating to 404")]`
	`289`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work when navigating to 404")]`
`290`	`290`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`291`	`291`	`public async Task ShouldWorkWhenNavigatingTo404()`
`292`	`292`	`{`
`293`	`293`	`var response = await Page.GoToAsync(TestConstants.ServerUrl + "/not-found");`
`294`	`294`	`Assert.Equal(HttpStatusCode.NotFound, response.Status);`
`295`	`295`	`}`
`296`	`296`
`297`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should return last response in redirect chain")]`
	`297`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should return last response in redirect chain")]`
`298`	`298`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`299`	`299`	`public async Task ShouldReturnLastResponseInRedirectChain()`
`300`	`300`	`{`
`@@ -307,7 +307,7 @@ public async Task ShouldReturnLastResponseInRedirectChain()`
`307`	`307`	`Assert.Equal(TestConstants.EmptyPage, response.Url);`
`308`	`308`	`}`
`309`	`309`
`310`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should wait for network idle to succeed navigation")]`
	`310`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should wait for network idle to succeed navigation")]`
`311`	`311`	`[SkipBrowserFact(skipFirefox: true)]`
`312`	`312`	`public async Task ShouldWaitForNetworkIdleToSucceedNavigation()`
`313`	`313`	`{`
`@@ -397,7 +397,7 @@ await Task.WhenAll(`
`397`	`397`	`Assert.Equal(HttpStatusCode.OK, navigationResponse.Status);`
`398`	`398`	`}`
`399`	`399`
`400`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to dataURL and fire dataURL requests")]`
	`400`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to dataURL and fire dataURL requests")]`
`401`	`401`	`[SkipBrowserFact(skipFirefox: true)]`
`402`	`402`	`public async Task ShouldNavigateToDataURLAndFireDataURLRequests()`
`403`	`403`	`{`
`@@ -416,7 +416,7 @@ public async Task ShouldNavigateToDataURLAndFireDataURLRequests()`
`416`	`416`	`Assert.Equal(dataUrl, requests[0].Url);`
`417`	`417`	`}`
`418`	`418`
`419`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should navigate to URL with hash and fire requests without hash")]`
	`419`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should navigate to URL with hash and fire requests without hash")]`
`420`	`420`	`[SkipBrowserFact(skipFirefox: true)]`
`421`	`421`	`public async Task ShouldNavigateToURLWithHashAndFireRequestsWithoutHash()`
`422`	`422`	`{`
`@@ -435,7 +435,7 @@ public async Task ShouldNavigateToURLWithHashAndFireRequestsWithoutHash()`
`435`	`435`	`Assert.Equal(TestConstants.EmptyPage, requests[0].Url);`
`436`	`436`	`}`
`437`	`437`
`438`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should work with self requesting page")]`
	`438`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should work with self requesting page")]`
`439`	`439`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`440`	`440`	`public async Task ShouldWorkWithSelfRequestingPage()`
`441`	`441`	`{`
`@@ -444,7 +444,7 @@ public async Task ShouldWorkWithSelfRequestingPage()`
`444`	`444`	`Assert.Contains("self-request.html", response.Url);`
`445`	`445`	`}`
`446`	`446`
`447`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should fail when navigating and show the url at the error message")]`
	`447`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should fail when navigating and show the url at the error message")]`
`448`	`448`	`[Fact(Timeout = TestConstants.DefaultTestTimeout)]`
`449`	`449`	`public async Task ShouldFailWhenNavigatingAndShowTheUrlAtTheErrorMessage()`
`450`	`450`	`{`
`@@ -454,7 +454,7 @@ public async Task ShouldFailWhenNavigatingAndShowTheUrlAtTheErrorMessage()`
`454`	`454`	`Assert.Contains(url, exception.Url);`
`455`	`455`	`}`
`456`	`456`
`457`		`- [PuppeteerTest("page.spec.ts", "Page.goto", "should send referer")]`
	`457`	`+ [PuppeteerTest("navigation.spec.ts", "Page.goto", "should send referer")]`
`458`	`458`	`[SkipBrowserFact(skipFirefox: true)]`
`459`	`459`	`public async Task ShouldSendReferer()`
`460`	`460`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`using Xunit;`
`8`	`8`	`using Xunit.Abstractions;`
`9`	`9`
`10`		`-namespace PuppeteerSharp.Tests.NetworkTests`
	`10`	`+namespace PuppeteerSharp.Tests.RequestInterceptionTests`
`11`	`11`	`{`
`12`	`12`	`[Collection(TestConstants.TestFixtureCollectionName)]`
`13`	`13`	`public class RequestRespondTests : PuppeteerPageBaseTest`
`@@ -16,7 +16,7 @@ public RequestRespondTests(ITestOutputHelper output) : base(output)`
`16`	`16`	`{`
`17`	`17`	`}`
`18`	`18`
`19`		`- [PuppeteerTest("network.spec.ts", "Request.respond", "should work")]`
	`19`	`+ [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should work")]`
`20`	`20`	`[SkipBrowserFact(skipFirefox: true)]`
`21`	`21`	`public async Task ShouldWork()`
`22`	`22`	`{`
`@@ -45,14 +45,14 @@ await e.Request.RespondAsync(new ResponseData`
`45`	`45`	`/// I found that status 422 is not available in all .NET runtimes (see https://github.com/dotnet/core/blob/4c4642d548074b3fbfd425541a968aadd75fea99/release-notes/2.1/Preview/api-diff/preview2/2.1-preview2_System.Net.md)`
`46`	`46`	`/// As the goal here is testing HTTP codes that are not in Chromium (see https://cs.chromium.org/chromium/src/net/http/http_status_code_list.h?sq=package:chromium&g=0) we will use code 426: Upgrade Required`
`47`	`47`	`/// </summary>`
`48`		`- [PuppeteerTest("network.spec.ts", "Request.respond", "should work with status code 422")]`
	`48`	`+ [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should work with status code 422")]`
`49`	`49`	`[SkipBrowserFact(skipFirefox: true)]`
`50`	`50`	`public async Task ShouldWorkReturnStatusPhrases()`
`51`	`51`	`{`
`52`	`52`	`await Page.SetRequestInterceptionAsync(true);`
`53`	`53`	`Page.Request += async (_, e) =>`
`54`	`54`	`{`
`55`		`- await e.Request.RespondAsync(new ResponseData`
	`55`	`+ await e. Request.RespondAsync(new ResponseData`
`56`	`56`	`{`
`57`	`57`	`Status = HttpStatusCode.UpgradeRequired,`
`58`	`58`	`Body = "Yo, page!"`
`@@ -65,7 +65,7 @@ await e.Request.RespondAsync(new ResponseData`
`65`	`65`	`Assert.Equal("Yo, page!", await Page.EvaluateExpressionAsync<string>("document.body.textContent"));`
`66`	`66`	`}`
`67`	`67`
`68`		`- [PuppeteerTest("network.spec.ts", "Request.respond", "should redirect")]`
	`68`	`+ [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should redirect")]`
`69`	`69`	`[SkipBrowserFact(skipFirefox: true)]`
`70`	`70`	`public async Task ShouldRedirect()`
`71`	`71`	`{`
`@@ -96,7 +96,7 @@ await e.Request.RespondAsync(new ResponseData`
`96`	`96`	`Assert.Equal(TestConstants.EmptyPage, response.Url);`
`97`	`97`	`}`
`98`	`98`
`99`		`- [PuppeteerTest("network.spec.ts", "Request.respond", "should allow mocking binary responses")]`
	`99`	`+ [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should allow mocking binary responses")]`
`100`	`100`	`[SkipBrowserFact(skipFirefox: true)]`
`101`	`101`	`public async Task ShouldAllowMockingBinaryResponses()`
`102`	`102`	`{`
`@@ -122,7 +122,7 @@ await Page.EvaluateFunctionAsync(@"PREFIX =>`
`122`	`122`	`Assert.True(ScreenshotHelper.PixelMatch("mock-binary-response.png", await img.ScreenshotDataAsync()));`
`123`	`123`	`}`
`124`	`124`
`125`		`- [PuppeteerTest("network.spec.ts", "Request.respond", "should stringify intercepted request response headers")]`
	`125`	`+ [PuppeteerTest("requestinterception.spec.ts", "Request.respond", "should stringify intercepted request response headers")]`
`126`	`126`	`[SkipBrowserFact(skipFirefox: true)]`
`127`	`127`	`public async Task ShouldStringifyInterceptedRequestResponseHeaders()`
`128`	`128`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public TouchScreenTests(ITestOutputHelper output) : base(output)`
`16`	`16`	`{`
`17`	`17`	`}`
`18`	`18`
`19`		`- [PuppeteerTest("touchescreen.spec.ts", "Touchscreen", "tap the button")]`
	`19`	`+ [PuppeteerTest("touchscreen.spec.ts", "Touchscreen", "tap the button")]`
`20`	`20`	`[SkipBrowserFact(skipFirefox: true)]`
`21`	`21`	`public async Task ShouldTapTheButton()`
`22`	`22`	`{`
`@@ -26,7 +26,7 @@ public async Task ShouldTapTheButton()`
`26`	`26`	`Assert.Equal("Clicked", await Page.EvaluateExpressionAsync<string>("result"));`
`27`	`27`	`}`
`28`	`28`
`29`		`- [PuppeteerTest("touchescreen.spec.ts", "Touchscreen", "should report touches")]`
	`29`	`+ [PuppeteerTest("touchscreen.spec.ts", "Touchscreen", "should report touches")]`
`30`	`30`	`[SkipBrowserFact(skipFirefox: true)]`
`31`	`31`	`public async Task ShouldReportTouches()`
`32`	`32`	`{`