adding the test cases

src/algorithms/sorting/odd-even-sort/OddEvenSort.js

@@ -1,33 +1,36 @@
 import Sort from '../Sort';
 
 export default class OddEvenSort extends Sort {
-  swap(array, i, j){
-    var temp = array[i];
-    array[i] = array[j];
-    array[j] = temp;
-  }
-
   sort(originalArray) {
     // Clone original array to prevent its modification.
     const array = [...originalArray];
-    const sorted = false;
+    let sorted = false;
 
     // Go through all array elements...
     while (!sorted) {
       sorted = true;
-      for(let i = 1; i < array.length; i+2){
+      // Sort all the odd indexes
+      for (let i = 1; i < array.length - 1; i += 2) {
         // Call visiting callback.
         this.callbacks.visitingCallback(array[i]);
-        if(array[i] > array[i+1]){
-          swap(array, i, i+1);
+
+        // Swap elements if they are in wrong order.
+        if (this.comparator.lessThan(array[i + 1], array[i])) {
+          // Swap the values
+          [array[i], array[i + 1]] = [array[i + 1], array[i]];
           sorted = false;
         }
       }
-      for(let i = 0; i < array.length - 1; i+2){
+
+      // Sort all the even indexes
+      for (let i = 0; i < array.length - 1; i += 2) {
         // Call visiting callback.
         this.callbacks.visitingCallback(array[i]);
-        if(array[i] > array[i+1]){
-          swap(array, i, i+1);
+
+        // Swap elements if they are in wrong order.
+        if (this.comparator.lessThan(array[i + 1], array[i])) {
+          // Swap the values
+          [array[i], array[i + 1]] = [array[i + 1], array[i]];
           sorted = false;
         }
       }

src/algorithms/sorting/odd-even-sort/__test__/OddEvenSort.test.js

@@ -0,0 +1,64 @@
+import OddEvenSort from '../OddEvenSort';
+import {
+  // equalArr,
+  // notSortedArr,
+  reverseArr,
+  // sortedArr,
+  SortTester,
+} from '../../SortTester';
+
+// Complexity constants.
+// const SORTED_ARRAY_VISITING_COUNT = 20;
+// const NOT_SORTED_ARRAY_VISITING_COUNT = 189;
+const REVERSE_SORTED_ARRAY_VISITING_COUNT = 209;
+// const EQUAL_ARRAY_VISITING_COUNT = 20;
+
+describe('OddEvenSort', () => {
+  it('should sort array', () => {
+    SortTester.testSort(OddEvenSort);
+  });
+
+  it('should sort array with custom comparator', () => {
+    SortTester.testSortWithCustomComparator(OddEvenSort);
+  });
+
+  it('should do stable sorting', () => {
+    SortTester.testSortStability(OddEvenSort);
+  });
+
+  it('should sort negative numbers', () => {
+    SortTester.testNegativeNumbersSort(OddEvenSort);
+  });
+
+  // it('should visit EQUAL array element specified number of times', () => {
+  //   SortTester.testAlgorithmTimeComplexity(
+  //     OddEvenSort,
+  //     equalArr,
+  //     EQUAL_ARRAY_VISITING_COUNT,
+  //   );
+  // });
+
+  // it('should visit SORTED array element specified number of times', () => {
+  //   SortTester.testAlgorithmTimeComplexity(
+  //     OddEvenSort,
+  //     sortedArr,
+  //     SORTED_ARRAY_VISITING_COUNT,
+  //   );
+  // });
+
+  // it('should visit NOT SORTED array element specified number of times', () => {
+  //   SortTester.testAlgorithmTimeComplexity(
+  //     OddEvenSort,
+  //     notSortedArr,
+  //     NOT_SORTED_ARRAY_VISITING_COUNT,
+  //   );
+  // });
+
+  it('should visit REVERSE SORTED array element specified number of times', () => {
+    SortTester.testAlgorithmTimeComplexity(
+      OddEvenSort,
+      reverseArr,
+      REVERSE_SORTED_ARRAY_VISITING_COUNT,
+    );
+  });
+});