Rename tests and add tests for calling Execute multiple times

Author: campersau

CefSharp.Core.Runtime/Internals/JavascriptCallbackProxy.cpp

@@ -27,7 +27,7 @@ namespace CefSharp
             auto browser = GetBrowser();
             if (browser == nullptr)
             {
-                return Task::FromException<JavascriptResponse^>(gcnew InvalidOperationException("Browser instance is null. Check CanExecute before calling this method."));
+                throw gcnew InvalidOperationException("Browser instance is null. Check CanExecute before calling this method.");
             }
 
             auto browserWrapper = static_cast<CefBrowserWrapper^>(browser);

CefSharp.Test/Javascript/EvaluateScriptAsyncTests.cs

@@ -64,7 +64,7 @@ public async Task V8Context()
         }
 
         [Fact]
-        public async Task CancelEvaluateOnCrash()
+        public async Task ShouldCancelOnCrash()
         {
             AssertInitialLoadComplete();
 

CefSharp.Test/Javascript/JavascriptCallbackTests.cs

@@ -27,6 +27,7 @@ public JavascriptCallbackTests(ITestOutputHelper output, CefSharpFixture collect
         [Fact]
         public async Task V8Context()
         {
+            IJavascriptCallback callbackExecuteCancelAfterDisposeCallback;
             Task callbackExecuteCancelAfterDisposeTask;
             using (var browser = new CefSharp.OffScreen.ChromiumWebBrowser(automaticallyCreateBrowser: false))
             {
@@ -54,24 +55,29 @@ public async Task V8Context()
 
                 var callbackExecuteCancelAfterV8ContextResponse = await browser.EvaluateScriptAsync("(function() { return new Promise(resolve => setTimeout(resolve, 1000)); })");
                 Assert.True(callbackExecuteCancelAfterV8ContextResponse.Success);
-                var evaluateCancelAfterV8ContextCallback = (IJavascriptCallback)callbackExecuteCancelAfterV8ContextResponse.Result;
-                var evaluateCancelAfterV8ContextTask = evaluateCancelAfterV8ContextCallback.ExecuteAsync();
+                var callbackExecuteCancelAfterV8ContextCallback = (IJavascriptCallback)callbackExecuteCancelAfterV8ContextResponse.Result;
+                var callbackExecuteCancelAfterV8ContextTask = callbackExecuteCancelAfterV8ContextCallback.ExecuteAsync();
 
                 // change V8 context
                 await browser.LoadUrlAsync(CefExample.HelloWorldUrl);
 
-                await Assert.ThrowsAsync<TaskCanceledException>(() => evaluateCancelAfterV8ContextTask);
+                await Assert.ThrowsAsync<TaskCanceledException>(() => callbackExecuteCancelAfterV8ContextTask);
+                var callbackExecuteCancelAfterV8ContextResult = await callbackExecuteCancelAfterV8ContextCallback.ExecuteAsync();
+                Assert.False(callbackExecuteCancelAfterV8ContextResult.Success);
+                Assert.StartsWith("Unable to find JavascriptCallback with Id " + callbackExecuteCancelAfterV8ContextCallback.Id, callbackExecuteCancelAfterV8ContextResult.Message);
 
                 var callbackExecuteCancelAfterDisposeResponse = await browser.EvaluateScriptAsync("(function() { return new Promise(resolve => setTimeout(resolve, 1000)); })");
                 Assert.True(callbackExecuteCancelAfterDisposeResponse.Success);
-                var callbackExecuteCancelAfterDisposeCallback = (IJavascriptCallback)callbackExecuteCancelAfterDisposeResponse.Result;
+                callbackExecuteCancelAfterDisposeCallback = (IJavascriptCallback)callbackExecuteCancelAfterDisposeResponse.Result;
                 callbackExecuteCancelAfterDisposeTask = callbackExecuteCancelAfterDisposeCallback.ExecuteAsync();
             }
+            Assert.False(callbackExecuteCancelAfterDisposeCallback.CanExecute);
             await Assert.ThrowsAsync<TaskCanceledException>(() => callbackExecuteCancelAfterDisposeTask);
+            await Assert.ThrowsAsync<InvalidOperationException>(() => callbackExecuteCancelAfterDisposeCallback.ExecuteAsync());
         }
 
         [Fact]
-        public async Task CancelCallbackOnCrash()
+        public async Task ShouldCancelOnCrash()
         {
             AssertInitialLoadComplete();
 
@@ -296,5 +302,23 @@ public async Task ShouldWorkWithExpandoObject()
 
             output.WriteLine("Expected {0} : Actual {1}", expectedDateTime, actualDateTime);
         }
+
+        [Fact]
+        public async Task ShouldWorkWhenExecutedMultipleTimes()
+        {
+            AssertInitialLoadComplete();
+
+            var javascriptResponse = await Browser.EvaluateScriptAsync("(function() { return 42; })");
+            Assert.True(javascriptResponse.Success);
+
+            var callback = (IJavascriptCallback)javascriptResponse.Result;
+
+            for (var i = 0; i < 3; i++)
+            {
+                var callbackResponse = await callback.ExecuteAsync();
+                Assert.True(callbackResponse.Success);
+                Assert.Equal(42, callbackResponse.Result);
+            }
+        }
     }
 }