tests: Port insertSorted() test to jasmine

Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/3164>

tests/meson.build

@@ -22,6 +22,7 @@ unit_testenv.append('GI_TYPELIB_PATH', st_typelib_path, separator: ':')
 unit_tests = [
     'highlighter',
     'injectionManager',
+    'insertSorted',
 ]
 
 foreach test : unit_tests
@@ -40,7 +41,6 @@ foreach test : unit_tests
 endforeach
 
 legacy_tests = [
-    'insertSorted',
     'jsParse',
     'markup',
     'params',

tests/unit/insertSorted.js

@@ -6,53 +6,59 @@
 // we don't actually use
 import 'resource:///org/gnome/shell/ui/environment.js';
 
-import * as Assertions from '../common/assertions.js';
+import {insertSorted} from 'resource:///org/gnome/shell/misc/util.js';
 
-import * as Util from 'resource:///org/gnome/shell/misc/util.js';
+describe('insertSorted()', () => {
+    it('uses integer sorting by default', () => {
+        const arrayInt = [1, 2, 3, 5, 6];
+        insertSorted(arrayInt, 4);
+        expect(arrayInt).toEqual([1, 2, 3, 4, 5, 6]);
+    });
 
-let arrayInt = [1, 2, 3, 5, 6];
+    it('inserts elements with a custom compare function', () => {
-Util.insertSorted(arrayInt, 4, (one, two) => one - two);
+        const arrayInt = [6, 5, 3, 2, 1];
+        insertSorted(arrayInt, 4, (one, two) => two - one);
+        expect(arrayInt).toEqual([6, 5, 4, 3, 2, 1]);
+    });
 
-Assertions.assertArrayEquals('first test', [1, 2, 3, 4, 5, 6], arrayInt);
+    it('inserts before first equal match', () => {
+        const obj1 = {a: 1};
+        const obj2 = {a: 2, b: 0};
+        const obj3 = {a: 2, b: 1};
+        const obj4 = {a: 3};
 
-// no comparator, integer sorting is implied
+        const arrayObj = [obj1, obj3, obj4];
-Util.insertSorted(arrayInt, 3);
+        insertSorted(arrayObj, obj2, (one, two) => one.a - two.a);
+        expect(arrayObj).toEqual([obj1, obj2, obj3, obj4]);
+    });
 
-Assertions.assertArrayEquals('second test', [1, 2, 3, 3, 4, 5, 6], arrayInt);
+    it('does not call compare func when array was empty', () => {
+        const cmp = jasmine.createSpy();
+        const empty = [];
+        insertSorted(empty, 3, cmp);
+        expect(cmp).not.toHaveBeenCalled();
+    });
 
-let obj1 = {a: 1};
+    const checkedCmp = (one, two) => {
-let obj2 = {a: 2, b: 0};
+        if (typeof one !== 'number' || typeof two !== 'number')
-let obj3 = {a: 2, b: 1};
-let obj4 = {a: 3};
-
-let arrayObj = [obj1, obj3, obj4];
-
-// obj2 compares equivalent to obj3, should be
-// inserted before
-Util.insertSorted(arrayObj, obj2, (one, two) => one.a - two.a);
-
-Assertions.assertArrayEquals('object test', [obj1, obj2, obj3, obj4], arrayObj);
-
-const checkedCmp = (one, two) => {
-    if (typeof one != 'number' || typeof two != 'number')
             throw new TypeError('Invalid type passed to checkedCmp');
 
         return one - two;
-};
+    };
 
-let arrayEmpty = [];
+    it('does not access past bounds when inserting at end', () => {
+        const array = [3];
+        expect(() => {
+            insertSorted(array, 4, checkedCmp);
+            insertSorted(array, 5, checkedCmp);
+        }).not.toThrow();
+    });
 
-// check that no comparisons are made when
+    it('does not access past bounds when inserting at beginning', () => {
-// inserting in a empty array
+        const array = [4, 5];
-Util.insertSorted(arrayEmpty, 3, checkedCmp);
+        expect(() => {
-
+            insertSorted(array, 1, checkedCmp);
-// Insert at the end and check that we don't
+            insertSorted(array, 2, checkedCmp);
-// access past it
+        }).not.toThrow();
-Util.insertSorted(arrayEmpty, 4, checkedCmp);
+    });
-Util.insertSorted(arrayEmpty, 5, checkedCmp);
+});
-
-// Some more insertions
-Util.insertSorted(arrayEmpty, 2, checkedCmp);
-Util.insertSorted(arrayEmpty, 1, checkedCmp);
-
-Assertions.assertArrayEquals('checkedCmp test', [1, 2, 3, 4, 5], arrayEmpty);