How to use EvaluateFunctionAsync method of PuppeteerSharp.ExecutionContext class

Best Puppeteer-sharp code snippet using PuppeteerSharp.ExecutionContext.EvaluateFunctionAsync

ElementHandle.cs

Source:ElementHandle.cs Github

copy

Full Screen

...121 });122 await Page.SetViewportAsync(newRawViewport.ToObject<ViewPortOptions>()).ConfigureAwait(false);123 needsViewportReset = true;124 }125 await ExecutionContext.EvaluateFunctionAsync(@"function(element) {126 element.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant'});127 }", this).ConfigureAwait(false);128 await ScrollIntoViewIfNeededAsync().ConfigureAwait(false);129 boundingBox = await BoundingBoxAsync().ConfigureAwait(false);130 if (boundingBox == null)131 {132 throw new PuppeteerException("Node is either not visible or not an HTMLElement");133 }134 var getLayoutMetricsResponse = await Client.SendAsync<GetLayoutMetricsResponse>("Page.getLayoutMetrics").ConfigureAwait(false);135 var clip = boundingBox;136 clip.X += getLayoutMetricsResponse.LayoutViewport.PageX;137 clip.Y += getLayoutMetricsResponse.LayoutViewport.PageY;138 options.Clip = boundingBox.ToClip();139 var imageData = await Page.ScreenshotBase64Async(options).ConfigureAwait(false);140 if (needsViewportReset)141 {142 await Page.SetViewportAsync(viewport).ConfigureAwait(false);143 }144 return imageData;145 }146 /// <summary>147 /// Scrolls element into view if needed, and then uses <see cref="Page.Mouse"/> to hover over the center of the element.148 /// </summary>149 /// <returns>Task which resolves when the element is successfully hovered</returns>150 public async Task HoverAsync()151 {152 await ScrollIntoViewIfNeededAsync().ConfigureAwait(false);153 var (x, y) = await ClickablePointAsync().ConfigureAwait(false);154 await Page.Mouse.MoveAsync(x, y).ConfigureAwait(false);155 }156 /// <summary>157 /// Scrolls element into view if needed, and then uses <see cref="Page.Mouse"/> to click in the center of the element.158 /// </summary>159 /// <param name="options">click options</param>160 /// <exception cref="PuppeteerException">if the element is detached from DOM</exception>161 /// <returns>Task which resolves when the element is successfully clicked</returns>162 public async Task ClickAsync(ClickOptions options = null)163 {164 await ScrollIntoViewIfNeededAsync().ConfigureAwait(false);165 var (x, y) = await ClickablePointAsync().ConfigureAwait(false);166 await Page.Mouse.ClickAsync(x, y, options).ConfigureAwait(false);167 }168 /// <summary>169 /// Uploads files170 /// </summary>171 /// <param name="filePaths">Sets the value of the file input these paths. paths are resolved using <see cref="Path.GetFullPath(string)"/></param>172 /// <remarks>This method expects <c>elementHandle</c> to point to an <c>input element</c> <see href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input"/> </remarks>173 /// <returns>Task</returns>174 public Task UploadFileAsync(params string[] filePaths)175 {176 var files = filePaths.Select(Path.GetFullPath).ToArray();177 var objectId = RemoteObject[MessageKeys.ObjectId].AsString();178 return Client.SendAsync("DOM.setFileInputFiles", new { objectId, files });179 }180 /// <summary>181 /// Scrolls element into view if needed, and then uses <see cref="Touchscreen.TapAsync(decimal, decimal)"/> to tap in the center of the element.182 /// </summary>183 /// <exception cref="PuppeteerException">if the element is detached from DOM</exception>184 /// <returns>Task which resolves when the element is successfully tapped</returns>185 public async Task TapAsync()186 {187 await ScrollIntoViewIfNeededAsync().ConfigureAwait(false);188 var (x, y) = await ClickablePointAsync().ConfigureAwait(false);189 await Page.Touchscreen.TapAsync(x, y).ConfigureAwait(false);190 }191 /// <summary>192 /// Calls <c>focus</c> <see href="https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus"/> on the element.193 /// </summary>194 /// <returns>Task</returns>195 public Task FocusAsync() => ExecutionContext.EvaluateFunctionAsync("element => element.focus()", this);196 /// <summary>197 /// Focuses the element, and sends a <c>keydown</c>, <c>keypress</c>/<c>input</c>, and <c>keyup</c> event for each character in the text.198 /// </summary>199 /// <param name="text">A text to type into a focused element</param>200 /// <param name="options">type options</param>201 /// <remarks>202 /// To press a special key, like <c>Control</c> or <c>ArrowDown</c> use <see cref="ElementHandle.PressAsync(string, PressOptions)"/>203 /// </remarks>204 /// <example>205 /// <code>206 /// elementHandle.TypeAsync("#mytextarea", "Hello"); // Types instantly207 /// elementHandle.TypeAsync("#mytextarea", "World", new TypeOptions { Delay = 100 }); // Types slower, like a user208 /// </code>209 /// An example of typing into a text field and then submitting the form:210 /// <code>211 /// var elementHandle = await page.GetElementAsync("input");212 /// await elementHandle.TypeAsync("some text");213 /// await elementHandle.PressAsync("Enter");214 /// </code>215 /// </example>216 /// <returns>Task</returns>217 public async Task TypeAsync(string text, TypeOptions options = null)218 {219 await FocusAsync().ConfigureAwait(false);220 await Page.Keyboard.TypeAsync(text, options).ConfigureAwait(false);221 }222 /// <summary>223 /// Focuses the element, and then uses <see cref="Keyboard.DownAsync(string, DownOptions)"/> and <see cref="Keyboard.UpAsync(string)"/>.224 /// </summary>225 /// <param name="key">Name of key to press, such as <c>ArrowLeft</c>. See <see cref="KeyDefinitions"/> for a list of all key names.</param>226 /// <param name="options">press options</param>227 /// <remarks>228 /// If <c>key</c> is a single character and no modifier keys besides <c>Shift</c> are being held down, a <c>keypress</c>/<c>input</c> event will also be generated. The <see cref="DownOptions.Text"/> option can be specified to force an input event to be generated.229 /// </remarks>230 /// <returns></returns>231 public async Task PressAsync(string key, PressOptions options = null)232 {233 await FocusAsync().ConfigureAwait(false);234 await Page.Keyboard.PressAsync(key, options).ConfigureAwait(false);235 }236 /// <summary>237 /// The method runs <c>element.querySelector</c> within the page. If no element matches the selector, the return value resolve to <c>null</c>.238 /// </summary>239 /// <param name="selector">A selector to query element for</param>240 /// <returns>Task which resolves to <see cref="ElementHandle"/> pointing to the frame element</returns>241 public async Task<ElementHandle> QuerySelectorAsync(string selector)242 {243 var handle = await ExecutionContext.EvaluateFunctionHandleAsync(244 "(element, selector) => element.querySelector(selector)",245 this, selector).ConfigureAwait(false);246 if (handle is ElementHandle element)247 {248 return element;249 }250 await handle.DisposeAsync().ConfigureAwait(false);251 return null;252 }253 /// <summary>254 /// Runs <c>element.querySelectorAll</c> within the page. If no elements match the selector, the return value resolve to <see cref="Array.Empty{T}"/>.255 /// </summary>256 /// <param name="selector">A selector to query element for</param>257 /// <returns>Task which resolves to ElementHandles pointing to the frame elements</returns>258 public async Task<ElementHandle[]> QuerySelectorAllAsync(string selector)259 {260 var arrayHandle = await ExecutionContext.EvaluateFunctionHandleAsync(261 "(element, selector) => element.querySelectorAll(selector)",262 this, selector).ConfigureAwait(false);263 var properties = await arrayHandle.GetPropertiesAsync().ConfigureAwait(false);264 await arrayHandle.DisposeAsync().ConfigureAwait(false);265 return properties.Values.OfType<ElementHandle>().ToArray();266 }267 /// <summary>268 /// A utility function to be used with <see cref="Extensions.EvaluateFunctionAsync{T}(Task{JSHandle}, string, object[])"/>269 /// </summary>270 /// <param name="selector">A selector to query element for</param>271 /// <returns>Task which resolves to a <see cref="JSHandle"/> of <c>document.querySelectorAll</c> result</returns>272 public Task<JSHandle> QuerySelectorAllHandleAsync(string selector)273 => ExecutionContext.EvaluateFunctionHandleAsync(274 "(element, selector) => Array.from(element.querySelectorAll(selector))", this, selector);275 /// <summary>276 /// Evaluates the XPath expression relative to the elementHandle. If there's no such element, the method will resolve to <c>null</c>.277 /// </summary>278 /// <param name="expression">Expression to evaluate <see href="https://developer.mozilla.org/en-US/docs/Web/API/Document/evaluate"/></param>279 /// <returns>Task which resolves to an array of <see cref="ElementHandle"/></returns>280 public async Task<ElementHandle[]> XPathAsync(string expression)281 {282 var arrayHandle = await ExecutionContext.EvaluateFunctionHandleAsync(283 @"(element, expression) => {284 const document = element.ownerDocument || element;285 const iterator = document.evaluate(expression, element, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE);286 const array = [];287 let item;288 while ((item = iterator.iterateNext()))289 array.push(item);290 return array;291 }",292 this, expression293 ).ConfigureAwait(false);294 var properties = await arrayHandle.GetPropertiesAsync().ConfigureAwait(false);295 await arrayHandle.DisposeAsync().ConfigureAwait(false);296 return properties.Values.OfType<ElementHandle>().ToArray();297 }298 /// <summary>299 /// This method returns the bounding box of the element (relative to the main frame), 300 /// or null if the element is not visible.301 /// </summary>302 /// <returns>The BoundingBox task.</returns>303 public async Task<BoundingBox> BoundingBoxAsync()304 {305 var result = await GetBoxModelAsync().ConfigureAwait(false);306 if (result == null)307 {308 return null;309 }310 var quad = result.Model.Border;311 var x = new[] { quad[0], quad[2], quad[4], quad[6] }.Min();312 var y = new[] { quad[1], quad[3], quad[5], quad[7] }.Min();313 var width = new[] { quad[0], quad[2], quad[4], quad[6] }.Max() - x;314 var height = new[] { quad[1], quad[3], quad[5], quad[7] }.Max() - y;315 return new BoundingBox(x, y, width, height);316 }317 /// <summary>318 /// returns boxes of the element, or <c>null</c> if the element is not visible. Box points are sorted clock-wise.319 /// </summary>320 /// <returns>Task BoxModel task.</returns>321 public async Task<BoxModel> BoxModelAsync()322 {323 var result = await GetBoxModelAsync().ConfigureAwait(false);324 return result == null325 ? null326 : new BoxModel327 {328 Content = FromProtocolQuad(result.Model.Content),329 Padding = FromProtocolQuad(result.Model.Padding),330 Border = FromProtocolQuad(result.Model.Border),331 Margin = FromProtocolQuad(result.Model.Margin),332 Width = result.Model.Width,333 Height = result.Model.Height334 };335 }336 /// <summary>337 ///Content frame for element handles referencing iframe nodes, or null otherwise.338 /// </summary>339 /// <returns>Resolves to the content frame</returns>340 public async Task<Frame> ContentFrameAsync()341 {342 var nodeInfo = await Client.SendAsync<DomDescribeNodeResponse>("DOM.describeNode", new Dictionary<string, object>343 {344 { MessageKeys.ObjectId, RemoteObject[MessageKeys.ObjectId] }345 }).ConfigureAwait(false);346 return string.IsNullOrEmpty(nodeInfo.Node.FrameId) ? null : _frameManager.Frames[nodeInfo.Node.FrameId];347 }348 /// <summary>349 /// Evaluates if the element is visible in the current viewport.350 /// </summary>351 /// <returns>A task which resolves to true if the element is visible in the current viewport.</returns>352 public Task<bool> IsIntersectingViewportAsync()353 => ExecutionContext.EvaluateFunctionAsync<bool>(@"async element =>354 {355 const visibleRatio = await new Promise(resolve =>356 {357 const observer = new IntersectionObserver(entries =>358 {359 resolve(entries[0].intersectionRatio);360 observer.disconnect();361 });362 observer.observe(element);363 });364 return visibleRatio > 0;365 }", this);366 private async Task<(decimal x, decimal y)> ClickablePointAsync()367 {368 GetContentQuadsResponse result = null;369 try370 {371 result = await Client.SendAsync<GetContentQuadsResponse>("DOM.getContentQuads", new Dictionary<string, object>372 {373 { MessageKeys.ObjectId, RemoteObject[MessageKeys.ObjectId] }374 }).ConfigureAwait(false);375 }376 catch (Exception ex)377 {378 _logger.LogError(ex.Message);379 }380 if (result == null || result.Quads.Length == 0)381 {382 throw new PuppeteerException("Node is either not visible or not an HTMLElement");383 }384 // Filter out quads that have too small area to click into.385 var quads = result.Quads.Select(FromProtocolQuad).Where(q => ComputeQuadArea(q) > 1);386 if (!quads.Any())387 {388 throw new PuppeteerException("Node is either not visible or not an HTMLElement");389 }390 // Return the middle point of the first quad.391 var quad = quads.First();392 var x = 0m;393 var y = 0m;394 foreach (var point in quad)395 {396 x += point.X;397 y += point.Y;398 }399 return (400 x: x / 4,401 y: y / 4402 );403 }404 private async Task ScrollIntoViewIfNeededAsync()405 {406 var errorMessage = await ExecutionContext.EvaluateFunctionAsync<string>(@"async(element, pageJavascriptEnabled) => {407 if (!element.isConnected)408 return 'Node is detached from document';409 if (element.nodeType !== Node.ELEMENT_NODE)410 return 'Node is not of type HTMLElement';411 // force-scroll if page's javascript is disabled.412 if (!pageJavascriptEnabled) {413 element.scrollIntoView({block: 'center', inline: 'center', behavior: 'instant'});414 return false;415 }416 const visibleRatio = await new Promise(resolve => {417 const observer = new IntersectionObserver(entries => {418 resolve(entries[0].intersectionRatio);419 observer.disconnect();420 });...

Full Screen

Full Screen

EvaluateTests.cs

Source:EvaluateTests.cs Github

copy

Full Screen

...18 [InlineData("() => 7 * 3", 21)] //ShouldWork19 [InlineData("() => Promise.resolve(8 * 7)", 56)] //ShouldAwaitPromise20 public async Task BasicIntFunctionEvaluationTest(string script, object expected)21 {22 var result = await Page.EvaluateFunctionAsync<int>(script);23 Assert.Equal(expected, result);24 }25 [Fact]26 public async Task ShouldTransferBigInt()27 {28 var result = await Page.EvaluateFunctionAsync<BigInteger>("a => a", new BigInteger(42));29 Assert.Equal(new BigInteger(42), result);30 }31 [Theory]32 [InlineData(double.NaN)] //ShouldTransferNaN33 [InlineData(-0)] //ShouldTransferNegative034 [InlineData(double.PositiveInfinity)] //ShouldTransferInfinity35 [InlineData(double.NegativeInfinity)] //ShouldTransferNegativeInfinty36 public async Task BasicTransferTest(object transferObject)37 {38 var result = await Page.EvaluateFunctionAsync<object>("a => a", transferObject);39 Assert.Equal(transferObject, result);40 }41 [Fact]42 public async Task ShouldTransferArrays()43 {44 var result = await Page.EvaluateFunctionAsync<int[]>("a => a", new int[] { 1, 2, 3 });45 Assert.Equal(new int[] { 1, 2, 3 }, result);46 }47 [Fact]48 public async Task ShouldTransferArraysAsArraysNotObjects()49 {50 var result = await Page.EvaluateFunctionAsync<bool>("a => Array.isArray(a)", new int[] { 1, 2, 3 });51 Assert.True(result);52 }53 [Fact]54 public async Task ShouldModifyGlobalEnvironment()55 {56 await Page.EvaluateFunctionAsync("() => window.globalVar = 123");57 Assert.Equal(123, await Page.EvaluateFunctionAsync<int>("() => window.globalVar"));58 }59 [Fact]60 public async Task ShouldEvaluateInThePageContext()61 {62 await Page.GoToAsync(TestConstants.ServerUrl + "/global-var.html");63 Assert.Equal(123, await Page.EvaluateFunctionAsync<int>("() => window.globalVar"));64 }65 [Fact]66 public async Task ShouldReturnUndefinedForObjectsWithSymbols()67 => Assert.Null(await Page.EvaluateFunctionAsync<object>("() => [Symbol('foo4')]"));68 [Fact]69 public async Task ShouldWorkWithUnicodeChars()70 => Assert.Equal(42, await Page.EvaluateFunctionAsync<int>("a => a['中文字符']", new Dictionary<string, int> { ["中文字符"] = 42 }));71 [Fact]72 public async Task ShouldThrowWhenEvaluationTriggersReload()73 {74 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(() =>75 {76 return Page.EvaluateFunctionAsync(@"() => {77 location.reload();78 return new Promise(() => {});79 }");80 });81 Assert.Contains("Protocol error", exception.Message);82 }83 [Fact]84 public async Task ShouldWorkRightAfterFrameNavigated()85 {86 Task<int> frameEvaluation = null;87 Page.FrameNavigated += (sender, e) =>88 {89 frameEvaluation = e.Frame.EvaluateFunctionAsync<int>("() => 6 * 7");90 };91 await Page.GoToAsync(TestConstants.EmptyPage);92 Assert.Equal(42, await frameEvaluation);93 }94 [Fact]95 public async Task ShouldWorkFromInsideAnExposedFunction()96 {97 await Page.ExposeFunctionAsync("callController", async (int a, int b) =>98 {99 return await Page.EvaluateFunctionAsync<int>("(a, b) => a * b", a, b);100 });101 var result = await Page.EvaluateFunctionAsync<int>(@"async function() {102 return await callController(9, 3);103 }");104 Assert.Equal(27, result);105 }106 [Fact]107 public async Task ShouldRejectPromiseWithExeption()108 {109 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(() =>110 {111 return Page.EvaluateFunctionAsync("() => not_existing_object.property");112 });113 Assert.Contains("not_existing_object", exception.Message);114 }115 [Fact]116 public async Task ShouldSupportThrownStringsAsErrorMessages()117 {118 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(119 () => Page.EvaluateExpressionAsync("throw 'qwerty'"));120 Assert.Contains("qwerty", exception.Message);121 }122 [Fact]123 public async Task ShouldSupportThrownNumbersAsErrorMessages()124 {125 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(126 () => Page.EvaluateExpressionAsync("throw 100500"));127 Assert.Contains("100500", exception.Message);128 }129 [Fact]130 public async Task SouldReturnComplexObjects()131 {132 dynamic obj = new133 {134 foo = "bar!"135 };136 var result = await Page.EvaluateFunctionAsync("a => a", obj);137 Assert.Equal("bar!", result.foo.ToString());138 }139 [Fact]140 public async Task ShouldReturnBigInt()141 {142 var result = await Page.EvaluateFunctionAsync<object>("() => BigInt(42)");143 Assert.Equal(new BigInteger(42), result);144 }145 [Theory]146 [InlineData("() => NaN", double.NaN)] //ShouldReturnNaN147 [InlineData("() => -0", -0)] //ShouldReturnNegative0148 [InlineData("() => Infinity", double.PositiveInfinity)] //ShouldReturnInfinity149 [InlineData("() => -Infinity", double.NegativeInfinity)] //ShouldReturnNegativeInfinty150 public async Task BasicEvaluationTest(string script, object expected)151 {152 var result = await Page.EvaluateFunctionAsync<object>(script);153 Assert.Equal(expected, result);154 }155 [Fact]156 public async Task ShouldAcceptNullAsOneOfMultipleParameters()157 {158 var result = await Page.EvaluateFunctionAsync<bool>(159 "(a, b) => Object.is(a, null) && Object.is(b, 'foo')",160 null,161 "foo");162 Assert.True(result);163 }164 [Fact]165 public async Task ShouldReturnNullForNonSerializableObjects()166 => Assert.Null(await Page.EvaluateFunctionAsync("() => window"));167 [Fact]168 public async Task ShouldFailForCircularObject()169 {170 var result = await Page.EvaluateFunctionAsync(@"() => {171 const a = {};172 const b = {a};173 a.b = b;174 return a;175 }");176 Assert.Null(result);177 }178 [Fact]179 public async Task ShouldBeAbleToThrowATrickyError()180 {181 var windowHandle = await Page.EvaluateFunctionHandleAsync("() => window");182 PuppeteerException exception = await Assert.ThrowsAsync<MessageException>(() => windowHandle.JsonValueAsync());183 var errorText = exception.Message;184 exception = await Assert.ThrowsAsync<EvaluationFailedException>(() => Page.EvaluateFunctionAsync(@"errorText =>185 {186 throw new Error(errorText);187 }", errorText));188 Assert.Contains(errorText, exception.Message);189 }190 [Theory]191 [InlineData("1 + 5;", 6)] //ShouldAcceptSemiColons192 [InlineData("2 + 5\n// do some math!'", 7)] //ShouldAceptStringComments193 public async Task BasicIntExressionEvaluationTest(string script, object expected)194 {195 var result = await Page.EvaluateExpressionAsync<int>(script);196 Assert.Equal(expected, result);197 }198 [Fact]199 public async Task ShouldAcceptElementHandleAsAnArgument()200 {201 await Page.SetContentAsync("<section>42</section>");202 var element = await Page.QuerySelectorAsync("section");203 var text = await Page.EvaluateFunctionAsync<string>("e => e.textContent", element);204 Assert.Equal("42", text);205 }206 [Fact]207 public async Task ShouldThrowIfUnderlyingElementWasDisposed()208 {209 await Page.SetContentAsync("<section>39</section>");210 var element = await Page.QuerySelectorAsync("section");211 Assert.NotNull(element);212 await element.DisposeAsync();213 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(()214 => Page.EvaluateFunctionAsync<string>("e => e.textContent", element));215 Assert.Contains("JSHandle is disposed", exception.Message);216 }217 [Fact]218 public async Task ShouldThrowIfElementHandlesAreFromOtherFrames()219 {220 await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);221 var bodyHandle = await Page.FirstChildFrame().QuerySelectorAsync("body");222 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(()223 => Page.EvaluateFunctionAsync<string>("body => body.innerHTML", bodyHandle));224 Assert.Contains("JSHandles can be evaluated only in the context they were created", exception.Message);225 }226 [Fact]227 public async Task ShouldSimulateAUserGesture()228 => Assert.True(await Page.EvaluateFunctionAsync<bool>(@"() => {229 document.body.appendChild(document.createTextNode('test'));230 document.execCommand('selectAll');231 return document.execCommand('copy'); 232 }"));233 [Fact]234 public async Task ShouldThrowANiceErrorAfterANavigation()235 {236 var executionContext = await Page.MainFrame.GetExecutionContextAsync();237 await Task.WhenAll(238 Page.WaitForNavigationAsync(),239 executionContext.EvaluateFunctionAsync("() => window.location.reload()")240 );241 var ex = await Assert.ThrowsAsync<EvaluationFailedException>(() =>242 {243 return executionContext.EvaluateFunctionAsync("() => null");244 });245 Assert.Contains("navigation", ex.Message);246 }247 [Fact]248 public async Task ShouldNotThrowAnErrorWhenEvaluationDoesANavigation()249 {250 await Page.GoToAsync(TestConstants.ServerUrl + "/one-style.html");251 var result = await Page.EvaluateFunctionAsync<int[]>(@"() =>252 {253 window.location = '/empty.html';254 return [42];255 }");256 Assert.Equal(new[] { 42 }, result);257 }258 /// <summary>259 /// Original Name "should transfer 100Mb of data from page to node.js"260 /// </summary>261 [Fact]262 public async Task ShouldTransfer100MbOfDataFromPage()263 {264 var a = await Page.EvaluateFunctionAsync<string>("() => Array(100 * 1024 * 1024 + 1).join('a')");265 Assert.Equal(100 * 1024 * 1024, a.Length);266 }267 [Fact]268 public async Task ShouldThrowErrorWithDetailedInformationOnExceptionInsidePromise()269 {270 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(() =>271 Page.EvaluateFunctionAsync(272 @"() => new Promise(() => {273 throw new Error('Error in promise');274 })"));275 Assert.Contains("Error in promise", exception.Message);276 }277 [Fact]278 public async Task ShouldWorkWithDifferentSerializerSettings()279 {280 var result = await Page.EvaluateFunctionAsync<ComplexObjectTestClass>("() => { return { foo: 'bar' }}");281 Assert.Equal("bar", result.Foo);282 result = (await Page.EvaluateFunctionAsync<JToken>("() => { return { Foo: 'bar' }}"))283 .ToObject<ComplexObjectTestClass>(new JsonSerializerSettings());284 Assert.Equal("bar", result.Foo);285 result = await Page.EvaluateExpressionAsync<ComplexObjectTestClass>("var obj = { foo: 'bar' }; obj;");286 Assert.Equal("bar", result.Foo);287 result = (await Page.EvaluateExpressionAsync<JToken>("var obj = { Foo: 'bar' }; obj;"))288 .ToObject<ComplexObjectTestClass>(new JsonSerializerSettings());289 Assert.Equal("bar", result.Foo);290 }291 [Fact]292 public async Task ShouldProperlyIgnoreUndefinedFields()293 {294 var result = await Page.EvaluateFunctionAsync<Dictionary<string, object>>("() => ({a: undefined})");295 Assert.Empty(result);296 }297 [Fact]298 public async Task ShouldProperlySerializeNullFields()299 {300 var result = await Page.EvaluateFunctionAsync<Dictionary<string, object>>("() => ({a: null})");301 Assert.True(result.ContainsKey("a"));302 Assert.Null(result["a"]);303 }304 [Fact]305 public async Task ShouldAcceptObjectHandleAsAnArgument()306 {307 var navigatorHandle = await Page.EvaluateExpressionHandleAsync("navigator");308 var text = await Page.EvaluateFunctionAsync<string>("e => e.userAgent", navigatorHandle);309 Assert.Contains("Mozilla", text);310 }311 [Fact]312 public async Task ShouldAcceptObjectHandleToPrimitiveTypes()313 {314 var aHandle = await Page.EvaluateExpressionHandleAsync("5");315 var isFive = await Page.EvaluateFunctionAsync<bool>("e => Object.is(e, 5)", aHandle);316 Assert.True(isFive);317 }318 [Fact]319 public async Task ShouldWarnOnNestedObjectHandles()320 {321 var handle = await Page.EvaluateFunctionHandleAsync("() => document.body");322 var elementHandle = handle as ElementHandle;323 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(()324 => Page.EvaluateFunctionHandleAsync(325 "opts => opts.elem.querySelector('p')",326 new { elem = handle }));327 Assert.Contains("Are you passing a nested JSHandle?", exception.Message);328 //Check with ElementHandle329 exception = await Assert.ThrowsAsync<EvaluationFailedException>(()...

Full Screen

Full Screen

DOMWorld.cs

Source:DOMWorld.cs Github

copy

Full Screen

...75 {76 var context = await GetExecutionContextAsync().ConfigureAwait(false);77 return await context.EvaluateExpressionAsync(script).ConfigureAwait(false);78 }79 internal async Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)80 {81 var context = await GetExecutionContextAsync().ConfigureAwait(false);82 return await context.EvaluateFunctionAsync<T>(script, args).ConfigureAwait(false);83 }84 internal async Task<JToken> EvaluateFunctionAsync(string script, params object[] args)85 {86 var context = await GetExecutionContextAsync().ConfigureAwait(false);87 return await context.EvaluateFunctionAsync(script, args).ConfigureAwait(false);88 }89 internal Task<string> GetContentAsync() => EvaluateFunctionAsync<string>(@"() => {90 let retVal = '';91 if (document.doctype)92 retVal = new XMLSerializer().serializeToString(document.doctype);93 if (document.documentElement)94 retVal += document.documentElement.outerHTML;95 return retVal;96 }");97 internal async Task SetContentAsync(string html, NavigationOptions options = null)98 {99 var waitUntil = options?.WaitUntil ?? new[] { WaitUntilNavigation.Load };100 var timeout = options?.Timeout ?? _timeoutSettings.NavigationTimeout;101 // We rely upon the fact that document.open() will reset frame lifecycle with "init"102 // lifecycle event. @see https://crrev.com/608658103 await EvaluateFunctionAsync(@"html => {104 document.open();105 document.write(html);106 document.close();107 }", html).ConfigureAwait(false);108 using (var watcher = new LifecycleWatcher(_frameManager, Frame, waitUntil, timeout))109 {110 var watcherTask = await Task.WhenAny(111 watcher.TimeoutOrTerminationTask,112 watcher.LifecycleTask).ConfigureAwait(false);113 await watcherTask.ConfigureAwait(false);114 }115 }116 internal async Task<ElementHandle> AddScriptTagAsync(AddTagOptions options)117 {...

Full Screen

Full Screen

ExecutionContext.cs

Source:ExecutionContext.cs Github

copy

Full Screen

...43 /// <param name="script">Script to be evaluated in browser context</param>44 /// <remarks>45 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.46 /// </remarks>47 /// <seealso cref="EvaluateFunctionAsync{T}(string, object[])"/>48 /// <seealso cref="EvaluateExpressionHandleAsync(string)"/>49 /// <returns>Task which resolves to script return value</returns>50 public Task<JToken> EvaluateExpressionAsync(string script) => EvaluateExpressionAsync<JToken>(script);51 /// <summary>52 /// Executes a script in browser context53 /// </summary>54 /// <typeparam name="T">The type to deserialize the result to</typeparam>55 /// <param name="script">Script to be evaluated in browser context</param>56 /// <remarks>57 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.58 /// </remarks>59 /// <seealso cref="EvaluateFunctionAsync{T}(string, object[])"/>60 /// <seealso cref="EvaluateExpressionHandleAsync(string)"/>61 /// <returns>Task which resolves to script return value</returns>62 public Task<T> EvaluateExpressionAsync<T>(string script)63 => RemoteObjectTaskToObject<T>(EvaluateExpressionInternalAsync(true, script));64 internal async Task<JSHandle> EvaluateExpressionHandleAsync(string script)65 => CreateJSHandle(await EvaluateExpressionInternalAsync(false, script).ConfigureAwait(false));66 /// <summary>67 /// Executes a function in browser context68 /// </summary>69 /// <param name="script">Script to be evaluated in browser context</param>70 /// <param name="args">Arguments to pass to script</param>71 /// <remarks>72 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.73 /// <see cref="JSHandle"/> instances can be passed as arguments74 /// </remarks>75 /// <seealso cref="EvaluateExpressionAsync{T}(string)"/>76 /// <returns>Task which resolves to script return value</returns>77 public Task<JToken> EvaluateFunctionAsync(string script, params object[] args) => EvaluateFunctionAsync<JToken>(script, args);78 /// <summary>79 /// Executes a function in browser context80 /// </summary>81 /// <typeparam name="T">The type to deserialize the result to</typeparam>82 /// <param name="script">Script to be evaluated in browser context</param>83 /// <param name="args">Arguments to pass to script</param>84 /// <remarks>85 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.86 /// <see cref="JSHandle"/> instances can be passed as arguments87 /// </remarks>88 /// <seealso cref="EvaluateExpressionAsync{T}(string)"/>89 /// <returns>Task which resolves to script return value</returns>90 public Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)91 => RemoteObjectTaskToObject<T>(EvaluateFunctionInternalAsync(true, script, args));92 internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params object[] args)93 => CreateJSHandle(await EvaluateFunctionInternalAsync(false, script, args).ConfigureAwait(false));94 /// <summary>95 /// The method iterates JavaScript heap and finds all the objects with the given prototype.96 /// </summary>97 /// <returns>A task which resolves to a handle to an array of objects with this prototype.</returns>98 /// <param name="prototypeHandle">A handle to the object prototype.</param>99 public async Task<JSHandle> QueryObjectsAsync(JSHandle prototypeHandle)100 {101 if (prototypeHandle.Disposed)102 {103 throw new PuppeteerException("Prototype JSHandle is disposed!");104 }...

Full Screen

Full Screen

JSHandle.cs

Source:JSHandle.cs Github

copy

Full Screen

...169 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.170 /// <see cref="JSHandle"/> instances can be passed as arguments171 /// </remarks>172 /// <returns>Task which resolves to script return value</returns>173 public Task<JToken> EvaluateFunctionAsync(string script, params object[] args)174 {175 var list = new List<object>(args);176 list.Insert(0, this);177 return ExecutionContext.EvaluateFunctionAsync<JToken>(script, list.ToArray());178 }179 /// <summary>180 /// Executes a function in browser context181 /// </summary>182 /// <typeparam name="T">The type to deserialize the result to</typeparam>183 /// <param name="script">Script to be evaluated in browser context</param>184 /// <param name="args">Arguments to pass to script</param>185 /// <remarks>186 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.187 /// <see cref="JSHandle"/> instances can be passed as arguments188 /// </remarks>189 /// <returns>Task which resolves to script return value</returns>190 public Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)191 {192 var list = new List<object>(args);193 list.Insert(0, this);194 return ExecutionContext.EvaluateFunctionAsync<T>(script, list.ToArray());195 }196 internal object FormatArgument(ExecutionContext context)197 {198 if (ExecutionContext != context)199 {200 throw new PuppeteerException("JSHandles can be evaluated only in the context they were created!");201 }202 if (Disposed)203 {204 throw new PuppeteerException("JSHandle is disposed!");205 }206 var unserializableValue = RemoteObject.UnserializableValue;207 if (unserializableValue != null)208 {...

Full Screen

Full Screen

Worker.cs

Source:Worker.cs Github

copy

Full Screen

...86 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.87 /// <see cref="JSHandle"/> instances can be passed as arguments88 /// </remarks>89 /// <returns>Task which resolves to script return value</returns>90 public async Task<JToken> EvaluateFunctionAsync(string script, params object[] args)91 => await (await ExecutionContextTask.ConfigureAwait(false)).EvaluateFunctionAsync(script, args).ConfigureAwait(false);92 /// <summary>93 /// Executes a function in the context94 /// </summary>95 /// <typeparam name="T">The type to deserialize the result to</typeparam>96 /// <param name="script">Script to be evaluated in browser context</param>97 /// <param name="args">Arguments to pass to script</param>98 /// <remarks>99 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.100 /// <see cref="JSHandle"/> instances can be passed as arguments101 /// </remarks>102 /// <returns>Task which resolves to script return value</returns>103 public async Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)104 => await (await ExecutionContextTask.ConfigureAwait(false)).EvaluateFunctionAsync<T>(script, args).ConfigureAwait(false);105 /// <summary>106 /// Executes a script in browser context107 /// </summary>108 /// <param name="script">Script to be evaluated in browser context</param>109 /// <remarks>110 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.111 /// </remarks>112 /// <returns>Task which resolves to script return value</returns>113 /// <seealso cref="ExecutionContext.EvaluateExpressionHandleAsync(string)"/>114 public async Task<JSHandle> EvaluateExpressionHandleAsync(string script)115 => await (await ExecutionContextTask.ConfigureAwait(false)).EvaluateExpressionHandleAsync(script).ConfigureAwait(false);116 internal Task<ExecutionContext> ExecutionContextTask => _executionContextCallback.Task;117 internal async void OnMessageReceived(object sender, MessageEventArgs e)118 {...

Full Screen

Full Screen

QueryObjectsTests.cs

Source:QueryObjectsTests.cs Github

copy

Full Screen

...18 // Instantiate an object19 await Page.EvaluateExpressionAsync("window.set = new Set(['hello', 'world'])");20 var prototypeHandle = await Page.EvaluateExpressionHandleAsync("Set.prototype");21 var objectsHandle = await Page.QueryObjectsAsync(prototypeHandle);22 var count = await Page.EvaluateFunctionAsync<int>("objects => objects.length", objectsHandle);23 Assert.Equal(1, count);24 var values = await Page.EvaluateFunctionAsync<string[]>("objects => Array.from(objects[0].values())", objectsHandle);25 Assert.Equal(new[] { "hello", "world" }, values);26 }27 [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should work for non-blank page")]28 [SkipBrowserFact(skipFirefox: true)]29 public async Task ShouldWorkForNonBlankPage()30 {31 // Instantiate an object32 await Page.GoToAsync(TestConstants.EmptyPage);33 await Page.EvaluateFunctionAsync("() => window.set = new Set(['hello', 'world'])");34 var prototypeHandle = await Page.EvaluateFunctionHandleAsync("() => Set.prototype");35 var objectsHandle = await Page.QueryObjectsAsync(prototypeHandle);36 var count = await Page.EvaluateFunctionAsync<int>("objects => objects.length", objectsHandle);37 Assert.Equal(1, count);38 }39 [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should fail for disposed handles")]40 [PuppeteerFact]41 public async Task ShouldFailForDisposedHandles()42 {43 var prototypeHandle = await Page.EvaluateExpressionHandleAsync("HTMLBodyElement.prototype");44 await prototypeHandle.DisposeAsync();45 var exception = await Assert.ThrowsAsync<PuppeteerException>(()46 => Page.QueryObjectsAsync(prototypeHandle));47 Assert.Equal("Prototype JSHandle is disposed!", exception.Message);48 }49 [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should fail primitive values as prototypes")]50 [PuppeteerFact]...

Full Screen

Full Screen

Extensions.cs

Source:Extensions.cs Github

copy

Full Screen

...14 /// <param name="pageFunction">Function to be evaluated in browser context</param>15 /// <param name="args">Arguments to pass to <c>pageFunction</c></param>16 /// <returns>Task which resolves to the return value of <c>pageFunction</c></returns>17 /// <exception cref="SelectorException">If <paramref name="elementHandleTask"/> resolves to <c>null</c></exception>18 public static async Task<T> EvaluateFunctionAsync<T>(this Task<ElementHandle> elementHandleTask, string pageFunction, params object[] args)19 {20 var elementHandle = await elementHandleTask;21 if (elementHandle == null)22 {23 throw new SelectorException($"Error: failed to find element matching selector");24 }25 var newArgs = new object[args.Length + 1];26 newArgs[0] = elementHandle;27 args.CopyTo(newArgs, 1);28 var result = await elementHandle.ExecutionContext.EvaluateFunctionAsync<T>(pageFunction, newArgs);29 await elementHandle.DisposeAsync();30 return result;31 }32 /// <summary>33 /// Runs <paramref name="pageFunction"/> within the frame and passes it the outcome of <paramref name="arrayHandleTask"/> as the first argument. Use only after <see cref="Page.QuerySelectorAllHandleAsync(string)"/>34 /// </summary>35 /// <typeparam name="T"></typeparam>36 /// <param name="arrayHandleTask">A task that returns an <see cref="JSHandle"/> that represents an array of <see cref="ElementHandle"/> that will be used as the first argument in <paramref name="pageFunction"/></param>37 /// <param name="pageFunction">Function to be evaluated in browser context</param>38 /// <param name="args">Arguments to pass to <c>pageFunction</c></param>39 /// <returns>Task which resolves to the return value of <c>pageFunction</c></returns>40 public static async Task<T> EvaluateFunctionAsync<T>(this Task<JSHandle> arrayHandleTask, string pageFunction, params object[] args)41 {42 var arrayHandle = await arrayHandleTask;43 var newArgs = new object[args.Length + 1];44 newArgs[0] = arrayHandle;45 args.CopyTo(newArgs, 1);46 var result = await arrayHandle.ExecutionContext.EvaluateFunctionAsync<T>(pageFunction, newArgs);47 await arrayHandle.DisposeAsync();48 return result;49 }50 }51}...

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static void Main(string[] args)7 {8 MainAsync().GetAwaiter().GetResult();9 }10 static async Task MainAsync()11 {12 Browser browser = await Puppeteer.LaunchAsync(new LaunchOptions() { Headless = false });13 Page page = await browser.NewPageAsync();14 var result = await page.EvaluateFunctionAsync("() => 1 + 1");15 Console.WriteLine(result);16 await browser.CloseAsync();17 }18 }19}20using System;21using System.Threading.Tasks;22using PuppeteerSharp;23{24 {25 static void Main(string[] args)26 {27 MainAsync().GetAwaiter().GetResult();28 }29 static async Task MainAsync()30 {31 Browser browser = await Puppeteer.LaunchAsync(new LaunchOptions() { Headless = false });32 Page page = await browser.NewPageAsync();33 var result = await page.EvaluateFunctionAsync("() => 1 + 1");34 Console.WriteLine(result);35 await browser.CloseAsync();36 }37 }38}39using System;40using System.Threading.Tasks;41using PuppeteerSharp;42{43 {44 static void Main(string[] args)45 {46 MainAsync().GetAwaiter().GetResult();47 }48 static async Task MainAsync()49 {50 Browser browser = await Puppeteer.LaunchAsync(new LaunchOptions() { Headless = false });51 Page page = await browser.NewPageAsync();52 var result = await page.EvaluateFunctionAsync("() => 1 + 1");53 Console.WriteLine(result);54 await browser.CloseAsync();55 }56 }57}58using System;59using System.Threading.Tasks;60using PuppeteerSharp;61{62 {

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static async Task Main(string[] args)7 {8 var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false });9 var page = await browser.NewPageAsync();10 var result = await page.EvaluateFunctionAsync("() => 1 + 2");11 Console.WriteLine(result);12 await browser.CloseAsync();13 }14 }15}16using System;17using System.Threading.Tasks;18using PuppeteerSharp;19{20 {21 static async Task Main(string[] args)22 {23 var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false });24 var page = await browser.NewPageAsync();25 var result = await page.EvaluateFunctionAsync<string>("() => 'Hello World'");26 Console.WriteLine(result);27 await browser.CloseAsync();28 }29 }30}31using System;32using System.Threading.Tasks;33using PuppeteerSharp;34{35 {36 static async Task Main(string[] args)37 {38 var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false });39 var page = await browser.NewPageAsync();40 var result = await page.EvaluateFunctionAsync<int>("() => 1 + 2");41 Console.WriteLine(result);42 await browser.CloseAsync();43 }44 }45}46using System;47using System.Threading.Tasks;48using PuppeteerSharp;49{50 {51 static async Task Main(string[] args)52 {53 var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false });54 var page = await browser.NewPageAsync();

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1var page = await browser.NewPageAsync();2var result = await page.EvaluateFunctionAsync<int>("() => 7 * 3");3Console.WriteLine(result);4await browser.CloseAsync();5var page = await browser.NewPageAsync();6var result = await page.EvaluateFunctionAsync<int>("(a, b) => a * b", 7, 3);7Console.WriteLine(result);8await browser.CloseAsync();9var page = await browser.NewPageAsync();10var result = await page.EvaluateFunctionAsync("() => document.title");11Console.WriteLine(result);12await browser.CloseAsync();13var page = await browser.NewPageAsync();14var result = await page.EvaluateFunctionAsync("() => window.location.href");15Console.WriteLine(result);16await browser.CloseAsync();17var page = await browser.NewPageAsync();18var result = await page.EvaluateFunctionAsync("() => document.querySelector('h1').innerText");19Console.WriteLine(result);20await browser.CloseAsync();21var page = await browser.NewPageAsync();22var result = await page.EvaluateFunctionAsync("() => document.querySelector('h1')");23Console.WriteLine(result);24await browser.CloseAsync();25var page = await browser.NewPageAsync();26var result = await page.EvaluateFunctionAsync("() => document.querySelector('h1').innerText");27Console.WriteLine(result);28await browser.CloseAsync();

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static async Task Main(string[] args)7 {8 var browser = await Puppeteer.LaunchAsync(new LaunchOptions9 {10 });11 var page = await browser.NewPageAsync();12 await page.EvaluateFunctionAsync("() => document.querySelector('input').value = 'PuppeteerSharp'");13 await page.PressAsync("input", "Enter");14 await page.WaitForNavigationAsync();15 var result = await page.EvaluateFunctionAsync<int>("() => document.querySelectorAll('h3').length");16 Console.WriteLine(result);17 await browser.CloseAsync();18 }19 }20}

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1var browser = await Puppeteer.LaunchAsync(new LaunchOptions2{3});4var page = await browser.NewPageAsync();5var html = await page.EvaluateFunctionAsync<string>("() => document.documentElement.outerHTML");6Console.WriteLine(html);7await browser.CloseAsync();8var browser = await Puppeteer.LaunchAsync(new LaunchOptions9{10});11var page = await browser.NewPageAsync();12var html = await page.EvaluateFunctionAsync<string>("() => document.documentElement.outerHTML");13Console.WriteLine(html);14await browser.CloseAsync();15var browser = await Puppeteer.LaunchAsync(new LaunchOptions16{17});18var page = await browser.NewPageAsync();19var html = await page.EvaluateFunctionAsync<string>("() => document.documentElement.outerHTML");20Console.WriteLine(html);21await browser.CloseAsync();22var browser = await Puppeteer.LaunchAsync(new LaunchOptions23{24});25var page = await browser.NewPageAsync();26var html = await page.EvaluateFunctionAsync<string>("() => document.documentElement.outerHTML");27Console.WriteLine(html);28await browser.CloseAsync();29var browser = await Puppeteer.LaunchAsync(new LaunchOptions30{31});32var page = await browser.NewPageAsync();

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1var context = await page.GetBrowser().GetDefaultBrowserContextAsync();2var page = await context.NewPageAsync();3var result = await page.EvaluateFunctionAsync("() => document.querySelector('div').innerText");4Console.WriteLine(result);5var page = await browser.NewPageAsync();6var result = await page.EvaluateFunctionAsync("() => document.querySelector('div').innerText");7Console.WriteLine(result);8var page = await browser.NewPageAsync();9var frame = page.MainFrame;10var result = await frame.EvaluateFunctionAsync("() => document.querySelector('div').innerText");11Console.WriteLine(result);12var page = await browser.NewPageAsync();13var element = await page.QuerySelectorAsync("div");14var result = await element.EvaluateFunctionAsync("() => document.querySelector('div').innerText");15Console.WriteLine(result);16var page = await browser.NewPageAsync();17var result = await page.EvaluateFunctionAsync("() => document.querySelector('div').innerText");18Console.WriteLine(result);19var page = await browser.NewPageAsync();20var result = await page.EvaluateFunctionAsync("() => document.querySelector('div').innerText");21Console.WriteLine(result);22var page = await browser.NewPageAsync();23var result = await page.EvaluateFunctionAsync("() => document.querySelector('div').innerText");24Console.WriteLine(result);

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1var page = await browser.NewPageAsync();2var result = await page.EvaluateFunctionAsync("() => 1 + 2");3Console.WriteLine(result.ToString());4Console.ReadLine();5var page = await browser.NewPageAsync();6var result = await page.EvaluateFunctionAsync("() => 1 + 2");7Console.WriteLine(result.ToString());8Console.ReadLine();

Full Screen

Full Screen

EvaluateFunctionAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static async Task Main(string[] args)7 {8 var browser = await Puppeteer.LaunchAsync(new LaunchOptions9 {10 });11 var page = await browser.NewPageAsync();12 var title = await page.EvaluateFunctionAsync<string>("() => document.title");13 Console.WriteLine(title);14 Console.ReadKey();15 }16 }17}

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Puppeteer-sharp automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

... View sample repo... View DocumentationSign up Free
›
_

Most used method in ExecutionContext

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

...
Sign up with GoogleSign up with Email
Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful