sebastienros.jint/Jint.Tests/Runtime/TypeConverterTests.cs

using Jint.Native;
using Jint.Runtime;
using Xunit.Abstractions;

namespace Jint.Tests.Runtime
{
    public class TypeConverterTests
    {
        private readonly Engine _engine;

        public TypeConverterTests(ITestOutputHelper output)
        {
            _engine = new Engine()
                .SetValue("log", new Action<object>(o => output.WriteLine(o.ToString())))
                .SetValue("assert", new Action<bool>(Assert.True))
                .SetValue("equal", new Action<object, object>(Assert.Equal))
                ;
        }

        public static readonly IEnumerable<object[]> ConvertNumberToInt32AndUint32TestData = new TheoryData<double, int>()
        {
            { 0.0, 0 },
            { -0.0, 0 },
            { double.Epsilon, 0 },
            { 0.5, 0 },
            { -0.5, 0 },
            { 0.9999999999999999, 0 },
            { 1.0, 1 },
            { 1.5, 1 },
            { 10.0, 10 },
            { -12.3, -12 },
            { 1485772.6, 1485772 },
            { -984737183.8, -984737183 },

            { Math.Pow(2, 31) - 1.0, int.MaxValue },
            { Math.Pow(2, 31) - 0.5, int.MaxValue },
            { Math.Pow(2, 32) - 1.0, -1 },
            { Math.Pow(2, 32) - 0.5, -1 },
            { Math.Pow(2, 32), 0 },
            { -Math.Pow(2, 32), 0 },
            { -Math.Pow(2, 32) - 0.5, 0 },
            { Math.Pow(2, 32) + 1.0, 1 },
            { Math.Pow(2, 45) + 17.56, 17 },
            { Math.Pow(2, 45) - 17.56, -18 },
            { -Math.Pow(2, 45) + 17.56, 18 },
            { Math.Pow(2, 51) + 17.5, 17 },
            { Math.Pow(2, 51) - 17.5, -18 },

            { Math.Pow(2, 53) - 1.0, -1 },
            { -Math.Pow(2, 53) + 1.0, 1 },
            { Math.Pow(2, 53), 0 },
            { -Math.Pow(2, 53), 0 },
            { Math.Pow(2, 53) + 12.0, 12 },
            { -Math.Pow(2, 53) - 12.0, -12 },

            { (Math.Pow(2, 53) - 1.0) * Math.Pow(2, 1), -2 },
            { -(Math.Pow(2, 53) - 1.0) * Math.Pow(2, 3), 8 },
            { -(Math.Pow(2, 53) - 1.0) * Math.Pow(2, 11), 1 << 11 },
            { (Math.Pow(2, 53) - 1.0) * Math.Pow(2, 20), -(1 << 20) },
            { (Math.Pow(2, 53) - 1.0) * Math.Pow(2, 31), int.MinValue },
            { -(Math.Pow(2, 53) - 1.0) * Math.Pow(2, 31), int.MinValue },
            { (Math.Pow(2, 53) - 1.0) * Math.Pow(2, 32), 0 },
            { -(Math.Pow(2, 53) - 1.0) * Math.Pow(2, 32), 0 },
            { (Math.Pow(2, 53) - 1.0) * Math.Pow(2, 36), 0 },

            { double.MaxValue, 0 },
            { double.MinValue, 0 },
            { double.PositiveInfinity, 0 },
            { double.NegativeInfinity, 0 },
            { double.NaN, 0 },
        };

        [Theory]
        [MemberData(nameof(ConvertNumberToInt32AndUint32TestData))]
        public void ConvertNumberToInt32AndUint32(double value, int expectedResult)
        {
            JsValue jsval = value;
            Assert.Equal(expectedResult, TypeConverter.ToInt32(jsval));
            Assert.Equal((uint)expectedResult, TypeConverter.ToUint32(jsval));
        }

        [Fact]
        public void ToPrimitiveShouldEvaluateOnlyOnceDuringInExpression()
        {
            _engine.Execute(@"
                var b = {};
                var bval = 0;
                b[Symbol.toPrimitive] = function(hint) { return bval++; };

                b in {};
                equal(1, bval);
            ");
        }
    }

}