// 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.Threading;

using System.Windows.Threading;

using Microsoft.CSharp.RuntimeBinder;

using Microsoft.ClearScript.Util;

using Microsoft.ClearScript.Windows;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Microsoft.ClearScript.Test

{

[TestClass]

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

public class JScriptEngineTest : ClearScriptTest

{

#region setup / teardown

private JScriptEngine engine;

[TestInitialize]

public void TestInitialize()

{

engine = new JScriptEngine(WindowsScriptEngineFlags.EnableDebugging);

}

[TestCleanup]

public void TestCleanup()

{

engine.Dispose();

BaseTestCleanup();

}

#endregion

#region test methods

// ReSharper disable InconsistentNaming

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AddHostObject()

{

var host = new HostFunctions();

engine.AddHostObject("host", host);

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

}

[TestMethod, TestCategory("JScriptEngine")]

[ExpectedException(typeof(InvalidOperationException))]

public void JScriptEngine_AddHostObject_Scalar()

{

engine.AddHostObject("value", 123);

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AddHostObject_Enum()

{

const DayOfWeek value = DayOfWeek.Wednesday;

engine.AddHostObject("value", value);

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AddHostObject_Struct()

{

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

engine.AddHostObject("date", date);

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

[ExpectedException(typeof(ScriptEngineException))]

public void JScriptEngine_AddHostObject_DefaultAccess()

{

engine.AddHostObject("test", this);

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AddHostObject_PrivateAccess()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_AddHostType()

{

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

[ExpectedException(typeof(ScriptEngineException))]

public void JScriptEngine_AddHostType_DefaultAccess()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AddHostType_PrivateAccess()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AddHostType_Static()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_AddHostType_ByName()

{

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AddHostType_ByNameWithAssembly()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_AddHostType_DefaultName()

{

engine.AddHostType(typeof(Random));

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_Evaluate()

{

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_WithDocumentName()

{

const string documentName = "DoTheMath";

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_DiscardDocument()

{

const string documentName = "DoTheMath";

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_RetainDocument()

{

const string documentName = "DoTheMath";

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_DocumentInfo_WithDocumentName()

{

const string documentName = "DoTheMath";

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_DocumentInfo_WithDocumentUri()

{

const string documentName = "DoTheMath";

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_DocumentInfo_WithDocumentUri_Relative()

{

const string documentName = "DoTheMath";

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_DocumentInfo_DiscardDocument()

{

const string documentName = "DoTheMath";

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Evaluate_DocumentInfo_RetainDocument()

{

const string documentName = "DoTheMath";

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_WithDocumentName()

{

const string documentName = "DoTheMath";

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_DiscardDocument()

{

const string documentName = "DoTheMath";

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_RetainDocument()

{

const string documentName = "DoTheMath";

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_DocumentInfo_WithDocumentName()

{

const string documentName = "DoTheMath";

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_DocumentInfo_WithDocumentUri()

{

const string documentName = "DoTheMath";

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

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_DocumentInfo_WithDocumentUri_Relative()

{

const string documentName = "DoTheMath";

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

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

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_DocumentInfo_DiscardDocument()

{

const string documentName = "DoTheMath";

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.GetDebugDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Execute_DocumentInfo_RetainDocument()

{

const string documentName = "DoTheMath";

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.GetDebugDocumentNames().Any(name => name.StartsWith(documentName, StringComparison.Ordinal)));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ExecuteCommand_EngineConvert()

{

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_ExecuteCommand_var()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ExecuteCommand_HostVariable()

{

engine.Script.host = new HostFunctions();

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Invoke_ScriptFunction()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_Interrupt()

{

var checkpoint = new ManualResetEvent(false);

ThreadPool.QueueUserWorkItem(state =>

{

checkpoint.WaitOne();

engine.Interrupt();

});

engine.AddHostObject("checkpoint", checkpoint);

TestUtil.AssertException<OperationCanceledException>(() => engine.Execute("checkpoint.Set(); while (true) { var foo = 'hello'; }"));

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

}

[TestMethod, TestCategory("JScriptEngine")]

[ExpectedException(typeof(ScriptEngineException))]

public void JScriptEngine_AccessContext_Default()

{

engine.AddHostObject("test", this);

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_AccessContext_Private()

{

engine.AddHostObject("test", this);

engine.AccessContext = GetType();

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ContinuationCallback()

{

engine.ContinuationCallback = () => false;

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

engine.ContinuationCallback = null;

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_FileNameExtension()

{

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Property()

{

var host = new HostFunctions();

engine.Script.host = host;

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Property_Scalar()

{

const int value = 123;

engine.Script.value = value;

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Property_Enum()

{

const DayOfWeek value = DayOfWeek.Wednesday;

engine.Script.value = value;

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_Script_Method()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Method_Intrinsic()

{

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Property_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

Dim host As New HostFunctions

engine.Script.host = host

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

End Using

");

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Property_Scalar_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

Dim value = 123

engine.Script.value = value

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

End Using

");

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Property_Enum_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

Dim value = DayOfWeek.Wednesday

engine.Script.value = value

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

End Using

");

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Property_Struct_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

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("JScriptEngine")]

public void JScriptEngine_Script_Index_ArrayItem_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

Dim 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""))

End Using

");

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Index_Property_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

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("JScriptEngine")]

public void JScriptEngine_Script_Method_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

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

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

End Using

");

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_Script_Method_Intrinsic_VB()

{

TestUtil.InvokeVBTestSub(@"

Using engine As New JScriptEngine

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

End Using

");

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_CollectGarbage()

{

engine.Execute(@"x = []; for (i = 0; i < 1024 * 1024; i++) { x.push(x); }");

engine.CollectGarbage(true);

// can't test JScript GC effectiveness

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_new_NoMatch()

{

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

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

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_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("JScriptEngine")]

public void JScriptEngine_ErrorHandling_SyntaxError()

{

TestUtil.AssertException<ScriptEngineException>(() =>

{

try

{

engine.Execute("function foo() { int c; }");

}

catch (ScriptEngineException exception)

{

TestUtil.AssertValidException(engine, exception);

Assert.IsNull(exception.InnerException);

Assert.IsTrue(exception.Message.StartsWith("Expected", StringComparison.Ordinal));

throw;

}

});

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ErrorHandling_ThrowNonError()

{

TestUtil.AssertException<ScriptEngineException>(() =>

{

try

{

engine.Execute("(function () { throw 123; })()");

}

catch (ScriptEngineException exception)

{

TestUtil.AssertValidException(engine, exception);

Assert.IsNull(exception.InnerException);

Assert.IsTrue(exception.ErrorDetails.Contains(" -> throw 123"));

throw;

}

});

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ErrorHandling_ScriptError()

{

TestUtil.AssertException<ScriptEngineException>(() =>

{

try

{

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

}

catch (ScriptEngineException exception)

{

TestUtil.AssertValidException(engine, exception);

Assert.IsNull(exception.InnerException);

throw;

}

});

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ErrorHandling_HostException()

{

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

TestUtil.AssertException<ScriptEngineException>(() =>

{

try

{

engine.Evaluate("host.proc(0)");

}

catch (ScriptEngineException exception)

{

TestUtil.AssertValidException(engine, exception);

Assert.IsNotNull(exception.InnerException);

var hostException = exception.InnerException;

Assert.IsInstanceOfType(hostException, typeof(RuntimeBinderException));

TestUtil.AssertValidException(hostException);

Assert.IsNull(hostException.InnerException);

Assert.AreEqual(hostException.Message, exception.Message);

throw;

}

});

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ErrorHandling_IgnoredHostException()

{

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

TestUtil.AssertException<ScriptEngineException>(() =>

{

try

{

engine.Execute("try { host.newObj(null); } catch(ex) {} foo = {}; foo();");

}

catch (ScriptEngineException exception)

{

TestUtil.AssertValidException(engine, exception);

Assert.IsNull(exception.InnerException);

throw;

}

});

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ErrorHandling_NestedScriptError()

{

using (var innerEngine = new JScriptEngine("inner", WindowsScriptEngineFlags.EnableDebugging))

{

engine.AddHostObject("engine", innerEngine);

TestUtil.AssertException<ScriptEngineException>(() =>

{

try

{

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

}

catch (ScriptEngineException exception)

{

TestUtil.AssertValidException(engine, exception);

Assert.IsNotNull(exception.InnerException);

var hostException = exception.InnerException;

Assert.IsInstanceOfType(hostException, typeof(TargetInvocationException));

TestUtil.AssertValidException(hostException);

Assert.IsNotNull(hostException.InnerException);

var nestedException = hostException.InnerException as ScriptEngineException;

Assert.IsNotNull(nestedException);

// ReSharper disable once AccessToDisposedClosure

TestUtil.AssertValidException(innerEngine, nestedException);

// ReSharper disable once PossibleNullReferenceException

Assert.IsNull(nestedException.InnerException);

Assert.AreEqual(hostException.Message, exception.Message);

throw;

}

});

}

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_ErrorHandling_NestedHostException()

{

using (var innerEngine = new JScriptEngine("inner", WindowsScriptEngineFlags.EnableDebugging))

{

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

engine.AddHostObject("engine", innerEngine);

TestUtil.AssertException<ScriptEngineException>(() =>

{

try

{

engine.Execute("engine.Evaluate('host.proc(0)')");

}

catch (ScriptEngineException exception)

{

TestUtil.AssertValidException(engine, exception);

Assert.IsNotNull(exception.InnerException);

var hostException = exception.InnerException;

Assert.IsInstanceOfType(hostException, typeof(TargetInvocationException));

TestUtil.AssertValidException(hostException);

Assert.IsNotNull(hostException.InnerException);

var nestedException = hostException.InnerException as ScriptEngineException;

Assert.IsNotNull(nestedException);

// ReSharper disable once AccessToDisposedClosure

TestUtil.AssertValidException(innerEngine, nestedException);

// ReSharper disable once PossibleNullReferenceException

Assert.IsNotNull(nestedException.InnerException);

var nestedHostException = nestedException.InnerException;

Assert.IsInstanceOfType(nestedHostException, typeof(RuntimeBinderException));

TestUtil.AssertValidException(nestedHostException);

Assert.IsNull(nestedHostException.InnerException);

Assert.AreEqual(nestedHostException.Message, nestedException.Message);

Assert.AreEqual(hostException.Message, exception.Message);

throw;

}

});

}

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_CreateInstance()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual("foo bar baz qux", engine.Evaluate("new testObject('foo', 'bar', 'baz', 'qux')"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_CreateInstance_Fail()

{

engine.Script.testObject = new DynamicTestObject();

TestUtil.AssertException<InvalidOperationException>(() => engine.Evaluate("new testObject()"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_Invoke()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual("foo,bar,baz,qux", engine.Evaluate("testObject('foo', 'bar', 'baz', 'qux')"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_Invoke_Fail()

{

engine.Script.testObject = new DynamicTestObject();

TestUtil.AssertException<InvalidOperationException>(() => engine.Evaluate("testObject()"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual("foo-bar-baz-qux", engine.Evaluate("testObject.DynamicMethod('foo', 'bar', 'baz', 'qux')"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_Fail()

{

engine.Script.testObject = new DynamicTestObject();

TestUtil.AssertException<MissingMemberException>(() => engine.Evaluate("testObject.DynamicMethod()"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_FieldOverride()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual("foo.bar.baz.qux", engine.Evaluate("testObject.SomeField('foo', 'bar', 'baz', 'qux')"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_FieldOverride_Fail()

{

engine.Script.testObject = new DynamicTestObject();

TestUtil.AssertException<MissingMemberException>(() => engine.Evaluate("testObject.SomeField()"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_PropertyOverride()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual("foo:bar:baz:qux", engine.Evaluate("testObject.SomeProperty('foo', 'bar', 'baz', 'qux')"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_PropertyOverride_Fail()

{

engine.Script.testObject = new DynamicTestObject();

TestUtil.AssertException<MissingMemberException>(() => engine.Evaluate("testObject.SomeProperty()"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_DynamicOverload()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual("foo;bar;baz;qux", engine.Evaluate("testObject.SomeMethod('foo', 'bar', 'baz', 'qux')"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_NonDynamicOverload()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual(Math.PI, engine.Evaluate("testObject.SomeMethod()"));

}

[TestMethod, TestCategory("JScriptEngine")]

public void JScriptEngine_DynamicHostObject_InvokeMethod_NonDynamic()

{

engine.Script.testObject = new DynamicTestObject();

Assert.AreEqual("Super Bass-O-Matic '76", engine.Evaluate("testObject.ToString()"));

}

[TestMethod, TestCategory("JScriptEngine")]