{{/* Generated unit tests from the config examples. */ -}}
package {{.Package}}

import (
	"reflect"
	"testing"

{{range .TestImports}}{{printf "%q" .}}
{{end}}
)

// testValues contains an ordered sequence of ten set keys used for testing.
// The order of the keys must reflect the expected order of key listings.
var testValues = [10]{{.Type}}{
{{range .TestValues}}   {{.}},
{{end}}
}

func testKeys(ixs ...int) (keys []{{.Type}}) {
	for _, i := range ixs {
		keys = append(keys, testValues[i])
	}
	return
}

func testSet(ixs ...int) Set { return New(testKeys(ixs...)...) }

func keyPos(key {{.Type}}) int {
	for i, v := range testValues {
		if v == key {
			return i
		}
	}
	return -1
}

func TestEmptiness(t *testing.T) {
	var s Set
	if !s.Empty() {
		t.Errorf("nil Set is not reported empty: %v", s)
	}

	s = New()
	if !s.Empty() {
		t.Errorf("Empty Set is not reported empty: %v", s)
	}
	if s == nil {
		t.Error("New() unexpectedly returned nil")
	}

	if s := testSet(0); s.Empty() {
		t.Errorf("Nonempty Set is reported empty: %v", s)
	}
}

func TestClone(t *testing.T) {
	a := New(testValues[:]...)
	b := testSet(1, 8, 5)
	c := a.Clone()
	c.Remove(b)
	if c.Equals(a) {
		t.Errorf("Unexpected equality: %v == %v", a, c)
	} else {
		t.Logf("%v.Clone().Remove(%v) == %v", a, b, c)
	}
	c.Update(b)
	if !c.Equals(a) {
		t.Errorf("Unexpected inequality: %v != %v", a, c)
	}

	var s Set
	if got := s.Clone(); got != nil {
		t.Errorf("Clone of nil set: got %v, want nil", got)
	}
}

func TestUniqueness(t *testing.T) {
	// Sets should not contain duplicates.  Obviously this is impossible with
	// the map implementation, but other representations are viable.
	s := testSet(0, 5, 1, 2, 1, 3, 8, 4, 9, 4, 4, 6, 7, 2, 0, 0, 1, 4, 8, 4, 9)
	if got, want := s.Len(), len(testValues); got != want {
		t.Errorf("s.Len(): got %d, want %d [%v]", got, want, s)
	}

	// Keys should come out sorted.
	if got := s.Elements(); !reflect.DeepEqual(got, testValues[:]) {
		t.Errorf("s.Elements():\n got %+v,\nwant %+v", got, testValues)
	}
}

func TestMembership(t *testing.T) {
	s := testSet(0, 1, 2, 3, 4)
	for i, v := range testValues {
		if got, want := s.ContainsAny(v), i < 5; got != want {
			t.Errorf("s.ContainsAny(%v): got %v, want %v", v, got, want)
		}
	}

{{if .Transforms}}
	// Test non-mutating selection.
	if got, ok := s.Choose(func(s {{.Type}}) bool {
		return s == testValues[0]
	}); !ok {
		t.Error("Choose(0): missing element")
	} else {
		t.Logf("Found %v for element 0", got)
	}
	if got, ok := s.Choose(func({{.Type}}) bool { return false }); ok {
		t.Errorf(`Choose(impossible): got %v, want {{.Zero}}`, got)
	}
	if got, ok := New().Choose(nil); ok {
		t.Errorf(`Choose(nil): got %v, want {{.Zero}}`, got)
	}

	// Test mutating selection.
	if got, ok := s.Pop(func(s {{.Type}}) bool {
		return s == testValues[1]
	}); !ok {
		t.Error("Pop(1): missing element")
	} else {
		t.Logf("Found %v for element 1", got)
	}
	// A popped item is removed from the set.
	if len(s) != 4 {
		t.Errorf("Length after pop: got %d, want %d", len(s), 4)
	}
	// Pop of a nonexistent key returns not-found.
	if got, ok := s.Pop(func({{.Type}}) bool { return false }); ok {
		t.Errorf(`Pop(impossible): got %v, want {{.Zero}}`, got)
	}
	// Pop from an empty set returns not-found.
	if got, ok := New().Pop(nil); ok {
		t.Errorf(`Pop(nil) on empty: got %v, want {{.Zero}}`, got)
	}{{end}}
}

func TestContainsAny(t *testing.T) {
	set := New(testValues[2:]...)
	tests := []struct {
		keys []{{.Type}}
		want bool
	}{
		{nil, false},
		{[]{{.Type}}{}, false},
		{testKeys(0), false},
		{testKeys(1), false},
		{testKeys(0, 1), false},
		{testKeys(7), true},
		{testKeys(8, 3, 4, 9), true},
		{testKeys(0, 7, 1, 0), true},
	}
	t.Logf("Test set: %v", set)
	for _, test := range tests {
		got := set.ContainsAny(test.keys...)
		if got != test.want {
			t.Errorf("ContainsAny(%+v): got %v, want %v", test.keys, got, test.want)
		}
	}
}

func TestContainsAll(t *testing.T) {
	//set := New("a", "e", "i", "y")
	set := New(testValues[2:]...)
	tests := []struct {
		keys []{{.Type}}
		want bool
	}{
		{nil, true},
		{[]{{.Type}}{}, true},
		{testKeys(2, 4, 6), true},
		{testKeys(1, 3, 5, 7), false},
		{testKeys(0), false},
		{testKeys(5, 5, 5), true},
	}
	t.Logf("Test set: %v", set)
	for _, test := range tests {
		got := set.Contains(test.keys...)
		if got != test.want {
			t.Errorf("Contains(%+v): got %v, want %v", test.keys, got, test.want)
		}
	}
}

func TestIsSubset(t *testing.T) {
	var empty Set
	key := testSet(0, 2, 6, 7, 9)
	for _, test := range [][]{{.Type}}{
		{}, testKeys(2, 6), testKeys(0, 7, 9),
	} {
		probe := New(test...)
		if !probe.IsSubset(key) {
			t.Errorf("IsSubset %+v ⊂ %+v is false", probe, key)
		}
		if !empty.IsSubset(probe) { // ø is a subset of everything, including itself.
			t.Errorf("IsSubset ø ⊂ %+v is false", probe)
		}
	}
}

func TestNotSubset(t *testing.T) {
	tests := []struct {
		probe, key Set
	}{
		{testSet(0), New()},
		{testSet(0), testSet(1)},
		{testSet(0, 1), testSet(1)},
		{testSet(0, 2, 1), testSet(0, 2, 3)},
	}
	for _, test := range tests {
		if test.probe.IsSubset(test.key) {
			t.Errorf("IsSubset %+v ⊂ %+v is true", test.probe, test.key)
		}
	}
}

func TestEquality(t *testing.T) {
	nat := New(testValues[:]...)
	odd := testSet(1, 3, 4, 5, 8)
	tests := []struct {
		left, right Set
		eq          bool
	}{
		{nil, nil, true},
		{nat, nat, true},               // Equality with the same value
		{testSet(0), testSet(0), true}, // Equality with Different values
		{testSet(0), nil, false},
		{nat, odd, false},
		{nil, testSet(0), false},
		{testSet(0), testSet(1), false},

		// Various set operations...
		{nat.Intersect(odd), odd, true},
		{odd, nat.Intersect(odd), true},
		{odd.Intersect(nat), odd, true},
		{odd, odd.Intersect(nat), true},
		{nat.Intersect(nat), nat, true},
		{nat, nat.Intersect(nat), true},
		{nat.Union(odd), nat, true},
		{nat, nat.Union(odd), true},
		{odd.Diff(nat), odd, false},
		{odd, odd.Diff(nat), false},
		{odd.Diff(nat), nil, true},
		{nil, odd.Diff(nat), true},

		{testSet(0, 1, 2).Diff(testSet(2, 5, 6)), testSet(1).Union(testSet(0)), true},
	}
	for _, test := range tests {
		if got := test.left.Equals(test.right); got != test.eq {
			t.Errorf("%v.Equals(%v): got %v, want %v", test.left, test.right, got, test.eq)
		}
	}
}

func TestUnion(t *testing.T) {
	vkeys := testKeys(0, 4)
	vowels := testSet(4, 0)
	consonants := testSet(1, 2, 3, 5, 6, 7, 8, 9)

	if got := vowels.Union(nil).Elements(); !reflect.DeepEqual(got, vkeys) {
		t.Errorf("Vowels ∪ ø: got %+v, want %+v", got, vkeys)
	}
	if got := New().Union(vowels).Elements(); !reflect.DeepEqual(got, vkeys) {
		t.Errorf("ø ∪ Vowels: got %+v, want %+v", got, vkeys)
	}

	if got, want := vowels.Union(consonants).Elements(), testValues[:]; !reflect.DeepEqual(got, want) {
		t.Errorf("Vowels ∪ Consonants: got %+v, want %+v", got, want)
	}
}

func TestIntersect(t *testing.T) {
	empty := New()
	nat := New(testValues[:]...)
	odd := testSet(1, 3, 5, 7, 9)
	prime := testSet(2, 3, 5, 7)

	tests := []struct {
		left, right Set
		want        []{{.Type}}
	}{
		{empty, empty, nil},
		{empty, nat, nil},
		{nat, empty, nil},
		{nat, nat, testValues[:]},
		{nat, odd, testKeys(1, 3, 5, 7, 9)},
		{odd, nat, testKeys(1, 3, 5, 7, 9)},
		{odd, prime, testKeys(3, 5, 7)},
		{prime, nat, testKeys(2, 3, 5, 7)},
	}
	for _, test := range tests {
		got := test.left.Intersect(test.right).Elements()
		if !reflect.DeepEqual(got, test.want) {
			t.Errorf("%v ∩ %v: got %+v, want %+v", test.left, test.right, got, test.want)
		} else if want, ok := len(test.want) != 0, test.left.Intersects(test.right); ok != want {
			t.Errorf("%+v.Intersects(%+v): got %v, want %v", test.left, test.right, ok, want)
		}
	}
}

func TestDiff(t *testing.T) {
	empty := New()
	nat := New(testValues[:]...)
	odd := testSet(1, 3, 5, 7, 9)
	prime := testSet(2, 3, 5, 7)

	tests := []struct {
		left, right Set
		want        []{{.Type}}
	}{
		{empty, empty, nil},
		{empty, nat, nil},
		{nat, empty, testValues[:]},
		{nat, nat, nil},
		{nat, odd, testKeys(0, 2, 4, 6, 8)},
		{odd, nat, nil},
		{odd, prime, testKeys(1, 9)},
		{prime, nat, nil},
	}
	for _, test := range tests {
		got := test.left.Diff(test.right).Elements()
		if !reflect.DeepEqual(got, test.want) {
			t.Errorf("%v \\ %v: got %+q, want %+q", test.left, test.right, got, test.want)
		}
	}
}

func TestSymDiff(t *testing.T) {
	a := testSet(0, 1, 2, 3, 4)
	b := testSet(0, 4, 5, 6, 7)
	c := testSet(3, 4, 8, 9)
	empty := New()

	tests := []struct {
		left, right Set
		want        []{{.Type}}
	}{
		{empty, empty, nil},
		{empty, a, a.Elements()},
		{b, empty, b.Elements()},
		{a, a, nil},
		{a, b, testKeys(1, 2, 3, 5, 6, 7)},
		{b, a, testKeys(1, 2, 3, 5, 6, 7)},
		{a, c, testKeys(0, 1, 2, 8, 9)},
		{c, a, testKeys(0, 1, 2, 8, 9)},
		{c, b, testKeys(0, 3, 5, 6, 7, 8, 9)},
	}
	for _, test := range tests {
		got := test.left.SymDiff(test.right).Elements()
		if !reflect.DeepEqual(got, test.want) {
			t.Errorf("%v ∆ %v: got %+v, want %+v", test.left, test.right, got, test.want)
		}
	}
}

func TestUpdate(t *testing.T) {
	tests := []struct {
		before, update Set
		want           []{{.Type}}
		changed        bool
	}{
		{nil, nil, nil, false},
		{nil, testSet(0), testKeys(0), true},
		{testSet(1), nil, testKeys(1), false},
		{testSet(2, 3), testSet(4, 4, 3), testKeys(2, 3, 4), true},
	}
	for _, test := range tests {
		ok := test.before.Update(test.update)
		if got := test.before.Elements(); !reflect.DeepEqual(got, test.want) {
			t.Errorf("Update %v: got %+v, want %+q", test.before, got, test.want)
		}
		if ok != test.changed {
			t.Errorf("Update %v reported change=%v, want %v", test.before, ok, test.changed)
		}
	}
}

func TestAdd(t *testing.T) {
	tests := []struct {
		before       Set
		update, want []{{.Type}}
		changed      bool
	}{
		{nil, nil, nil, false},
		{nil, testKeys(0), testKeys(0), true},
		{testSet(1), nil, testKeys(1), false},
		{testSet(0, 1), testKeys(2, 2, 1), testKeys(0, 1, 2), true},
	}
	for _, test := range tests {
		ok := test.before.Add(test.update...)
		if got := test.before.Elements(); !reflect.DeepEqual(got, test.want) {
			t.Errorf("Add %v: got %+v, want %+v", test.before, got, test.want)
		}
		if ok != test.changed {
			t.Errorf("Add %v reported change=%v, want %v", test.before, ok, test.changed)
		}
	}
}

func TestRemove(t *testing.T) {
	tests := []struct {
		before, update Set
		want           []{{.Type}}
		changed        bool
	}{
		{nil, nil, nil, false},
		{nil, testSet(0), nil, false},
		{testSet(5), nil, testKeys(5), false},
		{testSet(3, 9), testSet(5, 1, 9), testKeys(3), true},
		{testSet(0, 1, 2), testSet(4, 6), testKeys(0, 1, 2), false},
	}
	for _, test := range tests {
		ok := test.before.Remove(test.update)
		if got := test.before.Elements(); !reflect.DeepEqual(got, test.want) {
			t.Errorf("Remove %v: got %+v, want %+v", test.before, got, test.want)
		}
		if ok != test.changed {
			t.Errorf("Remove %v reported change=%v, want %v", test.before, ok, test.changed)
		}
	}
}

func TestDiscard(t *testing.T) {
	tests := []struct {
		before       Set
		update, want []{{.Type}}
		changed      bool
	}{
		{nil, nil, nil, false},
		{nil, testKeys(0), nil, false},
		{testSet(1), nil, testKeys(1), false},
		{testSet(0, 1), testKeys(2, 2, 1), testKeys(0), true},
		{testSet(0, 1, 2), testKeys(3, 4), testKeys(0, 1, 2), false},
	}
	for _, test := range tests {
		ok := test.before.Discard(test.update...)
		if got := test.before.Elements(); !reflect.DeepEqual(got, test.want) {
			t.Errorf("Discard %v: got %+v, want %+v", test.before, got, test.want)
		}
		if ok != test.changed {
			t.Errorf("Discard %v reported change=%v, want %v", test.before, ok, test.changed)
		}
	}
}

{{if .Transforms}}
func TestMap(t *testing.T) {
	in := New(testValues[:]...)
	got := make([]{{.Type}}, len(testValues))
	out := in.Map(func(s {{.Type}}) {{.Type}} {
		if p := keyPos(s); p < 0 {
			t.Errorf("Unknown input key %v", s)
		} else {
			got[p] = s
		}
		return s
	})
	if !reflect.DeepEqual(got, testValues[:]) {
		t.Errorf("Incomplete mapping:\n got %+v\nwant %+v", got, testValues)
	}
	if !out.Equals(in) {
		t.Errorf("Incorrect mapping:\n got %v\nwant %v", out, in)
	}
}

func TestEach(t *testing.T) {
	in := New(testValues[:]...)
	saw := make(map[{{.Type}}]int)
	in.Each(func(name {{.Type}}) {
		saw[name]++
	})
	for want := range in {
		if saw[want] != 1 {
			t.Errorf("Saw [%v] %d times, wanted 1", want, saw[want])
		}
	}
	for got, n := range saw {
		if _, ok := in[got]; !ok {
			t.Errorf("Saw [%v] %d times, wanted 0", got, n)
		}
	}
}

func TestSelection(t *testing.T) {
	in := New(testValues[:]...)
	want := testSet(0, 2, 4, 6, 8)
	if got := in.Select(func(s {{.Type}}) bool {
		pos := keyPos(s)
		return pos >= 0 && pos%2 == 0
	}); !got.Equals(want) {
		t.Errorf("%v.Select(evens): got %v, want %v", in, got, want)
	}
	if got := New().Select(func({{.Type}}) bool { return true }); !got.Empty() {
		t.Errorf("%v.Select(true): got %v, want empty", New(), got)
	}
	if got := in.Select(func({{.Type}}) bool { return false }); !got.Empty() {
		t.Errorf("%v.Select(false): got %v, want empty", in, got)
	}
}

func TestPartition(t *testing.T) {
	in := New(testValues[:]...)
	tests := []struct {
		in, left, right Set
		f               func({{.Type}}) bool
		desc            string
	}{
		{testSet(0, 1), testSet(0, 1), nil,
			func({{.Type}}) bool { return true },
			"all true",
		},
		{testSet(0, 1), nil, testSet(0, 1),
			func({{.Type}}) bool { return false },
			"all false",
		},
		{in,
			testSet(0, 1, 2, 3, 4),
			testSet(5, 6, 7, 8, 9),
			func(s {{.Type}}) bool { return keyPos(s) < 5 },
			"pos(s) < 5",
		},
		{in,
			testSet(1, 3, 5, 7, 9), // odd
			testSet(0, 2, 4, 6, 8), // even
			func(s {{.Type}}) bool { return keyPos(s)%2 == 1 },
			"odd/even",
		},
	}
	for _, test := range tests {
		gotLeft, gotRight := test.in.Partition(test.f)
		if !gotLeft.Equals(test.left) {
			t.Errorf("Partition %s left: got %v, want %v", test.desc, gotLeft, test.left)
		}
		if !gotRight.Equals(test.right) {
			t.Errorf("Partition %s right: got %v, want %v", test.desc, gotRight, test.right)
		}
		t.Logf("Partition %v %s\n\t left: %v\n\tright: %v", test.in, test.desc, gotLeft, gotRight)
	}
}
{{end}}

func TestIndex(t *testing.T) {
	tests := []struct {
		needle {{.Type}}
		keys   []{{.Type}}
		want   int
	}{
		{testValues[0], nil, -1},
		{testValues[1], []{{.Type}}{}, -1},
		{testValues[2], testKeys(0, 1), -1},
		{testValues[0], testKeys(0, 1), 0},
		{testValues[1], testKeys(0, 1), 1},
		{testValues[2], testKeys(0, 2, 1, 2), 1},
		{testValues[9], testKeys(0, 2, 1, 9, 6), 3},
		{testValues[4], testKeys(0, 2, 4, 9, 4), 2},
	}
	for _, test := range tests {
		got := Index(test.needle, test.keys)
		if got != test.want {
			t.Errorf("Index(%+v, %+v): got %d, want %d", test.needle, test.keys, got, test.want)
		}
	}
}

type keyer []{{.Type}}

func (k keyer) Keys() []{{.Type}} {
	p := make([]{{.Type}}, len(k))
	copy(p, k)
	return p
}

type uniq int

func TestFromValues(t *testing.T) {
	tests := []struct {
		input interface{}
		want  []{{.Type}}
	}{
		{nil, nil},
		{map[float64]{{.Type}}{}, nil},
		{map[int]{{.Type}}{1: testValues[1], 2: testValues[2], 3: testValues[2]}, testKeys(1, 2)},
		{map[string]{{.Type}}{"foo": testValues[4], "baz": testValues[4]}, testKeys(4)},
		{map[int]uniq{1: uniq(2), 3: uniq(4), 5: uniq(6)}, nil},
		{map[*int]{{.Type}}{nil: testValues[0]}, testKeys(0)},
	}
	for _, test := range tests {
		got := FromValues(test.input)
		want := New(test.want...)
		if !got.Equals(want) {
			t.Errorf("MapValues %v: got %v, want %v", test.input, got, want)
		}
	}
}

func TestFromKeys(t *testing.T) {
	tests := []struct {
		input interface{}
		want  Set
	}{
		{3.5, nil},                  // unkeyable type
		{map[uniq]uniq{1: 1}, nil},  // unkeyable type
		{nil, nil},                  // empty
		{[]string{}, nil},           // empty
		{map[{{.Type}}]float64{}, nil}, // empty
		{testValues[0], testSet(0)},
		{testKeys(0, 1, 0, 0), testSet(0, 1)},
		{map[{{.Type}}]int{testValues[0]: 1, testValues[1]: 2}, testSet(0, 1)},
		{keyer(testValues[:3]), testSet(0, 1, 2)},
		{testSet(4, 7, 8), testSet(4, 7, 8)},
		{map[{{.Type}}]struct{}{testValues[2]: {}, testValues[7]: {}}, testSet(2, 7)},
	}
	for _, test := range tests {
		got := FromKeys(test.input)
		if !got.Equals(test.want) {
			t.Errorf("FromKeys %v: got %v, want %v", test.input, got, test.want)
		}
	}
}

func TestContainsFunc(t *testing.T) {
	tests := []struct {
		input  interface{}
		needle {{.Type}}
		want   bool
	}{
		{[]{{.Type}}(nil), testValues[0], false},
		{[]{{.Type}}{}, testValues[0], false},
		{testKeys(0), testValues[0], true},
		{testKeys(1), testValues[0], false},
		{testKeys(0, 1, 9, 2), testValues[0], true},

		{map[{{.Type}}]int(nil), testValues[2], false},
		{map[{{.Type}}]int{}, testValues[2], false},
		{map[{{.Type}}]int{testValues[2]: 1}, testValues[2], true},
		{map[{{.Type}}]int{testValues[3]: 3}, testValues[2], false},
		{map[{{.Type}}]float32{testValues[2]: 1, testValues[4]: 2}, testValues[2], true},
		{map[{{.Type}}]float32{testValues[5]: 0, testValues[6]: 1, testValues[7]: 2, testValues[8]: 3}, testValues[2], false},

		{Set(nil), testValues[3], false},
		{New(), testValues[3], false},
		{New(testValues[3]), testValues[3], true},
		{New(testValues[5]), testValues[3], false},
		{testSet(0, 1), testValues[3], false},
		{testSet(0, 3, 1), testValues[3], true},

		{keyer(nil), testValues[9], false},
		{keyer{}, testValues[9], false},
		{keyer{testValues[9]}, testValues[9], true},
		{keyer{testValues[0]}, testValues[9], false},
		{keyer(testKeys(0, 6, 9)), testValues[9], true},
		{keyer(testKeys(0, 6, 7)), testValues[9], false},
	}
	for _, test := range tests {
		got := Contains(test.input, test.needle)
		if got != test.want {
			t.Errorf("Contains(%+v, %v): got %v, want %v", test.input, test.needle, got, test.want)
		}
	}
}

func TestFromIndexed(t *testing.T) {
	tests := []struct {
		input []int
		want  Set
	}{
		{nil, nil},
		{[]int{}, nil},
		{[]int{0}, testSet(0)},
		{[]int{1, 8, 2, 9}, testSet(1, 2, 8, 9)},
		{[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, New(testValues[:]...)},
	}
	for _, test := range tests {
		got := FromIndexed(len(test.input), func(i int) {{.Type}} {
			return testValues[test.input[i]]
		})
		if !got.Equals(test.want) {
			t.Errorf("FromIndexed(%d, <...>): got %v, want %v", len(test.input), got, test.want)
		}
	}
}