summaryrefslogtreecommitdiff
path: root/src/pkg/exp/iterable/iterable_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/exp/iterable/iterable_test.go')
-rw-r--r--src/pkg/exp/iterable/iterable_test.go302
1 files changed, 151 insertions, 151 deletions
diff --git a/src/pkg/exp/iterable/iterable_test.go b/src/pkg/exp/iterable/iterable_test.go
index 242a725a9..1d60d4b91 100644
--- a/src/pkg/exp/iterable/iterable_test.go
+++ b/src/pkg/exp/iterable/iterable_test.go
@@ -5,42 +5,42 @@
package iterable
import (
- "container/vector";
- "testing";
+ "container/vector"
+ "testing"
)
func TestArrayTypes(t *testing.T) {
// Test that conversion works correctly.
- bytes := ByteArray([]byte{1, 2, 3});
+ bytes := ByteArray([]byte{1, 2, 3})
if x := Data(bytes)[1].(byte); x != 2 {
t.Error("Data(bytes)[1].(byte) = %v, want 2", x)
}
- ints := IntArray([]int{1, 2, 3});
+ ints := IntArray([]int{1, 2, 3})
if x := Data(ints)[2].(int); x != 3 {
t.Error("Data(ints)[2].(int) = %v, want 3", x)
}
- floats := FloatArray([]float{1, 2, 3});
+ floats := FloatArray([]float{1, 2, 3})
if x := Data(floats)[0].(float); x != 1 {
t.Error("Data(floats)[0].(float) = %v, want 1", x)
}
- strings := StringArray([]string{"a", "b", "c"});
+ strings := StringArray([]string{"a", "b", "c"})
if x := Data(strings)[1].(string); x != "b" {
t.Error(`Data(strings)[1].(string) = %q, want "b"`, x)
}
}
var (
- oneToFive = IntArray{1, 2, 3, 4, 5};
- sixToTen = IntArray{6, 7, 8, 9, 10};
- elevenToTwenty = IntArray{11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+ oneToFive = IntArray{1, 2, 3, 4, 5}
+ sixToTen = IntArray{6, 7, 8, 9, 10}
+ elevenToTwenty = IntArray{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
)
-func isNegative(n interface{}) bool { return n.(int) < 0 }
-func isPositive(n interface{}) bool { return n.(int) > 0 }
-func isAbove3(n interface{}) bool { return n.(int) > 3 }
-func isEven(n interface{}) bool { return n.(int)%2 == 0 }
-func doubler(n interface{}) interface{} { return n.(int) * 2 }
-func addOne(n interface{}) interface{} { return n.(int) + 1 }
+func isNegative(n interface{}) bool { return n.(int) < 0 }
+func isPositive(n interface{}) bool { return n.(int) > 0 }
+func isAbove3(n interface{}) bool { return n.(int) > 3 }
+func isEven(n interface{}) bool { return n.(int)%2 == 0 }
+func doubler(n interface{}) interface{} { return n.(int) * 2 }
+func addOne(n interface{}) interface{} { return n.(int) + 1 }
func adder(acc interface{}, n interface{}) interface{} {
return acc.(int) + n.(int)
}
@@ -49,13 +49,13 @@ func adder(acc interface{}, n interface{}) interface{} {
type integerStream struct{}
func (i integerStream) Iter() <-chan interface{} {
- ch := make(chan interface{});
+ ch := make(chan interface{})
go func() {
for i := 0; ; i++ {
ch <- i
}
- }();
- return ch;
+ }()
+ return ch
}
func TestAll(t *testing.T) {
@@ -78,236 +78,236 @@ func TestAny(t *testing.T) {
func assertArraysAreEqual(t *testing.T, res []interface{}, expected []int) {
if len(res) != len(expected) {
- t.Errorf("len(res) = %v, want %v", len(res), len(expected));
- goto missing;
+ t.Errorf("len(res) = %v, want %v", len(res), len(expected))
+ goto missing
}
for i := range res {
if v := res[i].(int); v != expected[i] {
- t.Errorf("res[%v] = %v, want %v", i, v, expected[i]);
- goto missing;
+ t.Errorf("res[%v] = %v, want %v", i, v, expected[i])
+ goto missing
}
}
- return;
+ return
missing:
- t.Errorf("res = %v\nwant %v", res, expected);
+ t.Errorf("res = %v\nwant %v", res, expected)
}
func TestFilter(t *testing.T) {
- ints := integerStream{};
- moreInts := Filter(ints, isAbove3).Iter();
- res := make([]interface{}, 3);
+ ints := integerStream{}
+ moreInts := Filter(ints, isAbove3).Iter()
+ res := make([]interface{}, 3)
for i := 0; i < 3; i++ {
res[i] = <-moreInts
}
- assertArraysAreEqual(t, res, []int{4, 5, 6});
+ assertArraysAreEqual(t, res, []int{4, 5, 6})
}
func TestFind(t *testing.T) {
- ints := integerStream{};
- first := Find(ints, isAbove3);
+ ints := integerStream{}
+ first := Find(ints, isAbove3)
if first.(int) != 4 {
t.Errorf("Find(ints, isAbove3) = %v, want 4", first)
}
}
func TestInject(t *testing.T) {
- res := Inject(oneToFive, 0, adder);
+ res := Inject(oneToFive, 0, adder)
if res.(int) != 15 {
t.Errorf("Inject(oneToFive, 0, adder) = %v, want 15", res)
}
}
func TestMap(t *testing.T) {
- res := Data(Map(Map(oneToFive, doubler), addOne));
- assertArraysAreEqual(t, res, []int{3, 5, 7, 9, 11});
+ res := Data(Map(Map(oneToFive, doubler), addOne))
+ assertArraysAreEqual(t, res, []int{3, 5, 7, 9, 11})
}
func TestPartition(t *testing.T) {
- ti, fi := Partition(oneToFive, isEven);
- assertArraysAreEqual(t, Data(ti), []int{2, 4});
- assertArraysAreEqual(t, Data(fi), []int{1, 3, 5});
+ ti, fi := Partition(oneToFive, isEven)
+ assertArraysAreEqual(t, Data(ti), []int{2, 4})
+ assertArraysAreEqual(t, Data(fi), []int{1, 3, 5})
}
func TestTake(t *testing.T) {
- res := Take(oneToFive, 2);
- assertArraysAreEqual(t, Data(res), []int{1, 2});
- assertArraysAreEqual(t, Data(res), []int{1, 2}); // second test to ensure that .Iter() returns a new channel
+ res := Take(oneToFive, 2)
+ assertArraysAreEqual(t, Data(res), []int{1, 2})
+ assertArraysAreEqual(t, Data(res), []int{1, 2}) // second test to ensure that .Iter() returns a new channel
// take none
- res = Take(oneToFive, 0);
- assertArraysAreEqual(t, Data(res), []int{});
+ res = Take(oneToFive, 0)
+ assertArraysAreEqual(t, Data(res), []int{})
// try to take more than available
- res = Take(oneToFive, 20);
- assertArraysAreEqual(t, Data(res), oneToFive);
+ res = Take(oneToFive, 20)
+ assertArraysAreEqual(t, Data(res), oneToFive)
}
func TestTakeWhile(t *testing.T) {
// take some
- res := TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) <= 3 });
- assertArraysAreEqual(t, Data(res), []int{1, 2, 3});
- assertArraysAreEqual(t, Data(res), []int{1, 2, 3}); // second test to ensure that .Iter() returns a new channel
+ res := TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) <= 3 })
+ assertArraysAreEqual(t, Data(res), []int{1, 2, 3})
+ assertArraysAreEqual(t, Data(res), []int{1, 2, 3}) // second test to ensure that .Iter() returns a new channel
// take none
- res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) > 3000 });
- assertArraysAreEqual(t, Data(res), []int{});
+ res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) > 3000 })
+ assertArraysAreEqual(t, Data(res), []int{})
// take all
- res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3000 });
- assertArraysAreEqual(t, Data(res), oneToFive);
+ res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3000 })
+ assertArraysAreEqual(t, Data(res), oneToFive)
}
func TestDrop(t *testing.T) {
// drop none
- res := Drop(oneToFive, 0);
- assertArraysAreEqual(t, Data(res), oneToFive);
- assertArraysAreEqual(t, Data(res), oneToFive); // second test to ensure that .Iter() returns a new channel
+ res := Drop(oneToFive, 0)
+ assertArraysAreEqual(t, Data(res), oneToFive)
+ assertArraysAreEqual(t, Data(res), oneToFive) // second test to ensure that .Iter() returns a new channel
// drop some
- res = Drop(oneToFive, 2);
- assertArraysAreEqual(t, Data(res), []int{3, 4, 5});
- assertArraysAreEqual(t, Data(res), []int{3, 4, 5}); // second test to ensure that .Iter() returns a new channel
+ res = Drop(oneToFive, 2)
+ assertArraysAreEqual(t, Data(res), []int{3, 4, 5})
+ assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel
// drop more than available
- res = Drop(oneToFive, 88);
- assertArraysAreEqual(t, Data(res), []int{});
+ res = Drop(oneToFive, 88)
+ assertArraysAreEqual(t, Data(res), []int{})
}
func TestDropWhile(t *testing.T) {
// drop some
- res := DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3 });
- assertArraysAreEqual(t, Data(res), []int{3, 4, 5});
- assertArraysAreEqual(t, Data(res), []int{3, 4, 5}); // second test to ensure that .Iter() returns a new channel
+ res := DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3 })
+ assertArraysAreEqual(t, Data(res), []int{3, 4, 5})
+ assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel
// test case where all elements are dropped
- res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 100 });
- assertArraysAreEqual(t, Data(res), []int{});
+ res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 100 })
+ assertArraysAreEqual(t, Data(res), []int{})
// test case where none are dropped
- res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) > 1000 });
- assertArraysAreEqual(t, Data(res), oneToFive);
+ res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) > 1000 })
+ assertArraysAreEqual(t, Data(res), oneToFive)
}
func TestCycle(t *testing.T) {
- res := Cycle(oneToFive);
- exp := []int{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4};
+ res := Cycle(oneToFive)
+ exp := []int{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4}
// read the first nineteen values from the iterable
- out := make([]interface{}, 19);
+ out := make([]interface{}, 19)
for i, it := 0, res.Iter(); i < 19; i++ {
out[i] = <-it
}
- assertArraysAreEqual(t, out, exp);
+ assertArraysAreEqual(t, out, exp)
- res2 := Cycle(sixToTen);
- exp2 := []int{6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9};
+ res2 := Cycle(sixToTen)
+ exp2 := []int{6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9}
for i, it := 0, res2.Iter(); i < 19; i++ {
out[i] = <-it
}
- assertArraysAreEqual(t, out, exp2);
+ assertArraysAreEqual(t, out, exp2)
// ensure first iterator was not harmed
for i, it := 0, res.Iter(); i < 19; i++ {
out[i] = <-it
}
- assertArraysAreEqual(t, out, exp);
+ assertArraysAreEqual(t, out, exp)
}
func TestChain(t *testing.T) {
- exp := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
- res := Chain([]Iterable{oneToFive, sixToTen, elevenToTwenty});
- assertArraysAreEqual(t, Data(res), exp);
+ exp := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+ res := Chain([]Iterable{oneToFive, sixToTen, elevenToTwenty})
+ assertArraysAreEqual(t, Data(res), exp)
// reusing the same iterator should produce the same result again
- assertArraysAreEqual(t, Data(res), exp);
+ assertArraysAreEqual(t, Data(res), exp)
// test short read from Chain
- i := 0;
- out := make([]interface{}, 4);
+ i := 0
+ out := make([]interface{}, 4)
for v := range res.Iter() {
- out[i] = v;
- i++;
+ out[i] = v
+ i++
if i == len(out) {
break
}
}
- assertArraysAreEqual(t, out, exp[0:4]);
+ assertArraysAreEqual(t, out, exp[0:4])
// test zero length array
- res = Chain([]Iterable{});
- assertArraysAreEqual(t, Data(res), []int{});
+ res = Chain([]Iterable{})
+ assertArraysAreEqual(t, Data(res), []int{})
}
func TestZipWith(t *testing.T) {
- exp := []int{7, 9, 11, 13, 15};
+ exp := []int{7, 9, 11, 13, 15}
// f with 2 args and 1 return value
- f := func(a, b interface{}) interface{} { return a.(int) + b.(int) };
- res := ZipWith2(f, oneToFive, sixToTen);
- assertArraysAreEqual(t, Data(res), exp);
+ f := func(a, b interface{}) interface{} { return a.(int) + b.(int) }
+ res := ZipWith2(f, oneToFive, sixToTen)
+ assertArraysAreEqual(t, Data(res), exp)
// test again to make sure returns new iter each time
- assertArraysAreEqual(t, Data(res), exp);
+ assertArraysAreEqual(t, Data(res), exp)
// test a function with 3 args
- f2 := func(a, b, c interface{}) interface{} { return a.(int) + b.(int) + c.(int) };
- res = ZipWith3(f2, oneToFive, sixToTen, oneToFive);
- exp = []int{8, 11, 14, 17, 20};
- assertArraysAreEqual(t, Data(res), exp);
+ f2 := func(a, b, c interface{}) interface{} { return a.(int) + b.(int) + c.(int) }
+ res = ZipWith3(f2, oneToFive, sixToTen, oneToFive)
+ exp = []int{8, 11, 14, 17, 20}
+ assertArraysAreEqual(t, Data(res), exp)
// test a function with multiple values returned
- f3 := func(a, b interface{}) interface{} { return ([]interface{}{a.(int) + 1, b.(int) + 1}) };
- res = ZipWith2(f3, oneToFive, sixToTen);
+ f3 := func(a, b interface{}) interface{} { return ([]interface{}{a.(int) + 1, b.(int) + 1}) }
+ res = ZipWith2(f3, oneToFive, sixToTen)
- exp2 := [][]int{[]int{2, 7}, []int{3, 8}, []int{4, 9}, []int{5, 10}, []int{6, 11}};
- i := 0;
+ exp2 := [][]int{[]int{2, 7}, []int{3, 8}, []int{4, 9}, []int{5, 10}, []int{6, 11}}
+ i := 0
for v := range res.Iter() {
- out := v.([]interface{});
- assertArraysAreEqual(t, out, exp2[i]);
- i++;
+ out := v.([]interface{})
+ assertArraysAreEqual(t, out, exp2[i])
+ i++
}
// test different length iterators--should stop after shortest is exhausted
- res = ZipWith2(f, elevenToTwenty, oneToFive);
- exp = []int{12, 14, 16, 18, 20};
- assertArraysAreEqual(t, Data(res), exp);
+ res = ZipWith2(f, elevenToTwenty, oneToFive)
+ exp = []int{12, 14, 16, 18, 20}
+ assertArraysAreEqual(t, Data(res), exp)
}
func TestSlice(t *testing.T) {
- out := Data(Slice(elevenToTwenty, 2, 6));
- exp := []int{13, 14, 15, 16};
- assertArraysAreEqual(t, out, exp);
+ out := Data(Slice(elevenToTwenty, 2, 6))
+ exp := []int{13, 14, 15, 16}
+ assertArraysAreEqual(t, out, exp)
// entire iterable
- out = Data(Slice(elevenToTwenty, 0, len(elevenToTwenty)));
- exp = []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
- assertArraysAreEqual(t, out, exp);
+ out = Data(Slice(elevenToTwenty, 0, len(elevenToTwenty)))
+ exp = []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+ assertArraysAreEqual(t, out, exp)
// empty slice at offset 0
- exp = []int{};
- out = Data(Slice(elevenToTwenty, 0, 0));
- assertArraysAreEqual(t, out, exp);
+ exp = []int{}
+ out = Data(Slice(elevenToTwenty, 0, 0))
+ assertArraysAreEqual(t, out, exp)
// slice upper bound exceeds length of iterable
- exp = []int{1, 2, 3, 4, 5};
- out = Data(Slice(oneToFive, 0, 88));
- assertArraysAreEqual(t, out, exp);
+ exp = []int{1, 2, 3, 4, 5}
+ out = Data(Slice(oneToFive, 0, 88))
+ assertArraysAreEqual(t, out, exp)
// slice upper bounce is lower than lower bound
- exp = []int{};
- out = Data(Slice(oneToFive, 93, 4));
- assertArraysAreEqual(t, out, exp);
+ exp = []int{}
+ out = Data(Slice(oneToFive, 93, 4))
+ assertArraysAreEqual(t, out, exp)
// slice lower bound is greater than len of iterable
- exp = []int{};
- out = Data(Slice(oneToFive, 93, 108));
- assertArraysAreEqual(t, out, exp);
+ exp = []int{}
+ out = Data(Slice(oneToFive, 93, 108))
+ assertArraysAreEqual(t, out, exp)
}
func TestRepeat(t *testing.T) {
- res := Repeat(42);
- i := 0;
+ res := Repeat(42)
+ i := 0
for v := range res.Iter() {
if v.(int) != 42 {
t.Fatal("Repeat returned the wrong value")
@@ -315,25 +315,25 @@ func TestRepeat(t *testing.T) {
if i == 9 {
break
}
- i++;
+ i++
}
}
func TestRepeatTimes(t *testing.T) {
- res := RepeatTimes(84, 9);
- exp := []int{84, 84, 84, 84, 84, 84, 84, 84, 84};
- assertArraysAreEqual(t, Data(res), exp);
- assertArraysAreEqual(t, Data(res), exp); // second time to ensure new iter is returned
+ res := RepeatTimes(84, 9)
+ exp := []int{84, 84, 84, 84, 84, 84, 84, 84, 84}
+ assertArraysAreEqual(t, Data(res), exp)
+ assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned
// 0 repeat
- res = RepeatTimes(7, 0);
- exp = []int{};
- assertArraysAreEqual(t, Data(res), exp);
+ res = RepeatTimes(7, 0)
+ exp = []int{}
+ assertArraysAreEqual(t, Data(res), exp)
// negative repeat
- res = RepeatTimes(7, -3);
- exp = []int{};
- assertArraysAreEqual(t, Data(res), exp);
+ res = RepeatTimes(7, -3)
+ exp = []int{}
+ assertArraysAreEqual(t, Data(res), exp)
}
// a type that implements Key for ints
@@ -342,20 +342,20 @@ type intkey struct{}
func (v intkey) Key(a interface{}) interface{} {
return a
}
-func (v intkey) Equal(a, b interface{}) bool { return a.(int) == b.(int) }
+func (v intkey) Equal(a, b interface{}) bool { return a.(int) == b.(int) }
func TestGroupBy(t *testing.T) {
- in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
- exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}};
- i := 0;
+ in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5}
+ exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}}
+ i := 0
for x := range GroupBy(in, intkey{}).Iter() {
- gr := x.(Group);
+ gr := x.(Group)
if gr.Key.(int) != i+1 {
t.Fatal("group key wrong; expected", i+1, "but got", gr.Key.(int))
}
- vals := Data(gr.Vals);
- assertArraysAreEqual(t, vals, exp[i]);
- i++;
+ vals := Data(gr.Vals)
+ assertArraysAreEqual(t, vals, exp[i])
+ i++
}
if i != 5 {
t.Fatal("did not return expected number of groups")
@@ -367,21 +367,21 @@ func TestGroupBy(t *testing.T) {
}
// test case with only uniques
- var out vector.Vector;
+ var out vector.Vector
for x := range GroupBy(elevenToTwenty, intkey{}).Iter() {
out.Push(x.(Group).Key)
}
- assertArraysAreEqual(t, out.Data(), elevenToTwenty);
+ assertArraysAreEqual(t, out.Data(), elevenToTwenty)
}
func TestUnique(t *testing.T) {
- in := IntArray([]int{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5});
- exp := []int{1, 2, 3, 4, 5};
- res := Unique(in, intkey{});
- assertArraysAreEqual(t, Data(res), exp);
- assertArraysAreEqual(t, Data(res), exp); // second time to ensure new iter is returned
+ in := IntArray([]int{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5})
+ exp := []int{1, 2, 3, 4, 5}
+ res := Unique(in, intkey{})
+ assertArraysAreEqual(t, Data(res), exp)
+ assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned
// test case with only uniques
- res = Unique(elevenToTwenty, intkey{});
- assertArraysAreEqual(t, Data(res), elevenToTwenty);
+ res = Unique(elevenToTwenty, intkey{})
+ assertArraysAreEqual(t, Data(res), elevenToTwenty)
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-30 19:49:11 +0000