codec: re-organized test files to move common code into shared_test.go

codec/codec_test.go

@@ -22,7 +22,6 @@ package codec
 import (
 	"bytes"
 	"encoding/gob"
-	"flag"
 	"fmt"
 	"io/ioutil"
 	"math"
@@ -42,7 +41,6 @@ import (
 )
 
 func init() {
-	testInitFlags()
 	testPreInitFns = append(testPreInitFns, testInit)
 }
 
@@ -92,24 +90,6 @@ var (
 	testRpcInt = new(TestRpcInt)
 )
 
-func testInitFlags() {
-	// delete(testDecOpts.ExtFuncs, timeTyp)
-	flag.BoolVar(&testVerbose, "tv", false, "Test Verbose")
-	flag.BoolVar(&testInitDebug, "tg", false, "Test Init Debug")
-	flag.BoolVar(&testUseIoEncDec, "ti", false, "Use IO Reader/Writer for Marshal/Unmarshal")
-	flag.BoolVar(&testStructToArray, "ts", false, "Set StructToArray option")
-	flag.BoolVar(&testWriteNoSymbols, "tn", false, "Set NoSymbols option")
-	flag.BoolVar(&testCanonical, "tc", false, "Set Canonical option")
-	flag.BoolVar(&testInternStr, "te", false, "Set InternStr option")
-	flag.BoolVar(&testSkipIntf, "tf", false, "Skip Interfaces")
-	flag.BoolVar(&testUseReset, "tr", false, "Use Reset")
-	flag.IntVar(&testJsonIndent, "td", 0, "Use JSON Indent")
-	flag.IntVar(&testMaxInitLen, "tx", 0, "Max Init Len")
-	flag.BoolVar(&testUseMust, "tm", true, "Use Must(En|De)code")
-	flag.BoolVar(&testCheckCircRef, "tl", false, "Use Check Circular Ref")
-	flag.BoolVar(&testJsonHTMLCharsAsIs, "tas", false, "Set JSON HTMLCharsAsIs")
-}
-
 func testByteBuf(in []byte) *bytes.Buffer {
 	return bytes.NewBuffer(in)
 }

codec/helper_test.go

@@ -5,174 +5,14 @@ package codec
 
 // All non-std package dependencies related to testing live in this file,
 // so porting to different environment is easy (just update functions).
-//
-// This file sets up the variables used, including testInitFns.
-// Each file should add initialization that should be performed
-// after flags are parsed.
-//
-// init is a multi-step process:
-//   - setup vars (handled by init functions in each file)
-//   - parse flags
-//   - setup derived vars (handled by pre-init registered functions - registered in init function)
-//   - post init (handled by post-init registered functions - registered in init function)
-// This way, no one has to manage carefully control the initialization
-// using file names, etc.
-//
-// Tests which require external dependencies need the -tag=x parameter.
-// They should be run as:
-//    go test -tags=x -run=. <other parameters ...>
-// Benchmarks should also take this parameter, to include the sereal, xdr, etc.
-// To run against codecgen, etc, make sure you pass extra parameters.
-// Example usage:
-//    go test "-tags=x codecgen unsafe" -bench=. <other parameters ...>
-//
-// To fully test everything:
-//    go test -tags=x -benchtime=100ms -tv -bg -bi  -brw -bu -v -run=. -bench=.
-
-// Handling flags
-// codec_test.go will define a set of global flags for testing, including:
-//   - Use Reset
-//   - Use IO reader/writer (vs direct bytes)
-//   - Set Canonical
-//   - Set InternStrings
-//   - Use Symbols
-//
-// This way, we can test them all by running same set of tests with a different
-// set of flags.
-//
-// Following this, all the benchmarks will utilize flags set by codec_test.go
-// and will not redefine these "global" flags.
 
 import (
-	"bytes"
 	"errors"
-	"flag"
 	"fmt"
 	"reflect"
-	"sync"
 	"testing"
 )
 
-type testHED struct {
-	H Handle
-	E *Encoder
-	D *Decoder
-}
-
-var (
-	testNoopH    = NoopHandle(8)
-	testMsgpackH = &MsgpackHandle{}
-	testBincH    = &BincHandle{}
-	testSimpleH  = &SimpleHandle{}
-	testCborH    = &CborHandle{}
-	testJsonH    = &JsonHandle{}
-
-	testHandles     []Handle
-	testPreInitFns  []func()
-	testPostInitFns []func()
-
-	testOnce sync.Once
-
-	testHEDs []testHED
-)
-
-// variables used by tests
-var (
-	testVerbose        bool
-	testInitDebug      bool
-	testUseIoEncDec    bool
-	testStructToArray  bool
-	testCanonical      bool
-	testUseReset       bool
-	testWriteNoSymbols bool
-	testSkipIntf       bool
-	testInternStr      bool
-	testUseMust        bool
-	testCheckCircRef   bool
-	testJsonIndent     int
-	testMaxInitLen     int
-
-	testJsonHTMLCharsAsIs bool
-)
-
-func init() {
-	testHEDs = make([]testHED, 0, 32)
-	testHandles = append(testHandles,
-		testNoopH, testMsgpackH, testBincH, testSimpleH,
-		testCborH, testJsonH)
-}
-
-func testHEDGet(h Handle) *testHED {
-	for i := range testHEDs {
-		v := &testHEDs[i]
-		if v.H == h {
-			return v
-		}
-	}
-	testHEDs = append(testHEDs, testHED{h, NewEncoder(nil, h), NewDecoder(nil, h)})
-	return &testHEDs[len(testHEDs)-1]
-}
-
-func testInitAll() {
-	flag.Parse()
-	for _, f := range testPreInitFns {
-		f()
-	}
-	for _, f := range testPostInitFns {
-		f()
-	}
-}
-
-func testCodecEncode(ts interface{}, bsIn []byte,
-	fn func([]byte) *bytes.Buffer, h Handle) (bs []byte, err error) {
-	// bs = make([]byte, 0, approxSize)
-	var e *Encoder
-	var buf *bytes.Buffer
-	if testUseReset {
-		e = testHEDGet(h).E
-	} else {
-		e = NewEncoder(nil, h)
-	}
-	if testUseIoEncDec {
-		buf = fn(bsIn)
-		e.Reset(buf)
-	} else {
-		bs = bsIn
-		e.ResetBytes(&bs)
-	}
-	if testUseMust {
-		e.MustEncode(ts)
-	} else {
-		err = e.Encode(ts)
-	}
-	if testUseIoEncDec {
-		bs = buf.Bytes()
-	}
-	return
-}
-
-func testCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
-	var d *Decoder
-	var buf *bytes.Reader
-	if testUseReset {
-		d = testHEDGet(h).D
-	} else {
-		d = NewDecoder(nil, h)
-	}
-	if testUseIoEncDec {
-		buf = bytes.NewReader(bs)
-		d.Reset(buf)
-	} else {
-		d.ResetBytes(bs)
-	}
-	if testUseMust {
-		d.MustDecode(ts)
-	} else {
-		err = d.Decode(ts)
-	}
-	return
-}
-
 // ----- functions below are used only by tests (not benchmarks)
 
 const (

codec/shared_test.go

@@ -0,0 +1,228 @@
+// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+package codec
+
+// This file sets up the variables used, including testInitFns.
+// Each file should add initialization that should be performed
+// after flags are parsed.
+//
+// init is a multi-step process:
+//   - setup vars (handled by init functions in each file)
+//   - parse flags
+//   - setup derived vars (handled by pre-init registered functions - registered in init function)
+//   - post init (handled by post-init registered functions - registered in init function)
+// This way, no one has to manage carefully control the initialization
+// using file names, etc.
+//
+// Tests which require external dependencies need the -tag=x parameter.
+// They should be run as:
+//    go test -tags=x -run=. <other parameters ...>
+// Benchmarks should also take this parameter, to include the sereal, xdr, etc.
+// To run against codecgen, etc, make sure you pass extra parameters.
+// Example usage:
+//    go test "-tags=x codecgen unsafe" -bench=. <other parameters ...>
+//
+// To fully test everything:
+//    go test -tags=x -benchtime=100ms -tv -bg -bi  -brw -bu -v -run=. -bench=.
+
+// Handling flags
+// codec_test.go will define a set of global flags for testing, including:
+//   - Use Reset
+//   - Use IO reader/writer (vs direct bytes)
+//   - Set Canonical
+//   - Set InternStrings
+//   - Use Symbols
+//
+// This way, we can test them all by running same set of tests with a different
+// set of flags.
+//
+// Following this, all the benchmarks will utilize flags set by codec_test.go
+// and will not redefine these "global" flags.
+
+import (
+	"bytes"
+	"flag"
+	"sync"
+)
+
+// DO NOT REMOVE - replacement line for go-codec-bench import declaration tag //
+
+type testHED struct {
+	H Handle
+	E *Encoder
+	D *Decoder
+}
+
+var (
+	testNoopH    = NoopHandle(8)
+	testMsgpackH = &MsgpackHandle{}
+	testBincH    = &BincHandle{}
+	testSimpleH  = &SimpleHandle{}
+	testCborH    = &CborHandle{}
+	testJsonH    = &JsonHandle{}
+
+	testHandles     []Handle
+	testPreInitFns  []func()
+	testPostInitFns []func()
+
+	testOnce sync.Once
+
+	testHEDs []testHED
+)
+
+// flag variables used by tests (and bench)
+var (
+	testVerbose        bool
+	testInitDebug      bool
+	testUseIoEncDec    bool
+	testStructToArray  bool
+	testCanonical      bool
+	testUseReset       bool
+	testWriteNoSymbols bool
+	testSkipIntf       bool
+	testInternStr      bool
+	testUseMust        bool
+	testCheckCircRef   bool
+	testJsonIndent     int
+	testMaxInitLen     int
+
+	testJsonHTMLCharsAsIs bool
+)
+
+// flag variables used by bench
+var (
+	benchDoInitBench      bool
+	benchVerify           bool
+	benchUnscientificRes  bool = false
+	benchMapStringKeyOnly bool
+	//depth of 0 maps to ~400bytes json-encoded string, 1 maps to ~1400 bytes, etc
+	//For depth>1, we likely trigger stack growth for encoders, making benchmarking unreliable.
+	benchDepth     int
+	benchInitDebug bool
+)
+
+func init() {
+	testHEDs = make([]testHED, 0, 32)
+	testHandles = append(testHandles,
+		testNoopH, testMsgpackH, testBincH, testSimpleH,
+		testCborH, testJsonH)
+	testInitFlags()
+	benchInitFlags()
+}
+
+func testInitFlags() {
+	// delete(testDecOpts.ExtFuncs, timeTyp)
+	flag.BoolVar(&testVerbose, "tv", false, "Test Verbose")
+	flag.BoolVar(&testInitDebug, "tg", false, "Test Init Debug")
+	flag.BoolVar(&testUseIoEncDec, "ti", false, "Use IO Reader/Writer for Marshal/Unmarshal")
+	flag.BoolVar(&testStructToArray, "ts", false, "Set StructToArray option")
+	flag.BoolVar(&testWriteNoSymbols, "tn", false, "Set NoSymbols option")
+	flag.BoolVar(&testCanonical, "tc", false, "Set Canonical option")
+	flag.BoolVar(&testInternStr, "te", false, "Set InternStr option")
+	flag.BoolVar(&testSkipIntf, "tf", false, "Skip Interfaces")
+	flag.BoolVar(&testUseReset, "tr", false, "Use Reset")
+	flag.IntVar(&testJsonIndent, "td", 0, "Use JSON Indent")
+	flag.IntVar(&testMaxInitLen, "tx", 0, "Max Init Len")
+	flag.BoolVar(&testUseMust, "tm", true, "Use Must(En|De)code")
+	flag.BoolVar(&testCheckCircRef, "tl", false, "Use Check Circular Ref")
+	flag.BoolVar(&testJsonHTMLCharsAsIs, "tas", false, "Set JSON HTMLCharsAsIs")
+}
+
+func benchInitFlags() {
+	flag.BoolVar(&benchMapStringKeyOnly, "bs", false, "Bench use maps with string keys only")
+	flag.BoolVar(&benchInitDebug, "bg", false, "Bench Debug")
+	flag.IntVar(&benchDepth, "bd", 1, "Bench Depth")
+	flag.BoolVar(&benchDoInitBench, "bi", false, "Run Bench Init")
+	flag.BoolVar(&benchVerify, "bv", false, "Verify Decoded Value during Benchmark")
+	flag.BoolVar(&benchUnscientificRes, "bu", false, "Show Unscientific Results during Benchmark")
+}
+
+func testHEDGet(h Handle) *testHED {
+	for i := range testHEDs {
+		v := &testHEDs[i]
+		if v.H == h {
+			return v
+		}
+	}
+	testHEDs = append(testHEDs, testHED{h, NewEncoder(nil, h), NewDecoder(nil, h)})
+	return &testHEDs[len(testHEDs)-1]
+}
+
+func testInitAll() {
+	flag.Parse()
+	for _, f := range testPreInitFns {
+		f()
+	}
+	for _, f := range testPostInitFns {
+		f()
+	}
+}
+
+func testCodecEncode(ts interface{}, bsIn []byte,
+	fn func([]byte) *bytes.Buffer, h Handle) (bs []byte, err error) {
+	// bs = make([]byte, 0, approxSize)
+	var e *Encoder
+	var buf *bytes.Buffer
+	if testUseReset {
+		e = testHEDGet(h).E
+	} else {
+		e = NewEncoder(nil, h)
+	}
+	if testUseIoEncDec {
+		buf = fn(bsIn)
+		e.Reset(buf)
+	} else {
+		bs = bsIn
+		e.ResetBytes(&bs)
+	}
+	if testUseMust {
+		e.MustEncode(ts)
+	} else {
+		err = e.Encode(ts)
+	}
+	if testUseIoEncDec {
+		bs = buf.Bytes()
+	}
+	return
+}
+
+func testCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
+	var d *Decoder
+	var buf *bytes.Reader
+	if testUseReset {
+		d = testHEDGet(h).D
+	} else {
+		d = NewDecoder(nil, h)
+	}
+	if testUseIoEncDec {
+		buf = bytes.NewReader(bs)
+		d.Reset(buf)
+	} else {
+		d.ResetBytes(bs)
+	}
+	if testUseMust {
+		d.MustDecode(ts)
+	} else {
+		err = d.Decode(ts)
+	}
+	return
+}
+
+// ----- functions below are used only by benchmarks alone
+
+func fnBenchmarkByteBuf(bsIn []byte) (buf *bytes.Buffer) {
+	// var buf bytes.Buffer
+	// buf.Grow(approxSize)
+	buf = bytes.NewBuffer(bsIn)
+	buf.Truncate(0)
+	return
+}
+
+func benchFnCodecEncode(ts interface{}, bsIn []byte, h Handle) (bs []byte, err error) {
+	return testCodecEncode(ts, bsIn, fnBenchmarkByteBuf, h)
+}
+
+func benchFnCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
+	return testCodecDecode(bs, ts, h)
+}