go-toml/parse2/grammar_test.go

package main

import (
	"testing"
)

// func BenchmarkLongToml(b *testing.B) {
// 	benchmarkFile(b, "long.toml")
// }

// func BenchmarkNormalToml(b *testing.B) {
// 	benchmarkFile(b, "normal.toml")
// }

// func BenchmarkShortToml(b *testing.B) {
// 	benchmarkFile(b, "short.toml")
// }

// func benchmarkFile(b *testing.B, file string) {
// 	toml := BuildGrammar()
// 	inputBytes, err := ioutil.ReadFile(file)
// 	if err != nil {
// 		b.Fatalf("Cannot read input file (%s): %s", file, err)
// 	}
// 	inputStr := string(inputBytes)
// 	for i := 0; i < b.N; i++ {
// 		_, err := toml.Match(inputStr)
// 		if err != nil {
// 			b.Fatalf("Error in parsing TOML input: %s\n", err)
// 		}
// 	}
// }

// func BenchmarkReadArrayOfInt(b *testing.B) {
// 	type F [10]int
// 	arr := make([]F, 10000)
// 	for i := 0; i < 10000; i++ {
// 		arr[i] = [10]int{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 	}

// 	for i := 0; i < b.N; i++ {
// 		for x := 0; x < 10000; x++ {
// 			val := arr[x][0] + arr[x][1] + arr[x][2] + arr[x][3] + arr[x][4] + arr[x][5] + arr[x][6] + arr[x][7] + arr[x][8] + arr[x][9]
// 			val += 0
// 		}
// 	}
// }

// func BenchmarkWriteArrayOfInt(b *testing.B) {
// 	type F [10]int
// 	for i := 0; i < b.N; i++ {
// 		arr := make([]F, 10000)
// 		for i := 0; i < 10000; i++ {
// 			arr[i] = [10]int{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 		}
// 	}
// }

// func BenchmarkWriteRandomArrayOfInt(b *testing.B) {
// 	type F [10]int
// 	for i := 0; i < b.N; i++ {
// 		arr := make([]F, 10000)
// 		for i := 0; i < 10000; i++ {
// 			arr[i] = [10]int{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 			arr[i][0] = 666
// 			arr[i][1] = 666
// 			arr[i][2] = 666
// 			arr[i][3] = 666
// 			arr[i][4] = 666
// 			arr[i][5] = 666
// 			arr[i][6] = 666
// 			arr[i][7] = 666
// 			arr[i][8] = 666
// 			arr[i][9] = 666
// 		}
// 	}
// }

func BenchmarkReadArrayOfStructs(b *testing.B) {
	type F struct {
		A int
		B int
		C int
		D int
		E int
		F int
		G int
		H int
		I int
		J int
	}
	arr := make([]F, 10000)
	for i := 0; i < 10000; i++ {
		arr[i] = F{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	}

	for i := 0; i < b.N; i++ {
		for x := 0; x < 10000; x++ {
			val := arr[x].A + arr[x].B + arr[x].C + arr[x].D + arr[x].E + arr[x].F + arr[x].G + arr[x].H + arr[x].I + arr[x].J
			val += 0
		}
	}
}

func BenchmarkReadStructOfArrays(b *testing.B) {
	type F struct {
		A []int
		B []int
		C []int
		D []int
		E []int
		F []int
		G []int
		H []int
		I []int
		J []int
	}
	s := F{}
	for i := 0; i < 10000; i++ {
		s.A = append(s.A, 1)
		s.B = append(s.B, 1)
		s.C = append(s.C, 1)
		s.D = append(s.D, 1)
		s.E = append(s.E, 1)
		s.F = append(s.F, 1)
		s.G = append(s.G, 1)
		s.H = append(s.H, 1)
		s.I = append(s.I, 1)
		s.J = append(s.J, 1)
	}

	for i := 0; i < b.N; i++ {
		for x := 0; x < 10000; x++ {
			val := s.A[x] + s.B[x] + s.C[x] + s.D[x] + s.E[x] + s.F[x] + s.G[x] + s.H[x] + s.I[x] + s.J[x]
			val += 0
		}
	}
}

// func BenchmarkWriteArrayOfStructs(b *testing.B) {
// 	type F struct {
// 		A int
// 		B int
// 		C int
// 		D int
// 		E int
// 		F int
// 		G int
// 		H int
// 		I int
// 		J int
// 	}
// 	for i := 0; i < b.N; i++ {
// 		arr := make([]F, 10000)
// 		for i := 0; i < 10000; i++ {
// 			arr[i] = F{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 		}
// 	}
// }

// func BenchmarkWriteRandomArrayOfStructs(b *testing.B) {
// 	type F struct {
// 		A int
// 		B int
// 		C int
// 		D int
// 		E int
// 		F int
// 		G int
// 		H int
// 		I int
// 		J int
// 	}
// 	for i := 0; i < b.N; i++ {
// 		arr := make([]F, 10000)
// 		for i := 0; i < 10000; i++ {
// 			arr[i] = F{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 			arr[i].A = 666
// 			arr[i].B = 666
// 			arr[i].C = 666
// 			arr[i].D = 666
// 			arr[i].E = 666
// 			arr[i].F = 666
// 			arr[i].G = 666
// 			arr[i].H = 666
// 			arr[i].I = 666
// 			arr[i].J = 666
// 		}
// 	}
// }

// func BenchmarkReadMapOfStructs(b *testing.B) {
// 	type F struct {
// 		A int
// 		B int
// 		C int
// 		D int
// 		E int
// 		F int
// 		G int
// 		H int
// 		I int
// 		J int
// 	}
// 	fMap := make(map[int]F)
// 	for i := 0; i < 10000; i++ {
// 		fMap[i] = F{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 	}

// 	for i := 0; i < b.N; i++ {
// 		for x := 0; x < 10000; x++ {
// 			val := fMap[x].A + fMap[x].B + fMap[x].C + fMap[x].D + fMap[x].E + fMap[x].F + fMap[x].G + fMap[x].H + fMap[x].I + fMap[x].J
// 			val += 0
// 		}
// 	}
// }

// func BenchmarkWriteMapOfStructs(b *testing.B) {
// 	type F struct {
// 		A int
// 		B int
// 		C int
// 		D int
// 		E int
// 		F int
// 		G int
// 		H int
// 		I int
// 		J int
// 	}
// 	for i := 0; i < b.N; i++ {
// 		fMap := make(map[int]F)
// 		for i := 0; i < 10000; i++ {
// 			fMap[i] = F{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 		}
// 	}
// }

// func BenchmarkWriteRandomMapOfStructs(b *testing.B) {
// 	type F struct {
// 		A int
// 		B int
// 		C int
// 		D int
// 		E int
// 		F int
// 		G int
// 		H int
// 		I int
// 		J int
// 	}
// 	for i := 0; i < b.N; i++ {
// 		fMap := make(map[int]F)
// 		for i := 0; i < 10000; i++ {
// 			fMap[i] = F{i, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// 			s := fMap[i]
// 			s.A = 666
// 			s.B = 666
// 			s.C = 666
// 			s.D = 666
// 			s.E = 666
// 			s.F = 666
// 			s.G = 666
// 			s.H = 666
// 			s.I = 666
// 			s.J = 666
// 		}
// 	}
// }