@@ -2,7 +2,6 @@

 github.com/Azure/go-ansiterm d6e3b3328b783f23731bc4d058875b0371ff8109

 github.com/Microsoft/hcsshim v0.6.8

 github.com/Microsoft/go-winio v0.4.6

-github.com/davecgh/go-spew 346938d642f2ec3594ed81d874461961cd0faa76

 github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a

 github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git

 github.com/golang/gddo 9b12a26f3fbd7397dee4e20939ddca719d840d2a

@@ -19,10 +18,9 @@ golang.org/x/sys 37707fdb30a5b38865cfb95e5aab41707daec7fd

 github.com/docker/go-units 9e638d38cf6977a37a8ea0078f3ee75a7cdb2dd1

 github.com/docker/go-connections 7beb39f0b969b075d1325fecb092faf27fd357b6

 golang.org/x/text f72d8390a633d5dfb0cc84043294db9f6c935756

-github.com/stretchr/testify 4d4bfba8f1d1027c4fdbe371823030df51419987

 github.com/pmezard/go-difflib v1.0.0

-github.com/gotestyourself/gotestyourself 511344eed30e4384f010579a593dfb442033a692

-github.com/google/go-cmp v0.1.0

+github.com/gotestyourself/gotestyourself cf3a5ab914a2efa8bc838d09f5918c1d44d029

+github.com/google/go-cmp v0.2.0

 github.com/RackSec/srslog 456df3a81436d29ba874f3590eeeee25d666f8a5

 github.com/imdario/mergo 0.2.1

deleted file mode 100644

@@ -1,15 +0,0 @@

-ISC License

-

-Copyright (c) 2012-2016 Dave Collins <dave@davec.name>

-

-Permission to use, copy, modify, and distribute this software for any

-purpose with or without fee is hereby granted, provided that the above

-copyright notice and this permission notice appear in all copies.

-

-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

deleted file mode 100644

@@ -1,205 +0,0 @@

-go-spew

-=======

-

-[![Build Status](https://img.shields.io/travis/davecgh/go-spew.svg)]

-(https://travis-ci.org/davecgh/go-spew) [![ISC License]

-(http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org) [![Coverage Status]

-(https://img.shields.io/coveralls/davecgh/go-spew.svg)]

-(https://coveralls.io/r/davecgh/go-spew?branch=master)

-

-

-Go-spew implements a deep pretty printer for Go data structures to aid in

-debugging.  A comprehensive suite of tests with 100% test coverage is provided

-to ensure proper functionality.  See `test_coverage.txt` for the gocov coverage

-report.  Go-spew is licensed under the liberal ISC license, so it may be used in

-open source or commercial projects.

-

-If you're interested in reading about how this package came to life and some

-of the challenges involved in providing a deep pretty printer, there is a blog

-post about it

-[here](https://web.archive.org/web/20160304013555/https://blog.cyphertite.com/go-spew-a-journey-into-dumping-go-data-structures/).

-

-## Documentation

-

-[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)]

-(http://godoc.org/github.com/davecgh/go-spew/spew)

-

-Full `go doc` style documentation for the project can be viewed online without

-installing this package by using the excellent GoDoc site here:

-http://godoc.org/github.com/davecgh/go-spew/spew

-

-You can also view the documentation locally once the package is installed with

-the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to

-http://localhost:6060/pkg/github.com/davecgh/go-spew/spew

-

-## Installation

-

-```bash

-$ go get -u github.com/davecgh/go-spew/spew

-```

-

-## Quick Start

-

-Add this import line to the file you're working in:

-

-```Go

-import "github.com/davecgh/go-spew/spew"

-```

-

-To dump a variable with full newlines, indentation, type, and pointer

-information use Dump, Fdump, or Sdump:

-

-```Go

-spew.Dump(myVar1, myVar2, ...)

-spew.Fdump(someWriter, myVar1, myVar2, ...)

-str := spew.Sdump(myVar1, myVar2, ...)

-```

-

-Alternatively, if you would prefer to use format strings with a compacted inline

-printing style, use the convenience wrappers Printf, Fprintf, etc with %v (most

-compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types

-and pointer addresses): 

-

-```Go

-spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)

-spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)

-spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)

-spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)

-```

-

-## Debugging a Web Application Example

-

-Here is an example of how you can use `spew.Sdump()` to help debug a web application. Please be sure to wrap your output using the `html.EscapeString()` function for safety reasons. You should also only use this debugging technique in a development environment, never in production.

-

-```Go

-package main

-

-import (

-    "fmt"

-    "html"

-    "net/http"

-

-    "github.com/davecgh/go-spew/spew"

-)

-

-func handler(w http.ResponseWriter, r *http.Request) {

-    w.Header().Set("Content-Type", "text/html")

-    fmt.Fprintf(w, "Hi there, %s!", r.URL.Path[1:])

-    fmt.Fprintf(w, "<!--\n" + html.EscapeString(spew.Sdump(w)) + "\n-->")

-}

-

-func main() {

-    http.HandleFunc("/", handler)

-    http.ListenAndServe(":8080", nil)

-}

-```

-

-## Sample Dump Output

-

-```

-(main.Foo) {

- unexportedField: (*main.Bar)(0xf84002e210)({

-  flag: (main.Flag) flagTwo,

-  data: (uintptr) <nil>

- }),

- ExportedField: (map[interface {}]interface {}) {

-  (string) "one": (bool) true

- }

-}

-([]uint8) {

- 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |

- 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|

- 00000020  31 32                                             |12|

-}

-```

-

-## Sample Formatter Output

-

-Double pointer to a uint8:

-```

-	  %v: <**>5

-	 %+v: <**>(0xf8400420d0->0xf8400420c8)5

-	 %#v: (**uint8)5

-	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5

-```

-

-Pointer to circular struct with a uint8 field and a pointer to itself:

-```

-	  %v: <*>{1 <*><shown>}

-	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}

-	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}

-	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}

-```

-

-## Configuration Options

-

-Configuration of spew is handled by fields in the ConfigState type. For

-convenience, all of the top-level functions use a global state available via the

-spew.Config global.

-

-It is also possible to create a ConfigState instance that provides methods

-equivalent to the top-level functions. This allows concurrent configuration

-options. See the ConfigState documentation for more details.

-

-```

-* Indent

-	String to use for each indentation level for Dump functions.

-	It is a single space by default.  A popular alternative is "\t".

-

-* MaxDepth

-	Maximum number of levels to descend into nested data structures.

-	There is no limit by default.

-

-* DisableMethods

-	Disables invocation of error and Stringer interface methods.

-	Method invocation is enabled by default.

-

-* DisablePointerMethods

-	Disables invocation of error and Stringer interface methods on types

-	which only accept pointer receivers from non-pointer variables.  This option

-	relies on access to the unsafe package, so it will not have any effect when

-	running in environments without access to the unsafe package such as Google

-	App Engine or with the "safe" build tag specified.

-	Pointer method invocation is enabled by default.

-

-* DisablePointerAddresses

-	DisablePointerAddresses specifies whether to disable the printing of

-	pointer addresses. This is useful when diffing data structures in tests.

-

-* DisableCapacities

-	DisableCapacities specifies whether to disable the printing of capacities

-	for arrays, slices, maps and channels. This is useful when diffing data

-	structures in tests.

-

-* ContinueOnMethod

-	Enables recursion into types after invoking error and Stringer interface

-	methods. Recursion after method invocation is disabled by default.

-

-* SortKeys

-	Specifies map keys should be sorted before being printed. Use

-	this to have a more deterministic, diffable output.  Note that

-	only native types (bool, int, uint, floats, uintptr and string)

-	and types which implement error or Stringer interfaces are supported,

-	with other types sorted according to the reflect.Value.String() output

-	which guarantees display stability.  Natural map order is used by

-	default.

-

-* SpewKeys

-	SpewKeys specifies that, as a last resort attempt, map keys should be

-	spewed to strings and sorted by those strings.  This is only considered

-	if SortKeys is true.

-

-```

-

-## Unsafe Package Dependency

-

-This package relies on the unsafe package to perform some of the more advanced

-features, however it also supports a "limited" mode which allows it to work in

-environments where the unsafe package is not available.  By default, it will

-operate in this mode on Google App Engine and when compiled with GopherJS.  The

-"safe" build tag may also be specified to force the package to build without

-using the unsafe package.

-

-## License

-

-Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.

deleted file mode 100644

@@ -1,152 +0,0 @@

-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>

-//

-// Permission to use, copy, modify, and distribute this software for any

-// purpose with or without fee is hereby granted, provided that the above

-// copyright notice and this permission notice appear in all copies.

-//

-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

-// NOTE: Due to the following build constraints, this file will only be compiled

-// when the code is not running on Google App Engine, compiled by GopherJS, and

-// "-tags safe" is not added to the go build command line.  The "disableunsafe"

-// tag is deprecated and thus should not be used.

-// +build !js,!appengine,!safe,!disableunsafe

-

-package spew

-

-import (

-	"reflect"

-	"unsafe"

-)

-

-const (

-	// UnsafeDisabled is a build-time constant which specifies whether or

-	// not access to the unsafe package is available.

-	UnsafeDisabled = false

-

-	// ptrSize is the size of a pointer on the current arch.

-	ptrSize = unsafe.Sizeof((*byte)(nil))

-)

-

-var (

-	// offsetPtr, offsetScalar, and offsetFlag are the offsets for the

-	// internal reflect.Value fields.  These values are valid before golang

-	// commit ecccf07e7f9d which changed the format.  The are also valid

-	// after commit 82f48826c6c7 which changed the format again to mirror

-	// the original format.  Code in the init function updates these offsets

-	// as necessary.

-	offsetPtr    = uintptr(ptrSize)

-	offsetScalar = uintptr(0)

-	offsetFlag   = uintptr(ptrSize * 2)

-

-	// flagKindWidth and flagKindShift indicate various bits that the

-	// reflect package uses internally to track kind information.

-	//

-	// flagRO indicates whether or not the value field of a reflect.Value is

-	// read-only.

-	//

-	// flagIndir indicates whether the value field of a reflect.Value is

-	// the actual data or a pointer to the data.

-	//

-	// These values are valid before golang commit 90a7c3c86944 which

-	// changed their positions.  Code in the init function updates these

-	// flags as necessary.

-	flagKindWidth = uintptr(5)

-	flagKindShift = uintptr(flagKindWidth - 1)

-	flagRO        = uintptr(1 << 0)

-	flagIndir     = uintptr(1 << 1)

-)

-

-func init() {

-	// Older versions of reflect.Value stored small integers directly in the

-	// ptr field (which is named val in the older versions).  Versions

-	// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named

-	// scalar for this purpose which unfortunately came before the flag

-	// field, so the offset of the flag field is different for those

-	// versions.

-	//

-	// This code constructs a new reflect.Value from a known small integer

-	// and checks if the size of the reflect.Value struct indicates it has

-	// the scalar field. When it does, the offsets are updated accordingly.

-	vv := reflect.ValueOf(0xf00)

-	if unsafe.Sizeof(vv) == (ptrSize * 4) {

-		offsetScalar = ptrSize * 2

-		offsetFlag = ptrSize * 3

-	}

-

-	// Commit 90a7c3c86944 changed the flag positions such that the low

-	// order bits are the kind.  This code extracts the kind from the flags

-	// field and ensures it's the correct type.  When it's not, the flag

-	// order has been changed to the newer format, so the flags are updated

-	// accordingly.

-	upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)

-	upfv := *(*uintptr)(upf)

-	flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)

-	if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {

-		flagKindShift = 0

-		flagRO = 1 << 5

-		flagIndir = 1 << 6

-

-		// Commit adf9b30e5594 modified the flags to separate the

-		// flagRO flag into two bits which specifies whether or not the

-		// field is embedded.  This causes flagIndir to move over a bit

-		// and means that flagRO is the combination of either of the

-		// original flagRO bit and the new bit.

-		//

-		// This code detects the change by extracting what used to be

-		// the indirect bit to ensure it's set.  When it's not, the flag

-		// order has been changed to the newer format, so the flags are

-		// updated accordingly.

-		if upfv&flagIndir == 0 {

-			flagRO = 3 << 5

-			flagIndir = 1 << 7

-		}

-	}

-}

-

-// unsafeReflectValue converts the passed reflect.Value into a one that bypasses

-// the typical safety restrictions preventing access to unaddressable and

-// unexported data.  It works by digging the raw pointer to the underlying

-// value out of the protected value and generating a new unprotected (unsafe)

-// reflect.Value to it.

-//

-// This allows us to check for implementations of the Stringer and error

-// interfaces to be used for pretty printing ordinarily unaddressable and

-// inaccessible values such as unexported struct fields.

-func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {

-	indirects := 1

-	vt := v.Type()

-	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)

-	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))

-	if rvf&flagIndir != 0 {

-		vt = reflect.PtrTo(v.Type())

-		indirects++

-	} else if offsetScalar != 0 {

-		// The value is in the scalar field when it's not one of the

-		// reference types.

-		switch vt.Kind() {

-		case reflect.Uintptr:

-		case reflect.Chan:

-		case reflect.Func:

-		case reflect.Map:

-		case reflect.Ptr:

-		case reflect.UnsafePointer:

-		default:

-			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +

-				offsetScalar)

-		}

-	}

-

-	pv := reflect.NewAt(vt, upv)

-	rv = pv

-	for i := 0; i < indirects; i++ {

-		rv = rv.Elem()

-	}

-	return rv

-}

deleted file mode 100644

@@ -1,38 +0,0 @@

-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>

-//

-// Permission to use, copy, modify, and distribute this software for any

-// purpose with or without fee is hereby granted, provided that the above

-// copyright notice and this permission notice appear in all copies.

-//

-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

-// NOTE: Due to the following build constraints, this file will only be compiled

-// when the code is running on Google App Engine, compiled by GopherJS, or

-// "-tags safe" is added to the go build command line.  The "disableunsafe"

-// tag is deprecated and thus should not be used.

-// +build js appengine safe disableunsafe

-

-package spew

-

-import "reflect"

-

-const (

-	// UnsafeDisabled is a build-time constant which specifies whether or

-	// not access to the unsafe package is available.

-	UnsafeDisabled = true

-)

-

-// unsafeReflectValue typically converts the passed reflect.Value into a one

-// that bypasses the typical safety restrictions preventing access to

-// unaddressable and unexported data.  However, doing this relies on access to

-// the unsafe package.  This is a stub version which simply returns the passed

-// reflect.Value when the unsafe package is not available.

-func unsafeReflectValue(v reflect.Value) reflect.Value {

-	return v

-}

deleted file mode 100644

@@ -1,341 +0,0 @@

-/*

- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>

- *

- * Permission to use, copy, modify, and distribute this software for any

- * purpose with or without fee is hereby granted, provided that the above

- * copyright notice and this permission notice appear in all copies.

- *

- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- */

-

-package spew

-

-import (

-	"bytes"

-	"fmt"

-	"io"

-	"reflect"

-	"sort"

-	"strconv"

-)

-

-// Some constants in the form of bytes to avoid string overhead.  This mirrors

-// the technique used in the fmt package.

-var (

-	panicBytes            = []byte("(PANIC=")

-	plusBytes             = []byte("+")

-	iBytes                = []byte("i")

-	trueBytes             = []byte("true")

-	falseBytes            = []byte("false")

-	interfaceBytes        = []byte("(interface {})")

-	commaNewlineBytes     = []byte(",\n")

-	newlineBytes          = []byte("\n")

-	openBraceBytes        = []byte("{")

-	openBraceNewlineBytes = []byte("{\n")

-	closeBraceBytes       = []byte("}")

-	asteriskBytes         = []byte("*")

-	colonBytes            = []byte(":")

-	colonSpaceBytes       = []byte(": ")

-	openParenBytes        = []byte("(")

-	closeParenBytes       = []byte(")")

-	spaceBytes            = []byte(" ")

-	pointerChainBytes     = []byte("->")

-	nilAngleBytes         = []byte("<nil>")

-	maxNewlineBytes       = []byte("<max depth reached>\n")

-	maxShortBytes         = []byte("<max>")

-	circularBytes         = []byte("<already shown>")

-	circularShortBytes    = []byte("<shown>")

-	invalidAngleBytes     = []byte("<invalid>")

-	openBracketBytes      = []byte("[")

-	closeBracketBytes     = []byte("]")

-	percentBytes          = []byte("%")

-	precisionBytes        = []byte(".")

-	openAngleBytes        = []byte("<")

-	closeAngleBytes       = []byte(">")

-	openMapBytes          = []byte("map[")

-	closeMapBytes         = []byte("]")

-	lenEqualsBytes        = []byte("len=")

-	capEqualsBytes        = []byte("cap=")

-)

-

-// hexDigits is used to map a decimal value to a hex digit.

-var hexDigits = "0123456789abcdef"

-

-// catchPanic handles any panics that might occur during the handleMethods

-// calls.

-func catchPanic(w io.Writer, v reflect.Value) {

-	if err := recover(); err != nil {

-		w.Write(panicBytes)

-		fmt.Fprintf(w, "%v", err)

-		w.Write(closeParenBytes)

-	}

-}

-

-// handleMethods attempts to call the Error and String methods on the underlying

-// type the passed reflect.Value represents and outputes the result to Writer w.

-//

-// It handles panics in any called methods by catching and displaying the error

-// as the formatted value.

-func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {

-	// We need an interface to check if the type implements the error or

-	// Stringer interface.  However, the reflect package won't give us an

-	// interface on certain things like unexported struct fields in order

-	// to enforce visibility rules.  We use unsafe, when it's available,

-	// to bypass these restrictions since this package does not mutate the

-	// values.

-	if !v.CanInterface() {

-		if UnsafeDisabled {

-			return false

-		}

-

-		v = unsafeReflectValue(v)

-	}

-

-	// Choose whether or not to do error and Stringer interface lookups against

-	// the base type or a pointer to the base type depending on settings.

-	// Technically calling one of these methods with a pointer receiver can

-	// mutate the value, however, types which choose to satisify an error or

-	// Stringer interface with a pointer receiver should not be mutating their

-	// state inside these interface methods.

-	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {

-		v = unsafeReflectValue(v)

-	}

-	if v.CanAddr() {

-		v = v.Addr()

-	}

-

-	// Is it an error or Stringer?

-	switch iface := v.Interface().(type) {

-	case error:

-		defer catchPanic(w, v)

-		if cs.ContinueOnMethod {

-			w.Write(openParenBytes)

-			w.Write([]byte(iface.Error()))

-			w.Write(closeParenBytes)

-			w.Write(spaceBytes)

-			return false

-		}

-

-		w.Write([]byte(iface.Error()))

-		return true

-

-	case fmt.Stringer:

-		defer catchPanic(w, v)

-		if cs.ContinueOnMethod {

-			w.Write(openParenBytes)

-			w.Write([]byte(iface.String()))

-			w.Write(closeParenBytes)

-			w.Write(spaceBytes)

-			return false

-		}

-		w.Write([]byte(iface.String()))

-		return true

-	}

-	return false

-}

-

-// printBool outputs a boolean value as true or false to Writer w.

-func printBool(w io.Writer, val bool) {

-	if val {

-		w.Write(trueBytes)

-	} else {

-		w.Write(falseBytes)

-	}

-}

-

-// printInt outputs a signed integer value to Writer w.

-func printInt(w io.Writer, val int64, base int) {

-	w.Write([]byte(strconv.FormatInt(val, base)))

-}

-

-// printUint outputs an unsigned integer value to Writer w.

-func printUint(w io.Writer, val uint64, base int) {

-	w.Write([]byte(strconv.FormatUint(val, base)))

-}

-

-// printFloat outputs a floating point value using the specified precision,

-// which is expected to be 32 or 64bit, to Writer w.

-func printFloat(w io.Writer, val float64, precision int) {

-	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))

-}

-

-// printComplex outputs a complex value using the specified float precision

-// for the real and imaginary parts to Writer w.

-func printComplex(w io.Writer, c complex128, floatPrecision int) {

-	r := real(c)

-	w.Write(openParenBytes)

-	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))

-	i := imag(c)

-	if i >= 0 {

-		w.Write(plusBytes)

-	}

-	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))

-	w.Write(iBytes)

-	w.Write(closeParenBytes)

-}

-

-// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'

-// prefix to Writer w.

-func printHexPtr(w io.Writer, p uintptr) {

-	// Null pointer.

-	num := uint64(p)

-	if num == 0 {

-		w.Write(nilAngleBytes)

-		return

-	}

-

-	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix

-	buf := make([]byte, 18)

-

-	// It's simpler to construct the hex string right to left.

-	base := uint64(16)

-	i := len(buf) - 1

-	for num >= base {

-		buf[i] = hexDigits[num%base]

-		num /= base

-		i--

-	}

-	buf[i] = hexDigits[num]

-

-	// Add '0x' prefix.

-	i--

-	buf[i] = 'x'

-	i--

-	buf[i] = '0'

-

-	// Strip unused leading bytes.

-	buf = buf[i:]

-	w.Write(buf)

-}

-

-// valuesSorter implements sort.Interface to allow a slice of reflect.Value

-// elements to be sorted.

-type valuesSorter struct {

-	values  []reflect.Value

-	strings []string // either nil or same len and values

-	cs      *ConfigState

-}

-

-// newValuesSorter initializes a valuesSorter instance, which holds a set of

-// surrogate keys on which the data should be sorted.  It uses flags in

-// ConfigState to decide if and how to populate those surrogate keys.

-func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {

-	vs := &valuesSorter{values: values, cs: cs}

-	if canSortSimply(vs.values[0].Kind()) {

-		return vs

-	}

-	if !cs.DisableMethods {

-		vs.strings = make([]string, len(values))

-		for i := range vs.values {

-			b := bytes.Buffer{}

-			if !handleMethods(cs, &b, vs.values[i]) {

-				vs.strings = nil

-				break

-			}

-			vs.strings[i] = b.String()

-		}

-	}

-	if vs.strings == nil && cs.SpewKeys {

-		vs.strings = make([]string, len(values))

-		for i := range vs.values {

-			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())

-		}

-	}

-	return vs

-}

-

-// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted

-// directly, or whether it should be considered for sorting by surrogate keys

-// (if the ConfigState allows it).

-func canSortSimply(kind reflect.Kind) bool {

-	// This switch parallels valueSortLess, except for the default case.

-	switch kind {

-	case reflect.Bool:

-		return true

-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:

-		return true

-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:

-		return true

-	case reflect.Float32, reflect.Float64:

-		return true

-	case reflect.String:

-		return true

-	case reflect.Uintptr:

-		return true

-	case reflect.Array:

-		return true

-	}

-	return false

-}

-

-// Len returns the number of values in the slice.  It is part of the

-// sort.Interface implementation.

-func (s *valuesSorter) Len() int {

-	return len(s.values)

-}

-

-// Swap swaps the values at the passed indices.  It is part of the

-// sort.Interface implementation.

-func (s *valuesSorter) Swap(i, j int) {

-	s.values[i], s.values[j] = s.values[j], s.values[i]

-	if s.strings != nil {

-		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]

-	}

-}

-

-// valueSortLess returns whether the first value should sort before the second

-// value.  It is used by valueSorter.Less as part of the sort.Interface

-// implementation.

-func valueSortLess(a, b reflect.Value) bool {

-	switch a.Kind() {

-	case reflect.Bool:

-		return !a.Bool() && b.Bool()

-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:

-		return a.Int() < b.Int()

-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:

-		return a.Uint() < b.Uint()

-	case reflect.Float32, reflect.Float64:

-		return a.Float() < b.Float()

-	case reflect.String:

-		return a.String() < b.String()

-	case reflect.Uintptr:

-		return a.Uint() < b.Uint()

-	case reflect.Array:

-		// Compare the contents of both arrays.

-		l := a.Len()

-		for i := 0; i < l; i++ {

-			av := a.Index(i)

-			bv := b.Index(i)

-			if av.Interface() == bv.Interface() {

-				continue

-			}

-			return valueSortLess(av, bv)

-		}

-	}

-	return a.String() < b.String()

-}

-

-// Less returns whether the value at index i should sort before the

-// value at index j.  It is part of the sort.Interface implementation.

-func (s *valuesSorter) Less(i, j int) bool {

-	if s.strings == nil {

-		return valueSortLess(s.values[i], s.values[j])

-	}

-	return s.strings[i] < s.strings[j]

-}

-

-// sortValues is a sort function that handles both native types and any type that

-// can be converted to error or Stringer.  Other inputs are sorted according to

-// their Value.String() value to ensure display stability.

-func sortValues(values []reflect.Value, cs *ConfigState) {

-	if len(values) == 0 {

-		return

-	}

-	sort.Sort(newValuesSorter(values, cs))

-}

deleted file mode 100644

@@ -1,306 +0,0 @@

-/*

- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>

- *

- * Permission to use, copy, modify, and distribute this software for any

- * purpose with or without fee is hereby granted, provided that the above

- * copyright notice and this permission notice appear in all copies.

- *

- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

- */

-

-package spew

-

-import (

-	"bytes"

-	"fmt"

-	"io"

-	"os"

-)

-

-// ConfigState houses the configuration options used by spew to format and

-// display values.  There is a global instance, Config, that is used to control

-// all top-level Formatter and Dump functionality.  Each ConfigState instance

-// provides methods equivalent to the top-level functions.

-//

-// The zero value for ConfigState provides no indentation.  You would typically

-// want to set it to a space or a tab.

-//

-// Alternatively, you can use NewDefaultConfig to get a ConfigState instance

-// with default settings.  See the documentation of NewDefaultConfig for default

-// values.

-type ConfigState struct {

-	// Indent specifies the string to use for each indentation level.  The

-	// global config instance that all top-level functions use set this to a

-	// single space by default.  If you would like more indentation, you might

-	// set this to a tab with "\t" or perhaps two spaces with "  ".

-	Indent string

-

-	// MaxDepth controls the maximum number of levels to descend into nested

-	// data structures.  The default, 0, means there is no limit.

-	//

-	// NOTE: Circular data structures are properly detected, so it is not

-	// necessary to set this value unless you specifically want to limit deeply

-	// nested data structures.

-	MaxDepth int

-

-	// DisableMethods specifies whether or not error and Stringer interfaces are

-	// invoked for types that implement them.

-	DisableMethods bool

-

-	// DisablePointerMethods specifies whether or not to check for and invoke

-	// error and Stringer interfaces on types which only accept a pointer

-	// receiver when the current type is not a pointer.

-	//

-	// NOTE: This might be an unsafe action since calling one of these methods

-	// with a pointer receiver could technically mutate the value, however,

-	// in practice, types which choose to satisify an error or Stringer

-	// interface with a pointer receiver should not be mutating their state

-	// inside these interface methods.  As a result, this option relies on

-	// access to the unsafe package, so it will not have any effect when

-	// running in environments without access to the unsafe package such as

-	// Google App Engine or with the "safe" build tag specified.

-	DisablePointerMethods bool

-

-	// DisablePointerAddresses specifies whether to disable the printing of

-	// pointer addresses. This is useful when diffing data structures in tests.