csv_test.go

package otters

import (
	"math"
	"os"
	"testing"
	"time"
)

func TestReadCSVEdgeCases(t *testing.T) {
	// Test with skip rows
	csvData := `header1,header2
skip1,skip2
data1,data2
data3,data4`

	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString(csvData)
	tmpfile.Close()

	df, err := ReadCSVWithOptions(tmpfile.Name(), CSVOptions{
		HasHeader: true,
		Delimiter: ',',
		SkipRows:  1,
	})
	if err != nil {
		t.Errorf("ReadCSVWithOptions error: %v", err)
	}
	if df.Len() != 2 {
		t.Errorf("Expected 2 rows, got %d", df.Len())
	}
}

func TestReadCSVWithoutHeaders(t *testing.T) {
	csvData := `1,2,3
4,5,6
7,8,9`

	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString(csvData)
	tmpfile.Close()

	df, err := ReadCSVWithOptions(tmpfile.Name(), CSVOptions{
		HasHeader: false,
		Delimiter: ',',
	})
	if err != nil {
		t.Errorf("ReadCSVWithOptions error: %v", err)
	}
	if df.Width() != 3 {
		t.Errorf("Expected 3 columns, got %d", df.Width())
	}
	if !df.HasColumn("Column_0") {
		t.Error("Should have generated column names")
	}
}

func TestReadCSVMaxRows(t *testing.T) {
	csvData := `a,b
1,2
3,4
5,6
7,8`

	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString(csvData)
	tmpfile.Close()

	df, err := ReadCSVWithOptions(tmpfile.Name(), CSVOptions{
		HasHeader: true,
		Delimiter: ',',
		MaxRows:   2,
	})
	if err != nil {
		t.Errorf("ReadCSVWithOptions error: %v", err)
	}
	if df.Len() != 2 {
		t.Errorf("Expected 2 rows with MaxRows, got %d", df.Len())
	}
}

func TestReadCSVFromStringEdgeCases(t *testing.T) {
	csvData := `name,age
Alice,25
Bob,30`

	df, err := ReadCSVFromStringWithOptions(csvData, CSVOptions{
		HasHeader: true,
		Delimiter: ',',
	})
	if err != nil {
		t.Errorf("ReadCSVFromStringWithOptions error: %v", err)
	}
	if df.Len() != 2 {
		t.Errorf("Expected 2 rows, got %d", df.Len())
	}
}

func TestWriteCSVEdgeCases(t *testing.T) {
	data := map[string]any{
		"col1": []int64{1, 2, 3},
		"col2": []string{"a", "b", "c"},
	}
	df, _ := NewDataFrameFromMap(data)

	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.Close()

	err := df.WriteCSV(tmpfile.Name())
	if err != nil {
		t.Errorf("WriteCSV error: %v", err)
	}

	// Read it back
	df2, err := ReadCSV(tmpfile.Name())
	if err != nil {
		t.Errorf("ReadCSV error: %v", err)
	}
	if df2.Len() != 3 {
		t.Error("Written CSV should be readable")
	}
}

func TestDetectDelimiter(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("a;b;c\n1;2;3")
	tmpfile.Close()

	delim, err := DetectDelimiter(tmpfile.Name())
	if err != nil || delim != ';' {
		t.Errorf("DetectDelimiter = %c, %v, want ;", delim, err)
	}
}

func TestValidateCSV(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("a,b,c\n1,2,3\n4,5,6")
	tmpfile.Close()

	info, err := ValidateCSV(tmpfile.Name())
	if err != nil {
		t.Errorf("ValidateCSV error: %v", err)
	}
	if info.Columns != 3 {
		t.Errorf("ValidateCSV columns = %d, want 3", info.Columns)
	}
}

func TestCleanHeader(t *testing.T) {
	// Test BOM removal
	header := "\ufeffName"
	cleaned := cleanHeader(header)
	if cleaned != "Name" {
		t.Errorf("cleanHeader should remove BOM, got %s", cleaned)
	}

	// Test whitespace trimming
	header2 := "  Name  "
	cleaned2 := cleanHeader(header2)
	if cleaned2 != "Name" {
		t.Errorf("cleanHeader should trim spaces, got %s", cleaned2)
	}
}

func TestCSV_ConvertStringSliceToType_Success_AllTypes(t *testing.T) {
	// int64
	intData := []string{"1", "2", "3"}
	result, err := convertStringSliceToType(intData, Int64Type)
	if err != nil {
		t.Errorf("convertStringSliceToType int64 error: %v", err)
	}
	intSlice, ok := result.([]int64)
	if !ok || len(intSlice) != 3 || intSlice[0] != 1 {
		t.Error("convertStringSliceToType should convert to []int64")
	}

	// float64
	floatData := []string{"1.1", "2.2", "3.3"}
	result2, err2 := convertStringSliceToType(floatData, Float64Type)
	if err2 != nil {
		t.Errorf("convertStringSliceToType float64 error: %v", err2)
	}
	floatSlice, ok2 := result2.([]float64)
	if !ok2 || len(floatSlice) != 3 {
		t.Error("convertStringSliceToType should convert to []float64")
	}

	// bool
	boolData := []string{"true", "false", "true"}
	result3, err3 := convertStringSliceToType(boolData, BoolType)
	if err3 != nil {
		t.Errorf("convertStringSliceToType bool error: %v", err3)
	}
	boolSlice, ok3 := result3.([]bool)
	if !ok3 || len(boolSlice) != 3 || !boolSlice[0] {
		t.Error("convertStringSliceToType should convert to []bool")
	}

	// time
	timeData := []string{"2023-01-01", "2023-01-02"}
	result4, err4 := convertStringSliceToType(timeData, TimeType)
	if err4 != nil {
		t.Errorf("convertStringSliceToType time error: %v", err4)
	}
	timeSlice, ok4 := result4.([]time.Time)
	if !ok4 || len(timeSlice) != 2 {
		t.Error("convertStringSliceToType should convert to []time.Time")
	}

	// string
	strData := []string{"a", "b", "c"}
	result5, err5 := convertStringSliceToType(strData, StringType)
	if err5 != nil {
		t.Errorf("convertStringSliceToType string error: %v", err5)
	}
	strSlice, ok5 := result5.([]string)
	if !ok5 || len(strSlice) != 3 {
		t.Error("convertStringSliceToType should keep []string")
	}
}

func TestCSV_ConvertStringSliceToType_Failure_InvalidData(t *testing.T) {
	invalidInt := []string{"not", "a", "number"}
	_, err := convertStringSliceToType(invalidInt, Int64Type)
	if err == nil {
		t.Error("convertStringSliceToType should error on invalid int64")
	}

	invalidFloat := []string{"not", "a", "float"}
	_, err2 := convertStringSliceToType(invalidFloat, Float64Type)
	if err2 == nil {
		t.Error("convertStringSliceToType should error on invalid float64")
	}

	invalidBool := []string{"not", "a", "bool"}
	_, err3 := convertStringSliceToType(invalidBool, BoolType)
	if err3 == nil {
		t.Error("convertStringSliceToType should error on invalid bool")
	}

	invalidTime := []string{"not", "a", "time"}
	_, err4 := convertStringSliceToType(invalidTime, TimeType)
	if err4 == nil {
		t.Error("convertStringSliceToType should error on invalid time")
	}
}

func TestCSV_BuildDataFrameFromRows_EdgeCases(t *testing.T) {
	// Empty headers
	df, err := buildDataFrameFromRows([]string{}, [][]string{})
	if err != nil || df.Width() != 0 {
		t.Error("buildDataFrameFromRows empty should work")
	}

	// No rows
	df2, err2 := buildDataFrameFromRows([]string{"col1", "col2"}, [][]string{})
	if err2 != nil || df2.Width() != 2 {
		t.Error("buildDataFrameFromRows no rows should create empty DataFrame with columns")
	}
}

func TestCSV_ReadCSV_EmptyFile_ReturnsEmptyDataFrame(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.Close()

	df, err := ReadCSV(tmpfile.Name())
	if err != nil {
		t.Errorf("ReadCSV empty file error: %v", err)
	}
	if df.Len() != 0 {
		t.Error("ReadCSV empty file should return empty DataFrame")
	}
}

func TestCSV_ReadCSV_RowLengthMismatch_Errors(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("a,b,c\n1,2,3\n4,5\n")
	tmpfile.Close()

	_, err := ReadCSV(tmpfile.Name())
	if err == nil {
		t.Error("ReadCSV should error on row length mismatch")
	}
}

func TestCSV_ReadCSVWithOptions_SkipRowsPastEOF_ReturnsEmpty(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("header\n")
	tmpfile.Close()

	df, err := ReadCSVWithOptions(tmpfile.Name(), CSVOptions{
		HasHeader: true,
		Delimiter: ',',
		SkipRows:  10,
	})
	if err != nil {
		t.Errorf("ReadCSVWithOptions error: %v", err)
	}
	if df.Len() != 0 {
		t.Error("Should return empty DataFrame when skipping past EOF")
	}
}

func TestCSV_ReadCSVWithOptions_EOF_ReturnsEmpty(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("")
	tmpfile.Close()

	df, _ := ReadCSVWithOptions(tmpfile.Name(), CSVOptions{
		HasHeader: true,
		Delimiter: ',',
	})
	if df.Len() != 0 {
		t.Error("ReadCSVWithOptions EOF should return empty DataFrame")
	}
}

func TestCSV_ReadCSVWithOptions_MaxRows_NoHeader_LimitsRows(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("1,2,3\n4,5,6\n7,8,9\n10,11,12")
	tmpfile.Close()

	df, err := ReadCSVWithOptions(tmpfile.Name(), CSVOptions{
		HasHeader: false,
		Delimiter: ',',
		MaxRows:   2,
	})
	if err != nil {
		t.Errorf("ReadCSVWithOptions error: %v", err)
	}
	if df.Len() != 2 {
		t.Errorf("Expected 2 rows with MaxRows, got %d", df.Len())
	}
}

func TestCSV_ReadCSVFromStringWithOptions_NoHeader_GeneratesColumnNames(t *testing.T) {
	csvData := "1,2,3\n4,5,6"
	df, err := ReadCSVFromStringWithOptions(csvData, CSVOptions{
		HasHeader: false,
		Delimiter: ',',
	})
	if err != nil {
		t.Errorf("ReadCSVFromStringWithOptions error: %v", err)
	}
	if df.Width() != 3 {
		t.Error("Should generate column names")
	}
}

func TestCSV_ReadCSVFromStringWithOptions_RowMismatch_Errors(t *testing.T) {
	csvData := "a,b,c\n1,2,3\n4,5"
	_, err := ReadCSVFromStringWithOptions(csvData, CSVOptions{
		HasHeader: true,
		Delimiter: ',',
	})
	if err == nil {
		t.Error("Should error on row length mismatch")
	}
}

func TestCSV_ReadCSVFromStringWithOptions_MaxRows_LimitsRows(t *testing.T) {
	csvData := "a,b\n1,2\n3,4\n5,6\n7,8"
	df, err := ReadCSVFromStringWithOptions(csvData, CSVOptions{
		HasHeader: true,
		Delimiter: ',',
		MaxRows:   2,
	})
	if err != nil {
		t.Errorf("ReadCSVFromStringWithOptions error: %v", err)
	}
	if df.Len() != 2 {
		t.Errorf("Expected 2 rows with MaxRows, got %d", df.Len())
	}
}

func TestCSV_WriteCSV_PropagatesDataFrameError(t *testing.T) {
	df := NewDataFrame()
	df.err = newOpError("test", "error")

	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.Close()

	err := df.WriteCSV(tmpfile.Name())
	if err == nil {
		t.Error("WriteCSV should propagate error")
	}
}

func TestCSV_WriteCSVWithOptions_WritesFile(t *testing.T) {
	data := map[string]any{
		"col1": []int64{1, 2, 3},
		"col2": []float64{1.1, 2.2, 3.3},
		"col3": []bool{true, false, true},
	}
	df, _ := NewDataFrameFromMap(data)

	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.Close()

	err := df.WriteCSVWithOptions(tmpfile.Name(), CSVOptions{
		HasHeader: true,
		Delimiter: ',',
	})
	if err != nil {
		t.Errorf("WriteCSVWithOptions error: %v", err)
	}
}

func TestCSV_WriteCSV_TimeColumn_WritesFile(t *testing.T) {
	tm := time.Date(2023, 1, 1, 12, 30, 0, 0, time.UTC)
	data := map[string]any{
		"col1": []time.Time{tm, tm},
	}
	df, _ := NewDataFrameFromMap(data)

	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.Close()

	err := df.WriteCSV(tmpfile.Name())
	if err != nil {
		t.Errorf("WriteCSV with time error: %v", err)
	}
}

func TestCSV_DetectDelimiter_Tab(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("a\tb\tc\n1\t2\t3")
	tmpfile.Close()

	delim, err := DetectDelimiter(tmpfile.Name())
	if err != nil || delim != '\t' {
		t.Errorf("DetectDelimiter = %c, %v, want tab", delim, err)
	}
}

func TestCSV_DetectDelimiter_Pipe(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("a|b|c\n1|2|3")
	tmpfile.Close()

	delim, err := DetectDelimiter(tmpfile.Name())
	if err != nil || delim != '|' {
		t.Errorf("DetectDelimiter = %c, %v, want |", delim, err)
	}
}

func TestCSV_DetectDelimiter_DefaultComma(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("abc")
	tmpfile.Close()

	delim, err := DetectDelimiter(tmpfile.Name())
	if err != nil || delim != ',' {
		t.Errorf("DetectDelimiter should default to comma, got %c", delim)
	}
}

func TestCSV_DetectDelimiter_ErrorOnMissingFile(t *testing.T) {
	_, err := DetectDelimiter("/nonexistent/file.csv")
	if err == nil {
		t.Error("DetectDelimiter should error on nonexistent file")
	}
}

func TestCSV_CleanHeader_TrimsSpaces(t *testing.T) {
	header := "   Name   "
	cleaned := cleanHeader(header)
	if cleaned != "Name" {
		t.Errorf("cleanHeader = %s, want Name", cleaned)
	}
}

func TestCSV_CleanHeader_StripsBOMAndSpaces(t *testing.T) {
	header := "\ufeff  Name  "
	cleaned := cleanHeader(header)
	if cleaned != "Name" {
		t.Errorf("cleanHeader = %s, want Name", cleaned)
	}
}

func TestCSV_ValidateCSV_ErrorOnMissingFile(t *testing.T) {
	_, err := ValidateCSV("/nonexistent/file.csv")
	if err == nil {
		t.Error("ValidateCSV should error on nonexistent file")
	}
}

func TestCSV_ValidateCSV_ReturnsInfo(t *testing.T) {
	tmpfile, _ := os.CreateTemp("", "test*.csv")
	defer os.Remove(tmpfile.Name())
	tmpfile.WriteString("a,b,c\n1,2,3\n4,5,6")
	tmpfile.Close()

	info, err := ValidateCSV(tmpfile.Name())
	if err != nil {
		t.Errorf("ValidateCSV error: %v", err)
	}
	if info.Columns != 3 {
		t.Errorf("CSVInfo.Columns = %d, want 3", info.Columns)
	}
	if info.Rows < 2 {
		t.Errorf("CSVInfo.Rows = %d, want at least 2", info.Rows)
	}
	if info.Delimiter != ',' {
		t.Errorf("CSVInfo.Delimiter = %c, want ,", info.Delimiter)
	}
}

// Regression: a CSV column of 0/1 flags used to be inferred as BoolType
// because strconv.ParseBool accepts "0"/"1"/"t"/"f", so round-tripping a
// file rewrote the data as true/false.
func TestCSVZeroOneColumnRoundTrip(t *testing.T) {
	dir := t.TempDir()
	in := dir + "/in.csv"
	out := dir + "/out.csv"

	if err := os.WriteFile(in, []byte("id,flag\n10,0\n20,1\n30,0\n"), 0o644); err != nil {
		t.Fatal(err)
	}

	df, err := ReadCSV(in)
	if err != nil {
		t.Fatal(err)
	}

	colType, _ := df.GetColumnType("flag")
	if colType != Int64Type {
		t.Errorf("flag column inferred as %v, want int64", colType)
	}

	if err := df.WriteCSV(out); err != nil {
		t.Fatal(err)
	}
	data, err := os.ReadFile(out)
	if err != nil {
		t.Fatal(err)
	}
	want := "id,flag\n10,0\n20,1\n30,0\n"
	if string(data) != want {
		t.Errorf("round-trip changed the data:\n got: %q\nwant: %q", string(data), want)
	}
}

// TestCSVOperations covers CSV parsing with automatic type inference.
func TestCSVOperations(t *testing.T) {
	csvData := `name,age,score
Alice,25,95.5
Bob,30,87.2
Carol,28,92.1`

	df, err := ReadCSVFromString(csvData)
	if err != nil {
		t.Fatalf("Failed to read CSV: %v", err)
	}

	// Test automatic type inference
	ageType, err := df.GetColumnType("age")
	if err != nil {
		t.Fatalf("Failed to get column type: %v", err)
	}
	if ageType != Int64Type {
		t.Errorf("Expected Int64Type for age, got %v", ageType)
	}

	scoreType, err := df.GetColumnType("score")
	if err != nil {
		t.Fatalf("Failed to get column type: %v", err)
	}
	if scoreType != Float64Type {
		t.Errorf("Expected Float64Type for score, got %v", scoreType)
	}

	// Test statistics with proper floating point comparison
	avgScore, err := df.Mean("score")
	if err != nil {
		t.Fatalf("Failed to calculate mean: %v", err)
	}

	expectedAvg := (95.5 + 87.2 + 92.1) / 3
	// Use tolerance for floating point comparison
	tolerance := 0.001
	if math.Abs(avgScore-expectedAvg) > tolerance {
		t.Errorf("Expected average %.6f, got %.6f", expectedAvg, avgScore)
	}
}

// TestCSVFileOperations covers file-based CSV I/O using os.CreateTemp.
func TestCSVFileOperations(t *testing.T) {
	data := map[string]any{
		"id":   []int64{1, 2, 3},
		"name": []string{"Alice", "Bob", "Carol"},
		"age":  []int64{25, 30, 35},
	}
	df, err := NewDataFrameFromMap(data)
	if err != nil {
		t.Fatalf("setup failed: %v", err)
	}

	// WriteCSV + ReadCSV roundtrip
	tmpCSV, err := os.CreateTemp("", "otter_test_*.csv")
	if err != nil {
		t.Fatalf("CreateTemp error: %v", err)
	}
	tmpCSV.Close()
	defer os.Remove(tmpCSV.Name())

	if err := df.WriteCSV(tmpCSV.Name()); err != nil {
		t.Fatalf("WriteCSV error: %v", err)
	}
	df2, err := ReadCSV(tmpCSV.Name())
	if err != nil {
		t.Fatalf("ReadCSV error: %v", err)
	}
	rows, cols := df2.Shape()
	if rows != 3 || cols != 3 {
		t.Errorf("ReadCSV roundtrip: got shape (%d, %d), want (3, 3)", rows, cols)
	}

	// WriteCSVWithOptions + ReadCSVWithOptions with tab delimiter
	tmpTSV, err := os.CreateTemp("", "otter_test_*.tsv")
	if err != nil {
		t.Fatalf("CreateTemp error: %v", err)
	}
	tmpTSV.Close()
	defer os.Remove(tmpTSV.Name())

	if err := df.WriteCSVWithOptions(tmpTSV.Name(), CSVOptions{HasHeader: true, Delimiter: '\t'}); err != nil {
		t.Fatalf("WriteCSVWithOptions error: %v", err)
	}
	df3, err := ReadCSVWithOptions(tmpTSV.Name(), CSVOptions{HasHeader: true, Delimiter: '\t'})
	if err != nil {
		t.Fatalf("ReadCSVWithOptions error: %v", err)
	}
	rows, cols = df3.Shape()
	if rows != 3 || cols != 3 {
		t.Errorf("ReadCSVWithOptions tab roundtrip: got shape (%d, %d), want (3, 3)", rows, cols)
	}

	// DetectDelimiter on tab-delimited file
	delim, err := DetectDelimiter(tmpTSV.Name())
	if err != nil {
		t.Fatalf("DetectDelimiter error: %v", err)
	}
	if delim != '\t' {
		t.Errorf("DetectDelimiter: got %q, want tab", string(delim))
	}

	// ValidateCSV on valid file
	info, err := ValidateCSV(tmpCSV.Name())
	if err != nil {
		t.Fatalf("ValidateCSV error: %v", err)
	}
	if info == nil {
		t.Fatal("ValidateCSV returned nil info")
	}

	// ValidateCSV on invalid file (inconsistent column counts)
	tmpInvalid, err := os.CreateTemp("", "otter_invalid_*.csv")
	if err != nil {
		t.Fatalf("CreateTemp error: %v", err)
	}
	_, _ = tmpInvalid.WriteString("col1,col2\n1,2\n3,4,5\n")
	tmpInvalid.Close()
	defer os.Remove(tmpInvalid.Name())
	_, err = ValidateCSV(tmpInvalid.Name())
	if err == nil {
		t.Error("ValidateCSV: expected error for inconsistent columns, got nil")
	}

	// Headerless CSV
	tmpNoHeader, err := os.CreateTemp("", "otter_noheader_*.csv")
	if err != nil {
		t.Fatalf("CreateTemp error: %v", err)
	}
	_, _ = tmpNoHeader.WriteString("1,Alice\n2,Bob\n")
	tmpNoHeader.Close()
	defer os.Remove(tmpNoHeader.Name())
	dfNoHeader, err := ReadCSVWithOptions(tmpNoHeader.Name(), CSVOptions{HasHeader: false, Delimiter: ','})
	if err != nil {
		t.Fatalf("ReadCSVWithOptions headerless error: %v", err)
	}
	nhRows, nhCols := dfNoHeader.Shape()
	if nhRows != 2 || nhCols != 2 {
		t.Errorf("Headerless CSV: got shape (%d, %d), want (2, 2)", nhRows, nhCols)
	}

	// MaxRows option
	tmpMaxRows, err := os.CreateTemp("", "otter_maxrows_*.csv")
	if err != nil {
		t.Fatalf("CreateTemp error: %v", err)
	}
	_, _ = tmpMaxRows.WriteString("id,name\n1,Alice\n2,Bob\n3,Carol\n4,Dave\n")
	tmpMaxRows.Close()
	defer os.Remove(tmpMaxRows.Name())
	dfMax, err := ReadCSVWithOptions(tmpMaxRows.Name(), CSVOptions{HasHeader: true, Delimiter: ',', MaxRows: 2})
	if err != nil {
		t.Fatalf("ReadCSVWithOptions MaxRows error: %v", err)
	}
	maxRows, _ := dfMax.Shape()
	if maxRows != 2 {
		t.Errorf("MaxRows: got %d rows, want 2", maxRows)
	}
}