rows_test.go

package simplecsv

import (
	"reflect"
	"testing"
)

func TestSimpleCsv_GetNumberRows(t *testing.T) {
	tests := []struct {
		name string
		s    SimpleCsv
		want int
	}{
		{name: "GetNumberRows",
			want: 2,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.s.GetNumberRows(); got != tt.want {
				t.Errorf("SimpleCsv.GetNumberRows() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSimpleCsv_GetRow(t *testing.T) {
	type args struct {
		rowNumber int
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  []string
		want1 bool
	}{
		{name: "GetRow1",
			want:  []string{"Moo", "foo", "soo"},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowNumber: 1,
			},
		},
		{name: "GetRow2",
			want:  []string{},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowNumber: 3,
			},
		},
		{name: "GetRow3",
			want:  []string{},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowNumber: -1,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.GetRow(tt.args.rowNumber)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.GetRow() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.GetRow() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_GetRowAsMap(t *testing.T) {
	type args struct {
		rowNumber int
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  map[string]string
		want1 bool
	}{
		{name: "GetRowAsMap1",
			want: map[string]string{"Ann": "Moo",
				"Ban":  "foo",
				"Cann": "soo"},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowNumber: 1,
			},
		},
		{name: "GetRowAsMap2",
			want:  nil,
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowNumber: 10,
			},
		},
		{name: "GetRowAsMap3",
			want:  nil,
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowNumber: -1,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.GetRowAsMap(tt.args.rowNumber)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.GetRowAsMap() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.GetRowAsMap() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_AddRow(t *testing.T) {
	type args struct {
		rowValue []string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{name: "AddRow1",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue: []string{"Ah", "Eh", "Ih"},
			},
		},
		{name: "AddRow2",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue: []string{"Ah", "Eh", "Ih", "oh"},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.AddRow(tt.args.rowValue)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.AddRow() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.AddRow() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_AddRowFromMap(t *testing.T) {
	type args struct {
		rowValue map[string]string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{name: "AddRowFromMap1",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue: map[string]string{"Ann": "Ah",
					"Ban":  "Eh",
					"Cann": "Ih"},
			},
		},
		{name: "AddRowFromMap2",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "", ""},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue: map[string]string{"Ann": "Ah"},
			},
		},
		{name: "AddRowFromMap3",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue: map[string]string{"Ann": "Ah",
					"Ban":  "Eh",
					"Cann": "Ih",
					"Qwe":  "Sss"},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.AddRowFromMap(tt.args.rowValue)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.AddRowFromMap() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.AddRowFromMap() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_SetRow(t *testing.T) {
	type args struct {
		rowNumber int
		rowValue  []string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{name: "SetRow",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Ah", "Eh", "Ih"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue:  []string{"Ah", "Eh", "Ih"},
				rowNumber: 1,
			},
		},
		{name: "SetRow2",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue:  []string{"Ah", "Eh", "Ih"},
				rowNumber: 10,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.SetRow(tt.args.rowNumber, tt.args.rowValue)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.SetRow() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.SetRow() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_SetRowFromMap(t *testing.T) {
	type args struct {
		rowNumber int
		rowValue  map[string]string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{name: "SetRowFromMap",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Ah", "Eh", "Ih"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
			},
			args: args{
				rowValue: map[string]string{"Ann": "Ah",
					"Ban":  "Eh",
					"Cann": "Ih"},
				rowNumber: 1,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.SetRowFromMap(tt.args.rowNumber, tt.args.rowValue)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.SetRowFromMap() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.SetRowFromMap() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_UpdateRowCellsFromMap(t *testing.T) {
	type args struct {
		rowNumber int
		rowValue  map[string]string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{name: "UpdateRowCellsFromMap",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Ah", "foo", "Ih"},
				{"Bak", "Bek", "Bik"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Bak", "Bek", "Bik"},
			},
			args: args{
				rowValue: map[string]string{"Ann": "Ah",
					"Cann": "Ih"},
				rowNumber: 1,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.UpdateRowCellsFromMap(tt.args.rowNumber, tt.args.rowValue)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.UpdateRowCellsFromMap() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.UpdateRowCellsFromMap() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_DeleteRow(t *testing.T) {
	type args struct {
		rowNumber int
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{name: "DeleteRow1",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Ah", "Eh", "Ih"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			args: args{
				rowNumber: 1,
			},
		},
		{name: "DeleteRow2",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			args: args{
				rowNumber: 10,
			},
		},
		{name: "DeleteRowNegative",
			want: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			args: args{
				rowNumber: -1,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.DeleteRow(tt.args.rowNumber)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.DeleteRow() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.DeleteRow() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_GetNumberDataRows(t *testing.T) {
	tests := []struct {
		name string
		s    SimpleCsv
		want int
	}{
		{name: "GetNumberDataRows",
			want: 2,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
		},
		{name: "GetNumberDataRowsHeaderOnly",
			want: 0,
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
			},
		},
		{name: "GetNumberDataRowsEmpty",
			want: 0,
			s:    SimpleCsv{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.s.GetNumberDataRows(); got != tt.want {
				t.Errorf("SimpleCsv.GetNumberDataRows() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSimpleCsv_GetDataRows(t *testing.T) {
	tests := []struct {
		name string
		s    SimpleCsv
		want [][]string
	}{
		{name: "GetDataRows",
			want: [][]string{
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
		},
		{name: "GetDataRowsHeaderOnly",
			want: [][]string{},
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
			},
		},
		{name: "GetDataRowsEmpty",
			want: [][]string{},
			s:    SimpleCsv{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.s.GetDataRows(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.GetDataRows() got = %v, want %v", got, tt.want)
			}
		})
	}
}

type eachDataRowVisit struct {
	rowIndex int
	row      []string
	asMap    map[string]string
}

func TestSimpleCsv_EachDataRow(t *testing.T) {
	tests := []struct {
		name   string
		s      SimpleCsv
		stopAt int
		want   []eachDataRowVisit
	}{
		{name: "EachDataRowVisitsAll",
			want: []eachDataRowVisit{
				{rowIndex: 1, row: []string{"Moo", "foo", "soo"}, asMap: map[string]string{"Ann": "Moo", "Ban": "foo", "Cann": "soo"}},
				{rowIndex: 2, row: []string{"Ah", "Eh", "Ih"}, asMap: map[string]string{"Ann": "Ah", "Ban": "Eh", "Cann": "Ih"}},
			},
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
		},
		{name: "EachDataRowStopsEarly",
			stopAt: 1,
			want: []eachDataRowVisit{
				{rowIndex: 1, row: []string{"Moo", "foo", "soo"}, asMap: map[string]string{"Ann": "Moo", "Ban": "foo", "Cann": "soo"}},
			},
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
				{"Moo", "foo", "soo"},
				{"Ah", "Eh", "Ih"},
			},
		},
		{name: "EachDataRowHeaderOnly",
			want: []eachDataRowVisit{},
			s: SimpleCsv{
				{"Ann", "Ban", "Cann"},
			},
		},
		{name: "EachDataRowEmpty",
			want: []eachDataRowVisit{},
			s:    SimpleCsv{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := []eachDataRowVisit{}
			tt.s.EachDataRow(func(rowIndex int, row []string, asMap map[string]string) bool {
				got = append(got, eachDataRowVisit{rowIndex, row, asMap})
				return tt.stopAt == 0 || len(got) < tt.stopAt
			})
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.EachDataRow() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSimpleCsv_Head(t *testing.T) {
	type args struct {
		n int
	}
	tests := []struct {
		name string
		s    SimpleCsv
		args args
		want SimpleCsv
	}{
		{name: "Head2",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			args: args{n: 2},
		},
		{name: "HeadMoreThanRows",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
			},
			args: args{n: 10},
		},
		{name: "HeadZero",
			want: SimpleCsv{
				{"Ann", "Ban"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			args: args{n: 0},
		},
		{name: "HeadNegative",
			want: SimpleCsv{
				{"Ann", "Ban"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			args: args{n: -1},
		},
		{name: "HeadEmpty",
			want: SimpleCsv{},
			s:    SimpleCsv{},
			args: args{n: 2},
		},
		{name: "HeadHeaderOnly",
			want: SimpleCsv{
				{"Ann", "Ban"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
			},
			args: args{n: 5},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.s.Head(tt.args.n); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.Head() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSimpleCsv_Tail(t *testing.T) {
	type args struct {
		n int
	}
	tests := []struct {
		name string
		s    SimpleCsv
		args args
		want SimpleCsv
	}{
		{name: "Tail2",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			args: args{n: 2},
		},
		{name: "TailMoreThanRows",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
			},
			args: args{n: 10},
		},
		{name: "TailZero",
			want: SimpleCsv{
				{"Ann", "Ban"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			args: args{n: 0},
		},
		{name: "TailNegative",
			want: SimpleCsv{
				{"Ann", "Ban"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			args: args{n: -1},
		},
		{name: "TailEmpty",
			want: SimpleCsv{},
			s:    SimpleCsv{},
			args: args{n: 2},
		},
		{name: "TailHeaderOnly",
			want: SimpleCsv{
				{"Ann", "Ban"},
			},
			s: SimpleCsv{
				{"Ann", "Ban"},
			},
			args: args{n: 5},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.s.Tail(tt.args.n); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.Tail() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSimpleCsv_SliceRows(t *testing.T) {
	type args struct {
		start int
		end   int
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{name: "SliceRows1",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			args: args{start: 2, end: 4},
		},
		{name: "SliceRowsClamped",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			args: args{start: 1, end: 10},
		},
		{name: "SliceRowsEmptyRange",
			want: SimpleCsv{
				{"Ann", "Ban"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			args: args{start: 2, end: 2},
		},
		{name: "SliceRowsInvalidStart",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			args: args{start: 0, end: 2},
		},
		{name: "SliceRowsReversed",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			args: args{start: 3, end: 1},
		},
		{name: "SliceRowsEmpty",
			want:  SimpleCsv{},
			want1: false,
			s:     SimpleCsv{},
			args:  args{start: 1, end: 2},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.SliceRows(tt.args.start, tt.args.end)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.SliceRows() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.SliceRows() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_AppendRows(t *testing.T) {
	tests := []struct {
		name  string
		s     SimpleCsv
		other SimpleCsv
		want  SimpleCsv
		want1 bool
	}{
		{name: "AppendRows1",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			other: SimpleCsv{
				{"Ann", "Ban"},
				{"Ah", "Eh"},
			},
		},
		{name: "AppendRowsHeaderOnlyOther",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			other: SimpleCsv{
				{"Ann", "Ban"},
			},
		},
		{name: "AppendRowsHeaderOnlySource",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: true,
			s: SimpleCsv{
				{"Ann", "Ban"},
			},
			other: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
		},
		{name: "AppendRowsDifferentOrder",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			other: SimpleCsv{
				{"Ban", "Ann"},
				{"Ah", "Eh"},
			},
		},
		{name: "AppendRowsDifferentName",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			other: SimpleCsv{
				{"Ann", "Bann"},
				{"Ah", "Eh"},
			},
		},
		{name: "AppendRowsEmptySource",
			want:  SimpleCsv{},
			want1: false,
			s:     SimpleCsv{},
			other: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
		},
		{name: "AppendRowsEmptyOther",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: false,
			s: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			other: SimpleCsv{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.AppendRows(tt.other)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.AppendRows() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.AppendRows() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestConcat(t *testing.T) {
	tests := []struct {
		name  string
		csvs  []SimpleCsv
		want  SimpleCsv
		want1 bool
	}{
		{name: "Concat1",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
				{"Ih", "Oh"},
			},
			want1: true,
			csvs: []SimpleCsv{
				{
					{"Ann", "Ban"},
					{"Moo", "foo"},
				},
				{
					{"Ann", "Ban"},
					{"Ah", "Eh"},
					{"Ih", "Oh"},
				},
			},
		},
		{name: "ConcatLeadingEmpty",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: true,
			csvs: []SimpleCsv{
				{},
				{
					{"Ann", "Ban"},
					{"Moo", "foo"},
				},
			},
		},
		{name: "ConcatHeaderOnlyFirst",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
			},
			want1: true,
			csvs: []SimpleCsv{
				{
					{"Ann", "Ban"},
				},
				{
					{"Ann", "Ban"},
					{"Moo", "foo"},
				},
			},
		},
		{name: "ConcatEmptyInMiddle",
			want: SimpleCsv{
				{"Ann", "Ban"},
				{"Moo", "foo"},
				{"Ah", "Eh"},
			},
			want1: true,
			csvs: []SimpleCsv{
				{
					{"Ann", "Ban"},
					{"Moo", "foo"},
				},
				{},
				{
					{"Ann", "Ban"},
					{"Ah", "Eh"},
				},
			},
		},
		{name: "ConcatDifferentHeaders",
			want:  nil,
			want1: false,
			csvs: []SimpleCsv{
				{
					{"Ann", "Ban"},
					{"Moo", "foo"},
				},
				{
					{"Ann", "Bann"},
					{"Ah", "Eh"},
				},
			},
		},
		{name: "ConcatDifferentOrder",
			want:  nil,
			want1: false,
			csvs: []SimpleCsv{
				{
					{"Ann", "Ban"},
					{"Moo", "foo"},
				},
				{
					{"Ban", "Ann"},
					{"Ah", "Eh"},
				},
			},
		},
		{name: "ConcatAllEmpty",
			want:  nil,
			want1: false,
			csvs:  []SimpleCsv{{}, {}},
		},
		{name: "ConcatNoArgs",
			want:  nil,
			want1: false,
			csvs:  []SimpleCsv{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := Concat(tt.csvs...)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.Concat() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.Concat() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

// The original csvs are not modified, the results share no data with them,
// and failure paths return an independent copy.

func TestRowHelpersDoNotMutateSource(t *testing.T) {
	want := SimpleCsv{
		{"A", "B"},
		{"1", "2"},
		{"3", "4"},
	}
	s := SimpleCsv{
		{"A", "B"},
		{"1", "2"},
		{"3", "4"},
	}
	other := SimpleCsv{
		{"A", "B"},
		{"5", "6"},
	}

	if got := s.GetDataRows(); got[0][0] == "changed" {
		t.Errorf("GetDataRows() unexpected value")
	}
	gotData := s.GetDataRows()
	gotData[0][0] = "changed"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating GetDataRows result changed source: %v", s)
	}

	s.EachDataRow(func(rowIndex int, row []string, asMap map[string]string) bool {
		row[0] = "changed"
		asMap["A"] = "changed"
		return true
	})
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating row or map inside EachDataRow changed source: %v", s)
	}

	gotHead := s.Head(1)
	gotHead[1][0] = "changed"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating Head result changed source: %v", s)
	}

	gotTail := s.Tail(1)
	gotTail[1][0] = "changed"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating Tail result changed source: %v", s)
	}

	gotSlice, ok := s.SliceRows(1, 2)
	if !ok {
		t.Fatalf("SliceRows() ok = false, want true")
	}
	gotSlice[1][0] = "changed"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating SliceRows result changed source: %v", s)
	}

	gotAppend, ok := s.AppendRows(other)
	if !ok {
		t.Fatalf("AppendRows() ok = false, want true")
	}
	if gotAppend[3][0] != "5" {
		t.Errorf("AppendRows() row = %v, want [5 6]", gotAppend[3])
	}
	gotAppend[1][0] = "changed"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating AppendRows result changed source: %v", s)
	}
	if !reflect.DeepEqual(other, SimpleCsv{{"A", "B"}, {"5", "6"}}) {
		t.Errorf("AppendRows() modified other: %v", other)
	}

	gotConcat, ok := Concat(s, other)
	if !ok {
		t.Fatalf("Concat() ok = false, want true")
	}
	gotConcat[1][0] = "changed"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating Concat result changed source: %v", s)
	}

	failed, ok := s.SliceRows(0, 2)
	if ok {
		t.Fatalf("SliceRows() ok = true, want false")
	}
	failed[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating failed SliceRows result changed source: %v", s)
	}

	failed, ok = s.AppendRows(SimpleCsv{{"X", "Y"}, {"5", "6"}})
	if ok {
		t.Fatalf("AppendRows() ok = true, want false")
	}
	failed[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating failed AppendRows result changed source: %v", s)
	}
}