From 93023774d2719c8cf0f0d9b7c0a9cfd6c4a9550a Mon Sep 17 00:00:00 2001
From: Gregory Eremin <g@erem.in>
Date: Mon, 23 Feb 2015 20:51:56 +0700
Subject: [PATCH] Lexer benchmarks

---
 .gitignore          |  2 ++
 lexer/lexer_test.go | 69 +++++++++++++++++++++++++++++----------------
 2 files changed, 47 insertions(+), 24 deletions(-)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4b54934
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+main
+big*.json
diff --git a/lexer/lexer_test.go b/lexer/lexer_test.go
index d23a60e..46ae85d 100644
--- a/lexer/lexer_test.go
+++ b/lexer/lexer_test.go
@@ -1,62 +1,84 @@
 package lexer
 
 import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
 	"runtime"
 	"testing"
 
 	"github.com/localhots/punk/buffer"
 )
 
+func BenchmarkRun(t *testing.B) {
+	f, _ := os.Open("big1.json")
+	b, _ := ioutil.ReadAll(f)
+	t.ReportAllocs()
+	for i := 0; i < t.N; i++ {
+		lex(b)
+	}
+}
+
+func BenchmarkStandardJSON(t *testing.B) {
+	f, _ := os.Open("big1.json")
+	b, _ := ioutil.ReadAll(f)
+	t.ReportAllocs()
+	for i := 0; i < t.N; i++ {
+		var res interface{}
+		json.Unmarshal(b, &res)
+	}
+}
+
 func TestEmpty(t *testing.T) {
-	compare(t, lex(""), []Item{
+	compare(t, lex([]byte("")), []Item{
 		{EOF, "\x00", 0, 0},
 	})
 }
 
 func TestNull(t *testing.T) {
-	compare(t, lex("null"), []Item{
+	compare(t, lex([]byte("null")), []Item{
 		{Null, "null", 0, 0},
 		{EOF, "\x00", 0, 0},
 	})
 }
 
 func TesBool(t *testing.T) {
-	compare(t, lex("true"), []Item{
+	compare(t, lex([]byte("true")), []Item{
 		{Bool, "true", 0, 0},
 		{EOF, "\x00", 0, 0},
 	})
-	compare(t, lex("false"), []Item{
+	compare(t, lex([]byte("false")), []Item{
 		{Bool, "false", 0, 0},
 		{EOF, "\x00", 0, 0},
 	})
 }
 
 func TestString(t *testing.T) {
-	compare(t, lex(`"foo"`), []Item{
+	compare(t, lex([]byte(`"foo"`)), []Item{
 		{String, "foo", 0, 0},
 		{EOF, "\x00", 0, 0},
 	})
 }
 
 func TestNumber(t *testing.T) {
-	compare(t, lex("123"), []Item{
+	compare(t, lex([]byte("123")), []Item{
 		{Number, "123", 0, 0},
 		{EOF, "\x00", 0, 0},
 	})
-	compare(t, lex("123.456"), []Item{
+	compare(t, lex([]byte("123.456")), []Item{
 		{Number, "123.456", 0, 0},
 		{EOF, "\x00", 0, 0},
 	})
-	compare(t, lex("123.456.789"), []Item{
+	compare(t, lex([]byte("123.456.789")), []Item{
 		{Error, `Invalid number: "123.456.789"`, 0, 0},
 	})
-	compare(t, lex("123."), []Item{
+	compare(t, lex([]byte("123.")), []Item{
 		{Error, `Invalid number: "123."`, 0, 0},
 	})
 }
 
 func TestArray(t *testing.T) {
-	compare(t, lex(`[1, "2", 3]`), []Item{
+	compare(t, lex([]byte(`[1, "2", 3]`)), []Item{
 		{BracketOpen, "[", 0, 0},
 		{Number, "1", 0, 0},
 		{Comma, ",", 0, 0},
@@ -69,7 +91,7 @@ func TestArray(t *testing.T) {
 }
 
 func TestObject(t *testing.T) {
-	compare(t, lex(`{"a": 1, "b": 2}`), []Item{
+	compare(t, lex([]byte(`{"a": 1, "b": 2}`)), []Item{
 		{BraceOpen, "{", 0, 0},
 		{String, "a", 0, 0},
 		{Colon, ":", 0, 0},
@@ -85,17 +107,16 @@ func TestObject(t *testing.T) {
 
 // Yay!
 func TestEverything(t *testing.T) {
-	input := `
-{
-    "foo": true,
-    "bar": false,
-    "zilch": null,
-    "numbers": [1, 23, 4.56, 7.89],
-    "bullshit": {
-        "nothing": "anything"
-    }!
-}
-`
+	input := []byte(`{
+	    "foo": true,
+	    "bar": false,
+	    "zilch": null,
+	    "numbers": [1, 23, 4.56, 7.89],
+	    "bullshit": {
+	        "nothing": "anything"
+	    }!
+	}`)
+
 	compare(t, lex(input), []Item{
 		{BraceOpen, "{", 0, 0},
 		{String, "foo", 0, 0},
@@ -152,8 +173,8 @@ func compare(t *testing.T, reality, expectations []Item) {
 	}
 }
 
-func lex(jstr string) []Item {
-	buf := buffer.NewBytesBuffer([]byte(jstr))
+func lex(b []byte) []Item {
+	buf := buffer.NewBytesBuffer(b)
 	lex := New(buf)
 	go lex.Run()