usr/dsymonds/iterable/iterable_test.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package iterable

import (
	"iterable";
	"testing";
)

type IntArray []int;

func (arr IntArray) Iter() <-chan interface {} {
	ch := make(chan interface {});
	go func() {
		for i, x := range arr {
			ch <- x
		}
		close(ch)
	}();
	return ch
}

var oneToFive = IntArray{ 1, 2, 3, 4, 5 };

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)
}

// A stream of the natural numbers: 0, 1, 2, 3, ...
type integerStream struct {}
func (i integerStream) Iter() <-chan interface {} {
  ch := make(chan interface {});
  go func() {
    for i := 0; ; i++ {
      ch <- i
    }
  }();
  return ch
}

func TestAll(t *testing.T) {
	if !All(oneToFive, isPositive) {
		t.Error("All(oneToFive, isPositive) == false")
	}
	if All(oneToFive, isAbove3) {
		t.Error("All(oneToFive, isAbove3) == true")
	}
}

func TestAny(t *testing.T) {
	if Any(oneToFive, isNegative) {
		t.Error("Any(oneToFive, isNegative) == true")
	}
	if !Any(oneToFive, isEven) {
		t.Error("Any(oneToFive, isEven) == false")
	}
}

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
	}
	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
		}
	}
	return;
missing:
	t.Errorf("res = %v\nwant  %v", res, expected);
}

func TestFilter(t *testing.T) {
	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 })
}

func TestFind(t *testing.T) {
	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);
	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 })
}

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 })
}