// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT license.

using System;

using System.Collections;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.Diagnostics.CodeAnalysis;

using System.Dynamic;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Text;

using System.Threading;

using Microsoft.ClearScript.JavaScript;

using Microsoft.CSharp.RuntimeBinder;

using Microsoft.ClearScript.Util;

using Microsoft.ClearScript.V8;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using System.Numerics;

using System.Threading.Tasks;

namespace Microsoft.ClearScript.Test

{

// ReSharper disable once PartialTypeWithSinglePart

[TestClass]

[SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Test classes use TestCleanupAttribute for deterministic teardown.")]

[SuppressMessage("ReSharper", "StringLiteralTypo", Justification = "Typos in test code are acceptable.")]

public partial class V8ScriptEngineTest : ClearScriptTest

{

#region setup / teardown

private V8ScriptEngine engine;

[TestInitialize]

public void TestInitialize()

{

engine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDebugging);

}

[TestCleanup]

public void TestCleanup()

{

engine.Dispose();

BaseTestCleanup();

}

#endregion

#region test methods

// ReSharper disable InconsistentNaming

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostObject()

{

var host = new HostFunctions();

engine.AddHostObject("host", host);

Assert.AreSame(host, engine.Evaluate("host"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

[ExpectedException(typeof(InvalidOperationException))]

public void V8ScriptEngine_AddHostObject_Scalar()

{

engine.AddHostObject("value", 123);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostObject_Enum()

{

const DayOfWeek value = DayOfWeek.Wednesday;

engine.AddHostObject("value", value);

Assert.AreEqual(value, engine.Evaluate("value"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostObject_Struct()

{

var date = new DateTime(2007, 5, 22, 6, 15, 43);

engine.AddHostObject("date", date);

Assert.AreEqual(date, engine.Evaluate("date"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostObject_GlobalMembers()

{

var host = new HostFunctions();

engine.AddHostObject("host", HostItemFlags.GlobalMembers, host);

Assert.IsInstanceOfType(engine.Evaluate("newObj()"), typeof(PropertyBag));

engine.AddHostObject("test", HostItemFlags.GlobalMembers, this);

engine.Execute("TestProperty = newObj()");

Assert.IsInstanceOfType(TestProperty, typeof(PropertyBag));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostObject_GlobalMembers_Overwrite()

{

const int fooFirst = 123;

const int fooSecond = 456;

const int barSecond = 789;

engine.AddHostObject("bar", HostItemFlags.GlobalMembers, new { second = barSecond });

engine.AddHostObject("foo", HostItemFlags.GlobalMembers, new { second = fooSecond });

engine.AddHostObject("foo", HostItemFlags.GlobalMembers, new { first = fooFirst });

Assert.AreEqual(fooFirst, engine.Evaluate("first"));

Assert.AreEqual(barSecond, engine.Evaluate("second"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

[ExpectedException(typeof(ScriptEngineException))]

public void V8ScriptEngine_AddHostObject_DefaultAccess()

{

engine.AddHostObject("test", this);

engine.Execute("test.PrivateMethod()");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostObject_PrivateAccess()

{

engine.AddHostObject("test", HostItemFlags.PrivateAccess, this);

engine.Execute("test.PrivateMethod()");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddRestrictedHostObject_BaseClass()

{

var host = new ExtendedHostFunctions() as HostFunctions;

engine.AddRestrictedHostObject("host", host);

Assert.IsInstanceOfType(engine.Evaluate("host.newObj()"), typeof(PropertyBag));

TestUtil.AssertException<ScriptEngineException>(() => engine.Evaluate("host.type('System.Int32')"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddRestrictedHostObject_Interface()

{

const double value = 123.45;

engine.AddRestrictedHostObject("convertible", value as IConvertible);

engine.AddHostObject("culture", CultureInfo.InvariantCulture);

Assert.AreEqual(value, engine.Evaluate("convertible.ToDouble(culture)"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType()

{

engine.AddHostObject("host", new HostFunctions());

engine.AddHostType("Random", typeof(Random));

Assert.IsInstanceOfType(engine.Evaluate("host.newObj(Random)"), typeof(Random));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_GlobalMembers()

{

engine.AddHostType("Guid", HostItemFlags.GlobalMembers, typeof(Guid));

Assert.IsInstanceOfType(engine.Evaluate("NewGuid()"), typeof(Guid));

engine.AddHostType("Test", HostItemFlags.GlobalMembers, GetType());

engine.Execute("StaticTestProperty = NewGuid()");

Assert.IsInstanceOfType(StaticTestProperty, typeof(Guid));

}

[TestMethod, TestCategory("V8ScriptEngine")]

[ExpectedException(typeof(ScriptEngineException))]

public void V8ScriptEngine_AddHostType_DefaultAccess()

{

engine.AddHostType("Test", GetType());

engine.Execute("Test.PrivateStaticMethod()");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_PrivateAccess()

{

engine.AddHostType("Test", HostItemFlags.PrivateAccess, GetType());

engine.Execute("Test.PrivateStaticMethod()");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_Static()

{

engine.AddHostType("Enumerable", typeof(Enumerable));

Assert.IsInstanceOfType(engine.Evaluate("Enumerable.Range(0, 5).ToArray()"), typeof(int[]));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_OpenGeneric()

{

engine.AddHostObject("host", new HostFunctions());

engine.AddHostType("List", typeof(List<>));

engine.AddHostType("Guid", typeof(Guid));

Assert.IsInstanceOfType(engine.Evaluate("host.newObj(List(Guid))"), typeof(List<Guid>));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_ByName()

{

engine.AddHostObject("host", new HostFunctions());

engine.AddHostType("Random", "System.Random");

Assert.IsInstanceOfType(engine.Evaluate("host.newObj(Random)"), typeof(Random));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_ByNameWithAssembly()

{

engine.AddHostType("Enumerable", "System.Linq.Enumerable", "System.Core");

Assert.IsInstanceOfType(engine.Evaluate("Enumerable.Range(0, 5).ToArray()"), typeof(int[]));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_ByNameWithTypeArgs()

{

engine.AddHostObject("host", new HostFunctions());

engine.AddHostType("Dictionary", "System.Collections.Generic.Dictionary", typeof(string), typeof(int));

Assert.IsInstanceOfType(engine.Evaluate("host.newObj(Dictionary)"), typeof(Dictionary<string, int>));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_DefaultName()

{

engine.AddHostType(typeof(Random));

Assert.IsInstanceOfType(engine.Evaluate("new Random()"), typeof(Random));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostType_DefaultNameGeneric()

{

engine.AddHostType(typeof(List<int>));

Assert.IsInstanceOfType(engine.Evaluate("new List()"), typeof(List<int>));

engine.AddHostType(typeof(Dictionary<,>));

engine.AddHostType(typeof(int));

engine.AddHostType(typeof(double));

Assert.IsInstanceOfType(engine.Evaluate("new Dictionary(Int32, Double, 100)"), typeof(Dictionary<int, double>));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AddHostTypes()

{

engine.AddHostTypes(typeof(Dictionary<,>), typeof(int), typeof(double));

Assert.IsInstanceOfType(engine.Evaluate("new Dictionary(Int32, Double, 100)"), typeof(Dictionary<int, double>));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate()

{

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate("Math.E * Math.PI"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_WithDocumentName()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(documentName, "Math.E * Math.PI"));

Assert.IsFalse(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_DiscardDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(documentName, true, "Math.E * Math.PI"));

Assert.IsFalse(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_RetainDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(documentName, false, "Math.E * Math.PI"));

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_DocumentInfo_WithDocumentName()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(new DocumentInfo(documentName), "Math.E * Math.PI"));

Assert.IsFalse(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_DocumentInfo_WithDocumentUri()

{

const string documentName = "DoTheMath";

var documentUri = new Uri(@"c:\foo\bar\baz\" + documentName);

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(new DocumentInfo(documentUri) { Flags = DocumentFlags.None }, "Math.E * Math.PI"));

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_DocumentInfo_WithDocumentUri_Relative()

{

const string documentName = "DoTheMath";

var documentUri = new Uri(documentName, UriKind.Relative);

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(new DocumentInfo(documentUri) { Flags = DocumentFlags.None }, "Math.E * Math.PI"));

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_DocumentInfo_DiscardDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(new DocumentInfo(documentName) { Flags = DocumentFlags.IsTransient }, "Math.E * Math.PI"));

Assert.IsFalse(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Evaluate_DocumentInfo_RetainDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate(new DocumentInfo(documentName) { Flags = DocumentFlags.None }, "Math.E * Math.PI"));

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute()

{

engine.Execute("epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_WithDocumentName()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

engine.Execute(documentName, "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_DiscardDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

engine.Execute(documentName, true, "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsFalse(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_RetainDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

engine.Execute(documentName, false, "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_DocumentInfo_WithDocumentName()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

engine.Execute(new DocumentInfo(documentName), "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_DocumentInfo_WithDocumentUri()

{

const string documentName = "DoTheMath";

var documentUri = new Uri(@"c:\foo\bar\baz\" + documentName);

engine.EnableDocumentNameTracking();

engine.Execute(new DocumentInfo(documentUri), "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_DocumentInfo_WithDocumentUri_Relative()

{

const string documentName = "DoTheMath";

var documentUri = new Uri(documentName, UriKind.Relative);

engine.EnableDocumentNameTracking();

engine.Execute(new DocumentInfo(documentUri), "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_DocumentInfo_DiscardDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

engine.Execute(new DocumentInfo(documentName) { Flags = DocumentFlags.IsTransient }, "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsFalse(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_DocumentInfo_RetainDocument()

{

const string documentName = "DoTheMath";

engine.EnableDocumentNameTracking();

engine.Execute(new DocumentInfo(documentName) { Flags = DocumentFlags.None }, "epi = Math.E * Math.PI");

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

Assert.IsTrue(engine.GetDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Execute_CompiledScript()

{

using (var script = engine.Compile("epi = Math.E * Math.PI"))

{

engine.Execute(script);

Assert.AreEqual(Math.E * Math.PI, engine.Script.epi);

}

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_ExecuteCommand_EngineConvert()

{

Assert.AreEqual("[object Math]", engine.ExecuteCommand("Math"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_ExecuteCommand_HostConvert()

{

var dateHostItem = HostItem.Wrap(engine, new DateTime(2007, 5, 22, 6, 15, 43));

engine.AddHostObject("date", dateHostItem);

Assert.AreEqual(dateHostItem.ToString(), engine.ExecuteCommand("date"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_ExecuteCommand_var()

{

Assert.AreEqual("[undefined]", engine.ExecuteCommand("var x = 'foo'"));

Assert.AreEqual("foo", engine.Script.x);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_ExecuteCommand_HostVariable()

{

engine.Script.host = new HostFunctions();

Assert.AreEqual("[HostVariable:String]", engine.ExecuteCommand("host.newVar('foo')"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Invoke_ScriptFunction()

{

engine.Execute("function foo(x) { return x * Math.PI; }");

Assert.AreEqual(Math.E * Math.PI, engine.Invoke("foo", Math.E));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Invoke_HostDelegate()

{

engine.Script.foo = new Func<double, double>(x => x * Math.PI);

Assert.AreEqual(Math.E * Math.PI, engine.Invoke("foo", Math.E));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Interrupt()

{

var checkpoint = new ManualResetEvent(false);

ThreadPool.QueueUserWorkItem(_ =>

{

checkpoint.WaitOne();

engine.Interrupt();

});

engine.AddHostObject("checkpoint", checkpoint);

// V8 can't interrupt code that accesses only native data

engine.AddHostObject("test", new { foo = "bar" });

TestUtil.AssertException<OperationCanceledException>(() =>

{

try

{

engine.Execute("checkpoint.Set(); while (true) { var foo = test.foo; }");

}

catch (ScriptInterruptedException exception)

{

Assert.IsNull(exception.ScriptExceptionAsObject);

throw;

}

});

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate("Math.E * Math.PI"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Interrupt_AwaitDebuggerAndPauseOnStart()

{

engine.Dispose();

engine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDebugging | V8ScriptEngineFlags.AwaitDebuggerAndPauseOnStart);

ThreadPool.QueueUserWorkItem(_ =>

{

Thread.Sleep(1000);

engine.Interrupt();

});

TestUtil.AssertException<OperationCanceledException>(() =>

{

try

{

engine.Evaluate("Math.E * Math.PI");

}

catch (ScriptInterruptedException exception)

{

Assert.IsNull(exception.ScriptExceptionAsObject);

throw;

}

});

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate("Math.E * Math.PI"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

[ExpectedException(typeof(ScriptEngineException))]

public void V8ScriptEngine_AccessContext_Default()

{

engine.AddHostObject("test", this);

engine.Execute("test.PrivateMethod()");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_AccessContext_Private()

{

engine.AddHostObject("test", this);

engine.AccessContext = GetType();

engine.Execute("test.PrivateMethod()");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_ContinuationCallback()

{

// V8 can't interrupt code that accesses only native data

engine.AddHostObject("test", new { foo = "bar" });

engine.ContinuationCallback = () => false;

TestUtil.AssertException<OperationCanceledException>(() => engine.Execute("while (true) { var foo = test.foo; }"));

engine.ContinuationCallback = null;

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate("Math.E * Math.PI"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_ContinuationCallback_AwaitDebuggerAndPauseOnStart()

{

engine.Dispose();

engine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDebugging | V8ScriptEngineFlags.AwaitDebuggerAndPauseOnStart) { ContinuationCallback = () => false };

TestUtil.AssertException<OperationCanceledException>(() => engine.Evaluate("Math.E * Math.PI"));

engine.ContinuationCallback = null;

Assert.AreEqual(Math.E * Math.PI, engine.Evaluate("Math.E * Math.PI"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_FileNameExtension()

{

Assert.AreEqual("js", engine.FileNameExtension);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property()

{

var host = new HostFunctions();

engine.Script.host = host;

Assert.AreSame(host, engine.Script.host);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property_Scalar()

{

const int value = 123;

engine.Script.value = value;

Assert.AreEqual(value, engine.Script.value);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property_Enum()

{

const DayOfWeek value = DayOfWeek.Wednesday;

engine.Script.value = value;

Assert.AreEqual(value, engine.Script.value);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property_Struct()

{

var date = new DateTime(2007, 5, 22, 6, 15, 43);

engine.Script.date = date;

Assert.AreEqual(date, engine.Script.date);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Index_ArrayItem()

{

const int index = 5;

engine.Execute("foo = []");

engine.Script.foo[index] = engine.Script.Math.PI;

Assert.AreEqual(Math.PI, engine.Script.foo[index]);

Assert.AreEqual(index + 1, engine.Evaluate("foo.length"));

engine.Script.foo[index] = engine.Script.Math.E;

Assert.AreEqual(Math.E, engine.Script.foo[index]);

Assert.AreEqual(index + 1, engine.Evaluate("foo.length"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Index_Property()

{

const string name = "bar";

engine.Execute("foo = {}");

engine.Script.foo[name] = engine.Script.Math.PI;

Assert.AreEqual(Math.PI, engine.Script.foo[name]);

Assert.AreEqual(Math.PI, engine.Script.foo.bar);

engine.Script.foo[name] = engine.Script.Math.E;

Assert.AreEqual(Math.E, engine.Script.foo[name]);

Assert.AreEqual(Math.E, engine.Script.foo.bar);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Method()

{

engine.Execute("function foo(x) { return x * x; }");

Assert.AreEqual(25, engine.Script.foo(5));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Method_Intrinsic()

{

Assert.AreEqual(Math.E * Math.PI, engine.Script.eval("Math.E * Math.PI"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

Dim host As New HostFunctions

engine.Script.host = host

Assert.AreSame(host, engine.Script.host)

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property_Scalar_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

Dim value = 123

engine.Script.value = value

Assert.AreEqual(value, engine.Script.value)

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property_Enum_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

Dim value = DayOfWeek.Wednesday

engine.Script.value = value

Assert.AreEqual(value, engine.Script.value)

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Property_Struct_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

Dim value As New DateTime(2007, 5, 22, 6, 15, 43)

engine.Script.value = value

Assert.AreEqual(value, engine.Script.value)

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Index_ArrayItem_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

Dim index = 5

engine.Execute(""foo = []"")

engine.Script.foo(index) = engine.Script.Math.PI

rem Assert.AreEqual(Math.PI, engine.Script.foo(index))

rem Assert.AreEqual(index + 1, engine.Evaluate(""foo.length""))

rem engine.Script.foo(index) = engine.Script.Math.E

rem Assert.AreEqual(Math.E, engine.Script.foo(index))

rem Assert.AreEqual(index + 1, engine.Evaluate(""foo.length""))

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Index_Property_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

Dim name = ""bar""

engine.Execute(""foo = {}"")

engine.Script.foo(name) = engine.Script.Math.PI

Assert.AreEqual(Math.PI, engine.Script.foo(name))

Assert.AreEqual(Math.PI, engine.Script.foo.bar)

engine.Script.foo(name) = engine.Script.Math.E

Assert.AreEqual(Math.E, engine.Script.foo(name))

Assert.AreEqual(Math.E, engine.Script.foo.bar)

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Method_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

engine.Execute(""function foo(x) { return x * x; }"")

Assert.AreEqual(25, engine.Script.foo(5))

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Script_Method_Intrinsic_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New V8ScriptEngine

Assert.AreEqual(Math.E * Math.PI, engine.Script.eval(""Math.E * Math.PI""))

End Using

");

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_CollectGarbage()

{

engine.Execute("x = {}; for (i = 0; i < 1024 * 1024; i++) { x = { next: x }; }");

var usedHeapSize = engine.GetRuntimeHeapInfo().UsedHeapSize;

engine.CollectGarbage(true);

Assert.IsTrue(usedHeapSize > engine.GetRuntimeHeapInfo().UsedHeapSize);

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_CollectGarbage_HostObject()

{

// ReSharper disable RedundantAssignment

WeakReference wr = null;

new Action(() =>

{

var x = new object();

wr = new WeakReference(x);

engine.Script.x = x;

x = null;

engine.Script.x = null;

})();

GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);

GC.WaitForPendingFinalizers();

Assert.IsTrue(wr.IsAlive);

engine.CollectGarbage(true);

GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);

GC.WaitForPendingFinalizers();

Assert.IsFalse(wr.IsAlive);

// ReSharper restore RedundantAssignment

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_Parallel()

{

engine.AddHostObject("host", new HostFunctions());

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib"));

const int threadCount = 256;

engine.AddHostObject("list", Enumerable.Range(0, threadCount).ToList());

Assert.AreEqual(threadCount, engine.Evaluate("list.Count"));

var startEvent = new ManualResetEventSlim(false);

var stopEvent = new ManualResetEventSlim(false);

engine.AddHostObject("stopEvent", stopEvent);

ThreadStart body = () =>

{

// ReSharper disable once AccessToDisposedClosure

startEvent.Wait();

engine.Execute("list.RemoveAt(0); if (list.Count == 0) { stopEvent.Set(); }");

};

var threads = Enumerable.Range(0, threadCount).Select(_ => new Thread(body)).ToArray();

threads.ForEach(thread => thread.Start());

startEvent.Set();

stopEvent.Wait();

Assert.AreEqual(0, engine.Evaluate("list.Count"));

threads.ForEach(thread => thread.Join());

startEvent.Dispose();

stopEvent.Dispose();

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_new()

{

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib"));

Assert.IsInstanceOfType(engine.Evaluate("new System.Random()"), typeof(Random));

Assert.IsInstanceOfType(engine.Evaluate("new System.Random(100)"), typeof(Random));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_new_Generic()

{

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib"));

Assert.IsInstanceOfType(engine.Evaluate("new System.Collections.Generic.Dictionary(System.Int32, System.String)"), typeof(Dictionary<int, string>));

Assert.IsInstanceOfType(engine.Evaluate("new System.Collections.Generic.Dictionary(System.Int32, System.String, 100)"), typeof(Dictionary<int, string>));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_new_GenericNested()

{

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib", "System.Core"));

engine.AddHostObject("dict", new Dictionary<int, string> { { 12345, "foo" }, { 54321, "bar" } });

Assert.IsInstanceOfType(engine.Evaluate("vc = new (System.Collections.Generic.Dictionary(System.Int32, System.String).ValueCollection)(dict)"), typeof(Dictionary<int, string>.ValueCollection));

Assert.IsTrue((bool)engine.Evaluate("vc.SequenceEqual(dict.Values)"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_new_Scalar()

{

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib"));

Assert.AreEqual(default(int), engine.Evaluate("new System.Int32"));

Assert.AreEqual(default(int), engine.Evaluate("new System.Int32()"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_new_Enum()

{

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib"));

Assert.AreEqual(default(DayOfWeek), engine.Evaluate("new System.DayOfWeek"));

Assert.AreEqual(default(DayOfWeek), engine.Evaluate("new System.DayOfWeek()"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_new_Struct()

{

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib"));

Assert.AreEqual(default(DateTime), engine.Evaluate("new System.DateTime"));

Assert.AreEqual(default(DateTime), engine.Evaluate("new System.DateTime()"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_new_NoMatch()

{

engine.AddHostObject("clr", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib"));

TestUtil.AssertException<MissingMemberException>(() => engine.Execute("new System.Random('a')"));

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_General()

{

using (var console = new StringWriter())

{

var clr = new HostTypeCollection(type => type != typeof(Console), "mscorlib", "System", "System.Core");

clr.GetNamespaceNode("System").SetPropertyNoCheck("Console", console);

engine.AddHostObject("host", new ExtendedHostFunctions());

engine.AddHostObject("clr", clr);

engine.Execute(generalScript);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

}

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_General_Precompiled()

{

using (var script = engine.Compile(generalScript))

{

using (var console = new StringWriter())

{

var clr = new HostTypeCollection(type => type != typeof(Console), "mscorlib", "System", "System.Core");

clr.GetNamespaceNode("System").SetPropertyNoCheck("Console", console);

engine.AddHostObject("host", new ExtendedHostFunctions());

engine.AddHostObject("clr", clr);

engine.Evaluate(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

console.GetStringBuilder().Clear();

Assert.AreEqual(string.Empty, console.ToString());

engine.Evaluate(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

}

}

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_General_Precompiled_Dual()

{

engine.Dispose();

using (var runtime = new V8Runtime())

{

using (var script = runtime.Compile(generalScript))

{

engine = runtime.CreateScriptEngine();

using (var console = new StringWriter())

{

var clr = new HostTypeCollection(type => type != typeof(Console), "mscorlib", "System", "System.Core");

clr.GetNamespaceNode("System").SetPropertyNoCheck("Console", console);

engine.AddHostObject("host", new ExtendedHostFunctions());

engine.AddHostObject("clr", clr);

engine.Evaluate(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

console.GetStringBuilder().Clear();

Assert.AreEqual(string.Empty, console.ToString());

engine.Evaluate(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

}

engine.Dispose();

engine = runtime.CreateScriptEngine();

using (var console = new StringWriter())

{

var clr = new HostTypeCollection(type => type != typeof(Console), "mscorlib", "System", "System.Core");

clr.GetNamespaceNode("System").SetPropertyNoCheck("Console", console);

engine.AddHostObject("host", new ExtendedHostFunctions());

engine.AddHostObject("clr", clr);

engine.Evaluate(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

console.GetStringBuilder().Clear();

Assert.AreEqual(string.Empty, console.ToString());

engine.Evaluate(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

}

}

}

}

[TestMethod, TestCategory("V8ScriptEngine")]

public void V8ScriptEngine_General_Precompiled_Execute()

{

using (var script = engine.Compile(generalScript))

{

using (var console = new StringWriter())

{

var clr = new HostTypeCollection(type => type != typeof(Console), "mscorlib", "System", "System.Core");

clr.GetNamespaceNode("System").SetPropertyNoCheck("Console", console);

engine.AddHostObject("host", new ExtendedHostFunctions());

engine.AddHostObject("clr", clr);

engine.Execute(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

console.GetStringBuilder().Clear();

Assert.AreEqual(string.Empty, console.ToString());

engine.Execute(script);

Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));

}

}

}