zip_test.go

package go2linq

import (
	"fmt"
	"iter"
	"slices"
	"testing"

	"github.com/solsw/errorhelper"
	"github.com/solsw/iterhelper"
)

// https://github.com/jskeet/edulinq/blob/master/src/Edulinq.Tests/ZipTest.cs

func TestZip_string_int_string(t *testing.T) {
	type args struct {
		first          iter.Seq[string]
		second         iter.Seq[int]
		resultSelector func(string, int) string
	}
	tests := []struct {
		name string
		args args
		want iter.Seq[string]
	}{
		{name: "ShortFirst",
			args: args{
				first:          iterhelper.VarSeq("a", "b", "c"),
				second:         errorhelper.Must(Range(5, 10)),
				resultSelector: func(s string, i int) string { return fmt.Sprintf("%s:%d", s, i) },
			},
			want: iterhelper.VarSeq("a:5", "b:6", "c:7"),
		},
		{name: "ShortSecond",
			args: args{
				first:          iterhelper.VarSeq("a", "b", "c", "d", "e"),
				second:         errorhelper.Must(Range(5, 3)),
				resultSelector: func(s string, i int) string { return fmt.Sprintf("%s:%d", s, i) },
			},
			want: iterhelper.VarSeq("a:5", "b:6", "c:7"),
		},
		{name: "EqualLengthSequences",
			args: args{
				first:          iterhelper.VarSeq("a", "b", "c"),
				second:         errorhelper.Must(Range(5, 3)),
				resultSelector: func(s string, i int) string { return fmt.Sprintf("%s:%d", s, i) },
			},
			want: iterhelper.VarSeq("a:5", "b:6", "c:7"),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := Zip(tt.args.first, tt.args.second, tt.args.resultSelector)
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("Zip() = %v, want %v", iterhelper.StringDef(got), iterhelper.StringDef(tt.want))
			}
		})
	}
}

func TestZip_string_string_string(t *testing.T) {
	seq1 := iterhelper.VarSeq("a", "b", "c")
	seq2 := iterhelper.VarSeq("a", "b", "c", "d", "e")
	type args struct {
		first          iter.Seq[string]
		second         iter.Seq[string]
		resultSelector func(string, string) string
	}
	tests := []struct {
		name string
		args args
		want iter.Seq[string]
	}{
		{name: "1",
			args: args{
				first:          iterhelper.VarSeq("one", "two", "three", "four"),
				second:         errorhelper.Must(Reverse(iterhelper.VarSeq("one", "two", "three", "four"))),
				resultSelector: func(s1, s2 string) string { return s1 + s2 },
			},
			want: iterhelper.VarSeq("onefour", "twothree", "threetwo", "fourone"),
		},
		{name: "SameEnumerableString1",
			args: args{
				first:          seq1,
				second:         seq1,
				resultSelector: func(s1, s2 string) string { return fmt.Sprintf("%s:%s", s1, s2) },
			},
			want: iterhelper.VarSeq("a:a", "b:b", "c:c"),
		},
		{name: "AdjacentElements",
			args: args{
				first:          seq2,
				second:         errorhelper.Must(Skip(seq2, 1)),
				resultSelector: func(s1, s2 string) string { return s1 + s2 },
			},
			want: iterhelper.VarSeq("ab", "bc", "cd", "de"),
		},
		{name: "AdjacentElements2",
			args: args{
				first:          errorhelper.Must(Skip(seq2, 1)),
				second:         seq2,
				resultSelector: func(s1, s2 string) string { return s1 + s2 },
			},
			want: iterhelper.VarSeq("ba", "cb", "dc", "ed"),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := Zip(tt.args.first, tt.args.second, tt.args.resultSelector)
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("Zip() = %v, want %v", iterhelper.StringDef(got), iterhelper.StringDef(tt.want))
			}
		})
	}
}

func TestZip_int_int_string(t *testing.T) {
	range14, _ := Range(1, 4)
	take, _ := Take(errorhelper.Must(Range(1, 4)), 2)
	takeLast, _ := TakeLast(errorhelper.Must(Range(1, 4)), 2)
	type args struct {
		first          iter.Seq[int]
		second         iter.Seq[int]
		resultSelector func(int, int) string
	}
	tests := []struct {
		name string
		args args
		want iter.Seq[string]
	}{
		{name: "SameEnumerableInt00",
			args: args{
				first:          range14,
				second:         range14,
				resultSelector: func(i1, i2 int) string { return fmt.Sprintf("%d:%d", i1, i2) },
			},
			want: iterhelper.VarSeq("1:1", "2:2", "3:3", "4:4"),
		},
		{name: "SameEnumerableInt01",
			args: args{
				first:          errorhelper.Must(Skip(range14, 2)),
				second:         range14,
				resultSelector: func(i1, i2 int) string { return fmt.Sprintf("%d:%d", i1, i2) },
			},
			want: iterhelper.VarSeq("3:1", "4:2"),
		},
		{name: "SameEnumerableInt1",
			args: args{
				first:          take,
				second:         take,
				resultSelector: func(i1, i2 int) string { return fmt.Sprintf("%d:%d", i1, i2) },
			},
			want: iterhelper.VarSeq("1:1", "2:2"),
		},
		{name: "SameEnumerableInt2",
			args: args{
				first:          takeLast,
				second:         takeLast,
				resultSelector: func(i1, i2 int) string { return fmt.Sprintf("%d:%d", i1, i2) },
			},
			want: iterhelper.VarSeq("3:3", "4:4"),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := Zip(tt.args.first, tt.args.second, tt.args.resultSelector)
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("Zip() = %v, want %v", iterhelper.StringDef(got), iterhelper.StringDef(tt.want))
			}
		})
	}
}

func TestZip_string_string_int(t *testing.T) {
	type args struct {
		first          iter.Seq[string]
		second         iter.Seq[string]
		resultSelector func(string, string) int
	}
	tests := []struct {
		name string
		args args
		want iter.Seq[int]
	}{
		{name: "1",
			args: args{
				first:          iterhelper.VarSeq("a", "b", "c"),
				second:         iterhelper.VarSeq("one", "two", "three", "four"),
				resultSelector: func(s1, s2 string) int { return len(s1 + s2) },
			},
			want: iterhelper.VarSeq(4, 4, 6),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := Zip(tt.args.first, tt.args.second, tt.args.resultSelector)
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("Zip() = %v, want %v", iterhelper.StringDef(got), iterhelper.StringDef(tt.want))
			}
		})
	}
}

func TestZip_int_rune_string(t *testing.T) {
	type args struct {
		first          iter.Seq[int]
		second         iter.Seq[rune]
		resultSelector func(int, rune) string
	}
	tests := []struct {
		name string
		args args
		want iter.Seq[string]
	}{
		// https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/projection-operations#zip
		{name: "Zip",
			args: args{
				first:          iterhelper.VarSeq(1, 2, 3, 4, 5, 6, 7),
				second:         iterhelper.VarSeq('A', 'B', 'C', 'D', 'E', 'F'),
				resultSelector: func(number int, letter rune) string { return fmt.Sprintf("%d = %c (%[2]d)", number, letter) },
			},
			want: iterhelper.VarSeq("1 = A (65)", "2 = B (66)", "3 = C (67)", "4 = D (68)", "5 = E (69)", "6 = F (70)"),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := Zip(tt.args.first, tt.args.second, tt.args.resultSelector)
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("Zip() = %v, want %v", iterhelper.StringDef(got), iterhelper.StringDef(tt.want))
			}
		})
	}
}

// example from
// https://learn.microsoft.com/dotnet/api/system.linq.enumerable.zip
func ExampleZip() {
	numbers := []int{1, 2, 3, 4}
	words := []string{"one", "two", "three"}
	zip, _ := Zip(slices.Values(numbers), slices.Values(words),
		func(first int, second string) string { return fmt.Sprintf("%d %s", first, second) },
	)
	for item := range zip {
		fmt.Println(item)
	}
	// Output:
	// 1 one
	// 2 two
	// 3 three
}