Sorting: unifying tests

algorithms/maths/permutations-count/permutations_test.go

@@ -1,9 +1,7 @@
 package permutations
 
 import (
-	"bufio"
-	"os"
-	"strconv"
+	"github.com/arnauddri/algorithms/algorithms/sorting/utils"
 	"testing"
 )
 
@@ -26,37 +24,21 @@ func TestRecursive(t *testing.T) {
 }
 
 func BenchmarkRecursive(b *testing.B) {
-	array := _getArray()
+	array := dummy.GetArrayOfSize(10000)
 
 	for i := 0; i < b.N; i++ {
 		recursiveCount(array)
 	}
 }
 
 func BenchmarkIterative(b *testing.B) {
-	array := _getArray()
+	array := dummy.GetArrayOfSize(10000)
 
 	for i := 0; i < b.N; i++ {
 		iterativeCount(array)
 	}
 }
 
-func _getArray() []int {
-	f, err := os.Open("./IntegerArray.txt")
-	defer f.Close()
-	check(err)
-
-	numbers := make([]int, 0)
-	scanner := bufio.NewScanner(f)
-
-	for scanner.Scan() {
-		s, _ := strconv.Atoi(scanner.Text())
-		numbers = append(numbers, s)
-	}
-
-	return numbers
-}
-
 func check(e error) {
 	if e != nil {
 		panic(e)

algorithms/sorting/bubble-sort/bubble.go

@@ -5,12 +5,12 @@ import (
 //"fmt"
 )
 
-func sort(a []int) {
-	for itemCount := len(a) - 1; ; itemCount-- {
+func sort(arr []int) {
+	for itemCount := len(arr) - 1; ; itemCount-- {
 		swap := false
 		for i := 1; i <= itemCount; i++ {
-			if a[i-1] > a[i] {
-				a[i-1], a[i] = a[i], a[i-1]
+			if arr[i-1] > arr[i] {
+				arr[i-1], arr[i] = arr[i], arr[i-1]
 				swap = true
 			}
 		}

algorithms/sorting/bubble-sort/bubble_test.go

@@ -2,31 +2,19 @@ package bubble
 
 import (
 	"fmt"
+	"github.com/arnauddri/algorithms/algorithms/sorting/utils"
 	"testing"
 )
 
 func TestBubbleSort(t *testing.T) {
-	list := []int{1, 3, 2, 8, 4, 10, 54, 49, 6}
+	list := dummy.GetArrayOfSize(100)
 
 	sort(list)
-	sorted_list := []int{1, 2, 3, 4, 6, 8, 10, 49, 54}
 
-	if !deepEqual(list, sorted_list) {
-		fmt.Println(list)
-		t.Error()
-	}
-}
-
-func deepEqual(a, b []int) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
+	for i := 0; i < len(list)-2; i++ {
+		if list[i] > list[i+1] {
+			fmt.Println(list)
+			t.Error()
 		}
 	}
-
-	return true
 }

algorithms/sorting/heap-sort/heap.go

@@ -4,17 +4,15 @@ import (
 	"github.com/arnauddri/algorithms/data-structures/heap"
 )
 
-func sort(a []int) []int {
+func sort(arr []int) []int {
 	h := heap.NewMin()
-	for i := 0; i < len(a); i++ {
-		h.Insert(heap.Int(a[i]))
+	for i := 0; i < len(arr); i++ {
+		h.Insert(heap.Int(arr[i]))
 	}
 
-	sorted := make([]int, 0)
-
-	for i := 0; i < len(a); i++ {
-		sorted = append(sorted, int(h.Extract().(heap.Int)))
+	for i := 0; i < len(arr); i++ {
+		arr[i] = int(h.Extract().(heap.Int))
 	}
 
-	return sorted
+	return arr
 }

algorithms/sorting/heap-sort/heap_test.go

@@ -2,31 +2,19 @@ package heap
 
 import (
 	"fmt"
+	"github.com/arnauddri/algorithms/algorithms/sorting/utils"
 	"testing"
 )
 
 func TestHeapSort(t *testing.T) {
-	list := []int{1, 3, 2, 8, 4, 10, 54, 49, 6}
+	list := dummy.GetArrayOfSize(10)
 
-	sorted := sort(list)
-	sorted_list := []int{1, 2, 3, 4, 6, 8, 10, 49, 54}
+	sort(list)
 
-	if !deepEqual(sorted, sorted_list) {
-		fmt.Println(sorted)
-		t.Error()
-	}
-}
-
-func deepEqual(a, b []int) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
+	for i := 0; i < len(list)-2; i++ {
+		if list[i] > list[i+1] {
+			fmt.Println(list)
+			t.Error()
 		}
 	}
-
-	return true
 }

algorithms/sorting/insertion-sort/insertion.go

@@ -2,14 +2,14 @@ package insertion
 
 import ()
 
-func sort(a []int) {
-	for i := 1; i < len(a); i++ {
-		value := a[i]
+func sort(arr []int) {
+	for i := 1; i < len(arr); i++ {
+		value := arr[i]
 		j := i - 1
-		for j >= 0 && a[j] > value {
-			a[j+1] = a[j]
+		for j >= 0 && arr[j] > value {
+			arr[j+1] = arr[j]
 			j = j - 1
 		}
-		a[j+1] = value
+		arr[j+1] = value
 	}
 }

algorithms/sorting/insertion-sort/insertion_test.go

@@ -2,31 +2,19 @@ package insertion
 
 import (
 	"fmt"
+	"github.com/arnauddri/algorithms/algorithms/sorting/utils"
 	"testing"
 )
 
 func TestInsertionSort(t *testing.T) {
-	list := []int{1, 3, 2, 8, 4, 10, 54, 49, 6}
+	list := dummy.GetArrayOfSize(100)
 
 	sort(list)
-	sorted_list := []int{1, 2, 3, 4, 6, 8, 10, 49, 54}
 
-	if !deepEqual(list, sorted_list) {
-		fmt.Println(list)
-		t.Error()
-	}
-}
-
-func deepEqual(a, b []int) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
+	for i := 0; i < len(list)-2; i++ {
+		if list[i] > list[i+1] {
+			fmt.Println(list)
+			t.Error()
 		}
 	}
-
-	return true
 }

algorithms/sorting/merge-sort/merge.go

@@ -1,9 +1,7 @@
 package merge
 
-var arr = []int{20, 43, 52, -1, 43, 29, 34}
-var s = make([]int, len(arr)/2+1)
-
 func sort(arr []int) {
+	var s = make([]int, len(arr)/2+1)
 	if len(arr) < 2 {
 		return
 	}

algorithms/sorting/merge-sort/merge_test.go

@@ -2,31 +2,19 @@ package merge
 
 import (
 	"fmt"
+	"github.com/arnauddri/algorithms/algorithms/sorting/utils"
 	"testing"
 )
 
 func TestMergeSort(t *testing.T) {
-	list := []int{1, 3, 2, 8, 4, 10, 54, 49, 6}
+	list := dummy.GetArrayOfSize(100)
 
 	sort(list)
-	sorted_list := []int{1, 2, 3, 4, 6, 8, 10, 49, 54}
 
-	if !deepEqual(list, sorted_list) {
-		fmt.Println(list)
-		t.Error()
-	}
-}
-
-func deepEqual(a, b []int) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
+	for i := 0; i < len(list)-2; i++ {
+		if list[i] > list[i+1] {
+			fmt.Println(list)
+			t.Error()
 		}
 	}
-
-	return true
 }

algorithms/sorting/quick-sort/quick_test.go

@@ -2,31 +2,19 @@ package quick
 
 import (
 	"fmt"
+	"github.com/arnauddri/algorithms/algorithms/sorting/utils"
 	"testing"
 )
 
 func TestQuickSort(t *testing.T) {
-	list := []int{1, 3, 2, 8, 4, 10, 54, 49, 6}
+	list := dummy.GetArrayOfSize(100)
 
 	sort(list)
-	sorted_list := []int{1, 2, 3, 4, 6, 8, 10, 49, 54}
 
-	if !deepEqual(list, sorted_list) {
-		fmt.Println(list)
-		t.Error()
-	}
-}
-
-func deepEqual(a, b []int) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
+	for i := 0; i < len(list)-2; i++ {
+		if list[i] > list[i+1] {
+			fmt.Println(list)
+			t.Error()
 		}
 	}
-
-	return true
 }

algorithms/sorting/selection-sort/selection.go

@@ -1,16 +1,16 @@
 package selection
 
-func sort(a []int) []int {
-	for i := 0; i < len(a); i++ {
+func sort(arr []int) []int {
+	for i := 0; i < len(arr); i++ {
 		min := i
-		for j := i + 1; j < len(a); j++ {
-			if a[j] < a[min] {
+		for j := i + 1; j < len(arr); j++ {
+			if arr[j] < arr[min] {
 				min = j
 			}
 		}
 		if min != i {
-			a[i], a[min] = a[min], a[i]
+			arr[i], arr[min] = arr[min], arr[i]
 		}
 	}
-	return a
+	return arr
 }

algorithms/sorting/selection-sort/selection_test.go

@@ -2,31 +2,19 @@ package selection
 
 import (
 	"fmt"
+	"github.com/arnauddri/algorithms/algorithms/sorting/utils"
 	"testing"
 )
 
 func TestSelectionSort(t *testing.T) {
-	list := []int{1, 3, 2, 8, 4, 10, 54, 49, 6}
+	list := dummy.GetArrayOfSize(100)
 
 	sort(list)
-	sorted_list := []int{1, 2, 3, 4, 6, 8, 10, 49, 54}
 
-	if !deepEqual(list, sorted_list) {
-		fmt.Println(list)
-		t.Error()
-	}
-}
-
-func deepEqual(a, b []int) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
+	for i := 0; i < len(list)-2; i++ {
+		if list[i] > list[i+1] {
+			fmt.Println(list)
+			t.Error()
 		}
 	}
-
-	return true
 }