Array.sort should obey execution constraints

sebastienros · Dec 11, 2021 · 6fd8047 · 6fd8047
1 parent 8c4a51e
commit 6fd8047
Show file tree

Hide file tree

Showing 2 changed files with 23 additions and 5 deletions.
diff --git a/Jint.Tests/Runtime/ArrayTests.cs b/Jint.Tests/Runtime/ArrayTests.cs
@@ -115,6 +115,19 @@ public void ArraySortIsStable()
             _engine.Execute(code);
         }
 
+        [Fact]
+        public void ArraySortShouldObeyExecutionConstraints()
+        {
+            const string script = @"
+                let cases = [5,5];
+                let latestCase = cases.sort((c1, c2) => c1 > c2 ? -1: 1);";
+
+            var engine = new Engine(options => options
+                .TimeoutInterval(TimeSpan.FromSeconds(1))
+            );
+            Assert.Throws<TimeoutException>(() => engine.Evaluate(script));
+        }
+
         [Fact]
         public void ExtendingArrayAndInstanceOf()
         {

diff --git a/Jint/Native/Array/ArrayPrototype.cs b/Jint/Native/Array/ArrayPrototype.cs
@@ -959,7 +959,7 @@ private JsValue Sort(JsValue thisObj, JsValue[] arguments)
             // don't eat inner exceptions
             try
             {
-                var array = obj.OrderBy(x => x, ArrayComparer.WithFunction(compareFn)).ToArray();
+                var array = obj.OrderBy(x => x, ArrayComparer.WithFunction(_engine, compareFn)).ToArray();
 
                 for (uint i = 0; i < (uint) array.Length; ++i)
                 {
@@ -1399,22 +1399,25 @@ private sealed class ArrayComparer : IComparer<JsValue>
             /// <summary>
             /// Default instance without any compare function.
             /// </summary>
-            public static ArrayComparer Default = new ArrayComparer(null);
-            public static ArrayComparer WithFunction(ICallable compare)
+            public static readonly ArrayComparer Default = new(null, null);
+
+            public static ArrayComparer WithFunction(Engine engine, ICallable compare)
             {
                 if (compare == null)
                 {
                     return Default;
                 }
 
-                return new ArrayComparer(compare);
+                return new ArrayComparer(engine, compare);
             }
 
+            private readonly Engine _engine;
             private readonly ICallable _compare;
             private readonly JsValue[] _comparableArray = new JsValue[2];
 
-            private ArrayComparer(ICallable compare)
+            private ArrayComparer(Engine engine, ICallable compare)
             {
+                _engine = engine;
                 _compare = compare;
             }
 
@@ -1459,6 +1462,8 @@ public int Compare(JsValue x, JsValue y)
 
                 if (_compare != null)
                 {
+                    _engine.RunBeforeExecuteStatementChecks(null);
+
                     _comparableArray[0] = x;
                     _comparableArray[1] = y;