Merge pull request #4 from repeale/test/add-code-coverage

test: add code coverage

Author: repeale

README.md

@@ -196,7 +196,7 @@ func sumTwo(x int) int {
 	return x + 2
 }
 
-Pipe2(fp.Filter(isPositive), fp.Map(sumTwo))([]int{1, 2, 3, -1})
+Compose2(fp.Filter(isPositive), fp.Map(sumTwo))([]int{1, 2, 3, -1})
 
 // => []int{3,4,5,1}
 ```

compose_test.go

@@ -0,0 +1,42 @@
+package fp
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestCompose2_Example(t *testing.T) {
+	res := Compose2(
+		Map(func(x int) int { return x + 2 }),
+		Filter(func(x int) bool { return x > 0 }))([]int{1, 2, 3, -1})
+	expected := []int{3, 4, 5}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should perform right-to-left function composition of two functions. Received:", res)
+	}
+}
+
+func TestCompose3_Example(t *testing.T) {
+	res := Compose3(
+		Map(func(x int) int { return x + 2 }),
+		Map(func(x int) int { return x + 2 }),
+		Filter(func(x int) bool { return x > 0 }))([]int{1, 2, 3, -1})
+	expected := []int{5, 6, 7}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should perform right-to-left function composition of two functions. Received:", res)
+	}
+}
+
+func TestCompose4_Example(t *testing.T) {
+	res := Compose4(
+		Map(func(x int) int { return x + 2 }),
+		Map(func(x int) int { return x + 2 }),
+		Map(func(x int) int { return x + 2 }),
+		Filter(func(x int) bool { return x > 0 }))([]int{1, 2, 3, -1})
+	expected := []int{7, 8, 9}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should perform right-to-left function composition of two functions. Received:", res)
+	}
+}

curry_test.go

@@ -0,0 +1,29 @@
+package fp
+
+import (
+	"testing"
+)
+
+func TestCurry2_Example(t *testing.T) {
+	res := Curry2(func(a int, b int) int { return a + b })(1)(2)
+
+	if res != 3 {
+		t.Error("Should allow to curry a sum. Received:", res)
+	}
+}
+
+func TestCurry3_Example(t *testing.T) {
+	res := Curry3(func(a int, b int, c int) int { return a + b + c })(1)(2)(3)
+
+	if res != 6 {
+		t.Error("Should allow to curry a sum. Received:", res)
+	}
+}
+
+func TestCurry4_Example(t *testing.T) {
+	res := Curry4(func(a int, b int, c int, d int) int { return a + b + c + d })(1)(2)(3)(4)
+
+	if res != 10 {
+		t.Error("Should allow to curry a sum. Received:", res)
+	}
+}

every_test.go

@@ -0,0 +1,53 @@
+package fp
+
+import (
+	"testing"
+)
+
+func TestEvery_TrueExample(t *testing.T) {
+	res := Every(func(x int) bool { return x > 0 })([]int{1, 2, 3})
+
+	if res != true {
+		t.Error("Every should return true as all elements match the condition. Received:", res)
+	}
+}
+
+func TestEvery_FalseExample(t *testing.T) {
+	res := Every(func(x int) bool { return x < 0 })([]int{-1, -2, 3})
+
+	if res != false {
+		t.Error("Every should return false if at least one element does not match the condition. Received:", res)
+	}
+}
+
+func TestEveryWithIndex_TrueExample(t *testing.T) {
+	res := EveryWithIndex(func(x int, i int) bool { return x+i > 0 })([]int{1, 2, -1})
+
+	if res != true {
+		t.Error("Every should return true as all elements match the condition. Received:", res)
+	}
+}
+
+func TestEveryWithIndex_FalseExample(t *testing.T) {
+	res := EveryWithIndex(func(x int, i int) bool { return x+i < 0 })([]int{-1, -2, 3})
+
+	if res != false {
+		t.Error("Every should return false if at least one element does not match the condition. Received:", res)
+	}
+}
+
+func TestEveryWithSlice_TrueExample(t *testing.T) {
+	res := EveryWithSlice(func(x int, i int, xs []int) bool { return x+i+xs[0] > 0 })([]int{1, 2, -2})
+
+	if res != true {
+		t.Error("Every should return true as all elements match the condition. Received:", res)
+	}
+}
+
+func TestEveryWithSlice_FalseExample(t *testing.T) {
+	res := EveryWithSlice(func(x int, i int, xs []int) bool { return x+i+xs[0] < 0 })([]int{-1, -2, 3})
+
+	if res != false {
+		t.Error("Every should return false if at least one element does not match the condition. Received:", res)
+	}
+}

filter_test.go

@@ -0,0 +1,33 @@
+package fp
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestFilter(t *testing.T) {
+	res := Filter(func(x int) bool { return x > 0 })([]int{-1, 2, -3, 4})
+	expected := []int{2, 4}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Filter should return only elements for which the callback returns true. Received:", res)
+	}
+}
+
+func TestFilterWithIndex(t *testing.T) {
+	res := FilterWithIndex(func(x int, i int) bool { return x+i > 0 })([]int{-3, 2, -1, 4})
+	expected := []int{2, -1, 4}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Filter should return only elements for which the callback returns true. Received:", res)
+	}
+}
+
+func TestFilterWithSlice(t *testing.T) {
+	res := FilterWithSlice(func(x int, i int, xs []int) bool { return x+i+xs[0] > 0 })([]int{2, -1, 4, -3})
+	expected := []int{2, -1, 4, -3}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Filter should return only elements for which the callback returns true. Received:", res)
+	}
+}

flatMap_test.go

@@ -0,0 +1,32 @@
+package fp
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestFlatMap_Example(t *testing.T) {
+	res := FlatMap(func(x int) []int { return []int{x, x} })([]int{1, 2})
+	expected := []int{1, 1, 2, 2}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should call a defined callback function on each element of an array. Then, flattens the result into a new array. Received:", res)
+	}
+}
+
+func TestFlatMapWithIndex_Example(t *testing.T) {
+	res := FlatMapWithIndex(func(x int, i int) []int { return []int{x + i, x + i} })([]int{1, 2})
+	expected := []int{1, 1, 3, 3}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should call a defined callback function on each element of an array. Then, flattens the result into a new array. Received:", res)
+	}
+}
+func TestFlatMapWithSlice_Example(t *testing.T) {
+	res := FlatMapWithSlice(func(x int, i int, xs []int) []int { return []int{x + i + xs[0], x + i + xs[0]} })([]int{1, 2})
+	expected := []int{2, 2, 4, 4}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should call a defined callback function on each element of an array. Then, flattens the result into a new array. Received:", res)
+	}
+}

flat_test.go

@@ -0,0 +1,15 @@
+package fp
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestFlat_Example(t *testing.T) {
+	res := Flat([][]int{{1, 2}, {3, 4}})
+	expected := []int{1, 2, 3, 4}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should return a new array with all sub-array elements concatenated into it recursively up to the specified depth. Received:", res)
+	}
+}

map_test.go

@@ -0,0 +1,38 @@
+package fp
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestMap_ExampleTestMapWithIndex_Example(t *testing.T) {
+	res := Map(func(x int64) string {
+		return strconv.FormatInt(x, 10)
+	})([]int64{1, 2, 3})
+	expected := []string{"1", "2", "3"}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should map int64 into string. Received:", res)
+	}
+}
+
+func TestMapWithIndex_Example(t *testing.T) {
+	res := MapWithIndex(
+		func(x int64, i int) string { return strconv.FormatInt(x+int64(i), 10) })([]int64{1, 2, 3})
+	expected := []string{"1", "3", "5"}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should map int64 into string. Received:", res)
+	}
+}
+
+func TestMapWithSlice_Example(t *testing.T) {
+	res := MapWithSlice(
+		func(x int64, i int, xs []int64) string { return strconv.FormatInt(x+int64(i)+xs[0], 10) })([]int64{1, 2, 3})
+	expected := []string{"2", "4", "6"}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should map int64 into string. Received:", res)
+	}
+}

pipe_test.go

@@ -0,0 +1,42 @@
+package fp
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestPipe2_Example(t *testing.T) {
+	res := Pipe2(
+		Filter(func(x int) bool { return x > 0 }),
+		Map(func(x int) int { return x + 2 }))([]int{1, 2, 3, -1})
+	expected := []int{3, 4, 5}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should perform left-to-right function composition of two functions. Received:", res)
+	}
+}
+
+func TestPipe3_Example(t *testing.T) {
+	res := Pipe3(
+		Filter(func(x int) bool { return x > 0 }),
+		Map(func(x int) int { return x + 2 }),
+		Map(func(x int) int { return x + 2 }))([]int{1, 2, 3, -1})
+	expected := []int{5, 6, 7}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should perform left-to-right function composition of two functions. Received:", res)
+	}
+}
+
+func TestPipe4_Example(t *testing.T) {
+	res := Pipe4(
+		Filter(func(x int) bool { return x > 0 }),
+		Map(func(x int) int { return x + 2 }),
+		Map(func(x int) int { return x + 2 }),
+		Map(func(x int) int { return x + 2 }))([]int{1, 2, 3, -1})
+	expected := []int{7, 8, 9}
+
+	if reflect.DeepEqual(res, expected) == false {
+		t.Error("Should perform left-to-right function composition of two functions. Received:", res)
+	}
+}

reduce_test.go

@@ -0,0 +1,29 @@
+package fp
+
+import (
+	"testing"
+)
+
+func TestReduce_Example(t *testing.T) {
+	res := Reduce(func(acc int, curr int) int { return acc + curr }, 0)([]int{1, 2, 3})
+
+	if res != 6 {
+		t.Error("Reduce should call the specified callback function for all the elements in an array. The return value of the callback function should be the accumulated result, and is provided as an argument in the next call to the callback function. Received:", res)
+	}
+}
+
+func TestReduceWithIndex_Example(t *testing.T) {
+	res := ReduceWithIndex(func(acc int, curr int, i int) int { return acc + curr + i }, 0)([]int{1, 2, 3})
+
+	if res != 9 {
+		t.Error("Reduce should call the specified callback function for all the elements in an array. The return value of the callback function should be the accumulated result, and is provided as an argument in the next call to the callback function. Received:", res)
+	}
+}
+
+func TestReduceWithSlice_Example(t *testing.T) {
+	res := ReduceWithSlice(func(acc int, curr int, i int, xs []int) int { return acc + curr + i + xs[0] }, 0)([]int{1, 2, 3})
+
+	if res != 12 {
+		t.Error("Reduce should call the specified callback function for all the elements in an array. The return value of the callback function should be the accumulated result, and is provided as an argument in the next call to the callback function. Received:", res)
+	}
+}

some_test.go

@@ -0,0 +1,53 @@
+package fp
+
+import (
+	"testing"
+)
+
+func TestSome_TrueExmple(t *testing.T) {
+	res := Some(func(x int) bool { return x > 0 })([]int{-1, -2, 3})
+
+	if res != true {
+		t.Error("Some should return true as at least one element match the condition. Received:", res)
+	}
+}
+
+func TestSome_FalseExmple(t *testing.T) {
+	res := Some(func(x int) bool { return x < 0 })([]int{1, 2, 3})
+
+	if res != false {
+		t.Error("Some should return false as none of the element match the condition. Received:", res)
+	}
+}
+
+func TestSomeWithIndex_TrueExmple(t *testing.T) {
+	res := SomeWithIndex(func(x int, i int) bool { return x+i > 0 })([]int{-10, -20, -1})
+
+	if res != true {
+		t.Error("Some should return true as at least one element match the condition. Received:", res)
+	}
+}
+
+func TestSomeWithIndex_FalseExmple(t *testing.T) {
+	res := SomeWithIndex(func(x int, i int) bool { return x+i < 0 })([]int{1, 2, 3})
+
+	if res != false {
+		t.Error("Some should return false as none of the element match the condition. Received:", res)
+	}
+}
+
+func TestSomeWithSlice_TrueExmple(t *testing.T) {
+	res := SomeWithSlice(func(x int, i int, xs []int) bool { return x+i-xs[0] > 0 })([]int{-1, -20, -2})
+
+	if res != true {
+		t.Error("Some should return true as at least one element match the condition. Received:", res)
+	}
+}
+
+func TestSomeWithSlice_FalseExmple(t *testing.T) {
+	res := SomeWithSlice(func(x int, i int, xs []int) bool { return x+i+xs[0] < 0 })([]int{1, 2, 3, -4})
+
+	if res != false {
+		t.Error("Some should return false as none of the element match the condition. Received:", res)
+	}
+}