unionby_test.go

package go2linq

import (
	"cmp"
	"errors"
	"iter"
	"strconv"
	"testing"

	"github.com/solsw/iterhelper"
)

func TestUnionBy_string_int(t *testing.T) {
	type args struct {
		first       iter.Seq[string]
		second      iter.Seq[string]
		keySelector func(string) int
	}
	tests := []struct {
		name string
		args args
		want iter.Seq[string]
	}{
		{name: "1",
			args: args{
				first:       iterhelper.VarSeq("one", "three", "five"),
				second:      iterhelper.VarSeq("two", "four"),
				keySelector: func(s string) int { return len(s) },
			},
			want: iterhelper.VarSeq("one", "three", "five"),
		},
		{name: "2",
			args: args{
				first:       iterhelper.VarSeq("two", "four"),
				second:      iterhelper.VarSeq("one", "three", "five"),
				keySelector: func(s string) int { return len(s) },
			},
			want: iterhelper.VarSeq("two", "four", "three"),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := UnionBy(tt.args.first, tt.args.second, tt.args.keySelector)
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("UnionBy() = %v, want %v", iterhelper.StringDef(got), iterhelper.StringDef(tt.want))
			}
		})
	}
}

func TestUnionBy_Planet(t *testing.T) {
	type args struct {
		first       iter.Seq[Planet]
		second      iter.Seq[Planet]
		keySelector func(Planet) Planet
	}
	tests := []struct {
		name string
		args args
		want iter.Seq[Planet]
	}{
		// https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/set-operations#union-and-unionby
		{name: "UnionBy",
			args: args{
				first:       iterhelper.VarSeq(Mercury, Venus, Earth, Mars, Jupiter),
				second:      iterhelper.VarSeq(Mars, Jupiter, Saturn, Uranus, Neptune),
				keySelector: Identity[Planet],
			},
			want: iterhelper.VarSeq(Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := UnionBy(tt.args.first, tt.args.second, tt.args.keySelector)
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("UnionBy() = %v, want %v", iterhelper.StringDef(got), iterhelper.StringDef(tt.want))
			}
		})
	}
}

func TestUnionByCmp_int_string(t *testing.T) {
	ii, _ := Range(1, 10)
	type args struct {
		first       iter.Seq[int]
		second      iter.Seq[int]
		keySelector func(int) string
		compare     func(string, string) int
	}
	tests := []struct {
		name        string
		args        args
		want        iter.Seq[int]
		wantErr     bool
		expectedErr error
	}{
		{name: "NilFirst",
			args: args{
				first:       nil,
				second:      ii,
				keySelector: nil,
				compare:     nil,
			},
			wantErr:     true,
			expectedErr: ErrNilSource,
		},
		{name: "NilSecond",
			args: args{
				first:       ii,
				second:      nil,
				keySelector: nil,
				compare:     nil,
			},
			wantErr:     true,
			expectedErr: ErrNilSource,
		},
		{name: "NilSelector",
			args: args{
				first:       ii,
				second:      ii,
				keySelector: nil,
				compare:     nil,
			},
			wantErr:     true,
			expectedErr: ErrNilSelector,
		},
		{name: "NilComparer",
			args: args{
				first:       ii,
				second:      ii,
				keySelector: func(i int) string { return strconv.Itoa(i) },
				compare:     nil,
			},
			wantErr:     true,
			expectedErr: ErrNilCompare,
		},
		{name: "SameEnumerable1",
			args: args{
				first:       ii,
				second:      ii,
				keySelector: func(i int) string { return strconv.FormatBool(i%2 == 0) },
				compare:     cmp.Compare[string],
			},
			want: iterhelper.VarSeq(1, 2),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := UnionByCmp(tt.args.first, tt.args.second, tt.args.keySelector, tt.args.compare)
			if (err != nil) != tt.wantErr {
				t.Errorf("UnionByCmp() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if tt.wantErr {
				if !errors.Is(err, tt.expectedErr) {
					t.Errorf("UnionByCmp() error = %v, expectedErr %v", err, tt.expectedErr)
				}
				return
			}
			equal, _ := SequenceEqual(got, tt.want)
			if !equal {
				t.Errorf("UnionByCmp() = %v, want %v", got, tt.want)
			}
		})
	}
}