Fix the order of actual result and expected result

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hckrnews/arrays",
-    "version": "3.1.1",
+    "version": "3.1.2",
     "description": "Usefull array helpers.",
     "files": [
         "src/helpers.js",

test/diff-object.js

@@ -9,17 +9,17 @@ test('Diff array with objects', async (t) => {
     await t.test(
         'One side: Should return the difference, in this example should it be John.',
         () => {
-            assert.deepEqual([{ name: 'John' }], a.diff(b));
+            assert.deepEqual(a.diff(b), [{ name: 'John' }]);
         }
     );
 
     await t.test(
         'Average both sides: Should return the difference of both sides, in this example should it be John and Paul.',
         () => {
-            assert.deepEqual(
-                [{ name: 'John' }, { name: 'Paul' }],
-                a.diff(b, true)
-            );
+            assert.deepEqual(a.diff(b, true), [
+                { name: 'John' },
+                { name: 'Paul' },
+            ]);
         }
     );
 });

test/diff.js

@@ -9,14 +9,14 @@ test('Diff', async (t) => {
     await t.test(
         'One side: Should return the difference, in this example should it be John.',
         () => {
-            assert.deepEqual(['John'], a.diff(b));
+            assert.deepEqual(a.diff(b), ['John']);
         }
     );
 
     await t.test(
         'Average both sides: Should return the difference of both sides, in this example should it be John and Paul.',
         () => {
-            assert.deepEqual(['John', 'Paul'], a.diff(b, true));
+            assert.deepEqual(a.diff(b, true), ['John', 'Paul']);
         }
     );
 });

test/intersect-object.js

@@ -10,17 +10,17 @@ test('Intersect array with objects', async (t) => {
     await t.test(
         'One side: Should return the intersect, in this example should it be Peter and Luke.',
         () => {
-            assert.deepEqual(
-                [{ name: 'Peter' }, { name: 'Luke' }],
-                a.intersect(b)
-            );
+            assert.deepEqual(a.intersect(b), [
+                { name: 'Peter' },
+                { name: 'Luke' },
+            ]);
         }
     );
 
     await t.test(
         'Average both sides: Should return the intersect of more than 2 arrays, in this example should it be Luke.',
         () => {
-            assert.deepEqual([{ name: 'Luke' }], a.intersect([b, c], true));
+            assert.deepEqual(a.intersect([b, c], true), [{ name: 'Luke' }]);
         }
     );
 });

test/intersect.js

@@ -10,13 +10,13 @@ test('Intersect', async (t) => {
     await t.test(
         'One side: Should return the intersect, in this example should it be Peter and Luke.',
         () => {
-            assert.deepEqual(['Peter', 'Luke'], a.intersect(b));
+            assert.deepEqual(a.intersect(b), ['Peter', 'Luke']);
         }
     );
     await t.test(
         'Average both sides: Should return the intersect of more than 2 arrays, in this example should it be Luke.',
         () => {
-            assert.deepEqual(['Luke'], a.intersect([b, c], true));
+            assert.deepEqual(a.intersect([b, c], true), ['Luke']);
         }
     );
 });

test/multifilter.js

@@ -237,8 +237,8 @@ test('Test 1 (==)', async (t) => {
         'Should return 2 items from the array, where age is 62.',
         () => {
             assert.deepEqual(
-                expectedResults.test1,
-                exampleArray.multifilter('age', 62)
+                exampleArray.multifilter('age', 62),
+                expectedResults.test1
             );
         }
     );
@@ -249,8 +249,8 @@ test('Test 2 (!=)', async (t) => {
         'Should return 2 items from the array, where age is not 62.',
         () => {
             assert.deepEqual(
-                expectedResults.test2,
-                exampleArray.multifilter('age', 62, '!=')
+                exampleArray.multifilter('age', 62, '!='),
+                expectedResults.test2
             );
         }
     );
@@ -261,8 +261,8 @@ test('Test 3 (>)', async (t) => {
         'Should return 2 items from the array, where age is more than 62.',
         () => {
             assert.deepEqual(
-                expectedResults.test3,
-                exampleArray.multifilter('age', 62, '>')
+                exampleArray.multifilter('age', 62, '>'),
+                expectedResults.test3
             );
         }
     );
@@ -309,8 +309,8 @@ test('Test 7 (multiple ==)', async (t) => {
         'Should return 2 items from the array, where the name is John or Peter.',
         () => {
             assert.deepEqual(
-                expectedResults.test7,
-                exampleArray.multifilter('name', ['John', 'Peter'])
+                exampleArray.multifilter('name', ['John', 'Peter']),
+                expectedResults.test7
             );
         }
     );
@@ -321,8 +321,8 @@ test('Test 8 (multiple !=)', async (t) => {
         'Should return 2 items from the array, where the name is not John or Peter.',
         () => {
             assert.deepEqual(
-                expectedResults.test8,
-                exampleArray.multifilter('name', ['John', 'Peter'], '!=')
+                exampleArray.multifilter('name', ['John', 'Peter'], '!='),
+                expectedResults.test8
             );
         }
     );
@@ -333,8 +333,8 @@ test('Test 9 (multiple >)', async (t) => {
         'Should return 2 items from the array, where age is more than 62 and 63.',
         () => {
             assert.deepEqual(
-                expectedResults.test9,
-                exampleArray.multifilter('age', ['62', '63'], '>')
+                exampleArray.multifilter('age', ['62', '63'], '>'),
+                expectedResults.test9
             );
         }
     );

test/multikey.js

@@ -56,8 +56,8 @@ test('Multikey', async (t) => {
         'Test 1 (single): Should return the max, in this example should it be 3.',
         () => {
             assert.deepEqual(
-                expectedResults.test1,
-                exampleArray.multikey('name')
+                exampleArray.multikey('name'),
+                expectedResults.test1
             );
         }
     );
@@ -66,8 +66,8 @@ test('Multikey', async (t) => {
         'Test 2 (multiple): Should return the max, in this example should it be 3.',
         () => {
             assert.deepEqual(
-                expectedResults.test2,
-                exampleArray.multikey(['name', 'age'])
+                exampleArray.multikey(['name', 'age']),
+                expectedResults.test2
             );
         }
     );

test/multisort.js

@@ -117,8 +117,8 @@ test('Multisort', async (t) => {
         'Test 1 (ASC): Should return the array, sorted by age asc.',
         () => {
             assert.deepEqual(
-                expectedResults.test1,
-                exampleArray.multisort('age', 'asc')
+                exampleArray.multisort('age', 'asc'),
+                expectedResults.test1
             );
         }
     );
@@ -127,8 +127,8 @@ test('Multisort', async (t) => {
         'Test 2 (DESC): Should return the array, sorted by age desc.',
         () => {
             assert.deepEqual(
-                expectedResults.test2,
-                exampleArray.multisort('age', 'desc')
+                exampleArray.multisort('age', 'desc'),
+                expectedResults.test2
             );
         }
     );
@@ -137,8 +137,8 @@ test('Multisort', async (t) => {
         'Test 3 (sort text ASC): Should return the array, sorted by age asc.',
         () => {
             assert.deepEqual(
-                expectedResults.test3,
-                exampleArray.multisort('name', 'asc')
+                exampleArray.multisort('name', 'asc'),
+                expectedResults.test3
             );
         }
     );

test/unique.js

@@ -10,7 +10,7 @@ test('Unique', async (t) => {
     await t.test(
         'Should return the unique items from the array, in this example 4 items.',
         () => {
-            assert.deepEqual(expectedResults, a.unique);
+            assert.deepEqual(a.unique, expectedResults);
         }
     );
 });