test everything!

Author: orsinium

docs/slice/README.md

@@ -55,7 +55,7 @@ type Slice struct {
 | [Equal](./equal.md) | Equal returns true if slices are equal |
 | [Filter](./filter.md) | Filter returns slice of T for which F returned true |
 | [Find](./find.md) | Find returns the first element for which f returns true |
-| [FindIndex](./findindex.md) | FindIndex is like Find, but return element index instead of element itself |
+| [FindIndex](./findindex.md) | FindIndex is like Find, but return element index instead of element itself. Returns -1 if element not found |
 | [Join](./join.md) | Join concatenates elements of the slice to create a single string. |
 | [GroupBy](./groupby.md) | GroupBy groups element from array by value returned by f |
 | [InsertAt](./insertat.md) | InsertAt returns the slice with element inserted at given index. |

docs/slice/choice.md

@@ -55,3 +55,16 @@ func (s Slice) Choice(seed int64) (T, error) {
 }
 ```
 
+## Tests
+
+```go
+func TestSliceChoice(t *testing.T) {
+	f := func(given []T, seed int64, expected T) {
+		actual, _ := Slice{given}.Choice(seed)
+		assert.Equal(t, expected, actual, "they should be equal")
+	}
+	f([]T{1}, 0, 1)
+	f([]T{1, 2, 3}, 1, 3)
+	f([]T{1, 2, 3}, 2, 2)
+}
+```

docs/slice/findindex.md

@@ -1,10 +1,10 @@
 # Slice.FindIndex
 
 ```go
-func (s Slice) FindIndex(f func(el T) bool) (int, error)
+func (s Slice) FindIndex(f func(el T) bool) int
 ```
 
-FindIndex is like Find, but return element index instead of element itself
+FindIndex is like Find, but return element index instead of element itself. Returns -1 if element not found
 
 Generic types: T.
 
@@ -29,43 +29,37 @@ Generic types: T.
 | SliceUint64 | uint64 |
 | SliceInterface | interface{} |
 
-## Errors
-
-| Error | Message |
-| -------- | ------ |
-| ErrNotFound | given element is not found |
-
 ## Source
 
 ```go
-// FindIndex is like Find, but return element index instead of element itself
-func (s Slice) FindIndex(f func(el T) bool) (int, error) {
+// FindIndex is like Find, but return element index instead of element itself.
+// Returns -1 if element not found
+func (s Slice) FindIndex(f func(el T) bool) int {
 	for i, el := range s.Data {
 		if f(el) {
-			return i, nil
+			return i
 		}
 	}
-	return 0, ErrNotFound
+	return -1
 }
 ```
 
 ## Tests
 
 ```go
 func TestSliceFindIndex(t *testing.T) {
-	f := func(given []T, expectedInd int, expectedErr error) {
+	f := func(given []T, expectedInd int) {
 		even := func(t T) bool { return (t % 2) == 0 }
-		index, err := Slice{given}.FindIndex(even)
+		index := Slice{given}.FindIndex(even)
 		assert.Equal(t, expectedInd, index, "they should be equal")
-		assert.Equal(t, expectedErr, err, "they should be equal")
 	}
-	f([]T{}, 0, ErrNotFound)
-	f([]T{1}, 0, ErrNotFound)
-	f([]T{1}, 0, ErrNotFound)
-	f([]T{2}, 0, nil)
-	f([]T{1, 2}, 1, nil)
-	f([]T{1, 2, 3}, 1, nil)
-	f([]T{1, 3, 5, 7, 9, 2}, 5, nil)
-	f([]T{1, 3, 5}, 0, ErrNotFound)
+	f([]T{}, -1)
+	f([]T{1}, -1)
+	f([]T{1}, -1)
+	f([]T{2}, 0)
+	f([]T{1, 2}, 1)
+	f([]T{1, 2, 3}, 1)
+	f([]T{1, 3, 5, 7, 9, 2}, 5)
+	f([]T{1, 3, 5}, -1)
 }
 ```

docs/slice/without.md

@@ -50,3 +50,30 @@ func (s Slice) Without(elements ...T) []T {
 }
 ```
 
+## Tests
+
+```go
+func TestSliceWithout(t *testing.T) {
+	f := func(given []T, items []T, expected []T) {
+		actual := Slice{given}.Without(items...)
+		assert.Equal(t, expected, actual, "they should be equal")
+	}
+	f([]T{}, []T{}, []T{})
+	f([]T{}, []T{1, 2}, []T{})
+
+	f([]T{1}, []T{1}, []T{})
+	f([]T{1}, []T{1, 2}, []T{})
+	f([]T{1}, []T{2}, []T{1})
+
+	f([]T{1, 2, 3, 4}, []T{1}, []T{2, 3, 4})
+	f([]T{1, 2, 3, 4}, []T{2}, []T{1, 3, 4})
+	f([]T{1, 2, 3, 4}, []T{4}, []T{1, 2, 3})
+
+	f([]T{1, 2, 3, 4}, []T{1, 2}, []T{3, 4})
+	f([]T{1, 2, 3, 4}, []T{1, 2, 4}, []T{3})
+	f([]T{1, 2, 3, 4}, []T{1, 2, 3, 4}, []T{})
+	f([]T{1, 2, 3, 4}, []T{2, 4}, []T{1, 3})
+
+	f([]T{1, 1, 2, 3, 1, 4, 1}, []T{1}, []T{2, 3, 4})
+}
+```

docs/slices/README.md

@@ -36,4 +36,4 @@ type Slices struct {
 | -------- | ----------- |
 | [Concat](./concat.md) | Concat concatenates given slices into a single slice. |
 | [Product](./product.md) | Product returns cortesian product of elements {{1, 2}, {3, 4}} -> {1, 3}, {1, 4}, {2, 3}, {2, 4} |
-| [Zip](./zip.md) | Zip returns array of arrays of elements from given arrs on the same position |
+| [Zip](./zip.md) | Zip returns chan of arrays of elements from given arrs on the same position. |

docs/slices/concat.md

@@ -42,3 +42,19 @@ func (s Slices) Concat() []T {
 }
 ```
 
+## Tests
+
+```go
+func TestSlicesConcat(t *testing.T) {
+	f := func(given [][]T, expected []T) {
+		actual := Slices{given}.Concat()
+		assert.Equal(t, expected, actual, "they should be equal")
+	}
+	f([][]T{}, []T{})
+	f([][]T{{}}, []T{})
+	f([][]T{{1}}, []T{1})
+	f([][]T{{1}, {}}, []T{1})
+	f([][]T{{}, {1}}, []T{1})
+	f([][]T{{1, 2}, {3, 4, 5}}, []T{1, 2, 3, 4, 5})
+}
+```

docs/slices/zip.md

@@ -1,10 +1,10 @@
 # Slices.Zip
 
 ```go
-func (s Slices) Zip() [][]T
+func (s Slices) Zip() chan []T
 ```
 
-Zip returns array of arrays of elements from given arrs on the same position
+Zip returns chan of arrays of elements from given arrs on the same position.
 
 Generic types: T.
 
@@ -32,25 +32,56 @@ Generic types: T.
 ## Source
 
 ```go
-// Zip returns array of arrays of elements from given arrs
-// on the same position
-func (s Slices) Zip() [][]T {
+// Zip returns chan of arrays of elements from given arrs on the same position.
+func (s Slices) Zip() chan []T {
+	if len(s.Data) == 0 {
+		result := make(chan []T)
+		close(result)
+		return result
+	}
+
 	size := len(s.Data[0])
 	for _, arr := range s.Data[1:] {
-		if len(arr) > size {
+		if len(arr) < size {
 			size = len(arr)
 		}
 	}
 
-	result := make([][]T, 0, size)
-	for i := 0; i <= size; i++ {
-		chunk := make([]T, 0, len(s.Data))
-		for _, arr := range s.Data {
-			chunk = append(chunk, arr[i])
+	result := make(chan []T, 1)
+	go func() {
+		for i := 0; i < size; i++ {
+			chunk := make([]T, 0, len(s.Data))
+			for _, arr := range s.Data {
+				chunk = append(chunk, arr[i])
+			}
+			result <- chunk
 		}
-		result = append(result, chunk)
-	}
+		close(result)
+	}()
 	return result
 }
 ```
 
+## Tests
+
+```go
+func TestSlicesZip(t *testing.T) {
+	f := func(given [][]T, expected [][]T) {
+		actual := make([][]T, 0)
+		i := 0
+		s := Slices{given}
+		for el := range s.Zip() {
+			actual = append(actual, el)
+			i++
+			if i > 50 {
+				t.Fatal("infinite loop")
+			}
+		}
+		assert.Equal(t, expected, actual, "they should be equal")
+	}
+	f([][]T{}, [][]T{})
+	f([][]T{{1}, {2}}, [][]T{{1, 2}})
+	f([][]T{{1, 2}, {3, 4}}, [][]T{{1, 3}, {2, 4}})
+	f([][]T{{1, 2, 3}, {4, 5}}, [][]T{{1, 4}, {2, 5}})
+}
+```