public void EvaluationReturnsEmptyArraysWhenNull()
{
var result = TargetView.EvaluateScript <int[]>("null");
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Length);
}
public async Task EvaluateSimpleScript()
{
await Run(() => {
var result = TargetView.EvaluateScript <int>("2+1");
Assert.AreEqual(3, result);
});
}
public void EvaluationTimeoutIsThrown()
{
var exception = Assert.Throws <WebView.JavascriptException>(
() => TargetView.EvaluateScript <int>("var start = new Date().getTime(); while((new Date().getTime() - start) < 150);",
TimeSpan.FromMilliseconds(50)));
Assert.True(exception.Message.Contains("Timeout"));
}
public void JavascriptEngineInitializationTimeout()
{
LoadAndWaitReady("<html><body></body></html>");
var exception = Assert.Throws <WebView.JavascriptException>(() => TargetView.EvaluateScript <int>("1", TimeSpan.FromSeconds(1)));
Assert.IsNotNull(exception);
Assert.IsTrue(exception.Message.Contains("not initialized"));
}
public async Task EvaluationReturnsEmptyArraysWhenNull()
{
await Run(() => {
var result = TargetView.EvaluateScript <int[]>("null");
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Length);
});
}
public async Task EvaluationTimeoutIsThrown()
{
await Run(async() => {
var exception = await Assertions.AssertThrows <JavascriptException>(
async() => await TargetView.EvaluateScript <int>("var start = new Date().getTime(); while((new Date().getTime() - start) < 150);", timeout: TimeSpan.FromMilliseconds(50)));
StringAssert.Contains("Timeout", exception.Message);
});
}
public void ResourceRequestIsCanceled()
{
TargetView.BeforeResourceLoad += (resourceHandler) => resourceHandler.Cancel();
LoadAndWaitReady(HtmlWithResource);
var failed = TargetView.EvaluateScript <bool>("scriptFailed"); // check that the value of x is what was declared before in the resource
Assert.True(failed);
}
public void InterceptedResourceRequestIsLoaded()
{
TargetView.BeforeResourceLoad += (resourceHandler) => resourceHandler.RespondWith(ToStream("scriptLoaded = true"), "js"); // declare x
LoadAndWaitReady(HtmlWithResource);
var loaded = TargetView.EvaluateScript <bool>("scriptLoaded"); // check that the value of x is what was declared before in the resource
Assert.True(loaded);
}
public void EmbeddedFilesWithDashesInFilenameLoad()
{
var embeddedResourceUrl = new ResourceUrl(GetType().Assembly, "Resources", "dash-folder", "EmbeddedJavascriptFile-With-Dashes.js");
LoadAndWaitReady($"<html><script src='{embeddedResourceUrl}'></script></html>");
var embeddedFileLoaded = TargetView.EvaluateScript <bool>("embeddedFileLoaded");
Assert.IsTrue(embeddedFileLoaded);
}
public async Task EvaluateAfterInitialization()
{
await Run(async() => {
await Load("<html><script></script><body>1</body></html>");
await Load("<html><script></script><body>2</body></html>");
var result = await TargetView.EvaluateScript <int>("1", timeout: TimeSpan.FromSeconds(30));
Assert.AreEqual(result, 1);
});
}
public async Task HtmlIsWellEncoded()
{
await Run(async() => {
const string BodyContent = "some text and a double byte char '●'";
await Load($"<html><script>;</script><body>{BodyContent}</body></html>");
var body = TargetView.EvaluateScript <string>("document.body.innerText");
Assert.AreEqual(BodyContent, body);
});
}
public async Task EmbeddedFilesWithDashesInFilenameLoad()
{
await Run(async() => {
var embeddedResourceUrl = new ResourceUrl(GetType().Assembly, "Resources", "dash-folder", "EmbeddedJavascriptFile-With-Dashes.js");
await Load($"<html><script src='{embeddedResourceUrl}'></script></html>");
var embeddedFileLoaded = TargetView.EvaluateScript <bool>("embeddedFileLoaded");
Assert.IsTrue(embeddedFileLoaded);
});
}
public void UnhandledExceptionEventIsCalled()
{
const string ExceptionMessage = "nooo";
Exception exception = null;
var controlUnhandled = false;
var dispatcherUnhandled = false;
var markAsHandled = true;
DispatcherUnhandledExceptionEventHandler unhandledDispatcherException = (o, e) => {
exception = e.Exception;
dispatcherUnhandled = true;
e.Handled = true;
};
Action <int> assertResult = (result) => {
Assert.NotNull(exception);
Assert.IsTrue(exception.Message.Contains(exception.Message));
Assert.AreEqual(2, result, "Result should not be affected");
};
TargetView.Dispatcher.UnhandledException += unhandledDispatcherException;
WithUnhandledExceptionHandling(() => {
try {
TargetView.ExecuteScript($"throw new Error('{ExceptionMessage}')");
var result = TargetView.EvaluateScript <int>("1+1"); // force exception to occur
assertResult(result);
Assert.IsTrue(controlUnhandled);
Assert.IsFalse(dispatcherUnhandled);
controlUnhandled = false;
markAsHandled = false;
TargetView.ExecuteScript($"throw new Error('{ExceptionMessage}')");
result = TargetView.EvaluateScript <int>("1+1"); // force exception to occur
WaitFor(() => dispatcherUnhandled);
assertResult(result);
Assert.IsTrue(controlUnhandled);
Assert.IsTrue(dispatcherUnhandled);
} finally {
TargetView.Dispatcher.UnhandledException -= unhandledDispatcherException;
}
},
e => {
exception = e;
controlUnhandled = true;
return(markAsHandled);
});
}
public void EvaluationErrorsReturnsDetails()
{
var exception = Assert.Throws <WebView.JavascriptException>(() => TargetView.EvaluateScript <int>("(function foo() { (function bar() { throw new Error('ups'); })() })()"));
Assert.AreEqual("Error: ups", exception.Message);
var stack = exception.StackTrace.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
Assert.Greater(stack.Length, 2);
Assert.True(stack.ElementAt(0).StartsWith(" at bar"));
Assert.True(stack.ElementAt(1).StartsWith(" at foo"));
}
public void ComplexObjectsEvaluation()
{
var result = TargetView.EvaluateScript <TestObject>("({ Name: 'Snows', Age: 32, Parent: { Name: 'Snows Parent', Age: 60 }, Kind: 2 })");
Assert.IsNotNull(result);
Assert.AreEqual("Snows", result.Name);
Assert.AreEqual(32, result.Age);
Assert.IsNotNull(result.Parent);
Assert.AreEqual("Snows Parent", result.Parent.Name);
Assert.AreEqual(60, result.Parent.Age);
Assert.AreEqual(Kind.C, result.Kind);
}
public async Task EvaluationErrorsContainsMessageAndJavascriptStack()
{
await Run(() => {
var exception = Assert.Throws <JavascriptException>(() => TargetView.EvaluateScript <int>("(function foo() { (function bar() { throw new Error('ups'); })() })()"));
Assert.AreEqual("Error: ups", exception.Message);
var stack = exception.StackTrace.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
Assert.Greater(stack.Length, 2);
StringAssert.StartsWith(" at bar in about", stack.ElementAt(0));
StringAssert.StartsWith(" at foo in about", stack.ElementAt(1));
});
}
public async Task ScriptsWithComplexSyntaxAreEvaluated()
{
await Run(() => {
var result = TargetView.EvaluateScript <int>("2+1 // some comments");
Assert.AreEqual(3, result);
result = TargetView.EvaluateScript <int>("var x = 1; 5");
Assert.AreEqual(5, result);
var resultObj = TargetView.EvaluateScript <TestObject>("({ Name: 'Snows', Age: 32})");
Assert.IsNotNull(resultObj);
});
}
public void HtmlIsWellEncoded()
{
const string BodyContent = "some text and a double byte char '●'";
var navigated = false;
TargetView.Navigated += (_, __) => navigated = true;
TargetView.LoadHtml($"<html><script>;</script><body>{BodyContent}</body></html>");
WaitFor(() => navigated);
var body = TargetView.EvaluateScript <string>("document.body.innerText");
Assert.AreEqual(BodyContent, body);
}
public async Task JavascriptEvaluationOnNavigatedDoesNotBlock()
{
await Run(async() => {
var taskCompletionSource = new TaskCompletionSource <bool>();
TargetView.Navigated += delegate {
TargetView.EvaluateScript <int>("1+1");
taskCompletionSource.SetResult(true);
};
await Load("<html><body></body></html>");
var navigatedCalled = await taskCompletionSource.Task;
Assert.IsTrue(navigatedCalled, "JS evaluation on navigated event is blocked!");
});
}
public void JavascriptEvaluationOnNavigatedDoesNotBlock()
{
var navigated = false;
TargetView.Navigated += _ => {
TargetView.EvaluateScript <int>("1+1");
navigated = true;
};
LoadAndWaitReady("<html>><body></body></html>");
WaitFor(() => navigated);
Assert.IsTrue(navigated);
}
public async Task ResourceFile()
{
await Run(async() => {
var embeddedResourceUrl = new ResourceUrl(GetType().Assembly, "Resources", "ResourceJavascriptFile.js");
await Load($"<html><script src='{embeddedResourceUrl}'></script></html>");
var resourceFileLoaded = TargetView.EvaluateScript <bool>("resourceFileLoaded");
Assert.IsTrue(resourceFileLoaded);
Stream missingResource = null;
Assert.DoesNotThrow(() => missingResource = ResourcesManager.TryGetResourceWithFullPath(GetType().Assembly, new[] { "Resources", "Missing.txt" }));
Assert.IsNull(missingResource);
});
}
public async Task ResourceRequestIsCanceled()
{
await Run(async() => {
var taskCompletionSource = new TaskCompletionSource <bool>();
TargetView.BeforeResourceLoad += (resourceHandler) => {
resourceHandler.Cancel();
taskCompletionSource.SetResult(true);
};
await Load(HtmlWithResource);
await taskCompletionSource.Task;
var failed = TargetView.EvaluateScript <bool>("scriptFailed"); // check that the value of x is what was declared before in the resource
Assert.IsTrue(failed);
});
}
public async Task InterceptedResourceRequestIsLoaded()
{
await Run(async() => {
var taskCompletionSource = new TaskCompletionSource <bool>();
TargetView.BeforeResourceLoad += (resourceHandler) => {
resourceHandler.RespondWith(ToStream("scriptLoaded = true"), "js"); // declare x
taskCompletionSource.SetResult(true);
};
await Load(HtmlWithResource);
await taskCompletionSource.Task;
var loaded = TargetView.EvaluateScript <bool>("scriptLoaded"); // check that the value of x is what was declared before in the resource
Assert.IsTrue(loaded);
});
}
public void JavascriptEvaluationOnIframe()
{
LoadAndWaitReady(
"<html>" +
"<body>" +
"<script>" +
"var x = 1;" +
"</script>" +
"<iframe name='test' srcdoc='<html><body><script>var y = 2;</script></body></html>'></iframe>" +
"</body>" +
"</html>"
);
var x = TargetView.EvaluateScript <int>("x", "");
var y = TargetView.EvaluateScript <int>("y", "test");
Assert.AreEqual(1, x);
Assert.AreEqual(2, y);
}
public void RegisteredJsObjectMethodExecutesInDispatcherThreadWithoutBlocking()
{
const string DotNetObject = "DotNetObject";
bool functionCalled = false;
Func <int> functionToCall = () => {
TargetView.EvaluateScript <int>("1+1");
functionCalled = true;
return(1);
};
TargetView.RegisterJavascriptObject(DotNetObject, functionToCall, executeCallsInUI: true);
LoadAndWaitReady("<html><script>function test() { DotNetObject.invoke(); return 1; }</script><body></body></html>");
var result = TargetView.EvaluateScriptFunction <int>("test");
WaitFor(() => functionCalled, DefaultTimeout);
Assert.AreEqual(1, result);
}
public async Task JavascriptEvaluationOnIframe()
{
await Run(async() => {
await Load(
"<html>" +
"<body>" +
"<script>" +
"var x = 1;" +
"</script>" +
"<iframe name='test' srcdoc='<html><body><script>var y = 2;</script></body></html>'></iframe>" +
"</body>" +
"</html>"
);
var x = await TargetView.EvaluateScript <int>("x", "");
var y = await TargetView.EvaluateScript <int>("test.y", "");
Assert.AreEqual(1, x);
Assert.AreEqual(2, y);
});
}
public async Task RegisteredJsObjectMethodExecutesInDispatcherThreadWithoutBlocking()
{
await Run(async() => {
const string DotNetObject = "DotNetObject";
var taskCompletionSource = new TaskCompletionSource <bool>();
Func <int> functionToCall = () => {
TargetView.EvaluateScript <int>("1+1");
taskCompletionSource.SetResult(true);
return(1);
};
TargetView.RegisterJavascriptObject(DotNetObject, functionToCall, executeCallsInUI: true);
await Load("<html><script>function test() { DotNetObject.invoke(); return 1; }</script><body></body></html>");
var result = await TargetView.EvaluateScriptFunction <int>("test");
await taskCompletionSource.Task;
Assert.AreEqual(1, result);
});
}
public void ExecutionOrderIsRespected()
{
try {
TargetView.ExecuteScript("x = ''");
var expectedResult = "";
// queue 10000 scripts
for (var i = 0; i < 10000; i++)
{
TargetView.ExecuteScript($"x += '{i},'");
expectedResult += i + ",";
}
var result = TargetView.EvaluateScript <string>("x");
Assert.AreEqual(expectedResult, result);
TargetView.ExecuteScript("x = '-'");
result = TargetView.EvaluateScript <string>("x");
Assert.AreEqual("-", result);
} finally {
TargetView.EvaluateScript <bool>("delete x");
}
}
public async Task LoadCustomScheme()
{
await Run(async() => {
var embeddedResourceUrl = new ResourceUrl(GetType().Assembly, "Resources", "EmbeddedHtml.html");
var taskCompletionSource = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
void OnNavigated(string url, string frameName)
{
if (url != UrlHelper.AboutBlankUrl)
{
TargetView.Navigated -= OnNavigated;
taskCompletionSource.SetResult(true);
}
}
TargetView.Navigated += OnNavigated;
TargetView.LoadResource(embeddedResourceUrl);
await taskCompletionSource.Task;
var content = await TargetView.EvaluateScript <string>("document.documentElement.innerText");
Assert.AreEqual("test", content);
});
}
public async Task UnhandledExceptionEventIsCalled()
{
await Run(() => {
const string ExceptionMessage = "nooo";
var taskCompletionSource = new TaskCompletionSource <Exception>();
WithUnhandledExceptionHandling(() => {
TargetView.ExecuteScript($"throw new Error('{ExceptionMessage}')");
var result = TargetView.EvaluateScript <int>("1+1"); // force exception to occur
Assert.AreEqual(2, result, "Result should not be affected");
var exception = taskCompletionSource.Task.Result;
StringAssert.Contains(ExceptionMessage, exception.Message);
},
e => {
taskCompletionSource.SetResult(e);
return(true);
});
});
}