tiendc · July 4, 2023 10:58
diff --git a/csvlib_benchmark.go b/csvlib_benchmark.go
 package benchmark

 import (
 	"bytes"
 	"encoding/csv"
 	"testing"

 	"github.com/gocarina/gocsv"
 	"github.com/jszwec/csvutil"
 	"github.com/tiendc/go-csvlib"
 	"github.com/yunabe/easycsv"
 )

 // NOTE: This benchmark code is copied from the bench test of the project https://github.com/jszwec/csvutil
 // Unmarshal bench: https://gist.github.com/jszwec/e8515e741190454fa3494bcd3e1f100f
 // Marshal bench: https://gist.github.com/jszwec/31980321e1852ebb5615a44ccf374f17

 func BenchmarkUnmarshal(b *testing.B) {
 	type A struct {
 		A int     `csv:"a" name:"a"`
 		B float64 `csv:"b" name:"b"`
 		C string  `csv:"c" name:"c"`
 		D int64   `csv:"d" name:"d"`
 		E int8    `csv:"e" name:"e"`
 		F float32 `csv:"f" name:"f"`
 		G float32 `csv:"g" name:"g"`
 		H float32 `csv:"h" name:"h"`
 		I string  `csv:"i" name:"i"`
 		J int     `csv:"j" name:"j"`
 	}

 	fixture := []struct {
 		desc    string
 		records int
 	}{
 		{
 			desc:    "100 records",
 			records: 100,
 		},
 		{
 			desc:    "1000 records",
 			records: 1000,
 		},
 		{
 			desc:    "10000 records",
 			records: 10000,
 		},
 		{
 			desc:    "100000 records",
 			records: 100000,
 		},
 	}

 	tests := []struct {
 		desc string
 		fn   func([]byte, *testing.B)
 	}{
 		{
 			desc: "csvlib.Unmarshal",
 			fn: func(data []byte, b *testing.B) {
 				var a []A
 				if _, err := csvlib.Unmarshal(data, &a); err != nil {
 					b.Error(err)
 				}
 			},
 		},
 		{
 			desc: "csvutil.Unmarshal",
 			fn: func(data []byte, b *testing.B) {
 				var a []A
 				if err := csvutil.Unmarshal(data, &a); err != nil {
 					b.Error(err)
 				}
 			},
 		},
 		{
 			desc: "gocsv.Unmarshal",
 			fn: func(data []byte, b *testing.B) {
 				var a []A
 				if err := gocsv.UnmarshalBytes(data, &a); err != nil {
 					b.Error(err)
 				}
 			},
 		},
 		{
 			desc: "easycsv.ReadAll",
 			fn: func(data []byte, b *testing.B) {
 				r := easycsv.NewReader(bytes.NewReader(data))
 				var a []A
 				if err := r.ReadAll(&a); err != nil {
 					b.Error(err)
 				}
 			},
 		},
 	}

 	for _, t := range tests {
 		b.Run(t.desc, func(b *testing.B) {
 			for _, f := range fixture {
 				b.Run(f.desc, func(b *testing.B) {
 					data := genData(f.records)
 					for i := 0; i < b.N; i++ {
 						t.fn(data, b)
 					}
 				})
 			}
 		})
 	}
 }

 func genData(records int) []byte {
 	header := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}
 	record := []string{"1", "2.5", "foo", "6", "7", "8", "9", "10", "bar", "10"}

 	var buf bytes.Buffer
 	w := csv.NewWriter(&buf)
 	w.Write(header)

 	for i := 0; i < records; i++ {
 		w.Write(record)
 	}
 	w.Flush()
 	if err := w.Error(); err != nil {
 		panic(err)
 	}
 	return buf.Bytes()
 }

 func BenchmarkMarshal(b *testing.B) {
 	type A struct {
 		A int     `csv:"a"`
 		B float64 `csv:"b"`
 		C string  `csv:"c"`
 		D int64   `csv:"d"`
 		E int8    `csv:"e"`
 		F float32 `csv:"f"`
 		G float32 `csv:"g"`
 		H float32 `csv:"h"`
 		I string  `csv:"i"`
 		J int     `csv:"j"`
 	}

 	fixture := []struct {
 		desc    string
 		records int
 	}{
 		{
 			desc:    "100 records",
 			records: 100,
 		},
 		{
 			desc:    "1000 records",
 			records: 1000,
 		},
 		{
 			desc:    "10000 records",
 			records: 10000,
 		},
 		{
 			desc:    "100000 records",
 			records: 100000,
 		},
 	}

 	tests := []struct {
 		desc string
 		fn   func([]A, *testing.B)
 	}{
 		{
 			desc: "csvlib.Marshal",
 			fn: func(as []A, b *testing.B) {
 				if _, err := csvlib.Marshal(as); err != nil {
 					b.Error(err)
 				}
 			},
 		},
 		{
 			desc: "csvutil.Marshal",
 			fn: func(as []A, b *testing.B) {
 				if _, err := csvutil.Marshal(as); err != nil {
 					b.Error(err)
 				}
 			},
 		},
 		{
 			desc: "gocsv.Marshal",
 			fn: func(as []A, b *testing.B) {
 				var buf bytes.Buffer
 				if err := gocsv.Marshal(as, &buf); err != nil {
 					b.Error(err)
 				}
 			},
 		},
 	}

 	a := A{
 		A: 1,
 		B: 3.14,
 		C: "string",
 		D: 1,
 		E: 1,
 		F: 3.13,
 		G: 3.14,
 		H: 3.14,
 		I: "string",
 		J: 10,
 	}

 	for _, t := range tests {
 		b.Run(t.desc, func(b *testing.B) {
 			for _, f := range fixture {
 				b.Run(f.desc, func(b *testing.B) {
 					as := make([]A, f.records)
 					for i := range as {
 						as[i] = a
 					}
 					for i := 0; i < b.N; i++ {
 						t.fn(as, b)
 					}
 				})
 			}
 		})
 	}
 }
	package benchmark

	import (
	"bytes"
	"encoding/csv"
	"testing"

	"github.com/gocarina/gocsv"
	"github.com/jszwec/csvutil"
	"github.com/tiendc/go-csvlib"
	"github.com/yunabe/easycsv"
	)

	// NOTE: This benchmark code is copied from the bench test of the project https://github.com/jszwec/csvutil
	// Unmarshal bench: https://gist.github.com/jszwec/e8515e741190454fa3494bcd3e1f100f
	// Marshal bench: https://gist.github.com/jszwec/31980321e1852ebb5615a44ccf374f17

	func BenchmarkUnmarshal(b *testing.B) {
	type A struct {
	A int `csv:"a" name:"a"`
	B float64 `csv:"b" name:"b"`
	C string `csv:"c" name:"c"`
	D int64 `csv:"d" name:"d"`
	E int8 `csv:"e" name:"e"`
	F float32 `csv:"f" name:"f"`
	G float32 `csv:"g" name:"g"`
	H float32 `csv:"h" name:"h"`
	I string `csv:"i" name:"i"`
	J int `csv:"j" name:"j"`
	}

	fixture := []struct {
	desc string
	records int
	}{
	{
	desc: "100 records",
	records: 100,
	},
	{
	desc: "1000 records",
	records: 1000,
	},
	{
	desc: "10000 records",
	records: 10000,
	},
	{
	desc: "100000 records",
	records: 100000,
	},
	}

	tests := []struct {
	desc string
	fn func([]byte, *testing.B)
	}{
	{
	desc: "csvlib.Unmarshal",
	fn: func(data []byte, b *testing.B) {
	var a []A
	if _, err := csvlib.Unmarshal(data, &a); err != nil {
	b.Error(err)
	}
	},
	},
	{
	desc: "csvutil.Unmarshal",
	fn: func(data []byte, b *testing.B) {
	var a []A
	if err := csvutil.Unmarshal(data, &a); err != nil {
	b.Error(err)
	}
	},
	},
	{
	desc: "gocsv.Unmarshal",
	fn: func(data []byte, b *testing.B) {
	var a []A
	if err := gocsv.UnmarshalBytes(data, &a); err != nil {
	b.Error(err)
	}
	},
	},
	{
	desc: "easycsv.ReadAll",
	fn: func(data []byte, b *testing.B) {
	r := easycsv.NewReader(bytes.NewReader(data))
	var a []A
	if err := r.ReadAll(&a); err != nil {
	b.Error(err)
	}
	},
	},
	}

	for _, t := range tests {
	b.Run(t.desc, func(b *testing.B) {
	for _, f := range fixture {
	b.Run(f.desc, func(b *testing.B) {
	data := genData(f.records)
	for i := 0; i < b.N; i++ {
	t.fn(data, b)
	}
	})
	}
	})
	}
	}

	func genData(records int) []byte {
	header := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}
	record := []string{"1", "2.5", "foo", "6", "7", "8", "9", "10", "bar", "10"}

	var buf bytes.Buffer
	w := csv.NewWriter(&buf)
	w.Write(header)

	for i := 0; i < records; i++ {
	w.Write(record)
	}
	w.Flush()
	if err := w.Error(); err != nil {
	panic(err)
	}
	return buf.Bytes()
	}

	func BenchmarkMarshal(b *testing.B) {
	type A struct {
	A int `csv:"a"`
	B float64 `csv:"b"`
	C string `csv:"c"`
	D int64 `csv:"d"`
	E int8 `csv:"e"`
	F float32 `csv:"f"`
	G float32 `csv:"g"`
	H float32 `csv:"h"`
	I string `csv:"i"`
	J int `csv:"j"`
	}

	fixture := []struct {
	desc string
	records int
	}{
	{
	desc: "100 records",
	records: 100,
	},
	{
	desc: "1000 records",
	records: 1000,
	},
	{
	desc: "10000 records",
	records: 10000,
	},
	{
	desc: "100000 records",
	records: 100000,
	},
	}

	tests := []struct {
	desc string
	fn func([]A, *testing.B)
	}{
	{
	desc: "csvlib.Marshal",
	fn: func(as []A, b *testing.B) {
	if _, err := csvlib.Marshal(as); err != nil {
	b.Error(err)
	}
	},
	},
	{
	desc: "csvutil.Marshal",
	fn: func(as []A, b *testing.B) {
	if _, err := csvutil.Marshal(as); err != nil {
	b.Error(err)
	}
	},
	},
	{
	desc: "gocsv.Marshal",
	fn: func(as []A, b *testing.B) {
	var buf bytes.Buffer
	if err := gocsv.Marshal(as, &buf); err != nil {
	b.Error(err)
	}
	},
	},
	}

	a := A{
	A: 1,
	B: 3.14,
	C: "string",
	D: 1,
	E: 1,
	F: 3.13,
	G: 3.14,
	H: 3.14,
	I: "string",
	J: 10,
	}

	for _, t := range tests {
	b.Run(t.desc, func(b *testing.B) {
	for _, f := range fixture {
	b.Run(f.desc, func(b *testing.B) {
	as := make([]A, f.records)
	for i := range as {
	as[i] = a
	}
	for i := 0; i < b.N; i++ {
	t.fn(as, b)
	}
	})
	}
	})
	}
	}