using System.Collections;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using Jint.Native;
using Jint.Native.Symbol;
using Jint.Runtime;
using Jint.Runtime.Interop;
using Jint.Tests.Runtime.Converters;
using Jint.Tests.Runtime.Domain;
using Jint.Tests.Runtime.TestClasses;
using MongoDB.Bson;
using Shapes;

namespace Jint.Tests.Runtime
{
    public partial class InteropTests : IDisposable
    {
        private readonly Engine _engine;

        public InteropTests()
        {
            _engine = new Engine(cfg => cfg.AllowClr(
                        typeof(Shape).GetTypeInfo().Assembly,
                        typeof(Console).GetTypeInfo().Assembly,
                        typeof(File).GetTypeInfo().Assembly))
                    .SetValue("log", new Action<object>(Console.WriteLine))
                    .SetValue("assert", new Action<bool>(Assert.True))
                    .SetValue("equal", new Action<object, object>(Assert.Equal))
                ;
        }

        void IDisposable.Dispose()
        {
        }

        private void RunTest(string source)
        {
            _engine.Execute(source);
        }

        public class Foo
        {
            public static Bar GetBar()
            {
                return new Bar();
            }
        }

        public class Bar
        {
            public string Test { get; set; } = "123";
        }

        [Fact]
        public void ShouldStringifyNetObjects()
        {
            _engine.SetValue("foo", new Foo());
            var json = _engine.Evaluate("JSON.stringify(foo.GetBar())").AsString();
            Assert.Equal("{\"Test\":\"123\"}", json);
        }


        [Fact]
        public void EngineShouldStringifyADictionary()
        {
            var engine = new Engine();

            var d = new Hashtable();
            d["Values"] = 1;
            engine.SetValue("d", d);

            Assert.Equal("{\"Values\":1}", engine.Evaluate($"JSON.stringify(d)").AsString());
        }

        [Fact]
        public void EngineShouldStringifyADictionaryOfStringAndObjectCorrectly()
        {
            var engine = new Engine();

            var dictionary = new Dictionary<string, object>
            {
                { "foo", 5 },
                { "bar", "A string" }
            };
            engine.SetValue(nameof(dictionary), dictionary);

            var result = engine.Evaluate($"JSON.stringify({nameof(dictionary)})").AsString();
            Assert.Equal("{\"foo\":5,\"bar\":\"A string\"}", result);
        }

        [Fact]
        public void EngineShouldRoundtripParsedJSONBackToStringCorrectly()
        {
            var engine = new Engine();

            const string json = "{\"foo\":5,\"bar\":\"A string\"}";
            var parsed = engine.Evaluate($"JSON.parse('{json}')").ToObject();
            engine.SetValue(nameof(parsed), parsed);

            var result = engine.Evaluate($"JSON.stringify({nameof(parsed)})").AsString();
            Assert.Equal(json, result);
        }

        [Fact]
        public void PrimitiveTypesCanBeSet()
        {
            _engine.SetValue("x", 10);
            _engine.SetValue("y", true);
            _engine.SetValue("z", "foo");

            RunTest(@"
                assert(x === 10);
                assert(y === true);
                assert(z === 'foo');
            ");
        }

        [Fact]
        public void TypePropertyAccess()
        {
            var userClass = new Person();

            var result = new Engine()
                .SetValue("userclass", userClass)
                .Evaluate("userclass.TypeProperty.Name;")
                .AsString();

            Assert.Equal("Person", result);
        }

        [Fact]
        public void CanAccessMemberNamedItem()
        {
            _engine.Execute(@"
                    function item2(arg) {
                        return arg.item2
                    }
                    function item1(arg) {
                        return arg.item
                    }
                    function item3(arg) {
                        return arg.Item
                    }
            ");

            var argument = new Dictionary<string, object>
            {
                { "item2", "item2 value" },
                { "item", "item value" },
                { "Item", "Item value" }
            };

            Assert.Equal("item2 value", _engine.Invoke("item2", argument));
            Assert.Equal("item value", _engine.Invoke("item1", argument));
            Assert.Equal("Item value", _engine.Invoke("item3", argument));

            var company = new Company("Acme Ltd");
            _engine.SetValue("c", company);
            Assert.Equal("item thingie", _engine.Evaluate("c.Item"));
            Assert.Equal("item thingie", _engine.Evaluate("c.item"));
            Assert.Equal("value", _engine.Evaluate("c['key']"));
        }

        [Fact]
        public void DelegatesCanBeSet()
        {
            _engine.SetValue("square", new Func<double, double>(x => x * x));

            RunTest(@"
                assert(square(10) === 100);
            ");
        }

        [Fact]
        public void DelegateWithNullableParameterCanBePassedANull()
        {
            _engine.SetValue("isnull", new Func<double?, bool>(x => x == null));

            RunTest(@"
                assert(isnull(null) === true);
            ");
        }

        [Fact]
        public void DelegateWithObjectParameterCanBePassedANull()
        {
            _engine.SetValue("isnull", new Func<object, bool>(x => x == null));

            RunTest(@"
                assert(isnull(null) === true);
            ");
        }

        [Fact]
        public void DelegateWithNullableParameterCanBePassedAnUndefined()
        {
            _engine.SetValue("isnull", new Func<double?, bool>(x => x == null));

            RunTest(@"
                assert(isnull(undefined) === true);
            ");
        }

        [Fact]
        public void DelegateWithObjectParameterCanBePassedAnUndefined()
        {
            _engine.SetValue("isnull", new Func<object, bool>(x => x == null));

            RunTest(@"
                assert(isnull(undefined) === true);
            ");
        }

        [Fact]
        public void DelegateWithNullableParameterCanBeExcluded()
        {
            _engine.SetValue("isnull", new Func<double?, bool>(x => x == null));

            RunTest(@"
                assert(isnull() === true);
            ");
        }

        [Fact]
        public void DelegateWithObjectParameterCanBeExcluded()
        {
            _engine.SetValue("isnull", new Func<object, bool>(x => x == null));

            RunTest(@"
                assert(isnull() === true);
            ");
        }

        [Fact]
        public void DynamicDelegateCanBeSet()
        {
#if NETFRAMEWORK
            var parameters = new[]
            {
                System.Linq.Expressions.Expression.Parameter(typeof(int)),
                System.Linq.Expressions.Expression.Parameter(typeof(int))
            };
            var exp = System.Linq.Expressions.Expression.Add(parameters[0], parameters[1]);
            var del = System.Linq.Expressions.Expression.Lambda(exp, parameters).Compile();

            _engine.SetValue("add", del);

            RunTest(@"
                assert(add(1,1) === 2);
            ");
#endif
        }

        [Fact]
        public void ExtraParametersAreIgnored()
        {
            _engine.SetValue("passNumber", new Func<int, int>(x => x));

            RunTest(@"
                assert(passNumber(123,'test',{},[],null) === 123);
            ");
        }

        private delegate string callParams(params object[] values);

        private delegate string callArgumentAndParams(string firstParam, params object[] values);

        [Fact]
        public void DelegatesWithParamsParameterCanBeInvoked()
        {
            var a = new A();
            _engine.SetValue("callParams", new callParams(a.Call13));
            _engine.SetValue("callArgumentAndParams", new callArgumentAndParams(a.Call14));

            RunTest(@"
                assert(callParams('1','2','3') === '1,2,3');
                assert(callParams('1') === '1');
                assert(callParams() === '');

                assert(callArgumentAndParams('a','1','2','3') === 'a:1,2,3');
                assert(callArgumentAndParams('a','1') === 'a:1');
                assert(callArgumentAndParams('a') === 'a:');
                assert(callArgumentAndParams() === ':');
            ");
        }

        [Fact]
        public void CanGetObjectProperties()
        {
            var p = new Person
            {
                Name = "Mickey Mouse"
            };

            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.Name === 'Mickey Mouse');
            ");
        }

        [Fact]
        public void CanInvokeObjectMethods()
        {
            var p = new Person
            {
                Name = "Mickey Mouse"
            };

            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.ToString() === 'Mickey Mouse');
            ");
        }

        [Fact]
        public void CanInvokeObjectMethodsWithPascalCase()
        {
            var p = new Person
            {
                Name = "Mickey Mouse"
            };

            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.toString() === 'Mickey Mouse');
            ");
        }

        [Fact]
        public void CanSetObjectProperties()
        {
            var p = new Person
            {
                Name = "Mickey Mouse"
            };

            _engine.SetValue("p", p);

            RunTest(@"
                p.Name = 'Donald Duck';
                assert(p.Name === 'Donald Duck');
            ");

            Assert.Equal("Donald Duck", p.Name);
        }

        [Fact]
        public void CanGetIndexUsingStringKey()
        {
            var dictionary = new Dictionary<string, Person>();
            dictionary.Add("person1", new Person { Name = "Mickey Mouse" });
            dictionary.Add("person2", new Person { Name = "Goofy" });

            _engine.SetValue("dictionary", dictionary);

            RunTest(@"
                assert(dictionary['person1'].Name === 'Mickey Mouse');
                assert(dictionary['person2'].Name === 'Goofy');
            ");
        }

        [Fact]
        public void CanSetIndexUsingStringKey()
        {
            var dictionary = new Dictionary<string, Person>();
            dictionary.Add("person1", new Person { Name = "Mickey Mouse" });
            dictionary.Add("person2", new Person { Name = "Goofy" });

            _engine.SetValue("dictionary", dictionary);

            RunTest(@"
                dictionary['person2'].Name = 'Donald Duck';
                assert(dictionary['person2'].Name === 'Donald Duck');
            ");

            Assert.Equal("Donald Duck", dictionary["person2"].Name);
        }

        [Fact]
        public void CanGetIndexUsingIntegerKey()
        {
            var dictionary = new Dictionary<int, string>();
            dictionary.Add(1, "Mickey Mouse");
            dictionary.Add(2, "Goofy");

            _engine.SetValue("dictionary", dictionary);

            RunTest(@"
                assert(dictionary[1] === 'Mickey Mouse');
                assert(dictionary[2] === 'Goofy');
            ");
        }

        [Fact]
        public void CanSetIndexUsingIntegerKey()
        {
            var dictionary = new Dictionary<int, string>();
            dictionary.Add(1, "Mickey Mouse");
            dictionary.Add(2, "Goofy");

            _engine.SetValue("dictionary", dictionary);

            RunTest(@"
                dictionary[2] = 'Donald Duck';
                assert(dictionary[2] === 'Donald Duck');
            ");

            Assert.Equal("Mickey Mouse", dictionary[1]);
            Assert.Equal("Donald Duck", dictionary[2]);
        }

        private class DoubleIndexedClass
        {
            public int this[int index] => index;

            public string this[string index] => index;
        }

        [Fact]
        public void CanGetIndexUsingBothIntAndStringIndex()
        {
            var dictionary = new DoubleIndexedClass();

            _engine.SetValue("dictionary", dictionary);

            RunTest(@"
                assert(dictionary[1] === 1);
                assert(dictionary['test'] === 'test');
            ");
        }

        [Fact]
        public void CanUseGenericMethods()
        {
            var dictionary = new Dictionary<int, string>();
            dictionary.Add(1, "Mickey Mouse");


            _engine.SetValue("dictionary", dictionary);

            RunTest(@"
                dictionary.Add(2, 'Goofy');
                assert(dictionary[2] === 'Goofy');
            ");

            Assert.Equal("Mickey Mouse", dictionary[1]);
            Assert.Equal("Goofy", dictionary[2]);
        }

        [Fact]
        public void CanUseMultiGenericTypes()
        {
            RunTest(@"
                var type = System.Collections.Generic.Dictionary(System.Int32, System.String);
                var dictionary = new type();
                dictionary.Add(1, 'Mickey Mouse');
                dictionary.Add(2, 'Goofy');
                assert(dictionary[2] === 'Goofy');
            ");
        }

        [Fact]
        public void CanUseIndexOnCollection()
        {
            var collection = new System.Collections.ObjectModel.Collection<string>();
            collection.Add("Mickey Mouse");
            collection.Add("Goofy");

            _engine.SetValue("dictionary", collection);

            RunTest(@"
                dictionary[1] = 'Donald Duck';
                assert(dictionary[1] === 'Donald Duck');
            ");

            Assert.Equal("Mickey Mouse", collection[0]);
            Assert.Equal("Donald Duck", collection[1]);
        }

        [Fact]
        public void CanUseIndexOnList()
        {
            var list = new List<object>(2);
            list.Add("Mickey Mouse");
            list.Add("Goofy");

            _engine.SetValue("list", list);
            _engine.Evaluate("list[1] = 'Donald Duck';");

            Assert.Equal("Donald Duck", _engine.Evaluate("list[1]").AsString());
            Assert.Equal("Mickey Mouse", list[0]);
            Assert.Equal("Donald Duck", list[1]);
        }

        [Fact]
        public void ShouldForOfOnLists()
        {
            _engine.SetValue("list", new List<string> { "a", "b" });

            var result = _engine.Evaluate("var l = ''; for (var x of list) l += x; return l;").AsString();

            Assert.Equal("ab", result);
        }

        [Fact]
        public void ShouldForOfOnArrays()
        {
            _engine.SetValue("arr", new[] { "a", "b" });

            var result = _engine.Evaluate("var l = ''; for (var x of arr) l += x; return l;").AsString();

            Assert.Equal("ab", result);
        }

        [Fact]
        public void ShouldForOfOnDictionaries()
        {
            _engine.SetValue("dict", new Dictionary<string, string> { { "a", "1" }, { "b", "2" } });

            var result = _engine.Evaluate("var l = ''; for (var x of dict) l += x; return l;").AsString();

            Assert.Equal("a,1b,2", result);
        }

        [Fact]
        public void ShouldForOfOnEnumerable()
        {
            _engine.SetValue("c", new Company("name"));

            var result = _engine.Evaluate("var l = ''; for (var x of c.getNameChars()) l += x + ','; return l;").AsString();

            Assert.Equal("n,a,m,e,", result);
        }

        [Fact]
        public void ShouldThrowWhenForOfOnObject()
        {
            // normal objects are not iterable in javascript
            var o = new { A = 1, B = 2 };
            _engine.SetValue("anonymous", o);

            var ex = Assert.Throws<JavaScriptException>(() => _engine.Evaluate("for (var x of anonymous) {}"));
            Assert.Equal("The value is not iterable", ex.Message);
        }

        [Fact]
        public void CanAccessAnonymousObject()
        {
            var p = new
            {
                Name = "Mickey Mouse"
            };

            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.Name === 'Mickey Mouse');
            ");
        }

        [Fact]
        public void CanAccessAnonymousObjectProperties()
        {
            var p = new
            {
                Address = new
                {
                    City = "Mouseton"
                }
            };

            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.Address.City === 'Mouseton');
            ");
        }

        [Fact]
        public void PocosCanReturnJsValueDirectly()
        {
            var o = new
            {
                x = new JsNumber(1),
                y = new JsString("string")
            };

            _engine.SetValue("o", o);

            RunTest(@"
                assert(o.x === 1);
                assert(o.y === 'string');
            ");
        }

        [Fact]
        public void PocosCanReturnObjectInstanceDirectly()
        {
            var x = new JsObject(_engine);
            x.Set("foo", new JsString("bar"));

            var o = new
            {
                x
            };

            _engine.SetValue("o", o);

            RunTest(@"
                assert(o.x.foo === 'bar');
            ");
        }

        [Fact]
        public void DateTimeIsConvertedToDate()
        {
            var o = new
            {
                z = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
            };

            _engine.SetValue("o", o);

            RunTest(@"
                assert(o.z.valueOf() === 0);
            ");
        }

        [Fact]
        public void DateTimeOffsetIsConvertedToDate()
        {
            var o = new
            {
                z = new DateTimeOffset(1970, 1, 1, 0, 0, 0, new TimeSpan())
            };

            _engine.SetValue("o", o);

            RunTest(@"
                assert(o.z.valueOf() === 0);
            ");
        }

        [Fact]
        public void EcmaValuesAreAutomaticallyConvertedWhenSetInPoco()
        {
            var p = new Person
            {
                Name = "foo"
            };

            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.Name === 'foo');
                assert(p.Age === 0);
                p.Name = 'bar';
                p.Age = 10;
            ");

            Assert.Equal("bar", p.Name);
            Assert.Equal(10, p.Age);
        }

        [Fact]
        public void EcmaValuesAreAutomaticallyConvertedToBestMatchWhenSetInPoco()
        {
            var p = new Person
            {
                Name = "foo"
            };

            _engine.SetValue("p", p);

            RunTest(@"
                p.Name = 10;
                p.Age = '20';
            ");

            Assert.Equal("10", p.Name);
            Assert.Equal(20, p.Age);
        }

        [Fact]
        public void ShouldCallInstanceMethodWithoutArgument()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                assert(a.Call1() === 0);
            ");
        }

        [Fact]
        public void ShouldCallInstanceMethodOverloadArgument()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                assert(a.Call1(1) === 1);
            ");
        }

        [Fact]
        public void ShouldCallInstanceMethodWithString()
        {
            var p = new Person();
            _engine.SetValue("a", new A());
            _engine.SetValue("p", p);

            RunTest(@"
                p.Name = a.Call2('foo');
                assert(p.Name === 'foo');
            ");

            Assert.Equal("foo", p.Name);
        }

        [Fact]
        public void CanUseTrim()
        {
            var p = new Person { Name = "Mickey Mouse " };
            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.Name === 'Mickey Mouse ');
                p.Name = p.Name.trim();
                assert(p.Name === 'Mickey Mouse');
            ");

            Assert.Equal("Mickey Mouse", p.Name);
        }

        [Fact]
        public void CanUseMathFloor()
        {
            var p = new Person();
            _engine.SetValue("p", p);

            RunTest(@"
                p.Age = Math.floor(1.6);p
                assert(p.Age === 1);
            ");

            Assert.Equal(1, p.Age);
        }

        [Fact]
        public void CanUseDelegateAsFunction()
        {
            var even = new Func<int, bool>(x => x % 2 == 0);
            _engine.SetValue("even", even);

            RunTest(@"
                assert(even(2) === true);
            ");
        }

        private struct TestStruct
        {
            public int Value;

            public TestStruct(int value)
            {
                Value = value;
            }
        }

        private class TestClass
        {
            public string String { get; set; }
            public int Int { get; set; }
            public int? NullableInt { get; set; }
            public DateTime? NullableDate { get; set; }
            public bool? NullableBool { get; set; }
            public bool Bool { get; set; }
            public TestEnumInt32? NullableEnum { get; set; }
            public TestStruct? NullableStruct { get; set; }

            public void SetBool(bool value)
            {
                Bool = value;
            }

            public void SetInt(int value)
            {
                Int = value;
            }

            public void SetString(string value)
            {
                String = value;
            }
        }

        [Fact]
        public void CanSetNullablePropertiesOnPocos()
        {
            var instance = new TestClass();
            _engine.SetValue("instance", instance);
            _engine.SetValue("TestStruct", typeof(TestStruct));

            RunTest(@"
                instance.NullableInt = 2;
                instance.NullableDate = new Date();
                instance.NullableBool = true;
                instance.NullableEnum = 1;
                instance.NullableStruct = new TestStruct(5);

                assert(instance.NullableInt===2);
                assert(instance.NullableDate!=null);
                assert(instance.NullableBool===true);
                assert(instance.NullableEnum===1);
                assert(instance.NullableStruct.Value===5);
            ");
        }

        private class ReadOnlyList : IReadOnlyList<Person>
        {
            private readonly Person[] _data;

            public ReadOnlyList(params Person[] data)
            {
                _data = data;
            }

            public IEnumerator<Person> GetEnumerator()
            {
                return ((IEnumerable<Person>) _data).GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return _data.GetEnumerator();
            }

            public int Count => _data.Length;

            public Person this[int index] => _data[index];
        }

        [Fact]
        public void CanAddArrayPrototypeForArrayLikeClrObjects()
        {
            var e = new Engine(cfg => cfg
                .AllowClr(typeof(Person).Assembly)
            );

            var person = new Person
            {
                Age = 12,
                Name = "John"
            };

            dynamic obj = new
            {
                values = new ReadOnlyList(person)
            };

            e.SetValue("o", obj);

            var name = e.Evaluate("o.values.filter(x => x.age == 12)[0].name").ToString();
            Assert.Equal("John", name);
        }


        [Fact]
        public void CanSetIsConcatSpreadableForArrays()
        {
            var engine = new Engine();

            engine
                .SetValue("list1", new List<string> { "A", "B", "C" })
                .SetValue("list2", new List<string> { "D", "E", "F" })
                .Execute("var array1 = ['A', 'B', 'C'];")
                .Execute("var array2 = ['D', 'E', 'F'];");

            Assert.True(engine.Evaluate("list1[Symbol.isConcatSpreadable] = true; list1[Symbol.isConcatSpreadable];").AsBoolean());
            Assert.True(engine.Evaluate("list2[Symbol.isConcatSpreadable] = true; list2[Symbol.isConcatSpreadable];").AsBoolean());

            Assert.Equal("[\"A\",\"B\",\"C\"]", engine.Evaluate("JSON.stringify(array1);"));
            Assert.Equal("[\"D\",\"E\",\"F\"]", engine.Evaluate("JSON.stringify(array2);"));
            Assert.Equal("[\"A\",\"B\",\"C\"]", engine.Evaluate("JSON.stringify(list1);"));
            Assert.Equal("[\"D\",\"E\",\"F\"]", engine.Evaluate("JSON.stringify(list2);"));

            const string Concatenated = "[\"A\",\"B\",\"C\",\"D\",\"E\",\"F\"]";
            Assert.Equal(Concatenated, engine.Evaluate("JSON.stringify(array1.concat(array2));"));
            Assert.Equal(Concatenated, engine.Evaluate("JSON.stringify(array1.concat(list2));"));
            Assert.Equal(Concatenated, engine.Evaluate("JSON.stringify(list1.concat(array2));"));
            Assert.Equal(Concatenated, engine.Evaluate("JSON.stringify(list1.concat(list2));"));

            Assert.False(engine.Evaluate("list1[Symbol.isConcatSpreadable] = false; list1[Symbol.isConcatSpreadable];").AsBoolean());
            Assert.False(engine.Evaluate("list2[Symbol.isConcatSpreadable] = false; list2[Symbol.isConcatSpreadable];").AsBoolean());

            Assert.Equal("[[\"A\",\"B\",\"C\"]]", engine.Evaluate("JSON.stringify([].concat(list1));"));
            Assert.Equal("[[\"A\",\"B\",\"C\"],[\"D\",\"E\",\"F\"]]", engine.Evaluate("JSON.stringify(list1.concat(list2));"));
        }

        [Fact]
        public void ShouldConvertArrayToArrayInstance()
        {
            var result = _engine
                .SetValue("values", new[] { 1, 2, 3, 4, 5, 6 })
                .Evaluate("values.filter(function(x){ return x % 2 == 0; })");

            var parts = result.ToObject();

            Assert.True(parts.GetType().IsArray);
            Assert.Equal(3, ((object[]) parts).Length);
            Assert.Equal(2d, ((object[]) parts)[0]);
            Assert.Equal(4d, ((object[]) parts)[1]);
            Assert.Equal(6d, ((object[]) parts)[2]);
        }

        [Fact]
        public void ShouldConvertListsToArrayInstance()
        {
            var result = _engine
                .SetValue("values", new List<object> { 1, 2, 3, 4, 5, 6 })
                .Evaluate("new Array(values).filter(function(x){ return x % 2 == 0; })");

            var parts = result.ToObject();

            Assert.True(parts.GetType().IsArray);
            Assert.Equal(3, ((object[]) parts).Length);
            Assert.Equal(2d, ((object[]) parts)[0]);
            Assert.Equal(4d, ((object[]) parts)[1]);
            Assert.Equal(6d, ((object[]) parts)[2]);
        }

        [Fact]
        public void ShouldConvertArrayInstanceToArray()
        {
            var parts = _engine.Evaluate("'foo@bar.com'.split('@');").ToObject();

            Assert.True(parts.GetType().IsArray);
            Assert.Equal(2, ((object[]) parts).Length);
            Assert.Equal("foo", ((object[]) parts)[0]);
            Assert.Equal("bar.com", ((object[]) parts)[1]);
        }

        [Fact]
        public void ShouldLoopWithNativeEnumerator()
        {
            JsValue adder(JsValue argValue)
            {
                var args = argValue.AsArray();
                double sum = 0;
                foreach (var item in args)
                {
                    if (item.IsNumber())
                    {
                        sum += item.AsNumber();
                    }
                }

                return sum;
            }

            var result = _engine.SetValue("getSum", new Func<JsValue, JsValue>(adder))
                .Evaluate("getSum([1,2,3]);");

            Assert.True(result == 6);
        }

        [Fact]
        public void ShouldConvertBooleanInstanceToBool()
        {
            var value = _engine.Evaluate("new Boolean(true)").ToObject();

            Assert.Equal(typeof(bool), value.GetType());
            Assert.Equal(true, value);
        }

        [Fact]
        public void ShouldAllowBooleanCoercion()
        {
            var engine = new Engine(options => { options.Interop.ValueCoercion = ValueCoercionType.Boolean; });

            engine.SetValue("o", new TestClass());
            Assert.True(engine.Evaluate("o.Bool = 1; return o.Bool;").AsBoolean());
            Assert.True(engine.Evaluate("o.Bool = 'dog'; return o.Bool;").AsBoolean());
            Assert.True(engine.Evaluate("o.Bool = {}; return o.Bool;").AsBoolean());
            Assert.False(engine.Evaluate("o.Bool = 0; return o.Bool;").AsBoolean());
            Assert.False(engine.Evaluate("o.Bool = ''; return o.Bool;").AsBoolean());
            Assert.False(engine.Evaluate("o.Bool = null; return o.Bool;").AsBoolean());
            Assert.False(engine.Evaluate("o.Bool = undefined; return o.Bool;").AsBoolean());

            engine.Evaluate("class MyClass { valueOf() { return 42; } }");
            Assert.Equal(true, engine.Evaluate("let obj = new MyClass(); o.Bool = obj; return o.Bool;").AsBoolean());

            engine.SetValue("func3", new Action<bool, bool, bool>((param1, param2, param3) =>
            {
                Assert.True(param1);
                Assert.True(param2);
                Assert.True(param3);
            }));
            engine.Evaluate("func3(true, obj, [ 1, 2, 3])");

            Assert.Equal(true, engine.Evaluate("o.SetBool(42); return o.Bool;").AsBoolean());
            Assert.Equal(true, engine.Evaluate("o.SetBool(obj); return o.Bool;").AsBoolean());
            Assert.Equal(true, engine.Evaluate("o.SetBool([ 1, 2, 3].length); return o.Bool;").AsBoolean());
        }

        [Fact]
        public void ShouldAllowNumberCoercion()
        {
            var engine = new Engine(options => { options.Interop.ValueCoercion = ValueCoercionType.Number; });

            engine.SetValue("o", new TestClass());
            Assert.Equal(1, engine.Evaluate("o.Int = true; return o.Int;").AsNumber());
            Assert.Equal(0, engine.Evaluate("o.Int = false; return o.Int;").AsNumber());

            engine.Evaluate("class MyClass { valueOf() { return 42; } }");
            Assert.Equal(42, engine.Evaluate("let obj = new MyClass(); o.Int = obj; return o.Int;").AsNumber());

            // but null and undefined should be injected as nulls to nullable objects
            Assert.True(engine.Evaluate("o.NullableInt = null; return o.NullableInt;").IsNull());
            Assert.True(engine.Evaluate("o.NullableInt = undefined; return o.NullableInt;").IsNull());

            engine.SetValue("func3", new Action<int, double, long>((param1, param2, param3) =>
            {
                Assert.Equal(1, param1);
                Assert.Equal(42, param2);
                Assert.Equal(3, param3);
            }));
            engine.Evaluate("func3(true, obj, [ 1, 2, 3].length)");

            Assert.Equal(1, engine.Evaluate("o.SetInt(true); return o.Int;").AsNumber());
            Assert.Equal(42, engine.Evaluate("o.SetInt(obj); return o.Int;").AsNumber());
            Assert.Equal(3, engine.Evaluate("o.SetInt([ 1, 2, 3].length); return o.Int;").AsNumber());
        }

        [Fact]
        public void ShouldAllowStringCoercion()
        {
            var engine = new Engine(options => { options.Interop.ValueCoercion = ValueCoercionType.String; });

            // basic premise, booleans in JS are lower-case, so should the the toString under interop
            Assert.Equal("true", engine.Evaluate("'' + true").AsString());

            engine.SetValue("o", new TestClass());
            Assert.Equal("false", engine.Evaluate("'' + o.Bool").AsString());

            Assert.Equal("true", engine.Evaluate("o.Bool = true; o.String = o.Bool; return o.String;").AsString());

            Assert.Equal("true", engine.Evaluate("o.String = true; return o.String;").AsString());

            engine.SetValue("func1", new Func<bool>(() => true));
            Assert.Equal("true", engine.Evaluate("'' + func1()").AsString());

            engine.SetValue("func2", new Func<JsValue>(() => JsBoolean.True));
            Assert.Equal("true", engine.Evaluate("'' + func2()").AsString());

            // but null and undefined should be injected as nulls to c# objects
            Assert.True(engine.Evaluate("o.String = null; return o.String;").IsNull());
            Assert.True(engine.Evaluate("o.String = undefined; return o.String;").IsNull());

            Assert.Equal("1,2,3", engine.Evaluate("o.String = [ 1, 2, 3 ]; return o.String;").AsString());

            engine.Evaluate("class MyClass { toString() { return 'hello world'; } }");
            Assert.Equal("hello world", engine.Evaluate("let obj = new MyClass(); o.String = obj; return o.String;").AsString());

            engine.SetValue("func3", new Action<string, string, string>((param1, param2, param3) =>
            {
                Assert.Equal("true", param1);
                Assert.Equal("hello world", param2);
                Assert.Equal("1,2,3", param3);
            }));
            engine.Evaluate("func3(true, obj, [ 1, 2, 3])");

            Assert.Equal("true", engine.Evaluate("o.SetString(true); return o.String;").AsString());
            Assert.Equal("hello world", engine.Evaluate("o.SetString(obj); return o.String;").AsString());
            Assert.Equal("1,2,3", engine.Evaluate("o.SetString([ 1, 2, 3]); return o.String;").AsString());
        }

        [Fact]
        public void ShouldConvertDateInstanceToDateTime()
        {
            var result = _engine.Evaluate("new Date(0)");
            var value = result.ToObject() is DateTime ? (DateTime) result.ToObject() : default;

            Assert.Equal(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc), value);
            Assert.Equal(DateTimeKind.Utc, value.Kind);
        }

        [Fact]
        public void ShouldConvertDateInstanceToLocalDateTime()
        {
            TimeZoneInfo timeZone;
            try
            {
                timeZone = TimeZoneInfo.FindSystemTimeZoneById("Europe/Helsinki");
            }
            catch (TimeZoneNotFoundException)
            {
                timeZone = TimeZoneInfo.FindSystemTimeZoneById("FLE Standard Time");
            }

            var engine = new Engine(options =>
            {
                options.TimeZone = timeZone;
                options.Interop.DateTimeKind = DateTimeKind.Local;
            });

            var result = engine.Evaluate("new Date(0)");
            var value = result.ToObject() is DateTime ? (DateTime) result.ToObject() : default;

            Assert.Equal(new DateTime(1970, 1, 1, 2, 0, 0, DateTimeKind.Local), value);
            Assert.Equal(DateTimeKind.Local, value.Kind);
        }

        [Fact]
        public void ShouldConvertNumberInstanceToDouble()
        {
            var result = _engine.Evaluate("new Number(10)");
            var value = result.ToObject();

            Assert.Equal(typeof(double), value.GetType());
            Assert.Equal(10d, value);
        }

        [Fact]
        public void ShouldConvertStringInstanceToString()
        {
            var value = _engine.Evaluate("new String('foo')").ToObject();

            Assert.Equal(typeof(string), value.GetType());
            Assert.Equal("foo", value);
        }

        [Fact]
        public void ShouldNotTryToConvertCompatibleTypes()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                assert(a.Call3('foo') === 'foo');
                assert(a.Call3(1) === '1');
            ");
        }

        [Fact]
        public void ShouldNotTryToConvertDerivedTypes()
        {
            _engine.SetValue("a", new A());
            _engine.SetValue("p", new Person { Name = "Mickey" });

            RunTest(@"
                assert(a.Call4(p) === 'Mickey');
            ");
        }

        [Fact]
        public void ShouldExecuteFunctionCallBackAsDelegate()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                assert(a.Call5(function(a,b){ return a+b }) === '1foo');
            ");
        }

        [Fact]
        public void ShouldExecuteFunctionCallBackAsFuncAndThisCanBeAssigned()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                assert(a.Call6(function(a,b){ return this+a+b }) === 'bar1foo');
            ");
        }

        [Fact]
        public void ShouldExecuteFunctionCallBackAsPredicate()
        {
            _engine.SetValue("a", new A());

            // Func<>
            RunTest(@"
                assert(a.Call8(function(){ return 'foo'; }) === 'foo');
            ");
        }

        [Fact]
        public void ShouldExecuteFunctionWithParameterCallBackAsPredicate()
        {
            _engine.SetValue("a", new A());

            // Func<,>
            RunTest(@"
                assert(a.Call7('foo', function(a){ return a === 'foo'; }) === true);
            ");
        }

        [Fact]
        public void ShouldExecuteActionCallBackAsPredicate()
        {
            _engine.SetValue("a", new A());

            // Action
            RunTest(@"
                var value;
                a.Call9(function(){ value = 'foo'; });
                assert(value === 'foo');
            ");
        }

        [Fact]
        public void ShouldExecuteActionWithParameterCallBackAsPredicate()
        {
            _engine.SetValue("a", new A());

            // Action<>
            RunTest(@"
                var value;
                a.Call10('foo', function(b){ value = b; });
                assert(value === 'foo');
            ");
        }

        [Fact]
        public void ShouldExecuteActionWithMultipleParametersCallBackAsPredicate()
        {
            _engine.SetValue("a", new A());

            // Action<,>
            RunTest(@"
                var value;
                a.Call11('foo', 'bar', function(a,b){ value = a + b; });
                assert(value === 'foobar');
            ");
        }

        [Fact]
        public void ShouldExecuteFunc()
        {
            _engine.SetValue("a", new A());

            // Func<int, int>
            RunTest(@"
                var result = a.Call12(42, function(a){ return a + a; });
                assert(result === 84);
            ");
        }

        [Fact]
        public void ShouldExecuteActionCallbackOnEventChanged()
        {
            var collection = new System.Collections.ObjectModel.ObservableCollection<string>();
            Assert.True(collection.Count == 0);

            _engine.SetValue("collection", collection);

            RunTest(@"
                var callCount = 0;
                var handler = function(sender, eventArgs) { callCount++; } ;
                collection.add_CollectionChanged(handler);
                collection.Add('test');
                collection.remove_CollectionChanged(handler);
                collection.Add('test');

                var json = JSON.stringify(Object.keys(handler));
            ");

            var callCount = (int) _engine.GetValue("callCount").AsNumber();
            Assert.Equal(1, callCount);
            Assert.Equal(2, collection.Count);

            // make sure our delegate holder is hidden
            Assert.Equal("[]", _engine.Evaluate("json"));
        }

        [Fact]
        public void ShouldUseSystemIO()
        {
            RunTest(@"
                var filename = System.IO.Path.GetTempFileName();
                var sw = System.IO.File.CreateText(filename);
                sw.Write('Hello World');
                sw.Dispose();

                var content = System.IO.File.ReadAllText(filename);
                System.Console.WriteLine(content);

                assert(content === 'Hello World');
            ");
        }

        [Fact]
        public void ShouldImportNamespace()
        {
            RunTest(@"
                var Shapes = importNamespace('Shapes');
                var circle = new Shapes.Circle();
                assert(circle.Radius === 0);
                assert(circle.Perimeter() === 0);
            ");
        }

        [Fact]
        public void ShouldConstructReferenceTypeWithParameters()
        {
            RunTest(@"
                var Shapes = importNamespace('Shapes');
                var circle = new Shapes.Circle(1);
                assert(circle.Radius === 1);
                assert(circle.Perimeter() === Math.PI);
            ");
        }

        [Fact]
        public void ShouldConstructValueTypeWithoutParameters()
        {
            RunTest(@"
                var guid = new System.Guid();
                assert('00000000-0000-0000-0000-000000000000' === guid.ToString());
            ");
        }

        [Fact]
        public void ShouldInvokeAFunctionByName()
        {
            RunTest(@"
                function add(x, y) { return x + y; }
            ");

            Assert.Equal(3, _engine.Invoke("add", 1, 2));
        }

        [Fact]
        public void ShouldNotInvokeNonFunctionValue()
        {
            RunTest(@"
                var x= 10;
            ");

            Assert.Throws<JavaScriptException>(() => _engine.Invoke("x", 1, 2));
        }

        [Fact]
        public void CanGetField()
        {
            var o = new ClassWithField
            {
                Field = "Mickey Mouse"
            };

            _engine.SetValue("o", o);

            RunTest(@"
                assert(o.Field === 'Mickey Mouse');
            ");
        }

        [Fact]
        public void CanSetField()
        {
            var o = new ClassWithField();

            _engine.SetValue("o", o);

            RunTest(@"
                o.Field = 'Mickey Mouse';
                assert(o.Field === 'Mickey Mouse');
            ");

            Assert.Equal("Mickey Mouse", o.Field);
        }

        [Fact]
        public void CanGetStaticField()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var statics = domain.ClassWithStaticFields;
                assert(statics.Get == 'Get');
            ");
        }

        [Fact]
        public void CanSetStaticField()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var statics = domain.ClassWithStaticFields;
                statics.Set = 'hello';
                assert(statics.Set == 'hello');
            ");

            Assert.Equal(ClassWithStaticFields.Set, "hello");
        }

        [Fact]
        public void CanGetStaticAccessor()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var statics = domain.ClassWithStaticFields;
                assert(statics.Getter == 'Getter');
            ");
        }

        [Fact]
        public void CanSetStaticAccessor()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var statics = domain.ClassWithStaticFields;
                statics.Setter = 'hello';
                assert(statics.Setter == 'hello');
            ");

            Assert.Equal(ClassWithStaticFields.Setter, "hello");
        }

        [Fact]
        public void CantSetStaticReadonly()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var statics = domain.ClassWithStaticFields;
                statics.Readonly = 'hello';
                assert(statics.Readonly == 'Readonly');
            ");

            Assert.Equal(ClassWithStaticFields.Readonly, "Readonly");
        }

        [Fact]
        public void CanSetCustomConverters()
        {
            var engine1 = new Engine();
            engine1.SetValue("p", new { Test = true });
            engine1.Execute("var result = p.Test;");
            Assert.True((bool) engine1.GetValue("result").ToObject());

            var engine2 = new Engine(o => o.AddObjectConverter(new NegateBoolConverter()));
            engine2.SetValue("p", new { Test = true });
            engine2.Execute("var result = p.Test;");
            Assert.False((bool) engine2.GetValue("result").ToObject());
        }

        [Fact]
        public void CanConvertEnumsToString()
        {
            var engine1 = new Engine(o => o.AddObjectConverter(new EnumsToStringConverter()))
                .SetValue("assert", new Action<bool>(Assert.True));
            engine1.SetValue("p", new { Comparison = StringComparison.CurrentCulture });
            engine1.Execute("assert(p.Comparison === 'CurrentCulture');");
            engine1.Execute("var result = p.Comparison;");
            Assert.Equal("CurrentCulture", (string) engine1.GetValue("result").ToObject());
        }

        [Fact]
        public void CanUserIncrementOperator()
        {
            var p = new Person
            {
                Age = 1
            };

            _engine.SetValue("p", p);

            RunTest(@"
                assert(++p.Age === 2);
            ");

            Assert.Equal(2, p.Age);
        }

        [Fact]
        public void CanOverwriteValues()
        {
            _engine.SetValue("x", 3);
            _engine.SetValue("x", 4);

            RunTest(@"
                assert(x === 4);
            ");
        }

        [Fact]
        public void ShouldCreateGenericType()
        {
            RunTest(@"
                var ListOfString = System.Collections.Generic.List(System.String);
                var list = new ListOfString();
                list.Add('foo');
                list.Add(1);
                assert(2 === list.Count);
            ");
        }

        [Fact]
        public void EnumComparesByName()
        {
            var o = new
            {
                r = Colors.Red,
                b = Colors.Blue,
                g = Colors.Green,
                b2 = Colors.Red
            };

            _engine.SetValue("o", o);
            _engine.SetValue("assertFalse", new Action<bool>(Assert.False));

            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var colors = domain.Colors;
                assert(o.r === colors.Red);
                assert(o.g === colors.Green);
                assert(o.b === colors.Blue);
                assertFalse(o.b2 === colors.Blue);
            ");
        }

        [Fact]
        public void ShouldSetEnumProperty()
        {
            var s = new Circle
            {
                Color = Colors.Red
            };

            _engine.SetValue("s", s);

            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var colors = domain.Colors;

                s.Color = colors.Blue;
                assert(s.Color === colors.Blue);
            ");

            _engine.SetValue("s", s);

            RunTest(@"
                s.Color = colors.Blue | colors.Green;
                assert(s.Color === colors.Blue | colors.Green);
            ");

            Assert.Equal(Colors.Blue | Colors.Green, s.Color);
        }

        private enum TestEnumInt32 : int
        {
            None,
            One = 1,
            Min = int.MaxValue,
            Max = int.MaxValue
        }

        private enum TestEnumUInt32 : uint
        {
            None,
            One = 1,
            Min = uint.MaxValue,
            Max = uint.MaxValue
        }

        private enum TestEnumInt64 : long
        {
            None,
            One = 1,
            Min = long.MaxValue,
            Max = long.MaxValue
        }

        private enum TestEnumUInt64 : ulong
        {
            None,
            One = 1,
            Min = ulong.MaxValue,
            Max = ulong.MaxValue
        }

        private void TestEnum<T>(T enumValue)
        {
            var i = Convert.ChangeType(enumValue, Enum.GetUnderlyingType(typeof(T)));
            var s = Convert.ToString(i, CultureInfo.InvariantCulture);
            var o = new Tuple<T>(enumValue);
            _engine.SetValue("o", o);
            RunTest("assert(o.Item1 === " + s + ");");
        }

        [Fact]
        public void ShouldWorkWithEnumInt32()
        {
            TestEnum(TestEnumInt32.None);
            TestEnum(TestEnumInt32.One);
            TestEnum(TestEnumInt32.Min);
            TestEnum(TestEnumInt32.Max);
        }

        [Fact]
        public void ShouldWorkWithEnumUInt32()
        {
            TestEnum(TestEnumUInt32.None);
            TestEnum(TestEnumUInt32.One);
            TestEnum(TestEnumUInt32.Min);
            TestEnum(TestEnumUInt32.Max);
        }

        [Fact]
        public void ShouldWorkWithEnumInt64()
        {
            TestEnum(TestEnumInt64.None);
            TestEnum(TestEnumInt64.One);
            TestEnum(TestEnumInt64.Min);
            TestEnum(TestEnumInt64.Max);
        }

        [Fact]
        public void ShouldWorkWithEnumUInt64()
        {
            TestEnum(TestEnumUInt64.None);
            TestEnum(TestEnumUInt64.One);
            TestEnum(TestEnumUInt64.Min);
            TestEnum(TestEnumUInt64.Max);
        }

        [Fact]
        public void EnumIsConvertedToNumber()
        {
            var o = new
            {
                r = Colors.Red,
                b = Colors.Blue,
                g = Colors.Green
            };

            _engine.SetValue("o", o);

            RunTest(@"
                assert(o.r === 0);
                assert(o.g === 1);
                assert(o.b === 10);
            ");
        }

        [Fact]
        public void ShouldConvertToEnum()
        {
            var s = new Circle
            {
                Color = Colors.Red
            };

            _engine.SetValue("s", s);

            RunTest(@"
                assert(s.Color === 0);
                s.Color = 10;
                assert(s.Color === 10);
            ");

            _engine.SetValue("s", s);

            RunTest(@"
                s.Color = 11;
                assert(s.Color === 11);
            ");

            Assert.Equal(Colors.Blue | Colors.Green, s.Color);
        }

        [Fact]
        public void ShouldUseExplicitPropertyGetter()
        {
            _engine.SetValue("c", new Company("ACME"));
            Assert.Equal("ACME", _engine.Evaluate("c.Name"));
        }

        [Fact]
        public void ShouldUseExplicitIndexerPropertyGetter()
        {
            var company = new Company("ACME");
            ((ICompany) company)["Foo"] = "Bar";
            _engine.SetValue("c", company);
            Assert.Equal("Bar", _engine.Evaluate("c.Foo"));
        }

        [Fact]
        public void ShouldUseExplicitPropertySetter()
        {
            _engine.SetValue("c", new Company("ACME"));
            Assert.Equal("Foo", _engine.Evaluate("c.Name = 'Foo'; c.Name;"));
        }

        [Fact]
        public void ShouldUseExplicitIndexerPropertySetter()
        {
            var company = new Company("ACME");
            ((ICompany) company)["Foo"] = "Bar";
            _engine.SetValue("c", company);

            RunTest(@"
                c.Foo = 'Baz';
                assert(c.Foo === 'Baz');
            ");
        }

        [Fact]
        public void ShouldUseExplicitMethod()
        {
            _engine.SetValue("c", new Company("ACME"));

            RunTest(@"
                assert(0 === c.CompareTo(c));
            ");
        }

        [Fact]
        public void ShouldCallInstanceMethodWithParams()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                assert(a.Call13('1','2','3') === '1,2,3');
                assert(a.Call13('1') === '1');
                assert(a.Call13(1) === '1');
                assert(a.Call13() === '');

                assert(a.Call14('a','1','2','3') === 'a:1,2,3');
                assert(a.Call14('a','1') === 'a:1');
                assert(a.Call14('a') === 'a:');

                function call13wrapper(){ return a.Call13.apply(a, Array.prototype.slice.call(arguments)); }
                assert(call13wrapper('1','2','3') === '1,2,3');

                assert(a.Call13('1','2','3') === a.Call13(['1','2','3']));
            ");
        }

        [Fact]
        public void ShouldCallInstanceMethodWithJsValueParams()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                assert(a.Call16('1','2','3') === '1,2,3');
                assert(a.Call16('1') === '1');
                assert(a.Call16(1) === '1');
                assert(a.Call16() === '');
                assert(a.Call16('1','2','3') === a.Call16(['1','2','3']));
            ");
        }

        [Fact]
        public void NullValueAsArgumentShouldWork()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                var x = a.Call2(null);
                assert(x === null);
            ");
        }

        [Fact]
        public void ShouldSetPropertyToNull()
        {
            var p = new Person { Name = "Mickey" };
            _engine.SetValue("p", p);

            RunTest(@"
                assert(p.Name != null);
                p.Name = null;
                assert(p.Name == null);
            ");

            Assert.True(p.Name == null);
        }

        [Fact]
        public void ShouldCallMethodWithNull()
        {
            _engine.SetValue("a", new A());

            RunTest(@"
                a.Call15(null);
                var result = a.Call2(null);
                assert(result == null);
            ");
        }

        [Fact]
        public void ShouldReturnUndefinedProperty()
        {
            _engine.SetValue("uo", new { foo = "bar" });
            _engine.SetValue("ud", new Dictionary<string, object> { { "foo", "bar" } });
            _engine.SetValue("ul", new List<string> { "foo", "bar" });

            RunTest(@"
                assert(!uo.undefinedProperty);
                assert(!ul[5]);
                assert(!ud.undefinedProperty);
            ");
        }

        private class FailingObject2
        {
            public int this[int index] => throw new ArgumentException("index is bad", nameof(index));
        }

        [Fact]
        public void ShouldPropagateIndexerExceptions()
        {
            var engine = new Engine();
            engine.Execute(@"function f2(obj) { return obj[1]; }");

            var failingObject = new FailingObject2();
            Assert.Throws<ArgumentException>(() => engine.Invoke("f2", failingObject));
        }

        [Fact]
        public void ShouldAutomaticallyConvertArraysToFindBestInteropResolution()
        {
            _engine.SetValue("a", new ArrayConverterTestClass());
            _engine.SetValue("item1", new ArrayConverterItem(1));
            _engine.SetValue("item2", new ArrayConverterItem(2));

            RunTest(@"
                assert(a.MethodAcceptsArrayOfInt([false, '1', 2]) === a.MethodAcceptsArrayOfInt([0, 1, 2]));
                assert(a.MethodAcceptsArrayOfStrings(['1', 2]) === a.MethodAcceptsArrayOfStrings([1, 2]));
                assert(a.MethodAcceptsArrayOfBool(['1', 0]) === a.MethodAcceptsArrayOfBool([true, false]));

                assert(a.MethodAcceptsArrayOfStrings([item1, item2]) === a.MethodAcceptsArrayOfStrings(['1', '2']));
                assert(a.MethodAcceptsArrayOfInt([item1, item2]) === a.MethodAcceptsArrayOfInt([1, 2]));
            ");
        }

        [Fact]
        public void ShouldImportNamespaceNestedType()
        {
            RunTest(@"
                var shapes = importNamespace('Shapes.Circle');
                var kinds = shapes.Kind;
                assert(kinds.Unit === 0);
                assert(kinds.Ellipse === 1);
                assert(kinds.Round === 5);
            ");
        }

        [Fact]
        public void ShouldImportNamespaceNestedNestedType()
        {
            RunTest(@"
                var meta = importNamespace('Shapes.Circle.Meta');
                var usages = meta.Usage;
                assert(usages.Public === 0);
                assert(usages.Private === 1);
                assert(usages.Internal === 11);
            ");
        }

        [Fact]
        public void ShouldGetNestedTypeFromParentType()
        {
            RunTest(@"
                var Shapes = importNamespace('Shapes');
                var usages = Shapes.Circle.Meta.Usage;
                assert(usages.Public === 0);
                assert(usages.Private === 1);
                assert(usages.Internal === 11);
            ");
        }

        [Fact]
        public void ShouldGetNestedNestedProp()
        {
            RunTest(@"
                var meta = importNamespace('Shapes.Circle');
                var m = new meta.Meta();
                assert(m.Description === 'descp');
            ");
        }

        [Fact]
        public void ShouldSetNestedNestedProp()
        {
            RunTest(@"
                var meta = importNamespace('Shapes.Circle');
                var m = new meta.Meta();
                m.Description = 'hello';
                assert(m.Description === 'hello');
            ");
        }

        [Fact]
        public void CanGetStaticNestedField()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain.Nested');
                var statics = domain.ClassWithStaticFields;
                assert(statics.Get == 'Get');
            ");
        }

        [Fact]
        public void CanSetStaticNestedField()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain.Nested');
                var statics = domain.ClassWithStaticFields;
                statics.Set = 'hello';
                assert(statics.Set == 'hello');
            ");

            Assert.Equal(Nested.ClassWithStaticFields.Set, "hello");
        }

        [Fact]
        public void CanGetStaticNestedAccessor()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain.Nested');
                var statics = domain.ClassWithStaticFields;
                assert(statics.Getter == 'Getter');
            ");
        }

        [Fact]
        public void CanSetStaticNestedAccessor()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain.Nested');
                var statics = domain.ClassWithStaticFields;
                statics.Setter = 'hello';
                assert(statics.Setter == 'hello');
            ");

            Assert.Equal(Nested.ClassWithStaticFields.Setter, "hello");
        }

        [Fact]
        public void CantSetStaticNestedReadonly()
        {
            RunTest(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain.Nested');
                var statics = domain.ClassWithStaticFields;
                statics.Readonly = 'hello';
                assert(statics.Readonly == 'Readonly');
            ");

            Assert.Equal(Nested.ClassWithStaticFields.Readonly, "Readonly");
        }

        [Fact]
        public void ShouldExecuteFunctionWithValueTypeParameterCorrectly()
        {
            _engine.SetValue("a", new A());
            // Func<int, int>
            RunTest(@"
                assert(a.Call17(function(value){ return value; }) === 17);
            ");
        }

        [Fact]
        public void ShouldExecuteActionWithValueTypeParameterCorrectly()
        {
            _engine.SetValue("a", new A());
            // Action<int>
            RunTest(@"
                a.Call18(function(value){ assert(value === 18); });
            ");
        }

        [Fact]
        public void ShouldConvertToJsValue()
        {
            RunTest(@"
                var now = System.DateTime.Now;
                assert(new String(now) == now.toString());

                var zero = System.Int32.MaxValue;
                assert(new String(zero) == zero.toString());
            ");
        }

        [Fact]
        public void ShouldNotCatchClrExceptions()
        {
            var engine = new Engine()
                .SetValue("throwMyException", new Action(() => { throw new NotSupportedException(); }))
                .SetValue("Thrower", typeof(Thrower))
                .Execute(@"
                    function throwException1(){
                        try {
                            throwMyException();
                            return;
                        }
                        catch(e) {
                            return;
                        }
                    }

                    function throwException2(){
                        try {
                            new Thrower().ThrowNotSupportedException();
                            return;
                        }
                        catch(e) {
                            return;
                        }
                    }
                ");

            Assert.ThrowsAny<NotSupportedException>(() => engine.Invoke("throwException1"));
            Assert.ThrowsAny<NotSupportedException>(() => engine.Invoke("throwException2"));
        }

        [Fact]
        public void ShouldCatchAllClrExceptions()
        {
            var exceptionMessage = "myExceptionMessage";

            var engine = new Engine(o => o.CatchClrExceptions())
                .SetValue("throwMyException", new Action(() => { throw new Exception(exceptionMessage); }))
                .SetValue("Thrower", typeof(Thrower))
                .Execute(@"
                    function throwException1(){
                        try {
                            throwMyException();
                            return '';
                        }
                        catch(e) {
                            return e.message;
                        }
                    }

                    function throwException2(){
                        try {
                            new Thrower().ThrowExceptionWithMessage('myExceptionMessage');
                            return;
                        }
                        catch(e) {
                            return e.message;
                        }
                    }
                ");

            Assert.Equal(engine.Invoke("throwException1").AsString(), exceptionMessage);
            Assert.Equal(engine.Invoke("throwException2").AsString(), exceptionMessage);
        }

        [Fact]
        public void ShouldNotCatchClrFromApply()
        {
            var engine = new Engine(options =>
            {
                options.CatchClrExceptions(e =>
                {
                    Assert.Fail("was called");
                    return true;
                });
            });

            engine.Execute(@"
                function throwError() {
                    throw new Error();
                }

                // doesn't cause ExceptionDelegateHandler call
                try { throwError(); } catch {}

                // does cause ExceptionDelegateHandler call
                try { throwError.apply(); } catch {}
            ");
        }

        private class MemberExceptionTest
        {
            public MemberExceptionTest(bool throwOnCreate)
            {
                if (throwOnCreate)
                {
                    throw new InvalidOperationException("thrown as requested");
                }
            }

            public JsValue ThrowingProperty1
            {
                get => throw new InvalidOperationException();
                set => throw new InvalidOperationException();
            }

            public object ThrowingProperty2
            {
                get => throw new InvalidOperationException();
                set => throw new InvalidOperationException();
            }

            public void ThrowingFunction()
            {
                throw new InvalidOperationException();
            }
        }

        [Fact]
        public void ShouldCatchClrMemberExceptions()
        {
            var engine = new Engine(cfg =>
            {
                cfg.AllowClr();
                cfg.CatchClrExceptions();
            });

            engine.SetValue("assert", new Action<bool>(Assert.True));
            engine.SetValue("log", new Action<object>(Console.WriteLine));
            engine.SetValue("create", typeof(MemberExceptionTest));
            engine.SetValue("instance", new MemberExceptionTest(false));

            // Test calling a constructor that throws an exception
            engine.Execute(@"
                try
                {
                    create(true);
                    assert(false);
                }
                catch (e)
                {
                    assert(true);
                }
            ");

            // Test calling a member function that throws an exception
            engine.Execute(@"
                try
                {
                    instance.ThrowingFunction();
                    assert(false);
                }
                catch (e)
                {
                    assert(true);
                }
            ");

            // Test using a property getter that throws an exception
            engine.Execute(@"
                try
                {
                    log(o.ThrowingProperty);
                    assert(false);
                }
                catch (e)
                {
                    assert(true);
                }
            ");

            // Test using a property setter that throws an exception
            engine.Execute(@"
                try
                {
                    instance.ThrowingProperty1 = 123;
                    assert(false);
                }
                catch (e)
                {
                    assert(true);
                }

                try
                {
                    instance.ThrowingProperty2 = 456;
                    assert(false);
                }
                catch (e)
                {
                    assert(true);
                }
            ");
        }

        [Fact]
        public void ShouldCatchSomeExceptions()
        {
            var exceptionMessage = "myExceptionMessage";

            var engine = new Engine(o => o.CatchClrExceptions(e => e is NotSupportedException))
                .SetValue("throwMyException1", new Action(() => { throw new NotSupportedException(exceptionMessage); }))
                .SetValue("throwMyException2", new Action(() => { throw new ArgumentNullException(); }))
                .SetValue("Thrower", typeof(Thrower))
                .Execute(@"
                    function throwException1(){
                        try {
                            throwMyException1();
                            return '';
                        }
                        catch(e) {
                            return e.message;
                        }
                    }

                    function throwException2(){
                        try {
                            throwMyException2();
                            return '';
                        }
                        catch(e) {
                            return e.message;
                        }
                    }

                    function throwException3(){
                        try {
                            new Thrower().ThrowNotSupportedExceptionWithMessage('myExceptionMessage');
                            return '';
                        }
                        catch(e) {
                            return e.message;
                        }
                    }

                    function throwException4(){
                        try {
                            new Thrower().ThrowArgumentNullException();
                            return '';
                        }
                        catch(e) {
                            return e.message;
                        }
                    }
                ");

            Assert.Equal(engine.Invoke("throwException1").AsString(), exceptionMessage);
            Assert.Throws<ArgumentNullException>(() => engine.Invoke("throwException2"));
            Assert.Equal(engine.Invoke("throwException3").AsString(), exceptionMessage);
            Assert.Throws<ArgumentNullException>(() => engine.Invoke("throwException4"));
        }

        [Fact]
        public void ArrayFromShouldConvertListToArrayLike()
        {
            var list = new List<Person>
            {
                new Person { Name = "Mike" },
                new Person { Name = "Mika" }
            };
            _engine.SetValue("a", list);

            RunTest(@"
                var arr = new Array(a);
                assert(arr.length === 2);
                assert(arr[0].Name === 'Mike');
                assert(arr[1].Name === 'Mika');
            ");

            RunTest(@"
                var arr = Array.from(a);
                assert(arr.length === 2);
                assert(arr[0].Name === 'Mike');
                assert(arr[1].Name === 'Mika');
            ");
        }

        [Fact]
        public void ArrayFromShouldConvertArrayToArrayLike()
        {
            var list = new[]
            {
                new Person { Name = "Mike" },
                new Person { Name = "Mika" }
            };
            _engine.SetValue("a", list);

            RunTest(@"
                var arr = new Array(a);
                assert(arr.length === 2);
                assert(arr[0].Name === 'Mike');
                assert(arr[1].Name === 'Mika');
            ");

            RunTest(@"
                var arr = Array.from(a);
                assert(arr.length === 2);
                assert(arr[0].Name === 'Mike');
                assert(arr[1].Name === 'Mika');
            ");
        }

        [Fact]
        public void ArrayFromShouldConvertIEnumerable()
        {
            var enumerable = new[]
            {
                new Person { Name = "Mike" },
                new Person { Name = "Mika" }
            }.Select(x => x);

            _engine.SetValue("a", enumerable);

            RunTest(@"
                var arr = new Array(a);
                assert(arr.length === 2);
                assert(arr[0].Name === 'Mike');
                assert(arr[1].Name === 'Mika');
            ");

            RunTest(@"
                var arr = Array.from(a);
                assert(arr.length === 2);
                assert(arr[0].Name === 'Mike');
                assert(arr[1].Name === 'Mika');
            ");
        }

        [Fact]
        public void ShouldBeAbleToPlusAssignStringProperty()
        {
            var p = new Person();
            var engine = new Engine();
            engine.SetValue("P", p);
            engine.Evaluate("P.Name = 'b';");
            engine.Evaluate("P.Name += 'c';");
            Assert.Equal("bc", p.Name);
        }

        [Fact]
        public void ShouldNotResolveToPrimitiveSymbol()
        {
            var engine = new Engine(options =>
                options.AllowClr(typeof(FloatIndexer).GetTypeInfo().Assembly));
            var c = engine.Evaluate(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                return new domain.FloatIndexer();
            ");

            Assert.NotNull(c.ToString());
            Assert.Equal((uint) 0, c.AsObject().GetLength());
        }

        private class DictionaryWrapper
        {
            public IDictionary<string, object> Values { get; set; }
        }

        private class DictionaryTest
        {
            public void Test1(IDictionary<string, object> values)
            {
                Assert.Equal(1, Convert.ToInt32(values["a"]));
            }

            public void Test2(DictionaryWrapper dictionaryObject)
            {
                Assert.Equal(1, Convert.ToInt32(dictionaryObject.Values["a"]));
            }
        }

        [Fact]
        public void ShouldBeAbleToPassDictionaryToMethod()
        {
            var engine = new Engine();
            engine.SetValue("dictionaryTest", new DictionaryTest());
            engine.Evaluate("dictionaryTest.test1({ a: 1 });");
        }

        [Fact]
        public void ShouldBeAbleToPassDictionaryInObjectToMethod()
        {
            var engine = new Engine();
            engine.SetValue("dictionaryTest", new DictionaryTest());
            engine.Evaluate("dictionaryTest.test2({ values: { a: 1 } });");
        }

        [Fact]
        public void ShouldSupportSpreadForDictionary()
        {
            var engine = new Engine();
            var state = new Dictionary<string, object>
            {
                { "invoice", new Dictionary<string, object> { ["number"] = "42" } }
            };
            engine.SetValue("state", state);

            var result = (IDictionary<string, object>) engine
                .Evaluate("({ supplier: 'S1', ...state.invoice })")
                .ToObject();

            Assert.Equal("S1", result["supplier"]);
            Assert.Equal("42", result["number"]);
        }

        [Fact]
        public void ShouldSupportSpreadForDictionary2()
        {
            var engine = new Engine();
            var state = new Dictionary<string, object>
            {
                { "invoice", new Dictionary<string, object> { ["number"] = "42" } }
            };
            engine.SetValue("state", state);

            var result = (IDictionary<string, object>) engine
                .Execute("function getValue() { return {supplier: 'S1', ...state.invoice}; }")
                .Invoke("getValue")
                .ToObject();

            Assert.Equal("S1", result["supplier"]);
            Assert.Equal("42", result["number"]);
        }

        [Fact]
        public void ShouldSupportSpreadForObject()
        {
            var engine = new Engine();
            var person = new Person
            {
                Name = "Mike",
                Age = 20
            };
            engine.SetValue("p", person);

            var result = (IDictionary<string, object>) engine
                .Evaluate("({ supplier: 'S1', ...p })")
                .ToObject();

            Assert.Equal("S1", result["supplier"]);
            Assert.Equal("Mike", result["Name"]);
            Assert.Equal(20d, result["Age"]);
        }

        [Fact]
        public void ShouldBeAbleToJsonStringifyClrObjects()
        {
            var engine = new Engine();

            engine.Evaluate("var jsObj = { 'key1' :'value1', 'key2' : 'value2' }");

            engine.SetValue("netObj", new Dictionary<string, object>
            {
                { "key1", "value1" },
                { "key2", "value2" }
            });

            var jsValue = engine.Evaluate("jsObj['key1']").AsString();
            var clrValue = engine.Evaluate("netObj['key1']").AsString();
            Assert.Equal(jsValue, clrValue);

            jsValue = engine.Evaluate("JSON.stringify(jsObj)").AsString();
            clrValue = engine.Evaluate("JSON.stringify(netObj)").AsString();
            Assert.Equal(jsValue, clrValue);

            // Write properties on screen using showProps function defined on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_Objects
            engine.Execute(@"function showProps(obj, objName) {
  var result = """";
  for (var i in obj) {
    if (obj.hasOwnProperty(i)) {
      result += objName + ""."" + i + "" = "" + obj[i] + ""\n"";
    }
    }
  return result;
}");
            jsValue = engine.Evaluate("showProps(jsObj, 'theObject')").AsString();
            clrValue = engine.Evaluate("showProps(jsObj, 'theObject')").AsString();
            Assert.Equal(jsValue, clrValue);
        }

        [Fact]
        public void SettingValueViaIntegerIndexer()
        {
            var engine = new Engine(cfg => cfg.AllowClr(typeof(FloatIndexer).GetTypeInfo().Assembly));
            engine.SetValue("log", new Action<object>(Console.WriteLine));
            engine.Execute(@"
                var domain = importNamespace('Jint.Tests.Runtime.Domain');
                var fia = new domain.IntegerIndexer();
                log(fia[0]);
            ");

            Assert.Equal(123, engine.Evaluate("fia[0]").AsNumber());
            engine.Evaluate("fia[0] = 678;");
            Assert.Equal(678, engine.Evaluate("fia[0]").AsNumber());
        }

        [Fact]
        public void IndexingBsonProperties()
        {
            const string jsonAnimals = @" { ""Animals"": [ { ""Id"": 1, ""Type"": ""Cat"" } ] }";
            var bsonAnimals = BsonDocument.Parse(jsonAnimals);

            _engine.SetValue("animals", bsonAnimals["Animals"]);

            // weak equality does conversions from native types
            Assert.True(_engine.Evaluate("animals[0].Type == 'Cat'").AsBoolean());
            Assert.True(_engine.Evaluate("animals[0].Id == 1").AsBoolean());
        }

        [Fact]
        public void IntegerAndFloatInFunctionOverloads()
        {
            var engine = new Engine(options => options.AllowClr(GetType().Assembly));
            engine.SetValue("a", new OverLoading());
            Assert.Equal("int-val", engine.Evaluate("a.testFunc(123);").AsString());
            Assert.Equal("float-val", engine.Evaluate("a.testFunc(12.3);").AsString());
        }

        [Fact]
        public void TypeConversionWithTemporaryInvalidValuesShouldNotCache()
        {
            var engine = new Engine(options => options.AllowClr());
            engine.SetValue("IntValueInput", TypeReference.CreateTypeReference(engine, typeof(IntValueInput)));
            var ex = Assert.Throws<JavaScriptException>(() => engine.Evaluate("new IntValueInput().testFunc(NaN);").AsString());
            Assert.Equal("No public methods with the specified arguments were found.", ex.Message);

            Assert.Equal(123, engine.Evaluate("new IntValueInput().testFunc(123);").AsNumber());
        }

        [Fact]
        public void CanConvertFloatingPointToIntegerWithoutError()
        {
            var engine = new Engine(options => options.AllowClr());
            engine.SetValue("IntValueInput", TypeReference.CreateTypeReference(engine, typeof(IntValueInput)));
            Assert.Equal(12, engine.Evaluate("new IntValueInput().testFunc(12.3);").AsNumber());
        }

        public class IntValueInput
        {
            public int TestFunc(int value) => value;
        }

        public class TestItem
        {
            public double Cost { get; set; }

            public double Age { get; set; }

            public string Name { get; set; }
        }

        public class TestItemList : List<TestItem>
        {
            public double Sum(Func<TestItem, double> calc)
            {
                double rc = 0;

                foreach (var item in this)
                {
                    rc += calc(item);
                }

                return rc;
            }

            public TestItemList Where(Func<TestItem, bool> cond)
            {
                var rc = new TestItemList();

                foreach (var item in this)
                {
                    if (cond(item))
                    {
                        rc.Add(item);
                    }
                }

                return rc;
            }
        }

        [Fact]
        public void DelegateCanReturnValue()
        {
            var engine = new Engine(options => options.AllowClr(GetType().Assembly));

            var lst = new TestItemList();

            lst.Add(new TestItem() { Name = "a", Cost = 1, Age = 10 });
            lst.Add(new TestItem() { Name = "a", Cost = 1, Age = 10 });
            lst.Add(new TestItem() { Name = "b", Cost = 1, Age = 10 });
            lst.Add(new TestItem() { Name = "b", Cost = 1, Age = 10 });
            lst.Add(new TestItem() { Name = "b", Cost = 1, Age = 10 });

            engine.SetValue("lst", lst);

            Assert.Equal(5, engine.Evaluate("lst.Sum(x => x.Cost);").AsNumber());
            Assert.Equal(50, engine.Evaluate("lst.Sum(x => x.Age);").AsNumber());
            Assert.Equal(3, engine.Evaluate("lst.Where(x => x.Name == 'b').Count;").AsNumber());
            Assert.Equal(30, engine.Evaluate("lst.Where(x => x.Name == 'b').Sum(x => x.Age);").AsNumber());
        }

        [Fact]
        public void ObjectWrapperOverridingEquality()
        {
            // equality same via name
            _engine.SetValue("a", new Person { Name = "Name" });
            _engine.SetValue("b", new Person { Name = "Name" });
            _engine.Evaluate("const arr = [ null, a, undefined ];");

            Assert.Equal(1, _engine.Evaluate("arr.filter(x => x == b).length").AsNumber());
            Assert.Equal(1, _engine.Evaluate("arr.filter(x => x === b).length").AsNumber());

            Assert.True(_engine.Evaluate("arr.find(x => x == b) === a").AsBoolean());
            Assert.True(_engine.Evaluate("arr.find(x => x === b) == a").AsBoolean());

            Assert.Equal(1, _engine.Evaluate("arr.findIndex(x => x == b)").AsNumber());
            Assert.Equal(1, _engine.Evaluate("arr.findIndex(x => x === b)").AsNumber());

            Assert.Equal(1, _engine.Evaluate("arr.indexOf(b)").AsNumber());
            Assert.True(_engine.Evaluate("arr.includes(b)").AsBoolean());
        }

        [Fact]
        public void ObjectWrapperWrappingDictionaryShouldNotBeArrayLike()
        {
            var wrapper = ObjectWrapper.Create(_engine, new Dictionary<string, object>());
            Assert.False(wrapper.IsArrayLike);
        }

        [Fact]
        public void ShouldHandleCyclicReferences()
        {
            var engine = new Engine();

            static void Test(string message, object value)
            {
                Console.WriteLine(message);
            }

            engine.Realm.GlobalObject.FastSetDataProperty("global", engine.Realm.GlobalObject);
            engine.Realm.GlobalObject.FastSetDataProperty("test", new DelegateWrapper(engine, (Action<string, object>) Test));

            {
                var ex = Assert.Throws<JavaScriptException>(() => engine.Realm.GlobalObject.ToObject());
                Assert.Equal("Cyclic reference detected.", ex.Message);
            }

            {
                var ex = Assert.Throws<JavaScriptException>(() =>
                    engine.Execute(@"
                    var demo={};
                    demo.value=1;
                    test('Test 1', demo.value===1);
                    test('Test 2', demo.value);
                    demo.demo=demo;
                    test('Test 3', demo);
                    test('Test 4', global);"
                    )
                );
                Assert.Equal("Cyclic reference detected.", ex.Message);
            }
        }

        [Fact]
        public void CanConfigurePropertyNameMatcher()
        {
            // defaults
            var e = new Engine();
            e.SetValue("a", new A());
            Assert.True(e.Evaluate("a.call1").IsObject());
            Assert.True(e.Evaluate("a.Call1").IsObject());
            Assert.True(e.Evaluate("a.CALL1").IsUndefined());

            e = new Engine(options =>
            {
                options.SetTypeResolver(new TypeResolver
                {
                    MemberNameComparer = StringComparer.Ordinal
                });
            });
            e.SetValue("a", new A());
            Assert.True(e.Evaluate("a.call1").IsUndefined());
            Assert.True(e.Evaluate("a.Call1").IsObject());
            Assert.True(e.Evaluate("a.CALL1").IsUndefined());

            e = new Engine(options =>
            {
                options.SetTypeResolver(new TypeResolver
                {
                    MemberNameComparer = StringComparer.OrdinalIgnoreCase
                });
            });
            e.SetValue("a", new A());
            Assert.True(e.Evaluate("a.call1").IsObject());
            Assert.True(e.Evaluate("a.Call1").IsObject());
            Assert.True(e.Evaluate("a.CALL1").IsObject());
        }

        [Fact]
        public void ShouldNotEnumerateClassMethods()
        {
            var engine = new Engine();

            var dictionary = new Dictionary<string, object>
            {
                { "foo", 5 },
                { "bar", "A string" }
            };
            engine.SetValue("dictionary", dictionary);

            var result = engine.Evaluate($"Object.keys(dictionary).join(',')").AsString();
            Assert.Equal("foo,bar", result);


            engine.Execute("dictionary.ContainsKey('foo')");
            result = engine.Evaluate($"Object.keys(dictionary).join(',')").AsString();
            Assert.Equal("foo,bar", result);
        }

        [Fact]
        public void ShouldNotEnumerateExtensionMethods()
        {
            var engine = new Engine(cfg => cfg.AddExtensionMethods(typeof(Enumerable)));

            var result = engine.Evaluate("Object.keys({ ...[1,2,3] }).join(',')").AsString();
            Assert.Equal("0,1,2", result);

            var script = @"
                var arr = [1,2,3];
                var keys = [];
                for(var index in arr) keys.push(index);
                keys.join(',');
            ";
            result = engine.Evaluate(script).ToString();
            Assert.Equal("0,1,2", result);
        }

        [Fact]
        public void CanCheckIfCallable()
        {
            var engine = new Engine();
            engine.Evaluate("var f = () => true;");

            var result = engine.GetValue("f");
            Assert.True(result.IsCallable);

            Assert.True(result.Call(Array.Empty<JsValue>()).AsBoolean());
            Assert.True(result.Call().AsBoolean());
        }

        [Fact]
        public void CanGiveCustomNameToInteropMembers()
        {
            static IEnumerable<string> MemberNameCreator(MemberInfo prop)
            {
                var attributes = prop.GetCustomAttributes(typeof(CustomNameAttribute), true);
                if (attributes.Length > 0)
                {
                    foreach (CustomNameAttribute attribute in attributes)
                    {
                        yield return attribute.Name;
                    }
                }
                else
                {
                    yield return prop.Name;
                }
            }

            var customTypeResolver = new TypeResolver
            {
                MemberNameCreator = MemberNameCreator
            };

            var engine = new Engine(options =>
            {
                options.SetTypeResolver(customTypeResolver);
                options.AddExtensionMethods(typeof(CustomNamedExtensions));
            });
            engine.SetValue("o", new CustomNamed());
            Assert.Equal("StringField", engine.Evaluate("o.jsStringField").AsString());
            Assert.Equal("StringField", engine.Evaluate("o.jsStringField2").AsString());
            Assert.Equal("StaticStringField", engine.Evaluate("o.jsStaticStringField").AsString());
            Assert.Equal("StringProperty", engine.Evaluate("o.jsStringProperty").AsString());
            Assert.Equal("Method", engine.Evaluate("o.jsMethod()").AsString());
            Assert.Equal("StaticMethod", engine.Evaluate("o.jsStaticMethod()").AsString());
            Assert.Equal("InterfaceStringProperty", engine.Evaluate("o.jsInterfaceStringProperty").AsString());
            Assert.Equal("InterfaceMethod", engine.Evaluate("o.jsInterfaceMethod()").AsString());
            Assert.Equal("ExtensionMethod", engine.Evaluate("o.jsExtensionMethod()").AsString());

            engine.SetValue("XmlHttpRequest", typeof(CustomNamedEnum));
            engine.Evaluate("o.jsEnumProperty = XmlHttpRequest.HEADERS_RECEIVED;");
            Assert.Equal((int) CustomNamedEnum.HeadersReceived, engine.Evaluate("o.jsEnumProperty").AsNumber());
        }

        [Fact]
        public void ShouldBeAbleToHandleInvalidClrConversionViaCatchClrExceptions()
        {
            var engine = new Engine(cfg => cfg.CatchClrExceptions());
            engine.SetValue("a", new Person());
            var ex = Assert.Throws<JavaScriptException>(() => engine.Execute("a.age = 'It will not work, but it is normal'"));
            Assert.Contains("input string ", ex.Message, StringComparison.OrdinalIgnoreCase);
            Assert.Contains(" was not in a correct format", ex.Message, StringComparison.OrdinalIgnoreCase);
        }

        [Fact]
        public void ShouldLetNotSupportedExceptionBubble()
        {
            _engine.SetValue("profile", new Profile());
            var ex = Assert.Throws<NotSupportedException>(() => _engine.Evaluate("profile.AnyProperty"));
            Assert.Equal("NOT SUPPORTED", ex.Message);
        }

        [Fact]
        public void ShouldBeAbleToUseConvertibleStructAsMethodParameter()
        {
            _engine.SetValue("test", new DiscordTestClass());
            _engine.SetValue("id", new DiscordId("12345"));

            Assert.Equal("12345", _engine.Evaluate("String(id)").AsString());
            Assert.Equal("12345", _engine.Evaluate("test.echo('12345')").AsString());
            Assert.Equal("12345", _engine.Evaluate("test.create(12345)").AsString());
        }

        [Fact]
        public void ShouldGetIteratorForListAndDictionary()
        {
            const string Script = @"
                var it = collection[Symbol.iterator]();
                var result = it.next();
                var str = """";
                while (!result.done) {
                    str += result.value;
                    result = it.next();
                }
                return str;";

            _engine.SetValue("collection", new List<string> { "a", "b", "c" });
            Assert.Equal("abc", _engine.Evaluate(Script));

            _engine.SetValue("collection", new Dictionary<string, object> { { "a", 1 }, { "b", 2 }, { "c", 3 } });
            Assert.Equal("a,1b,2c,3", _engine.Evaluate(Script));
        }

        [Fact]
        public void ShouldNotIntroduceNewPropertiesWhenTraversing()
        {
            _engine.SetValue("x", new Dictionary<string, int> { { "First", 1 }, { "Second", 2 } });

            Assert.Equal("[\"First\",\"Second\"]", _engine.Evaluate("JSON.stringify(Object.keys(x))"));

            Assert.Equal("x['First']: 1", _engine.Evaluate("\"x['First']: \" + x['First']"));
            Assert.Equal("[\"First\",\"Second\"]", _engine.Evaluate("JSON.stringify(Object.keys(x))"));

            Assert.Equal("x['Third']: undefined", _engine.Evaluate("\"x['Third']: \" + x['Third']"));
            Assert.Equal("[\"First\",\"Second\"]", _engine.Evaluate("JSON.stringify(Object.keys(x))"));

            Assert.Equal(JsValue.Undefined, _engine.Evaluate("x.length"));
            Assert.Equal("[\"First\",\"Second\"]", _engine.Evaluate("JSON.stringify(Object.keys(x))"));

            Assert.Equal(2, _engine.Evaluate("x.Count").AsNumber());
            Assert.Equal("[\"First\",\"Second\"]", _engine.Evaluate("JSON.stringify(Object.keys(x))"));

            _engine.Evaluate("x.Clear();");

            Assert.Equal("[]", _engine.Evaluate("JSON.stringify(Object.keys(x))"));

            _engine.Evaluate("x['Fourth'] = 4;");
            Assert.Equal("[\"Fourth\"]", _engine.Evaluate("JSON.stringify(Object.keys(x))"));

            Assert.False(_engine.Evaluate("Object.prototype.hasOwnProperty.call(x, 'Third')").AsBoolean());
        }

        [Fact]
        public void CanConfigureCustomObjectTypeForJsToClrConversion()
        {
            var engine = new Engine(options =>
            {
                options.Interop.CreateClrObject = oi => new Dictionary<string, object>();
            });

            object capture = null;
            var callback = (object value) => capture = value;
            engine.SetValue("callback", callback);
            engine.Evaluate("callback(({'a': 'b'}));");

            Assert.IsType<Dictionary<string, object>>(capture);
            var dictionary = (Dictionary<string, object>) capture;
            Assert.Equal("b", dictionary["a"]);
        }

        [Fact]
        public void ArrayPrototypeIndexOfWithInteropList()
        {
            var engine = new Jint.Engine();

            engine.SetValue("list", new List<string> { "A", "B", "C" });

            Assert.Equal(1, engine.Evaluate("list.indexOf('B')"));
            Assert.Equal(1, engine.Evaluate("list.lastIndexOf('B')"));

            Assert.Equal(1, engine.Evaluate("Array.prototype.indexOf.call(list, 'B')"));
            Assert.Equal(1, engine.Evaluate("Array.prototype.lastIndexOf.call(list, 'B')"));
        }

        [Fact]
        public void ArrayPrototypeFindWithInteropList()
        {
            var engine = new Jint.Engine();
            var list = new List<string> { "A", "B", "C" };
 
            engine.SetValue("list", list);

            Assert.Equal(1, engine.Evaluate("list.findIndex((x) => x === 'B')"));
            Assert.Equal('B', engine.Evaluate("list.find((x) => x === 'B')"));
        }

        [Fact]
        public void ArrayPrototypePushWithInteropList()
        {
            var engine = new Jint.Engine();

            var list = new List<string> { "A", "B", "C" };

            engine.SetValue("list", list);

            engine.Evaluate("list.push('D')");
            Assert.Equal(4, list.Count);
            Assert.Equal("D", list[3]);
            Assert.Equal(3, engine.Evaluate("list.lastIndexOf('D')"));
        }

        [Fact]
        public void ArrayPrototypePopWithInteropList()
        {
            var engine = new Jint.Engine();

            var list = new List<string> { "A", "B", "C" };
            engine.SetValue("list", list);

            Assert.Equal(2, engine.Evaluate("list.lastIndexOf('C')"));
            Assert.Equal(3, list.Count);
            Assert.Equal("C", engine.Evaluate("list.pop()"));
            Assert.Equal(2, list.Count);
            Assert.Equal(-1, engine.Evaluate("list.lastIndexOf('C')"));
        }

        [Fact]
        public void ShouldBeJavaScriptException()
        {
            var engine = new Engine(cfg => cfg.AllowClr().AllowOperatorOverloading().CatchClrExceptions());
            engine.SetValue("Dimensional", typeof(Dimensional));

            engine.Execute(@"	
				function Eval(param0, param1)
				{ 
					var result = param0 + param1;
					return result;
				}");
            // checking working custom type
            Assert.Equal(new Dimensional("kg", 90), (new Dimensional("kg", 30) + new Dimensional("kg", 60)));
            Assert.Equal(new Dimensional("kg", 90), engine.Invoke("Eval", new object[] { new Dimensional("kg", 30), new Dimensional("kg", 60) }).ToObject());
            Assert.Throws<InvalidOperationException>(() => new Dimensional("kg", 30) + new Dimensional("piece", 70));

            // checking throwing exception in override operator
            string errorMsg = string.Empty;
            errorMsg = Assert.Throws<JavaScriptException>(() => engine.Invoke("Eval", new object[] { new Dimensional("kg", 30), new Dimensional("piece", 70) })).Message;
            Assert.Equal("Dimensionals with different measure types are non-summable", errorMsg);
        }

        private class Profile
        {
            public int AnyProperty => throw new NotSupportedException("NOT SUPPORTED");
        }

        [Fact]
        public void GenericParameterResolutionShouldWorkWithNulls()
        {
            var result = new Engine()
                .SetValue("JintCommon", new JintCommon())
                .Evaluate("JintCommon.sum(1, null)")
                .AsNumber();

            Assert.Equal(2, result);
        }

        public class JintCommon
        {
            public int Sum(int a, int? b) => a + b.GetValueOrDefault(1);
        }

        private delegate void ParamsTestDelegate(params Action[] callbacks);

        [Fact]
        public void CanUseParamsActions()
        {
            var engine = new Engine();
            engine.SetValue("print", new Action<string>(_ => { }));
            engine.SetValue("callAll", new DelegateWrapper(engine, new ParamsTestDelegate(ParamsTest)));

            engine.Execute(@"
                callAll(
                    function() { print('a'); },
                    function() { print('b'); },
                    function() { print('c'); }
                );
            ");
        }

        private static void ParamsTest(params Action[] callbacks)
        {
            foreach (var callback in callbacks)
            {
                callback.Invoke();
            }
        }

        [Fact]
        public void ObjectWrapperIdentityIsMaintained()
        {
            // run in separate method so stack won't keep reference
            var reference = RunWeakReferenceTest();

            GC.Collect();

            // make sure no dangling reference is left
            Assert.False(reference.IsAlive);
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private static WeakReference RunWeakReferenceTest()
        {
            var o = new object();

            var engine = new Engine()
                .SetValue("o", o);

            var wrapper1 = (ObjectWrapper) engine.GetValue("o");
            var reference = new WeakReference(wrapper1);

            Assert.Same(wrapper1, engine.GetValue("o"));
            Assert.Same(o, wrapper1.Target);

            // reset
            engine.Realm.GlobalObject.RemoveOwnProperty("o");
            return reference;
        }

        [Fact]
        public void CanUseClrFunction()
        {
            var engine = new Engine();
            engine.SetValue("fn", new ClrFunction(engine, "fn", (_, args) => (JsValue) (args[0].AsInteger() + 1)));

            var result = engine.Evaluate("fn(1)");

            Assert.Equal(2, result);
        }

        [Fact]
        public void ShouldAllowClrExceptionsThrough()
        {
            var engine = new Engine(opts => opts.CatchClrExceptions(exc => false));
            engine.SetValue("fn", new ClrFunction(engine, "fn", (_, _) => throw new InvalidOperationException("This is a C# error")));
            const string Source = @"
function wrap() {
  fn();
}
wrap();
";

            Assert.Throws<InvalidOperationException>(() => engine.Execute(Source));
        }

        [Fact]
        public void ShouldConvertClrExceptionsToErrors()
        {
            var engine = new Engine(opts => opts.CatchClrExceptions(exc => exc is InvalidOperationException));
            engine.SetValue("fn", new ClrFunction(engine, "fn", (_, _) => throw new InvalidOperationException("This is a C# error")));
            const string Source = @"
function wrap() {
  fn();
}
wrap();
";

            var exc = Assert.Throws<JavaScriptException>(() => engine.Execute(Source));
            Assert.Equal(exc.Message, "This is a C# error");
        }

        [Fact]
        public void ShouldAllowCatchingConvertedClrExceptions()
        {
            var engine = new Engine(opts => opts.CatchClrExceptions(exc => exc is InvalidOperationException));
            engine.SetValue("fn", new ClrFunction(engine, "fn", (_, _) => throw new InvalidOperationException("This is a C# error")));
            const string Source = @"
try {
  fn();
} catch (e) {
  throw new Error('Caught: ' + e.message);
}
";

            var exc = Assert.Throws<JavaScriptException>(() => engine.Execute(Source));
            Assert.Equal(exc.Message, "Caught: This is a C# error");
        }

        class Baz
        {
            public int DisposeCalls { get; private set; }
            public IEnumerable<int> Enumerator
            {
                get
                {
                    try
                    {
                        for (int i = 0; i < 10; i++) yield return i;
                    }
                    finally     // finally clause is translated into IDisposable.Dispose in underlying IEnumerator
                    {
                        ++DisposeCalls;
                    }
                }
            }
        }

        [Fact]
        public void ShouldCallEnumeratorDisposeOnNormalTermination()
        {
            var engine = new Engine();
            var baz = new Baz();
            engine.SetValue("baz", baz);
            const string Source = @"
for (let i of baz.Enumerator) {
}";
            engine.Execute(Source);
            Assert.Equal(1, baz.DisposeCalls);
        }

        [Fact]
        public void ShouldCallEnumeratorDisposeOnBreak()
        {
            var engine = new Engine();
            var baz = new Baz();
            engine.SetValue("baz", baz);
            const string Source = @"
for (let i of baz.Enumerator) {
  if (i == 2) break;
}";
            engine.Execute(Source);
            Assert.Equal(1, baz.DisposeCalls);
        }

        [Fact]
        public void ShouldCallEnumeratorDisposeOnException()
        {
            var engine = new Engine();
            var baz = new Baz();
            engine.SetValue("baz", baz);
            const string Source = @"
try {
  for (let i of baz.Enumerator) {
    if (i == 2) throw 'exception';
  }
} catch (e) {
}";
            engine.Execute(Source);
            Assert.Equal(1, baz.DisposeCalls);
        }

        public class PropertyTestClass
        {
            public object Value;
        }

        [Fact]
        public void PropertiesOfJsObjectPassedToClrShouldBeReadable()
        {
            _engine.SetValue("MyClass", typeof(PropertyTestClass));
            RunTest(@"
                var obj = new MyClass();
                obj.Value = { foo: 'bar' };
                equal('bar', obj.Value.foo);
            ");
        }

        [Fact]
        public void ShouldBeAbleToDeleteDictionaryEntries()
        {
            var engine = new Engine(options => options.Strict());

            var dictionary = new Dictionary<string, int>
            {
                { "a", 1 },
                { "b", 2 }
            };

            engine.SetValue("data", dictionary);

            Assert.True(engine.Evaluate("Object.hasOwn(data, 'a')").AsBoolean());
            Assert.True(engine.Evaluate("data['a'] === 1").AsBoolean());

            engine.Evaluate("data['a'] = 42");
            Assert.True(engine.Evaluate("data['a'] === 42").AsBoolean());

            Assert.Equal(42, dictionary["a"]);

            engine.Execute("delete data['a'];");

            Assert.False(engine.Evaluate("Object.hasOwn(data, 'a')").AsBoolean());
            Assert.False(engine.Evaluate("data['a'] === 42").AsBoolean());

            Assert.False(dictionary.ContainsKey("a"));

            var engineNoWrite = new Engine(options => options.Strict().AllowClrWrite(false));

            dictionary = new Dictionary<string, int>
            {
                { "a", 1 },
                { "b", 2 }
            };

            engineNoWrite.SetValue("data", dictionary);

            var ex1 = Assert.Throws<JavaScriptException>(() => engineNoWrite.Evaluate("data['a'] = 42"));
            Assert.Equal("Cannot assign to read only property 'a' of System.Collections.Generic.Dictionary`2[System.String,System.Int32]", ex1.Message);

            // no changes
            Assert.True(engineNoWrite.Evaluate("data['a'] === 1").AsBoolean());

            var ex2 = Assert.Throws<JavaScriptException>(() => engineNoWrite.Execute("delete data['a'];"));
            Assert.Equal("Cannot delete property 'a' of System.Collections.Generic.Dictionary`2[System.String,System.Int32]", ex2.Message);
        }

        public record RecordTestClass(object Value = null);

        public class RecordTestClassContext
        {
            public object Method(RecordTestClass recordTest)
            {
                return recordTest.Value;
            }
        }

        private class ClassWithIndexerAndProperty
        {
            public string MyProp { get; } = "from property";

            public string this[string name] => name != nameof(MyProp) ? "from indexer" : null;
        }

        [Fact]
        public void CanToStringObjectWithoutToPrimitiveSymbol()
        {
            var engine = new Engine();

            engine.SetValue("obj", new ClassWithIndexerAndProperty());
            Assert.Equal("Jint.Tests.Runtime.InteropTests+ClassWithIndexerAndProperty", engine.Evaluate("obj + ''").AsString());

            engine.SetValue("obj", new Company("name"));
            Assert.Equal("Jint.Tests.Runtime.Domain.Company", engine.Evaluate("obj + ''").AsString());
        }

        [Fact]
        public void CanConstructOptionalRecordClass()
        {
            _engine.SetValue("Context", new RecordTestClassContext());
            Assert.Equal(null, _engine.Evaluate("Context.method({});").ToObject());
            Assert.Equal(5, _engine.Evaluate("Context.method({ value: 5 });").AsInteger());
        }

        [Fact]
        public void CanPassDateTimeMinAndMaxViaInterop()
        {
            var engine = new Engine(cfg => cfg.AllowClrWrite());

            var dt = DateTime.UtcNow;
            engine.SetValue("capture", new Action<object>(o => dt = (DateTime) o));

            engine.SetValue("minDate", DateTime.MinValue);
            engine.Execute("capture(minDate);");
            Assert.Equal(DateTime.MinValue, dt);

            engine.SetValue("maxDate", DateTime.MaxValue);
            engine.Execute("capture(maxDate);");
            Assert.Equal(DateTime.MaxValue, dt);
        }

        private class Container
        {
            private readonly Child _child = new();
            public Child Child => _child;
            public BaseClass Get() => _child;
        }

        private class BaseClass { }

        private class Child : BaseClass { }

        [Fact]
        public void AccessingBaseTypeShouldBeEqualToAccessingDerivedType()
        {
            var engine = new Engine().SetValue("container", new Container());
            var res = engine.Evaluate("container.Child === container.Get()"); // These two should be the same object. But this PR makes `container.Get()` return a different object

            Assert.True(res.AsBoolean());
        }

        public interface IIndexer<out T>
        {
            T this[int index] { get; }
        }

        public interface ICountable<out T>
        {
            int Count { get; }
        }

        public interface IStringCollection : IIndexer<string>, ICountable<string>
        {
            string this[string name] { get; }
        }

        public class Strings : IStringCollection
        {
            private readonly string[] _strings;
            public Strings(string[] strings)
            {
                _strings = strings;
            }

            public string this[string name] => null;
            public string this[int index] => _strings[index];
            public int Count => _strings.Length;
        }

        public class Utils
        {
            public IStringCollection GetStrings() => new Strings(new [] { "a", "b", "c" });
        }

        [Fact]
        public void AccessingInterfaceShouldContainExtendedInterfaces()
        {
            var engine = new Engine();
            engine.SetValue("Utils", new Utils());
            var result = engine.Evaluate("const strings = Utils.GetStrings(); strings.Count;").AsNumber();
            Assert.Equal(3, result);
        }

        [Fact]
        public void IntegerIndexerIfPreferredOverStringIndexerWhenFound()
        {
            var engine = new Engine();
            engine.SetValue("Utils", new Utils());
            var result = engine.Evaluate("const strings = Utils.GetStrings(); strings[2];");
            Assert.Equal("c", result);
        }

        [Fact]
        public void CanDestructureInteropTargetMethod()
        {
            var engine = new Engine();
            engine.SetValue("test", new Utils());
            var result = engine.Evaluate("const { getStrings } = test; getStrings().Count;");
            Assert.Equal(3, result);
        }

        private class MetadataWrapper : IDictionary<string, object>
        {
            public IEnumerator<KeyValuePair<string, object>> GetEnumerator() => throw new NotImplementedException();
            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
            public void Add(KeyValuePair<string, object> item) => throw new NotImplementedException();
            public void Clear() => throw new NotImplementedException();
            public bool Contains(KeyValuePair<string, object> item) => throw new NotImplementedException();
            public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex) => throw new NotImplementedException();
            public bool Remove(KeyValuePair<string, object> item) => throw new NotImplementedException();
            public int Count { get; set; }
            public bool IsReadOnly { get; set; }
            public bool ContainsKey(string key) => throw new NotImplementedException();
            public void Add(string key, object value) => throw new NotImplementedException();
            public bool Remove(string key) => throw new NotImplementedException();
            public bool TryGetValue(string key, out object value)
            {
                value = "from-wrapper";
                return true;
            }

            public object this[string key]
            {
                get => "from-wrapper";
                set
                {
                }
            }

            public ICollection<string> Keys { get; set; }
            public ICollection<object> Values { get; set; }
        }

        private class ShadowedGetter : IReadOnlyDictionary<string, object>
        {
            private Dictionary<string, object> _dictionary = new();

            public void SetInitial(object value, string key)
            {
                _dictionary[key] = value;
            }

            public IEnumerator<KeyValuePair<string, object>> GetEnumerator() => throw new NotImplementedException();

            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

            public int Count { get; }
            public bool ContainsKey(string key) => _dictionary.ContainsKey(key);

            public bool TryGetValue(string key, out object value) => _dictionary.TryGetValue(key, out value);

            public object this[string key]
            {
                get
                {
                    _dictionary.TryGetValue(key, out var value);
                    return value;
                }
            }

            public IEnumerable<string> Keys { get; set; }
            public IEnumerable<object> Values { get; set; }
        }

        private class ShadowingSetter : ShadowedGetter
        {
            public Dictionary<string, int> Metadata
            {
                set
                {
                    SetInitial(new MetadataWrapper(), "metadata");
                }
            }
        }

        [Fact]
        public void CanSelectShadowedPropertiesBasedOnReadableAndWritable()
        {
            var engine = new Engine();
            engine.SetValue("test", new ShadowingSetter
            {
                Metadata = null
            });

            engine.Evaluate("test.metadata['abc'] = 123");
            var result = engine.Evaluate("test.metadata['abc']");
            Assert.Equal("from-wrapper", result);
        }

        [Fact]
        public void ShouldRespectConcreteGenericReturnTypes()
        {
            var engine = new Engine(opt =>
            {
                opt.AddExtensionMethods(typeof(Enumerable)); // Allow LINQ extension methods.
            });

            var result = new List<string>();
            void Debug(object o)
            {
                result.Add($"{o?.GetType().Name ?? "null"}: {o ?? "null"}");
            }

            engine.SetValue("debug", Debug);
            engine.SetValue("dict", new Dictionary<string, string> { ["test"] = "val" });

            engine.Execute("var t = dict.last(kvp => { debug(kvp); debug(kvp.key); return kvp.key != null; } );");
            engine.Execute("debug(t); debug(t.key);");

            Assert.Equal(4, result.Count);
            Assert.Equal("KeyValuePair`2: [test, val]", result[0]);
            Assert.Equal("String: test", result[1]);
            Assert.Equal("KeyValuePair`2: [test, val]", result[2]);
            Assert.Equal("String: test", result[3]);
        }
    }
}
