Update from Jint 2.11.58 -> Jint 3.0.0-beta-2052

[j-bernhard]

During update the Jint library from version 2 to 3 some of ours integration tests are failing related to the Jint engine.
I tried to collect all problems in separate example tests (how it is used in the application code).

For me it would be good to understand, why this is happened. Is there a chance to enable the previous behaviour of Jint 2x with some configuring options. Is the new behavior in Jint 3 correct and int Jint 2 wrong? Most important issue are test cases "Precision" / "Precision2".

I attached test project. In the project file you can easyli switch the used version of the library to see the differen behavior.

JintTesting.zip

Thx for help

namespace JintTesting
{
    using System;
    using System.Globalization;

    using Jint;

    using Xunit;

    public class UnitTest1
    {
        private readonly Engine engine;

        private const string ScriptTemplate = @"
            // prototype String
            String.prototype.trim=function(){{return this.replace(/^\s+|\s+$/g, '');}};
            String.prototype.ltrim=function(){{return this.replace(/^\s+/,'');}};
            String.prototype.rtrim=function(){{return this.replace(/\s+$/,'');}};
            String.prototype.Replace=function(searchValue, newValue)
            {{
                var expr = new RegExp(searchValue, 'g');
                return this.replace(expr, newValue);
            }};   

            // could be included in ECMA6  
            if (!String.prototype.StartsWith) 
            {{        
                String.prototype.StartsWith=function(searchString, position) 
                {{
                    position = position || 0;
                    return this.indexOf(searchString, position) === position;
                }}
            }}

            // could be included in ECMA6 
            if (!String.prototype.EndsWith) 
            {{ 
                String.prototype.EndsWith = function(searchString, position) 
                {{                                                                            
                    var subjectString = this.toString();
                    if (typeof position !== 'number' 
                            || !isFinite(position) 
                            || Math.floor(position) !== position 
                            || position > subjectString.length) 
                    {{
                        position = subjectString.length;
                    }}
                    position -= searchString.length;
                    var lastIndex = subjectString.indexOf(searchString, position);
                    return lastIndex !== -1 && lastIndex === position;                                                                            
                }}
            }}

            // prototype Date
            Date.prototype.ToUniversalTime=function(){{ return ToUniversalTime(this); }};
            Date.prototype.DayOfWeek=function(){{                                                    
                                                    var weekday = new Array(7);
                                                    weekday[0] = ""Sunday"";
                                                    weekday[1] = ""Monday"";
                                                    weekday[2] = ""Tuesday"";
                                                    weekday[3] = ""Wednesday"";
                                                    weekday[4] = ""Thursday"";
                                                    weekday[5] = ""Friday"";
                                                    weekday[6] = ""Saturday"";

                                                    return weekday[this.getDay()];
                                                }};               
            Date.prototype.ToString=function(format){{ return this.toString(format); }};
            Date.prototype.toString=function(format){{ return GetDateTimeFormatString(this, format); }};
            Date.prototype.toLocaleString=function(format){{ return getLocaleDateTimeFormatString(this, format); }};
            
            // function to run
            function resolve(input, result) 
            {{                
                // assign the result of the expressions to the script result
                result.Value = {0};                
                return result;
            }};
        ";

        public UnitTest1()
        {
            this.engine = new Engine(
                (Options options) =>
                    {
                        options.DebugMode();
                        options.AllowClr();
                        options.Culture(CultureInfo.GetCultureInfo("en-US"));
                    });

            this.engine.SetValue("GetCurrentTriggerTime", new Func<DateTime>(GetCurrentTriggerTime));
            this.engine.SetValue(
                "GetDateTimeFormatString",
                new Func<DateTime, string, string>(GetDateTimeFormatString));
            this.engine.SetValue("ToUniversalTime", new Func<DateTime, DateTime>(ToUniversalTime));

            DateTime GetCurrentTriggerTime()
            {
                var dt = DateTime.Parse("2014-04-14T14:51:30.6775258+02:00");

                return dt.Kind == DateTimeKind.Unspecified
                           ? new DateTime(dt.Ticks, DateTimeKind.Local).ToUniversalTime()
                           : dt.ToUniversalTime();
            }

            DateTime ToUniversalTime(DateTime dateTime)
            {
                return dateTime.ToUniversalTime();
            }

            string GetDateTimeFormatString(DateTime dateTime, string format)
            {
                return dateTime.ToString(format);
            }
        }

        /// <summary>
        ///     Result Jint 2.11.58: True
        ///     Result Jint 3.0.0-beta-2052: true
        /// </summary>
        [Fact]
        public void EndsWith_ReturnAsString_True()
        {
            var engine = new Engine((Options options) => { options.AllowClr(); });

            var script = string.Format(ScriptTemplate, "'bla'.EndsWith('a')");

            var result = new ScriptResult<string>();
            engine.Execute(script).Invoke("resolve", Array.Empty<string>(), result);

            Assert.Equal("True", result.Value);
        }

        /// <summary>
        ///     Result Jint 2.11.58: True
        ///     Result Jint 3.0.0-beta-2052: true
        /// </summary>
        [Fact]
        public void StartsWith_ReturnAsString_True()
        {
            var script = string.Format(ScriptTemplate, "'bla'.StartsWith('b')");

            var result = new ScriptResult<string>();
            this.engine.Execute(script).Invoke("resolve", Array.Empty<string>(), result);

            Assert.Equal("True", result.Value);
        }

        /// <summary>
        ///     Result Jint 2.11.58: 1.36812
        ///     Result Jint 3.0.0-beta-2052: 1.3681199999999998
        /// </summary>
        [Fact]
        public void Precision()
        {
            var script = string.Format(ScriptTemplate, "'1368,12'.replace(',','.')/1000");

            var result = new ScriptResult<string>();
            this.engine.Execute(script).Invoke("resolve", Array.Empty<string>(), result);

            Assert.Equal("1.36812", result.Value);
        }

        /// <summary>
        ///     Result Jint 2.11.58: 2.0170712075846E+15
        ///     Result Jint 3.0.0-beta-2052: 2017071207584600
        /// </summary>
        [Fact]
        public void Precision2()
        {
            var script = string.Format(ScriptTemplate, "2017071207584600");

            var result = new ScriptResult<string>();
            this.engine.Execute(script).Invoke("resolve", Array.Empty<string>(), result);

            Assert.Equal("2.0170712075846E+15", result.Value);
        }

        /// <summary>
        ///     Result Jint 2.11.58: 1.36812: 04/14/2014 12:51:30
        ///     Result Jint 3.0.0-beta-2052:  4/14/2014 12:51:30 PM
        /// </summary>
        [Fact]
        public void DateTimeFormat()
        {
            var script = string.Format(ScriptTemplate, "GetCurrentTriggerTime()");

            var result = new ScriptResult<string>();
            this.engine.Execute(script).Invoke("resolve", Array.Empty<string>(), result);

            Assert.Equal("04/14/2014 12:51:30", result.Value);
        }

        /// <summary>
        ///     Result Jint 2.11.58: 1.36812: 04/14/2014 12:51:30
        ///     Result Jint 3.0.0-beta-2052:  4/14/2014 12:51:30 PM
        /// </summary>
        [Fact]
        public void ToUniversalDateTime()
        {
            var script = string.Format(ScriptTemplate, "GetCurrentTriggerTime().ToUniversalTime()");

            var result = new ScriptResult<string>();
            this.engine.Execute(script).Invoke("resolve", Array.Empty<string>(), result);

            Assert.Equal("04/14/2014 12:51:30", result.Value);
        }
    }
}

/// <summary>
///     The script result.
/// </summary>
/// <typeparam name="T">The type of the result value.</typeparam>
public class ScriptResult<T>
{
    /// <summary>
    ///     Gets or sets a value indicating whether the condition is set or not.
    /// </summary>
    public bool Condition
    {
        get;
        set;
    }

    /// <summary>
    ///     Gets or sets the Name.
    /// </summary>
    public string Name
    {
        get;
        set;
    }

    /// <summary>
    ///     Gets or sets the value.
    /// </summary>
    public T Value
    {
        get;
        set;
    }
}

[lahma]

• trim is now built-in, no need to redefine with slower version
• all latest String prototype functions are now implemented, you should probably at least alias against existing ones to get better performing versions (String.prototype.ltrim = String.prototype.trimStart), all your custom versions seem redundant
• DateTimeFormat, ToUniversalDateTime - don't know what to expect here when relying on some implicit conversions, now the string is at least parseable with ambiguity (ISO format)
• EndsWith_ReturnAsString_True, StartsWith_ReturnAsString_True - same behavior as with Node.js - boolean value as string is lower-case unlike in .NET
• Precision and Precision2 - Jint has better support for precision now and this matches Node.js

[j-bernhard]

@lahma thx for spending time on that topic and giving me some advices, about some legacy stuff. I understand that all works as you expect and I agree with you.

But everyone who migrate from jint 2 -> 3 should be aware of that to not run into problem with there production system, because it is a differen behavior as before.