Upgrade to 0.12

13 files changed, 2372 insertions, 0 deletions

diff --git a/vendor/github.com/google/go-cmp/LICENSE b/vendor/github.com/google/go-cmp/LICENSE
new file mode 100644
index 0000000..32017f8
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2017 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/google/go-cmp/cmp/compare.go b/vendor/github.com/google/go-cmp/cmp/compare.go
new file mode 100644
index 0000000..7e215f2
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/compare.go
@@ -0,0 +1,553 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// Package cmp determines equality of values.
+//
+// This package is intended to be a more powerful and safer alternative to
+// reflect.DeepEqual for comparing whether two values are semantically equal.
+//
+// The primary features of cmp are:
+//
+// • When the default behavior of equality does not suit the needs of the test,
+// custom equality functions can override the equality operation.
+// For example, an equality function may report floats as equal so long as they
+// are within some tolerance of each other.
+//
+// • Types that have an Equal method may use that method to determine equality.
+// This allows package authors to determine the equality operation for the types
+// that they define.
+//
+// • If no custom equality functions are used and no Equal method is defined,
+// equality is determined by recursively comparing the primitive kinds on both
+// values, much like reflect.DeepEqual. Unlike reflect.DeepEqual, unexported
+// fields are not compared by default; they result in panics unless suppressed
+// by using an Ignore option (see cmpopts.IgnoreUnexported) or explicitly compared
+// using the AllowUnexported option.
+package cmp
+
+import (
+        "fmt"
+        "reflect"
+
+        "github.com/google/go-cmp/cmp/internal/diff"
+        "github.com/google/go-cmp/cmp/internal/function"
+        "github.com/google/go-cmp/cmp/internal/value"
+)
+
+// BUG(dsnet): Maps with keys containing NaN values cannot be properly compared due to
+// the reflection package's inability to retrieve such entries. Equal will panic
+// anytime it comes across a NaN key, but this behavior may change.
+//
+// See https://golang.org/issue/11104 for more details.
+
+var nothing = reflect.Value{}
+
+// Equal reports whether x and y are equal by recursively applying the
+// following rules in the given order to x and y and all of their sub-values:
+//
+// • If two values are not of the same type, then they are never equal
+// and the overall result is false.
+//
+// • Let S be the set of all Ignore, Transformer, and Comparer options that
+// remain after applying all path filters, value filters, and type filters.
+// If at least one Ignore exists in S, then the comparison is ignored.
+// If the number of Transformer and Comparer options in S is greater than one,
+// then Equal panics because it is ambiguous which option to use.
+// If S contains a single Transformer, then use that to transform the current
+// values and recursively call Equal on the output values.
+// If S contains a single Comparer, then use that to compare the current values.
+// Otherwise, evaluation proceeds to the next rule.
+//
+// • If the values have an Equal method of the form "(T) Equal(T) bool" or
+// "(T) Equal(I) bool" where T is assignable to I, then use the result of
+// x.Equal(y) even if x or y is nil.
+// Otherwise, no such method exists and evaluation proceeds to the next rule.
+//
+// • Lastly, try to compare x and y based on their basic kinds.
+// Simple kinds like booleans, integers, floats, complex numbers, strings, and
+// channels are compared using the equivalent of the == operator in Go.
+// Functions are only equal if they are both nil, otherwise they are unequal.
+// Pointers are equal if the underlying values they point to are also equal.
+// Interfaces are equal if their underlying concrete values are also equal.
+//
+// Structs are equal if all of their fields are equal. If a struct contains
+// unexported fields, Equal panics unless the AllowUnexported option is used or
+// an Ignore option (e.g., cmpopts.IgnoreUnexported) ignores that field.
+//
+// Arrays, slices, and maps are equal if they are both nil or both non-nil
+// with the same length and the elements at each index or key are equal.
+// Note that a non-nil empty slice and a nil slice are not equal.
+// To equate empty slices and maps, consider using cmpopts.EquateEmpty.
+// Map keys are equal according to the == operator.
+// To use custom comparisons for map keys, consider using cmpopts.SortMaps.
+func Equal(x, y interface{}, opts ...Option) bool {
+        s := newState(opts)
+        s.compareAny(reflect.ValueOf(x), reflect.ValueOf(y))
+        return s.result.Equal()
+}
+
+// Diff returns a human-readable report of the differences between two values.
+// It returns an empty string if and only if Equal returns true for the same
+// input values and options. The output string will use the "-" symbol to
+// indicate elements removed from x, and the "+" symbol to indicate elements
+// added to y.
+//
+// Do not depend on this output being stable.
+func Diff(x, y interface{}, opts ...Option) string {
+        r := new(defaultReporter)
+        opts = Options{Options(opts), r}
+        eq := Equal(x, y, opts...)
+        d := r.String()
+        if (d == "") != eq {
+                panic("inconsistent difference and equality results")
+        }
+        return d
+}
+
+type state struct {
+        // These fields represent the "comparison state".
+        // Calling statelessCompare must not result in observable changes to these.
+        result   diff.Result // The current result of comparison
+        curPath  Path        // The current path in the value tree
+        reporter reporter    // Optional reporter used for difference formatting
+
+        // dynChecker triggers pseudo-random checks for option correctness.
+        // It is safe for statelessCompare to mutate this value.
+        dynChecker dynChecker
+
+        // These fields, once set by processOption, will not change.
+        exporters map[reflect.Type]bool // Set of structs with unexported field visibility
+        opts      Options               // List of all fundamental and filter options
+}
+
+func newState(opts []Option) *state {
+        s := new(state)
+        for _, opt := range opts {
+                s.processOption(opt)
+        }
+        return s
+}
+
+func (s *state) processOption(opt Option) {
+        switch opt := opt.(type) {
+        case nil:
+        case Options:
+                for _, o := range opt {
+                        s.processOption(o)
+                }
+        case coreOption:
+                type filtered interface {
+                        isFiltered() bool
+                }
+                if fopt, ok := opt.(filtered); ok && !fopt.isFiltered() {
+                        panic(fmt.Sprintf("cannot use an unfiltered option: %v", opt))
+                }
+                s.opts = append(s.opts, opt)
+        case visibleStructs:
+                if s.exporters == nil {
+                        s.exporters = make(map[reflect.Type]bool)
+                }
+                for t := range opt {
+                        s.exporters[t] = true
+                }
+        case reporter:
+                if s.reporter != nil {
+                        panic("difference reporter already registered")
+                }
+                s.reporter = opt
+        default:
+                panic(fmt.Sprintf("unknown option %T", opt))
+        }
+}
+
+// statelessCompare compares two values and returns the result.
+// This function is stateless in that it does not alter the current result,
+// or output to any registered reporters.
+func (s *state) statelessCompare(vx, vy reflect.Value) diff.Result {
+        // We do not save and restore the curPath because all of the compareX
+        // methods should properly push and pop from the path.
+        // It is an implementation bug if the contents of curPath differs from
+        // when calling this function to when returning from it.
+
+        oldResult, oldReporter := s.result, s.reporter
+        s.result = diff.Result{} // Reset result
+        s.reporter = nil         // Remove reporter to avoid spurious printouts
+        s.compareAny(vx, vy)
+        res := s.result
+        s.result, s.reporter = oldResult, oldReporter
+        return res
+}
+
+func (s *state) compareAny(vx, vy reflect.Value) {
+        // TODO: Support cyclic data structures.
+
+        // Rule 0: Differing types are never equal.
+        if !vx.IsValid() || !vy.IsValid() {
+                s.report(vx.IsValid() == vy.IsValid(), vx, vy)
+                return
+        }
+        if vx.Type() != vy.Type() {
+                s.report(false, vx, vy) // Possible for path to be empty
+                return
+        }
+        t := vx.Type()
+        if len(s.curPath) == 0 {
+                s.curPath.push(&pathStep{typ: t})
+                defer s.curPath.pop()
+        }
+        vx, vy = s.tryExporting(vx, vy)
+
+        // Rule 1: Check whether an option applies on this node in the value tree.
+        if s.tryOptions(vx, vy, t) {
+                return
+        }
+
+        // Rule 2: Check whether the type has a valid Equal method.
+        if s.tryMethod(vx, vy, t) {
+                return
+        }
+
+        // Rule 3: Recursively descend into each value's underlying kind.
+        switch t.Kind() {
+        case reflect.Bool:
+                s.report(vx.Bool() == vy.Bool(), vx, vy)
+                return
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                s.report(vx.Int() == vy.Int(), vx, vy)
+                return
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                s.report(vx.Uint() == vy.Uint(), vx, vy)
+                return
+        case reflect.Float32, reflect.Float64:
+                s.report(vx.Float() == vy.Float(), vx, vy)
+                return
+        case reflect.Complex64, reflect.Complex128:
+                s.report(vx.Complex() == vy.Complex(), vx, vy)
+                return
+        case reflect.String:
+                s.report(vx.String() == vy.String(), vx, vy)
+                return
+        case reflect.Chan, reflect.UnsafePointer:
+                s.report(vx.Pointer() == vy.Pointer(), vx, vy)
+                return
+        case reflect.Func:
+                s.report(vx.IsNil() && vy.IsNil(), vx, vy)
+                return
+        case reflect.Ptr:
+                if vx.IsNil() || vy.IsNil() {
+                        s.report(vx.IsNil() && vy.IsNil(), vx, vy)
+                        return
+                }
+                s.curPath.push(&indirect{pathStep{t.Elem()}})
+                defer s.curPath.pop()
+                s.compareAny(vx.Elem(), vy.Elem())
+                return
+        case reflect.Interface:
+                if vx.IsNil() || vy.IsNil() {
+                        s.report(vx.IsNil() && vy.IsNil(), vx, vy)
+                        return
+                }
+                if vx.Elem().Type() != vy.Elem().Type() {
+                        s.report(false, vx.Elem(), vy.Elem())
+                        return
+                }
+                s.curPath.push(&typeAssertion{pathStep{vx.Elem().Type()}})
+                defer s.curPath.pop()
+                s.compareAny(vx.Elem(), vy.Elem())
+                return
+        case reflect.Slice:
+                if vx.IsNil() || vy.IsNil() {
+                        s.report(vx.IsNil() && vy.IsNil(), vx, vy)
+                        return
+                }
+                fallthrough
+        case reflect.Array:
+                s.compareArray(vx, vy, t)
+                return
+        case reflect.Map:
+                s.compareMap(vx, vy, t)
+                return
+        case reflect.Struct:
+                s.compareStruct(vx, vy, t)
+                return
+        default:
+                panic(fmt.Sprintf("%v kind not handled", t.Kind()))
+        }
+}
+
+func (s *state) tryExporting(vx, vy reflect.Value) (reflect.Value, reflect.Value) {
+        if sf, ok := s.curPath[len(s.curPath)-1].(*structField); ok && sf.unexported {
+                if sf.force {
+                        // Use unsafe pointer arithmetic to get read-write access to an
+                        // unexported field in the struct.
+                        vx = unsafeRetrieveField(sf.pvx, sf.field)
+                        vy = unsafeRetrieveField(sf.pvy, sf.field)
+                } else {
+                        // We are not allowed to export the value, so invalidate them
+                        // so that tryOptions can panic later if not explicitly ignored.
+                        vx = nothing
+                        vy = nothing
+                }
+        }
+        return vx, vy
+}
+
+func (s *state) tryOptions(vx, vy reflect.Value, t reflect.Type) bool {
+        // If there were no FilterValues, we will not detect invalid inputs,
+        // so manually check for them and append invalid if necessary.
+        // We still evaluate the options since an ignore can override invalid.
+        opts := s.opts
+        if !vx.IsValid() || !vy.IsValid() {
+                opts = Options{opts, invalid{}}
+        }
+
+        // Evaluate all filters and apply the remaining options.
+        if opt := opts.filter(s, vx, vy, t); opt != nil {
+                opt.apply(s, vx, vy)
+                return true
+        }
+        return false
+}
+
+func (s *state) tryMethod(vx, vy reflect.Value, t reflect.Type) bool {
+        // Check if this type even has an Equal method.
+        m, ok := t.MethodByName("Equal")
+        if !ok || !function.IsType(m.Type, function.EqualAssignable) {
+                return false
+        }
+
+        eq := s.callTTBFunc(m.Func, vx, vy)
+        s.report(eq, vx, vy)
+        return true
+}
+
+func (s *state) callTRFunc(f, v reflect.Value) reflect.Value {
+        v = sanitizeValue(v, f.Type().In(0))
+        if !s.dynChecker.Next() {
+                return f.Call([]reflect.Value{v})[0]
+        }
+
+        // Run the function twice and ensure that we get the same results back.
+        // We run in goroutines so that the race detector (if enabled) can detect
+        // unsafe mutations to the input.
+        c := make(chan reflect.Value)
+        go detectRaces(c, f, v)
+        want := f.Call([]reflect.Value{v})[0]
+        if got := <-c; !s.statelessCompare(got, want).Equal() {
+                // To avoid false-positives with non-reflexive equality operations,
+                // we sanity check whether a value is equal to itself.
+                if !s.statelessCompare(want, want).Equal() {
+                        return want
+                }
+                fn := getFuncName(f.Pointer())
+                panic(fmt.Sprintf("non-deterministic function detected: %s", fn))
+        }
+        return want
+}
+
+func (s *state) callTTBFunc(f, x, y reflect.Value) bool {
+        x = sanitizeValue(x, f.Type().In(0))
+        y = sanitizeValue(y, f.Type().In(1))
+        if !s.dynChecker.Next() {
+                return f.Call([]reflect.Value{x, y})[0].Bool()
+        }
+
+        // Swapping the input arguments is sufficient to check that
+        // f is symmetric and deterministic.
+        // We run in goroutines so that the race detector (if enabled) can detect
+        // unsafe mutations to the input.
+        c := make(chan reflect.Value)
+        go detectRaces(c, f, y, x)
+        want := f.Call([]reflect.Value{x, y})[0].Bool()
+        if got := <-c; !got.IsValid() || got.Bool() != want {
+                fn := getFuncName(f.Pointer())
+                panic(fmt.Sprintf("non-deterministic or non-symmetric function detected: %s", fn))
+        }
+        return want
+}
+
+func detectRaces(c chan<- reflect.Value, f reflect.Value, vs ...reflect.Value) {
+        var ret reflect.Value
+        defer func() {
+                recover() // Ignore panics, let the other call to f panic instead
+                c <- ret
+        }()
+        ret = f.Call(vs)[0]
+}
+
+// sanitizeValue converts nil interfaces of type T to those of type R,
+// assuming that T is assignable to R.
+// Otherwise, it returns the input value as is.
+func sanitizeValue(v reflect.Value, t reflect.Type) reflect.Value {
+        // TODO(dsnet): Remove this hacky workaround.
+        // See https://golang.org/issue/22143
+        if v.Kind() == reflect.Interface && v.IsNil() && v.Type() != t {
+                return reflect.New(t).Elem()
+        }
+        return v
+}
+
+func (s *state) compareArray(vx, vy reflect.Value, t reflect.Type) {
+        step := &sliceIndex{pathStep{t.Elem()}, 0, 0}
+        s.curPath.push(step)
+
+        // Compute an edit-script for slices vx and vy.
+        es := diff.Difference(vx.Len(), vy.Len(), func(ix, iy int) diff.Result {
+                step.xkey, step.ykey = ix, iy
+                return s.statelessCompare(vx.Index(ix), vy.Index(iy))
+        })
+
+        // Report the entire slice as is if the arrays are of primitive kind,
+        // and the arrays are different enough.
+        isPrimitive := false
+        switch t.Elem().Kind() {
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+                reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
+                reflect.Bool, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
+                isPrimitive = true
+        }
+        if isPrimitive && es.Dist() > (vx.Len()+vy.Len())/4 {
+                s.curPath.pop() // Pop first since we are reporting the whole slice
+                s.report(false, vx, vy)
+                return
+        }
+
+        // Replay the edit-script.
+        var ix, iy int
+        for _, e := range es {
+                switch e {
+                case diff.UniqueX:
+                        step.xkey, step.ykey = ix, -1
+                        s.report(false, vx.Index(ix), nothing)
+                        ix++
+                case diff.UniqueY:
+                        step.xkey, step.ykey = -1, iy
+                        s.report(false, nothing, vy.Index(iy))
+                        iy++
+                default:
+                        step.xkey, step.ykey = ix, iy
+                        if e == diff.Identity {
+                                s.report(true, vx.Index(ix), vy.Index(iy))
+                        } else {
+                                s.compareAny(vx.Index(ix), vy.Index(iy))
+                        }
+                        ix++
+                        iy++
+                }
+        }
+        s.curPath.pop()
+        return
+}
+
+func (s *state) compareMap(vx, vy reflect.Value, t reflect.Type) {
+        if vx.IsNil() || vy.IsNil() {
+                s.report(vx.IsNil() && vy.IsNil(), vx, vy)
+                return
+        }
+
+        // We combine and sort the two map keys so that we can perform the
+        // comparisons in a deterministic order.
+        step := &mapIndex{pathStep: pathStep{t.Elem()}}
+        s.curPath.push(step)
+        defer s.curPath.pop()
+        for _, k := range value.SortKeys(append(vx.MapKeys(), vy.MapKeys()...)) {
+                step.key = k
+                vvx := vx.MapIndex(k)
+                vvy := vy.MapIndex(k)
+                switch {
+                case vvx.IsValid() && vvy.IsValid():
+                        s.compareAny(vvx, vvy)
+                case vvx.IsValid() && !vvy.IsValid():
+                        s.report(false, vvx, nothing)
+                case !vvx.IsValid() && vvy.IsValid():
+                        s.report(false, nothing, vvy)
+                default:
+                        // It is possible for both vvx and vvy to be invalid if the
+                        // key contained a NaN value in it. There is no way in
+                        // reflection to be able to retrieve these values.
+                        // See https://golang.org/issue/11104
+                        panic(fmt.Sprintf("%#v has map key with NaNs", s.curPath))
+                }
+        }
+}
+
+func (s *state) compareStruct(vx, vy reflect.Value, t reflect.Type) {
+        var vax, vay reflect.Value // Addressable versions of vx and vy
+
+        step := &structField{}
+        s.curPath.push(step)
+        defer s.curPath.pop()
+        for i := 0; i < t.NumField(); i++ {
+                vvx := vx.Field(i)
+                vvy := vy.Field(i)
+                step.typ = t.Field(i).Type
+                step.name = t.Field(i).Name
+                step.idx = i
+                step.unexported = !isExported(step.name)
+                if step.unexported {
+                        // Defer checking of unexported fields until later to give an
+                        // Ignore a chance to ignore the field.
+                        if !vax.IsValid() || !vay.IsValid() {
+                                // For unsafeRetrieveField to work, the parent struct must
+                                // be addressable. Create a new copy of the values if
+                                // necessary to make them addressable.
+                                vax = makeAddressable(vx)
+                                vay = makeAddressable(vy)
+                        }
+                        step.force = s.exporters[t]
+                        step.pvx = vax
+                        step.pvy = vay
+                        step.field = t.Field(i)
+                }
+                s.compareAny(vvx, vvy)
+        }
+}
+
+// report records the result of a single comparison.
+// It also calls Report if any reporter is registered.
+func (s *state) report(eq bool, vx, vy reflect.Value) {
+        if eq {
+                s.result.NSame++
+        } else {
+                s.result.NDiff++
+        }
+        if s.reporter != nil {
+                s.reporter.Report(vx, vy, eq, s.curPath)
+        }
+}
+
+// dynChecker tracks the state needed to periodically perform checks that
+// user provided functions are symmetric and deterministic.
+// The zero value is safe for immediate use.
+type dynChecker struct{ curr, next int }
+
+// Next increments the state and reports whether a check should be performed.
+//
+// Checks occur every Nth function call, where N is a triangular number:
+//      0 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 ...
+// See https://en.wikipedia.org/wiki/Triangular_number
+//
+// This sequence ensures that the cost of checks drops significantly as
+// the number of functions calls grows larger.
+func (dc *dynChecker) Next() bool {
+        ok := dc.curr == dc.next
+        if ok {
+                dc.curr = 0
+                dc.next++
+        }
+        dc.curr++
+        return ok
+}
+
+// makeAddressable returns a value that is always addressable.
+// It returns the input verbatim if it is already addressable,
+// otherwise it creates a new value and returns an addressable copy.
+func makeAddressable(v reflect.Value) reflect.Value {
+        if v.CanAddr() {
+                return v
+        }
+        vc := reflect.New(v.Type()).Elem()
+        vc.Set(v)
+        return vc
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go
new file mode 100644
index 0000000..42afa49
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go
@@ -0,0 +1,17 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build !debug
+
+package diff
+
+var debug debugger
+
+type debugger struct{}
+
+func (debugger) Begin(_, _ int, f EqualFunc, _, _ *EditScript) EqualFunc {
+        return f
+}
+func (debugger) Update() {}
+func (debugger) Finish() {}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go
new file mode 100644
index 0000000..fd9f7f1
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go
@@ -0,0 +1,122 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build debug
+
+package diff
+
+import (
+        "fmt"
+        "strings"
+        "sync"
+        "time"
+)
+
+// The algorithm can be seen running in real-time by enabling debugging:
+//      go test -tags=debug -v
+//
+// Example output:
+//      === RUN   TestDifference/#34
+//      ┌───────────────────────────────┐
+//      │ \ · · · · · · · · · · · · · · │
+//      │ · # · · · · · · · · · · · · · │
+//      │ · \ · · · · · · · · · · · · · │
+//      │ · · \ · · · · · · · · · · · · │
+//      │ · · · X # · · · · · · · · · · │
+//      │ · · · # \ · · · · · · · · · · │
+//      │ · · · · · # # · · · · · · · · │
+//      │ · · · · · # \ · · · · · · · · │
+//      │ · · · · · · · \ · · · · · · · │
+//      │ · · · · · · · · \ · · · · · · │
+//      │ · · · · · · · · · \ · · · · · │
+//      │ · · · · · · · · · · \ · · # · │
+//      │ · · · · · · · · · · · \ # # · │
+//      │ · · · · · · · · · · · # # # · │
+//      │ · · · · · · · · · · # # # # · │
+//      │ · · · · · · · · · # # # # # · │
+//      │ · · · · · · · · · · · · · · \ │
+//      └───────────────────────────────┘
+//      [.Y..M.XY......YXYXY.|]
+//
+// The grid represents the edit-graph where the horizontal axis represents
+// list X and the vertical axis represents list Y. The start of the two lists
+// is the top-left, while the ends are the bottom-right. The '·' represents
+// an unexplored node in the graph. The '\' indicates that the two symbols
+// from list X and Y are equal. The 'X' indicates that two symbols are similar
+// (but not exactly equal) to each other. The '#' indicates that the two symbols
+// are different (and not similar). The algorithm traverses this graph trying to
+// make the paths starting in the top-left and the bottom-right connect.
+//
+// The series of '.', 'X', 'Y', and 'M' characters at the bottom represents
+// the currently established path from the forward and reverse searches,
+// separated by a '|' character.
+
+const (
+        updateDelay  = 100 * time.Millisecond
+        finishDelay  = 500 * time.Millisecond
+        ansiTerminal = true // ANSI escape codes used to move terminal cursor
+)
+
+var debug debugger
+
+type debugger struct {
+        sync.Mutex
+        p1, p2           EditScript
+        fwdPath, revPath *EditScript
+        grid             []byte
+        lines            int
+}
+
+func (dbg *debugger) Begin(nx, ny int, f EqualFunc, p1, p2 *EditScript) EqualFunc {
+        dbg.Lock()
+        dbg.fwdPath, dbg.revPath = p1, p2
+        top := "┌─" + strings.Repeat("──", nx) + "┐\n"
+        row := "│ " + strings.Repeat("· ", nx) + "│\n"
+        btm := "└─" + strings.Repeat("──", nx) + "┘\n"
+        dbg.grid = []byte(top + strings.Repeat(row, ny) + btm)
+        dbg.lines = strings.Count(dbg.String(), "\n")
+        fmt.Print(dbg)
+
+        // Wrap the EqualFunc so that we can intercept each result.
+        return func(ix, iy int) (r Result) {
+                cell := dbg.grid[len(top)+iy*len(row):][len("│ ")+len("· ")*ix:][:len("·")]
+                for i := range cell {
+                        cell[i] = 0 // Zero out the multiple bytes of UTF-8 middle-dot
+                }
+                switch r = f(ix, iy); {
+                case r.Equal():
+                        cell[0] = '\\'
+                case r.Similar():
+                        cell[0] = 'X'
+                default:
+                        cell[0] = '#'
+                }
+                return
+        }
+}
+
+func (dbg *debugger) Update() {
+        dbg.print(updateDelay)
+}
+
+func (dbg *debugger) Finish() {
+        dbg.print(finishDelay)
+        dbg.Unlock()
+}
+
+func (dbg *debugger) String() string {
+        dbg.p1, dbg.p2 = *dbg.fwdPath, dbg.p2[:0]
+        for i := len(*dbg.revPath) - 1; i >= 0; i-- {
+                dbg.p2 = append(dbg.p2, (*dbg.revPath)[i])
+        }
+        return fmt.Sprintf("%s[%v|%v]\n\n", dbg.grid, dbg.p1, dbg.p2)
+}
+
+func (dbg *debugger) print(d time.Duration) {
+        if ansiTerminal {
+                fmt.Printf("\x1b[%dA", dbg.lines) // Reset terminal cursor
+        }
+        fmt.Print(dbg)
+        time.Sleep(d)
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/diff/diff.go b/vendor/github.com/google/go-cmp/cmp/internal/diff/diff.go
new file mode 100644
index 0000000..260befe
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/diff.go
@@ -0,0 +1,363 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// Package diff implements an algorithm for producing edit-scripts.
+// The edit-script is a sequence of operations needed to transform one list
+// of symbols into another (or vice-versa). The edits allowed are insertions,
+// deletions, and modifications. The summation of all edits is called the
+// Levenshtein distance as this problem is well-known in computer science.
+//
+// This package prioritizes performance over accuracy. That is, the run time
+// is more important than obtaining a minimal Levenshtein distance.
+package diff
+
+// EditType represents a single operation within an edit-script.
+type EditType uint8
+
+const (
+        // Identity indicates that a symbol pair is identical in both list X and Y.
+        Identity EditType = iota
+        // UniqueX indicates that a symbol only exists in X and not Y.
+        UniqueX
+        // UniqueY indicates that a symbol only exists in Y and not X.
+        UniqueY
+        // Modified indicates that a symbol pair is a modification of each other.
+        Modified
+)
+
+// EditScript represents the series of differences between two lists.
+type EditScript []EditType
+
+// String returns a human-readable string representing the edit-script where
+// Identity, UniqueX, UniqueY, and Modified are represented by the
+// '.', 'X', 'Y', and 'M' characters, respectively.
+func (es EditScript) String() string {
+        b := make([]byte, len(es))
+        for i, e := range es {
+                switch e {
+                case Identity:
+                        b[i] = '.'
+                case UniqueX:
+                        b[i] = 'X'
+                case UniqueY:
+                        b[i] = 'Y'
+                case Modified:
+                        b[i] = 'M'
+                default:
+                        panic("invalid edit-type")
+                }
+        }
+        return string(b)
+}
+
+// stats returns a histogram of the number of each type of edit operation.
+func (es EditScript) stats() (s struct{ NI, NX, NY, NM int }) {
+        for _, e := range es {
+                switch e {
+                case Identity:
+                        s.NI++
+                case UniqueX:
+                        s.NX++
+                case UniqueY:
+                        s.NY++
+                case Modified:
+                        s.NM++
+                default:
+                        panic("invalid edit-type")
+                }
+        }
+        return
+}
+
+// Dist is the Levenshtein distance and is guaranteed to be 0 if and only if
+// lists X and Y are equal.
+func (es EditScript) Dist() int { return len(es) - es.stats().NI }
+
+// LenX is the length of the X list.
+func (es EditScript) LenX() int { return len(es) - es.stats().NY }
+
+// LenY is the length of the Y list.
+func (es EditScript) LenY() int { return len(es) - es.stats().NX }
+
+// EqualFunc reports whether the symbols at indexes ix and iy are equal.
+// When called by Difference, the index is guaranteed to be within nx and ny.
+type EqualFunc func(ix int, iy int) Result
+
+// Result is the result of comparison.
+// NSame is the number of sub-elements that are equal.
+// NDiff is the number of sub-elements that are not equal.
+type Result struct{ NSame, NDiff int }
+
+// Equal indicates whether the symbols are equal. Two symbols are equal
+// if and only if NDiff == 0. If Equal, then they are also Similar.
+func (r Result) Equal() bool { return r.NDiff == 0 }
+
+// Similar indicates whether two symbols are similar and may be represented
+// by using the Modified type. As a special case, we consider binary comparisons
+// (i.e., those that return Result{1, 0} or Result{0, 1}) to be similar.
+//
+// The exact ratio of NSame to NDiff to determine similarity may change.
+func (r Result) Similar() bool {
+        // Use NSame+1 to offset NSame so that binary comparisons are similar.
+        return r.NSame+1 >= r.NDiff
+}
+
+// Difference reports whether two lists of lengths nx and ny are equal
+// given the definition of equality provided as f.
+//
+// This function returns an edit-script, which is a sequence of operations
+// needed to convert one list into the other. The following invariants for
+// the edit-script are maintained:
+//      • eq == (es.Dist()==0)
+//      • nx == es.LenX()
+//      • ny == es.LenY()
+//
+// This algorithm is not guaranteed to be an optimal solution (i.e., one that
+// produces an edit-script with a minimal Levenshtein distance). This algorithm
+// favors performance over optimality. The exact output is not guaranteed to
+// be stable and may change over time.
+func Difference(nx, ny int, f EqualFunc) (es EditScript) {
+        // This algorithm is based on traversing what is known as an "edit-graph".
+        // See Figure 1 from "An O(ND) Difference Algorithm and Its Variations"
+        // by Eugene W. Myers. Since D can be as large as N itself, this is
+        // effectively O(N^2). Unlike the algorithm from that paper, we are not
+        // interested in the optimal path, but at least some "decent" path.
+        //
+        // For example, let X and Y be lists of symbols:
+        //      X = [A B C A B B A]
+        //      Y = [C B A B A C]
+        //
+        // The edit-graph can be drawn as the following:
+        //         A B C A B B A
+        //        ┌─────────────┐
+        //      C │_|_|\|_|_|_|_│ 0
+        //      B │_|\|_|_|\|\|_│ 1
+        //      A │\|_|_|\|_|_|\│ 2
+        //      B │_|\|_|_|\|\|_│ 3
+        //      A │\|_|_|\|_|_|\│ 4
+        //      C │ | |\| | | | │ 5
+        //        └─────────────┘ 6
+        //         0 1 2 3 4 5 6 7
+        //
+        // List X is written along the horizontal axis, while list Y is written
+        // along the vertical axis. At any point on this grid, if the symbol in
+        // list X matches the corresponding symbol in list Y, then a '\' is drawn.
+        // The goal of any minimal edit-script algorithm is to find a path from the
+        // top-left corner to the bottom-right corner, while traveling through the
+        // fewest horizontal or vertical edges.
+        // A horizontal edge is equivalent to inserting a symbol from list X.
+        // A vertical edge is equivalent to inserting a symbol from list Y.
+        // A diagonal edge is equivalent to a matching symbol between both X and Y.
+
+        // Invariants:
+        //      • 0 ≤ fwdPath.X ≤ (fwdFrontier.X, revFrontier.X) ≤ revPath.X ≤ nx
+        //      • 0 ≤ fwdPath.Y ≤ (fwdFrontier.Y, revFrontier.Y) ≤ revPath.Y ≤ ny
+        //
+        // In general:
+        //      • fwdFrontier.X < revFrontier.X
+        //      • fwdFrontier.Y < revFrontier.Y
+        // Unless, it is time for the algorithm to terminate.
+        fwdPath := path{+1, point{0, 0}, make(EditScript, 0, (nx+ny)/2)}
+        revPath := path{-1, point{nx, ny}, make(EditScript, 0)}
+        fwdFrontier := fwdPath.point // Forward search frontier
+        revFrontier := revPath.point // Reverse search frontier
+
+        // Search budget bounds the cost of searching for better paths.
+        // The longest sequence of non-matching symbols that can be tolerated is
+        // approximately the square-root of the search budget.
+        searchBudget := 4 * (nx + ny) // O(n)
+
+        // The algorithm below is a greedy, meet-in-the-middle algorithm for
+        // computing sub-optimal edit-scripts between two lists.
+        //
+        // The algorithm is approximately as follows:
+        //      • Searching for differences switches back-and-forth between
+        //      a search that starts at the beginning (the top-left corner), and
+        //      a search that starts at the end (the bottom-right corner). The goal of
+        //      the search is connect with the search from the opposite corner.
+        //      • As we search, we build a path in a greedy manner, where the first
+        //      match seen is added to the path (this is sub-optimal, but provides a
+        //      decent result in practice). When matches are found, we try the next pair
+        //      of symbols in the lists and follow all matches as far as possible.
+        //      • When searching for matches, we search along a diagonal going through
+        //      through the "frontier" point. If no matches are found, we advance the
+        //      frontier towards the opposite corner.
+        //      • This algorithm terminates when either the X coordinates or the
+        //      Y coordinates of the forward and reverse frontier points ever intersect.
+        //
+        // This algorithm is correct even if searching only in the forward direction
+        // or in the reverse direction. We do both because it is commonly observed
+        // that two lists commonly differ because elements were added to the front
+        // or end of the other list.
+        //
+        // Running the tests with the "debug" build tag prints a visualization of
+        // the algorithm running in real-time. This is educational for understanding
+        // how the algorithm works. See debug_enable.go.
+        f = debug.Begin(nx, ny, f, &fwdPath.es, &revPath.es)
+        for {
+                // Forward search from the beginning.
+                if fwdFrontier.X >= revFrontier.X || fwdFrontier.Y >= revFrontier.Y || searchBudget == 0 {
+                        break
+                }
+                for stop1, stop2, i := false, false, 0; !(stop1 && stop2) && searchBudget > 0; i++ {
+                        // Search in a diagonal pattern for a match.
+                        z := zigzag(i)
+                        p := point{fwdFrontier.X + z, fwdFrontier.Y - z}
+                        switch {
+                        case p.X >= revPath.X || p.Y < fwdPath.Y:
+                                stop1 = true // Hit top-right corner
+                        case p.Y >= revPath.Y || p.X < fwdPath.X:
+                                stop2 = true // Hit bottom-left corner
+                        case f(p.X, p.Y).Equal():
+                                // Match found, so connect the path to this point.
+                                fwdPath.connect(p, f)
+                                fwdPath.append(Identity)
+                                // Follow sequence of matches as far as possible.
+                                for fwdPath.X < revPath.X && fwdPath.Y < revPath.Y {
+                                        if !f(fwdPath.X, fwdPath.Y).Equal() {
+                                                break
+                                        }
+                                        fwdPath.append(Identity)
+                                }
+                                fwdFrontier = fwdPath.point
+                                stop1, stop2 = true, true
+                        default:
+                                searchBudget-- // Match not found
+                        }
+                        debug.Update()
+                }
+                // Advance the frontier towards reverse point.
+                if revPath.X-fwdFrontier.X >= revPath.Y-fwdFrontier.Y {
+                        fwdFrontier.X++
+                } else {
+                        fwdFrontier.Y++
+                }
+
+                // Reverse search from the end.
+                if fwdFrontier.X >= revFrontier.X || fwdFrontier.Y >= revFrontier.Y || searchBudget == 0 {
+                        break
+                }
+                for stop1, stop2, i := false, false, 0; !(stop1 && stop2) && searchBudget > 0; i++ {
+                        // Search in a diagonal pattern for a match.
+                        z := zigzag(i)
+                        p := point{revFrontier.X - z, revFrontier.Y + z}
+                        switch {
+                        case fwdPath.X >= p.X || revPath.Y < p.Y:
+                                stop1 = true // Hit bottom-left corner
+                        case fwdPath.Y >= p.Y || revPath.X < p.X:
+                                stop2 = true // Hit top-right corner
+                        case f(p.X-1, p.Y-1).Equal():
+                                // Match found, so connect the path to this point.
+                                revPath.connect(p, f)
+                                revPath.append(Identity)
+                                // Follow sequence of matches as far as possible.
+                                for fwdPath.X < revPath.X && fwdPath.Y < revPath.Y {
+                                        if !f(revPath.X-1, revPath.Y-1).Equal() {
+                                                break
+                                        }
+                                        revPath.append(Identity)
+                                }
+                                revFrontier = revPath.point
+                                stop1, stop2 = true, true
+                        default:
+                                searchBudget-- // Match not found
+                        }
+                        debug.Update()
+                }
+                // Advance the frontier towards forward point.
+                if revFrontier.X-fwdPath.X >= revFrontier.Y-fwdPath.Y {
+                        revFrontier.X--
+                } else {
+                        revFrontier.Y--
+                }
+        }
+
+        // Join the forward and reverse paths and then append the reverse path.
+        fwdPath.connect(revPath.point, f)
+        for i := len(revPath.es) - 1; i >= 0; i-- {
+                t := revPath.es[i]
+                revPath.es = revPath.es[:i]
+                fwdPath.append(t)
+        }
+        debug.Finish()
+        return fwdPath.es
+}
+
+type path struct {
+        dir   int // +1 if forward, -1 if reverse
+        point     // Leading point of the EditScript path
+        es    EditScript
+}
+
+// connect appends any necessary Identity, Modified, UniqueX, or UniqueY types
+// to the edit-script to connect p.point to dst.
+func (p *path) connect(dst point, f EqualFunc) {
+        if p.dir > 0 {
+                // Connect in forward direction.
+                for dst.X > p.X && dst.Y > p.Y {
+                        switch r := f(p.X, p.Y); {
+                        case r.Equal():
+                                p.append(Identity)
+                        case r.Similar():
+                                p.append(Modified)
+                        case dst.X-p.X >= dst.Y-p.Y:
+                                p.append(UniqueX)
+                        default:
+                                p.append(UniqueY)
+                        }
+                }
+                for dst.X > p.X {
+                        p.append(UniqueX)
+                }
+                for dst.Y > p.Y {
+                        p.append(UniqueY)
+                }
+        } else {
+                // Connect in reverse direction.
+                for p.X > dst.X && p.Y > dst.Y {
+                        switch r := f(p.X-1, p.Y-1); {
+                        case r.Equal():
+                                p.append(Identity)
+                        case r.Similar():
+                                p.append(Modified)
+                        case p.Y-dst.Y >= p.X-dst.X:
+                                p.append(UniqueY)
+                        default:
+                                p.append(UniqueX)
+                        }
+                }
+                for p.X > dst.X {
+                        p.append(UniqueX)
+                }
+                for p.Y > dst.Y {
+                        p.append(UniqueY)
+                }
+        }
+}
+
+func (p *path) append(t EditType) {
+        p.es = append(p.es, t)
+        switch t {
+        case Identity, Modified:
+                p.add(p.dir, p.dir)
+        case UniqueX:
+                p.add(p.dir, 0)
+        case UniqueY:
+                p.add(0, p.dir)
+        }
+        debug.Update()
+}
+
+type point struct{ X, Y int }
+
+func (p *point) add(dx, dy int) { p.X += dx; p.Y += dy }
+
+// zigzag maps a consecutive sequence of integers to a zig-zag sequence.
+//      [0 1 2 3 4 5 ...] => [0 -1 +1 -2 +2 ...]
+func zigzag(x int) int {
+        if x&1 != 0 {
+                x = ^x
+        }
+        return x >> 1
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/function/func.go b/vendor/github.com/google/go-cmp/cmp/internal/function/func.go
new file mode 100644
index 0000000..4c35ff1
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/function/func.go
@@ -0,0 +1,49 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// Package function identifies function types.
+package function
+
+import "reflect"
+
+type funcType int
+
+const (
+        _ funcType = iota
+
+        ttbFunc // func(T, T) bool
+        tibFunc // func(T, I) bool
+        trFunc  // func(T) R
+
+        Equal           = ttbFunc // func(T, T) bool
+        EqualAssignable = tibFunc // func(T, I) bool; encapsulates func(T, T) bool
+        Transformer     = trFunc  // func(T) R
+        ValueFilter     = ttbFunc // func(T, T) bool
+        Less            = ttbFunc // func(T, T) bool
+)
+
+var boolType = reflect.TypeOf(true)
+
+// IsType reports whether the reflect.Type is of the specified function type.
+func IsType(t reflect.Type, ft funcType) bool {
+        if t == nil || t.Kind() != reflect.Func || t.IsVariadic() {
+                return false
+        }
+        ni, no := t.NumIn(), t.NumOut()
+        switch ft {
+        case ttbFunc: // func(T, T) bool
+                if ni == 2 && no == 1 && t.In(0) == t.In(1) && t.Out(0) == boolType {
+                        return true
+                }
+        case tibFunc: // func(T, I) bool
+                if ni == 2 && no == 1 && t.In(0).AssignableTo(t.In(1)) && t.Out(0) == boolType {
+                        return true
+                }
+        case trFunc: // func(T) R
+                if ni == 1 && no == 1 {
+                        return true
+                }
+        }
+        return false
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/format.go b/vendor/github.com/google/go-cmp/cmp/internal/value/format.go
new file mode 100644
index 0000000..657e508
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/format.go
@@ -0,0 +1,277 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// Package value provides functionality for reflect.Value types.
+package value
+
+import (
+        "fmt"
+        "reflect"
+        "strconv"
+        "strings"
+        "unicode"
+)
+
+var stringerIface = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
+
+// Format formats the value v as a string.
+//
+// This is similar to fmt.Sprintf("%+v", v) except this:
+//      * Prints the type unless it can be elided
+//      * Avoids printing struct fields that are zero
+//      * Prints a nil-slice as being nil, not empty
+//      * Prints map entries in deterministic order
+func Format(v reflect.Value, conf FormatConfig) string {
+        conf.printType = true
+        conf.followPointers = true
+        conf.realPointers = true
+        return formatAny(v, conf, nil)
+}
+
+type FormatConfig struct {
+        UseStringer        bool // Should the String method be used if available?
+        printType          bool // Should we print the type before the value?
+        PrintPrimitiveType bool // Should we print the type of primitives?
+        followPointers     bool // Should we recursively follow pointers?
+        realPointers       bool // Should we print the real address of pointers?
+}
+
+func formatAny(v reflect.Value, conf FormatConfig, visited map[uintptr]bool) string {
+        // TODO: Should this be a multi-line printout in certain situations?
+
+        if !v.IsValid() {
+                return "<non-existent>"
+        }
+        if conf.UseStringer && v.Type().Implements(stringerIface) && v.CanInterface() {
+                if (v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface) && v.IsNil() {
+                        return "<nil>"
+                }
+
+                const stringerPrefix = "s" // Indicates that the String method was used
+                s := v.Interface().(fmt.Stringer).String()
+                return stringerPrefix + formatString(s)
+        }
+
+        switch v.Kind() {
+        case reflect.Bool:
+                return formatPrimitive(v.Type(), v.Bool(), conf)
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return formatPrimitive(v.Type(), v.Int(), conf)
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                if v.Type().PkgPath() == "" || v.Kind() == reflect.Uintptr {
+                        // Unnamed uints are usually bytes or words, so use hexadecimal.
+                        return formatPrimitive(v.Type(), formatHex(v.Uint()), conf)
+                }
+                return formatPrimitive(v.Type(), v.Uint(), conf)
+        case reflect.Float32, reflect.Float64:
+                return formatPrimitive(v.Type(), v.Float(), conf)
+        case reflect.Complex64, reflect.Complex128:
+                return formatPrimitive(v.Type(), v.Complex(), conf)
+        case reflect.String:
+                return formatPrimitive(v.Type(), formatString(v.String()), conf)
+        case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+                return formatPointer(v, conf)
+        case reflect.Ptr:
+                if v.IsNil() {
+                        if conf.printType {
+                                return fmt.Sprintf("(%v)(nil)", v.Type())
+                        }
+                        return "<nil>"
+                }
+                if visited[v.Pointer()] || !conf.followPointers {
+                        return formatPointer(v, conf)
+                }
+                visited = insertPointer(visited, v.Pointer())
+                return "&" + formatAny(v.Elem(), conf, visited)
+        case reflect.Interface:
+                if v.IsNil() {
+                        if conf.printType {
+                                return fmt.Sprintf("%v(nil)", v.Type())
+                        }
+                        return "<nil>"
+                }
+                return formatAny(v.Elem(), conf, visited)
+        case reflect.Slice:
+                if v.IsNil() {
+                        if conf.printType {
+                                return fmt.Sprintf("%v(nil)", v.Type())
+                        }
+                        return "<nil>"
+                }
+                if visited[v.Pointer()] {
+                        return formatPointer(v, conf)
+                }
+                visited = insertPointer(visited, v.Pointer())
+                fallthrough
+        case reflect.Array:
+                var ss []string
+                subConf := conf
+                subConf.printType = v.Type().Elem().Kind() == reflect.Interface
+                for i := 0; i < v.Len(); i++ {
+                        s := formatAny(v.Index(i), subConf, visited)
+                        ss = append(ss, s)
+                }
+                s := fmt.Sprintf("{%s}", strings.Join(ss, ", "))
+                if conf.printType {
+                        return v.Type().String() + s
+                }
+                return s
+        case reflect.Map:
+                if v.IsNil() {
+                        if conf.printType {
+                                return fmt.Sprintf("%v(nil)", v.Type())
+                        }
+                        return "<nil>"
+                }
+                if visited[v.Pointer()] {
+                        return formatPointer(v, conf)
+                }
+                visited = insertPointer(visited, v.Pointer())
+
+                var ss []string
+                keyConf, valConf := conf, conf
+                keyConf.printType = v.Type().Key().Kind() == reflect.Interface
+                keyConf.followPointers = false
+                valConf.printType = v.Type().Elem().Kind() == reflect.Interface
+                for _, k := range SortKeys(v.MapKeys()) {
+                        sk := formatAny(k, keyConf, visited)
+                        sv := formatAny(v.MapIndex(k), valConf, visited)
+                        ss = append(ss, fmt.Sprintf("%s: %s", sk, sv))
+                }
+                s := fmt.Sprintf("{%s}", strings.Join(ss, ", "))
+                if conf.printType {
+                        return v.Type().String() + s
+                }
+                return s
+        case reflect.Struct:
+                var ss []string
+                subConf := conf
+                subConf.printType = true
+                for i := 0; i < v.NumField(); i++ {
+                        vv := v.Field(i)
+                        if isZero(vv) {
+                                continue // Elide zero value fields
+                        }
+                        name := v.Type().Field(i).Name
+                        subConf.UseStringer = conf.UseStringer
+                        s := formatAny(vv, subConf, visited)
+                        ss = append(ss, fmt.Sprintf("%s: %s", name, s))
+                }
+                s := fmt.Sprintf("{%s}", strings.Join(ss, ", "))
+                if conf.printType {
+                        return v.Type().String() + s
+                }
+                return s
+        default:
+                panic(fmt.Sprintf("%v kind not handled", v.Kind()))
+        }
+}
+
+func formatString(s string) string {
+        // Use quoted string if it the same length as a raw string literal.
+        // Otherwise, attempt to use the raw string form.
+        qs := strconv.Quote(s)
+        if len(qs) == 1+len(s)+1 {
+                return qs
+        }
+
+        // Disallow newlines to ensure output is a single line.
+        // Only allow printable runes for readability purposes.
+        rawInvalid := func(r rune) bool {
+                return r == '`' || r == '\n' || !unicode.IsPrint(r)
+        }
+        if strings.IndexFunc(s, rawInvalid) < 0 {
+                return "`" + s + "`"
+        }
+        return qs
+}
+
+func formatPrimitive(t reflect.Type, v interface{}, conf FormatConfig) string {
+        if conf.printType && (conf.PrintPrimitiveType || t.PkgPath() != "") {
+                return fmt.Sprintf("%v(%v)", t, v)
+        }
+        return fmt.Sprintf("%v", v)
+}
+
+func formatPointer(v reflect.Value, conf FormatConfig) string {
+        p := v.Pointer()
+        if !conf.realPointers {
+                p = 0 // For deterministic printing purposes
+        }
+        s := formatHex(uint64(p))
+        if conf.printType {
+                return fmt.Sprintf("(%v)(%s)", v.Type(), s)
+        }
+        return s
+}
+
+func formatHex(u uint64) string {
+        var f string
+        switch {
+        case u <= 0xff:
+                f = "0x%02x"
+        case u <= 0xffff:
+                f = "0x%04x"
+        case u <= 0xffffff:
+                f = "0x%06x"
+        case u <= 0xffffffff:
+                f = "0x%08x"
+        case u <= 0xffffffffff:
+                f = "0x%010x"
+        case u <= 0xffffffffffff:
+                f = "0x%012x"
+        case u <= 0xffffffffffffff:
+                f = "0x%014x"
+        case u <= 0xffffffffffffffff:
+                f = "0x%016x"
+        }
+        return fmt.Sprintf(f, u)
+}
+
+// insertPointer insert p into m, allocating m if necessary.
+func insertPointer(m map[uintptr]bool, p uintptr) map[uintptr]bool {
+        if m == nil {
+                m = make(map[uintptr]bool)
+        }
+        m[p] = true
+        return m
+}
+
+// isZero reports whether v is the zero value.
+// This does not rely on Interface and so can be used on unexported fields.
+func isZero(v reflect.Value) bool {
+        switch v.Kind() {
+        case reflect.Bool:
+                return v.Bool() == false
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return v.Int() == 0
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                return v.Uint() == 0
+        case reflect.Float32, reflect.Float64:
+                return v.Float() == 0
+        case reflect.Complex64, reflect.Complex128:
+                return v.Complex() == 0
+        case reflect.String:
+                return v.String() == ""
+        case reflect.UnsafePointer:
+                return v.Pointer() == 0
+        case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
+                return v.IsNil()
+        case reflect.Array:
+                for i := 0; i < v.Len(); i++ {
+                        if !isZero(v.Index(i)) {
+                                return false
+                        }
+                }
+                return true
+        case reflect.Struct:
+                for i := 0; i < v.NumField(); i++ {
+                        if !isZero(v.Field(i)) {
+                                return false
+                        }
+                }
+                return true
+        }
+        return false
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go b/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
new file mode 100644
index 0000000..fe8aa27
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
@@ -0,0 +1,111 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package value
+
+import (
+        "fmt"
+        "math"
+        "reflect"
+        "sort"
+)
+
+// SortKeys sorts a list of map keys, deduplicating keys if necessary.
+// The type of each value must be comparable.
+func SortKeys(vs []reflect.Value) []reflect.Value {
+        if len(vs) == 0 {
+                return vs
+        }
+
+        // Sort the map keys.
+        sort.Sort(valueSorter(vs))
+
+        // Deduplicate keys (fails for NaNs).
+        vs2 := vs[:1]
+        for _, v := range vs[1:] {
+                if isLess(vs2[len(vs2)-1], v) {
+                        vs2 = append(vs2, v)
+                }
+        }
+        return vs2
+}
+
+// TODO: Use sort.Slice once Google AppEngine is on Go1.8 or above.
+type valueSorter []reflect.Value
+
+func (vs valueSorter) Len() int           { return len(vs) }
+func (vs valueSorter) Less(i, j int) bool { return isLess(vs[i], vs[j]) }
+func (vs valueSorter) Swap(i, j int)      { vs[i], vs[j] = vs[j], vs[i] }
+
+// isLess is a generic function for sorting arbitrary map keys.
+// The inputs must be of the same type and must be comparable.
+func isLess(x, y reflect.Value) bool {
+        switch x.Type().Kind() {
+        case reflect.Bool:
+                return !x.Bool() && y.Bool()
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return x.Int() < y.Int()
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                return x.Uint() < y.Uint()
+        case reflect.Float32, reflect.Float64:
+                fx, fy := x.Float(), y.Float()
+                return fx < fy || math.IsNaN(fx) && !math.IsNaN(fy)
+        case reflect.Complex64, reflect.Complex128:
+                cx, cy := x.Complex(), y.Complex()
+                rx, ix, ry, iy := real(cx), imag(cx), real(cy), imag(cy)
+                if rx == ry || (math.IsNaN(rx) && math.IsNaN(ry)) {
+                        return ix < iy || math.IsNaN(ix) && !math.IsNaN(iy)
+                }
+                return rx < ry || math.IsNaN(rx) && !math.IsNaN(ry)
+        case reflect.Ptr, reflect.UnsafePointer, reflect.Chan:
+                return x.Pointer() < y.Pointer()
+        case reflect.String:
+                return x.String() < y.String()
+        case reflect.Array:
+                for i := 0; i < x.Len(); i++ {
+                        if isLess(x.Index(i), y.Index(i)) {
+                                return true
+                        }
+                        if isLess(y.Index(i), x.Index(i)) {
+                                return false
+                        }
+                }
+                return false
+        case reflect.Struct:
+                for i := 0; i < x.NumField(); i++ {
+                        if isLess(x.Field(i), y.Field(i)) {
+                                return true
+                        }
+                        if isLess(y.Field(i), x.Field(i)) {
+                                return false
+                        }
+                }
+                return false
+        case reflect.Interface:
+                vx, vy := x.Elem(), y.Elem()
+                if !vx.IsValid() || !vy.IsValid() {
+                        return !vx.IsValid() && vy.IsValid()
+                }
+                tx, ty := vx.Type(), vy.Type()
+                if tx == ty {
+                        return isLess(x.Elem(), y.Elem())
+                }
+                if tx.Kind() != ty.Kind() {
+                        return vx.Kind() < vy.Kind()
+                }
+                if tx.String() != ty.String() {
+                        return tx.String() < ty.String()
+                }
+                if tx.PkgPath() != ty.PkgPath() {
+                        return tx.PkgPath() < ty.PkgPath()
+                }
+                // This can happen in rare situations, so we fallback to just comparing
+                // the unique pointer for a reflect.Type. This guarantees deterministic
+                // ordering within a program, but it is obviously not stable.
+                return reflect.ValueOf(vx.Type()).Pointer() < reflect.ValueOf(vy.Type()).Pointer()
+        default:
+                // Must be Func, Map, or Slice; which are not comparable.
+                panic(fmt.Sprintf("%T is not comparable", x.Type()))
+        }
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/options.go b/vendor/github.com/google/go-cmp/cmp/options.go
new file mode 100644
index 0000000..91d4b06
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/options.go
@@ -0,0 +1,453 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmp
+
+import (
+        "fmt"
+        "reflect"
+        "runtime"
+        "strings"
+
+        "github.com/google/go-cmp/cmp/internal/function"
+)
+
+// Option configures for specific behavior of Equal and Diff. In particular,
+// the fundamental Option functions (Ignore, Transformer, and Comparer),
+// configure how equality is determined.
+//
+// The fundamental options may be composed with filters (FilterPath and
+// FilterValues) to control the scope over which they are applied.
+//
+// The cmp/cmpopts package provides helper functions for creating options that
+// may be used with Equal and Diff.
+type Option interface {
+        // filter applies all filters and returns the option that remains.
+        // Each option may only read s.curPath and call s.callTTBFunc.
+        //
+        // An Options is returned only if multiple comparers or transformers
+        // can apply simultaneously and will only contain values of those types
+        // or sub-Options containing values of those types.
+        filter(s *state, vx, vy reflect.Value, t reflect.Type) applicableOption
+}
+
+// applicableOption represents the following types:
+//      Fundamental: ignore | invalid | *comparer | *transformer
+//      Grouping:    Options
+type applicableOption interface {
+        Option
+
+        // apply executes the option, which may mutate s or panic.
+        apply(s *state, vx, vy reflect.Value)
+}
+
+// coreOption represents the following types:
+//      Fundamental: ignore | invalid | *comparer | *transformer
+//      Filters:     *pathFilter | *valuesFilter
+type coreOption interface {
+        Option
+        isCore()
+}
+
+type core struct{}
+
+func (core) isCore() {}
+
+// Options is a list of Option values that also satisfies the Option interface.
+// Helper comparison packages may return an Options value when packing multiple
+// Option values into a single Option. When this package processes an Options,
+// it will be implicitly expanded into a flat list.
+//
+// Applying a filter on an Options is equivalent to applying that same filter
+// on all individual options held within.
+type Options []Option
+
+func (opts Options) filter(s *state, vx, vy reflect.Value, t reflect.Type) (out applicableOption) {
+        for _, opt := range opts {
+                switch opt := opt.filter(s, vx, vy, t); opt.(type) {
+                case ignore:
+                        return ignore{} // Only ignore can short-circuit evaluation
+                case invalid:
+                        out = invalid{} // Takes precedence over comparer or transformer
+                case *comparer, *transformer, Options:
+                        switch out.(type) {
+                        case nil:
+                                out = opt
+                        case invalid:
+                                // Keep invalid
+                        case *comparer, *transformer, Options:
+                                out = Options{out, opt} // Conflicting comparers or transformers
+                        }
+                }
+        }
+        return out
+}
+
+func (opts Options) apply(s *state, _, _ reflect.Value) {
+        const warning = "ambiguous set of applicable options"
+        const help = "consider using filters to ensure at most one Comparer or Transformer may apply"
+        var ss []string
+        for _, opt := range flattenOptions(nil, opts) {
+                ss = append(ss, fmt.Sprint(opt))
+        }
+        set := strings.Join(ss, "\n\t")
+        panic(fmt.Sprintf("%s at %#v:\n\t%s\n%s", warning, s.curPath, set, help))
+}
+
+func (opts Options) String() string {
+        var ss []string
+        for _, opt := range opts {
+                ss = append(ss, fmt.Sprint(opt))
+        }
+        return fmt.Sprintf("Options{%s}", strings.Join(ss, ", "))
+}
+
+// FilterPath returns a new Option where opt is only evaluated if filter f
+// returns true for the current Path in the value tree.
+//
+// The option passed in may be an Ignore, Transformer, Comparer, Options, or
+// a previously filtered Option.
+func FilterPath(f func(Path) bool, opt Option) Option {
+        if f == nil {
+                panic("invalid path filter function")
+        }
+        if opt := normalizeOption(opt); opt != nil {
+                return &pathFilter{fnc: f, opt: opt}
+        }
+        return nil
+}
+
+type pathFilter struct {
+        core
+        fnc func(Path) bool
+        opt Option
+}
+
+func (f pathFilter) filter(s *state, vx, vy reflect.Value, t reflect.Type) applicableOption {
+        if f.fnc(s.curPath) {
+                return f.opt.filter(s, vx, vy, t)
+        }
+        return nil
+}
+
+func (f pathFilter) String() string {
+        fn := getFuncName(reflect.ValueOf(f.fnc).Pointer())
+        return fmt.Sprintf("FilterPath(%s, %v)", fn, f.opt)
+}
+
+// FilterValues returns a new Option where opt is only evaluated if filter f,
+// which is a function of the form "func(T, T) bool", returns true for the
+// current pair of values being compared. If the type of the values is not
+// assignable to T, then this filter implicitly returns false.
+//
+// The filter function must be
+// symmetric (i.e., agnostic to the order of the inputs) and
+// deterministic (i.e., produces the same result when given the same inputs).
+// If T is an interface, it is possible that f is called with two values with
+// different concrete types that both implement T.
+//
+// The option passed in may be an Ignore, Transformer, Comparer, Options, or
+// a previously filtered Option.
+func FilterValues(f interface{}, opt Option) Option {
+        v := reflect.ValueOf(f)
+        if !function.IsType(v.Type(), function.ValueFilter) || v.IsNil() {
+                panic(fmt.Sprintf("invalid values filter function: %T", f))
+        }
+        if opt := normalizeOption(opt); opt != nil {
+                vf := &valuesFilter{fnc: v, opt: opt}
+                if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
+                        vf.typ = ti
+                }
+                return vf
+        }
+        return nil
+}
+
+type valuesFilter struct {
+        core
+        typ reflect.Type  // T
+        fnc reflect.Value // func(T, T) bool
+        opt Option
+}
+
+func (f valuesFilter) filter(s *state, vx, vy reflect.Value, t reflect.Type) applicableOption {
+        if !vx.IsValid() || !vy.IsValid() {
+                return invalid{}
+        }
+        if (f.typ == nil || t.AssignableTo(f.typ)) && s.callTTBFunc(f.fnc, vx, vy) {
+                return f.opt.filter(s, vx, vy, t)
+        }
+        return nil
+}
+
+func (f valuesFilter) String() string {
+        fn := getFuncName(f.fnc.Pointer())
+        return fmt.Sprintf("FilterValues(%s, %v)", fn, f.opt)
+}
+
+// Ignore is an Option that causes all comparisons to be ignored.
+// This value is intended to be combined with FilterPath or FilterValues.
+// It is an error to pass an unfiltered Ignore option to Equal.
+func Ignore() Option { return ignore{} }
+
+type ignore struct{ core }
+
+func (ignore) isFiltered() bool                                                     { return false }
+func (ignore) filter(_ *state, _, _ reflect.Value, _ reflect.Type) applicableOption { return ignore{} }
+func (ignore) apply(_ *state, _, _ reflect.Value)                                   { return }
+func (ignore) String() string                                                       { return "Ignore()" }
+
+// invalid is a sentinel Option type to indicate that some options could not
+// be evaluated due to unexported fields.
+type invalid struct{ core }
+
+func (invalid) filter(_ *state, _, _ reflect.Value, _ reflect.Type) applicableOption { return invalid{} }
+func (invalid) apply(s *state, _, _ reflect.Value) {
+        const help = "consider using AllowUnexported or cmpopts.IgnoreUnexported"
+        panic(fmt.Sprintf("cannot handle unexported field: %#v\n%s", s.curPath, help))
+}
+
+// Transformer returns an Option that applies a transformation function that
+// converts values of a certain type into that of another.
+//
+// The transformer f must be a function "func(T) R" that converts values of
+// type T to those of type R and is implicitly filtered to input values
+// assignable to T. The transformer must not mutate T in any way.
+//
+// To help prevent some cases of infinite recursive cycles applying the
+// same transform to the output of itself (e.g., in the case where the
+// input and output types are the same), an implicit filter is added such that
+// a transformer is applicable only if that exact transformer is not already
+// in the tail of the Path since the last non-Transform step.
+//
+// The name is a user provided label that is used as the Transform.Name in the
+// transformation PathStep. If empty, an arbitrary name is used.
+func Transformer(name string, f interface{}) Option {
+        v := reflect.ValueOf(f)
+        if !function.IsType(v.Type(), function.Transformer) || v.IsNil() {
+                panic(fmt.Sprintf("invalid transformer function: %T", f))
+        }
+        if name == "" {
+                name = "λ" // Lambda-symbol as place-holder for anonymous transformer
+        }
+        if !isValid(name) {
+                panic(fmt.Sprintf("invalid name: %q", name))
+        }
+        tr := &transformer{name: name, fnc: reflect.ValueOf(f)}
+        if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
+                tr.typ = ti
+        }
+        return tr
+}
+
+type transformer struct {
+        core
+        name string
+        typ  reflect.Type  // T
+        fnc  reflect.Value // func(T) R
+}
+
+func (tr *transformer) isFiltered() bool { return tr.typ != nil }
+
+func (tr *transformer) filter(s *state, _, _ reflect.Value, t reflect.Type) applicableOption {
+        for i := len(s.curPath) - 1; i >= 0; i-- {
+                if t, ok := s.curPath[i].(*transform); !ok {
+                        break // Hit most recent non-Transform step
+                } else if tr == t.trans {
+                        return nil // Cannot directly use same Transform
+                }
+        }
+        if tr.typ == nil || t.AssignableTo(tr.typ) {
+                return tr
+        }
+        return nil
+}
+
+func (tr *transformer) apply(s *state, vx, vy reflect.Value) {
+        // Update path before calling the Transformer so that dynamic checks
+        // will use the updated path.
+        s.curPath.push(&transform{pathStep{tr.fnc.Type().Out(0)}, tr})
+        defer s.curPath.pop()
+
+        vx = s.callTRFunc(tr.fnc, vx)
+        vy = s.callTRFunc(tr.fnc, vy)
+        s.compareAny(vx, vy)
+}
+
+func (tr transformer) String() string {
+        return fmt.Sprintf("Transformer(%s, %s)", tr.name, getFuncName(tr.fnc.Pointer()))
+}
+
+// Comparer returns an Option that determines whether two values are equal
+// to each other.
+//
+// The comparer f must be a function "func(T, T) bool" and is implicitly
+// filtered to input values assignable to T. If T is an interface, it is
+// possible that f is called with two values of different concrete types that
+// both implement T.
+//
+// The equality function must be:
+//      • Symmetric: equal(x, y) == equal(y, x)
+//      • Deterministic: equal(x, y) == equal(x, y)
+//      • Pure: equal(x, y) does not modify x or y
+func Comparer(f interface{}) Option {
+        v := reflect.ValueOf(f)
+        if !function.IsType(v.Type(), function.Equal) || v.IsNil() {
+                panic(fmt.Sprintf("invalid comparer function: %T", f))
+        }
+        cm := &comparer{fnc: v}
+        if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
+                cm.typ = ti
+        }
+        return cm
+}
+
+type comparer struct {
+        core
+        typ reflect.Type  // T
+        fnc reflect.Value // func(T, T) bool
+}
+
+func (cm *comparer) isFiltered() bool { return cm.typ != nil }
+
+func (cm *comparer) filter(_ *state, _, _ reflect.Value, t reflect.Type) applicableOption {
+        if cm.typ == nil || t.AssignableTo(cm.typ) {
+                return cm
+        }
+        return nil
+}
+
+func (cm *comparer) apply(s *state, vx, vy reflect.Value) {
+        eq := s.callTTBFunc(cm.fnc, vx, vy)
+        s.report(eq, vx, vy)
+}
+
+func (cm comparer) String() string {
+        return fmt.Sprintf("Comparer(%s)", getFuncName(cm.fnc.Pointer()))
+}
+
+// AllowUnexported returns an Option that forcibly allows operations on
+// unexported fields in certain structs, which are specified by passing in a
+// value of each struct type.
+//
+// Users of this option must understand that comparing on unexported fields
+// from external packages is not safe since changes in the internal
+// implementation of some external package may cause the result of Equal
+// to unexpectedly change. However, it may be valid to use this option on types
+// defined in an internal package where the semantic meaning of an unexported
+// field is in the control of the user.
+//
+// For some cases, a custom Comparer should be used instead that defines
+// equality as a function of the public API of a type rather than the underlying
+// unexported implementation.
+//
+// For example, the reflect.Type documentation defines equality to be determined
+// by the == operator on the interface (essentially performing a shallow pointer
+// comparison) and most attempts to compare *regexp.Regexp types are interested
+// in only checking that the regular expression strings are equal.
+// Both of these are accomplished using Comparers:
+//
+//      Comparer(func(x, y reflect.Type) bool { return x == y })
+//      Comparer(func(x, y *regexp.Regexp) bool { return x.String() == y.String() })
+//
+// In other cases, the cmpopts.IgnoreUnexported option can be used to ignore
+// all unexported fields on specified struct types.
+func AllowUnexported(types ...interface{}) Option {
+        if !supportAllowUnexported {
+                panic("AllowUnexported is not supported on purego builds, Google App Engine Standard, or GopherJS")
+        }
+        m := make(map[reflect.Type]bool)
+        for _, typ := range types {
+                t := reflect.TypeOf(typ)
+                if t.Kind() != reflect.Struct {
+                        panic(fmt.Sprintf("invalid struct type: %T", typ))
+                }
+                m[t] = true
+        }
+        return visibleStructs(m)
+}
+
+type visibleStructs map[reflect.Type]bool
+
+func (visibleStructs) filter(_ *state, _, _ reflect.Value, _ reflect.Type) applicableOption {
+        panic("not implemented")
+}
+
+// reporter is an Option that configures how differences are reported.
+type reporter interface {
+        // TODO: Not exported yet.
+        //
+        // Perhaps add PushStep and PopStep and change Report to only accept
+        // a PathStep instead of the full-path? Adding a PushStep and PopStep makes
+        // it clear that we are traversing the value tree in a depth-first-search
+        // manner, which has an effect on how values are printed.
+
+        Option
+
+        // Report is called for every comparison made and will be provided with
+        // the two values being compared, the equality result, and the
+        // current path in the value tree. It is possible for x or y to be an
+        // invalid reflect.Value if one of the values is non-existent;
+        // which is possible with maps and slices.
+        Report(x, y reflect.Value, eq bool, p Path)
+}
+
+// normalizeOption normalizes the input options such that all Options groups
+// are flattened and groups with a single element are reduced to that element.
+// Only coreOptions and Options containing coreOptions are allowed.
+func normalizeOption(src Option) Option {
+        switch opts := flattenOptions(nil, Options{src}); len(opts) {
+        case 0:
+                return nil
+        case 1:
+                return opts[0]
+        default:
+                return opts
+        }
+}
+
+// flattenOptions copies all options in src to dst as a flat list.
+// Only coreOptions and Options containing coreOptions are allowed.
+func flattenOptions(dst, src Options) Options {
+        for _, opt := range src {
+                switch opt := opt.(type) {
+                case nil:
+                        continue
+                case Options:
+                        dst = flattenOptions(dst, opt)
+                case coreOption:
+                        dst = append(dst, opt)
+                default:
+                        panic(fmt.Sprintf("invalid option type: %T", opt))
+                }
+        }
+        return dst
+}
+
+// getFuncName returns a short function name from the pointer.
+// The string parsing logic works up until Go1.9.
+func getFuncName(p uintptr) string {
+        fnc := runtime.FuncForPC(p)
+        if fnc == nil {
+                return "<unknown>"
+        }
+        name := fnc.Name() // E.g., "long/path/name/mypkg.(mytype).(long/path/name/mypkg.myfunc)-fm"
+        if strings.HasSuffix(name, ")-fm") || strings.HasSuffix(name, ")·fm") {
+                // Strip the package name from method name.
+                name = strings.TrimSuffix(name, ")-fm")
+                name = strings.TrimSuffix(name, ")·fm")
+                if i := strings.LastIndexByte(name, '('); i >= 0 {
+                        methodName := name[i+1:] // E.g., "long/path/name/mypkg.myfunc"
+                        if j := strings.LastIndexByte(methodName, '.'); j >= 0 {
+                                methodName = methodName[j+1:] // E.g., "myfunc"
+                        }
+                        name = name[:i] + methodName // E.g., "long/path/name/mypkg.(mytype)." + "myfunc"
+                }
+        }
+        if i := strings.LastIndexByte(name, '/'); i >= 0 {
+                // Strip the package name.
+                name = name[i+1:] // E.g., "mypkg.(mytype).myfunc"
+        }
+        return name
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/path.go b/vendor/github.com/google/go-cmp/cmp/path.go
new file mode 100644
index 0000000..c08a3cf
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/path.go
@@ -0,0 +1,309 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmp
+
+import (
+        "fmt"
+        "reflect"
+        "strings"
+        "unicode"
+        "unicode/utf8"
+)
+
+type (
+        // Path is a list of PathSteps describing the sequence of operations to get
+        // from some root type to the current position in the value tree.
+        // The first Path element is always an operation-less PathStep that exists
+        // simply to identify the initial type.
+        //
+        // When traversing structs with embedded structs, the embedded struct will
+        // always be accessed as a field before traversing the fields of the
+        // embedded struct themselves. That is, an exported field from the
+        // embedded struct will never be accessed directly from the parent struct.
+        Path []PathStep
+
+        // PathStep is a union-type for specific operations to traverse
+        // a value's tree structure. Users of this package never need to implement
+        // these types as values of this type will be returned by this package.
+        PathStep interface {
+                String() string
+                Type() reflect.Type // Resulting type after performing the path step
+                isPathStep()
+        }
+
+        // SliceIndex is an index operation on a slice or array at some index Key.
+        SliceIndex interface {
+                PathStep
+                Key() int // May return -1 if in a split state
+
+                // SplitKeys returns the indexes for indexing into slices in the
+                // x and y values, respectively. These indexes may differ due to the
+                // insertion or removal of an element in one of the slices, causing
+                // all of the indexes to be shifted. If an index is -1, then that
+                // indicates that the element does not exist in the associated slice.
+                //
+                // Key is guaranteed to return -1 if and only if the indexes returned
+                // by SplitKeys are not the same. SplitKeys will never return -1 for
+                // both indexes.
+                SplitKeys() (x int, y int)
+
+                isSliceIndex()
+        }
+        // MapIndex is an index operation on a map at some index Key.
+        MapIndex interface {
+                PathStep
+                Key() reflect.Value
+                isMapIndex()
+        }
+        // TypeAssertion represents a type assertion on an interface.
+        TypeAssertion interface {
+                PathStep
+                isTypeAssertion()
+        }
+        // StructField represents a struct field access on a field called Name.
+        StructField interface {
+                PathStep
+                Name() string
+                Index() int
+                isStructField()
+        }
+        // Indirect represents pointer indirection on the parent type.
+        Indirect interface {
+                PathStep
+                isIndirect()
+        }
+        // Transform is a transformation from the parent type to the current type.
+        Transform interface {
+                PathStep
+                Name() string
+                Func() reflect.Value
+
+                // Option returns the originally constructed Transformer option.
+                // The == operator can be used to detect the exact option used.
+                Option() Option
+
+                isTransform()
+        }
+)
+
+func (pa *Path) push(s PathStep) {
+        *pa = append(*pa, s)
+}
+
+func (pa *Path) pop() {
+        *pa = (*pa)[:len(*pa)-1]
+}
+
+// Last returns the last PathStep in the Path.
+// If the path is empty, this returns a non-nil PathStep that reports a nil Type.
+func (pa Path) Last() PathStep {
+        return pa.Index(-1)
+}
+
+// Index returns the ith step in the Path and supports negative indexing.
+// A negative index starts counting from the tail of the Path such that -1
+// refers to the last step, -2 refers to the second-to-last step, and so on.
+// If index is invalid, this returns a non-nil PathStep that reports a nil Type.
+func (pa Path) Index(i int) PathStep {
+        if i < 0 {
+                i = len(pa) + i
+        }
+        if i < 0 || i >= len(pa) {
+                return pathStep{}
+        }
+        return pa[i]
+}
+
+// String returns the simplified path to a node.
+// The simplified path only contains struct field accesses.
+//
+// For example:
+//      MyMap.MySlices.MyField
+func (pa Path) String() string {
+        var ss []string
+        for _, s := range pa {
+                if _, ok := s.(*structField); ok {
+                        ss = append(ss, s.String())
+                }
+        }
+        return strings.TrimPrefix(strings.Join(ss, ""), ".")
+}
+
+// GoString returns the path to a specific node using Go syntax.
+//
+// For example:
+//      (*root.MyMap["key"].(*mypkg.MyStruct).MySlices)[2][3].MyField
+func (pa Path) GoString() string {
+        var ssPre, ssPost []string
+        var numIndirect int
+        for i, s := range pa {
+                var nextStep PathStep
+                if i+1 < len(pa) {
+                        nextStep = pa[i+1]
+                }
+                switch s := s.(type) {
+                case *indirect:
+                        numIndirect++
+                        pPre, pPost := "(", ")"
+                        switch nextStep.(type) {
+                        case *indirect:
+                                continue // Next step is indirection, so let them batch up
+                        case *structField:
+                                numIndirect-- // Automatic indirection on struct fields
+                        case nil:
+                                pPre, pPost = "", "" // Last step; no need for parenthesis
+                        }
+                        if numIndirect > 0 {
+                                ssPre = append(ssPre, pPre+strings.Repeat("*", numIndirect))
+                                ssPost = append(ssPost, pPost)
+                        }
+                        numIndirect = 0
+                        continue
+                case *transform:
+                        ssPre = append(ssPre, s.trans.name+"(")
+                        ssPost = append(ssPost, ")")
+                        continue
+                case *typeAssertion:
+                        // As a special-case, elide type assertions on anonymous types
+                        // since they are typically generated dynamically and can be very
+                        // verbose. For example, some transforms return interface{} because
+                        // of Go's lack of generics, but typically take in and return the
+                        // exact same concrete type.
+                        if s.Type().PkgPath() == "" {
+                                continue
+                        }
+                }
+                ssPost = append(ssPost, s.String())
+        }
+        for i, j := 0, len(ssPre)-1; i < j; i, j = i+1, j-1 {
+                ssPre[i], ssPre[j] = ssPre[j], ssPre[i]
+        }
+        return strings.Join(ssPre, "") + strings.Join(ssPost, "")
+}
+
+type (
+        pathStep struct {
+                typ reflect.Type
+        }
+
+        sliceIndex struct {
+                pathStep
+                xkey, ykey int
+        }
+        mapIndex struct {
+                pathStep
+                key reflect.Value
+        }
+        typeAssertion struct {
+                pathStep
+        }
+        structField struct {
+                pathStep
+                name string
+                idx  int
+
+                // These fields are used for forcibly accessing an unexported field.
+                // pvx, pvy, and field are only valid if unexported is true.
+                unexported bool
+                force      bool                // Forcibly allow visibility
+                pvx, pvy   reflect.Value       // Parent values
+                field      reflect.StructField // Field information
+        }
+        indirect struct {
+                pathStep
+        }
+        transform struct {
+                pathStep
+                trans *transformer
+        }
+)
+
+func (ps pathStep) Type() reflect.Type { return ps.typ }
+func (ps pathStep) String() string {
+        if ps.typ == nil {
+                return "<nil>"
+        }
+        s := ps.typ.String()
+        if s == "" || strings.ContainsAny(s, "{}\n") {
+                return "root" // Type too simple or complex to print
+        }
+        return fmt.Sprintf("{%s}", s)
+}
+
+func (si sliceIndex) String() string {
+        switch {
+        case si.xkey == si.ykey:
+                return fmt.Sprintf("[%d]", si.xkey)
+        case si.ykey == -1:
+                // [5->?] means "I don't know where X[5] went"
+                return fmt.Sprintf("[%d->?]", si.xkey)
+        case si.xkey == -1:
+                // [?->3] means "I don't know where Y[3] came from"
+                return fmt.Sprintf("[?->%d]", si.ykey)
+        default:
+                // [5->3] means "X[5] moved to Y[3]"
+                return fmt.Sprintf("[%d->%d]", si.xkey, si.ykey)
+        }
+}
+func (mi mapIndex) String() string      { return fmt.Sprintf("[%#v]", mi.key) }
+func (ta typeAssertion) String() string { return fmt.Sprintf(".(%v)", ta.typ) }
+func (sf structField) String() string   { return fmt.Sprintf(".%s", sf.name) }
+func (in indirect) String() string      { return "*" }
+func (tf transform) String() string     { return fmt.Sprintf("%s()", tf.trans.name) }
+
+func (si sliceIndex) Key() int {
+        if si.xkey != si.ykey {
+                return -1
+        }
+        return si.xkey
+}
+func (si sliceIndex) SplitKeys() (x, y int) { return si.xkey, si.ykey }
+func (mi mapIndex) Key() reflect.Value      { return mi.key }
+func (sf structField) Name() string         { return sf.name }
+func (sf structField) Index() int           { return sf.idx }
+func (tf transform) Name() string           { return tf.trans.name }
+func (tf transform) Func() reflect.Value    { return tf.trans.fnc }
+func (tf transform) Option() Option         { return tf.trans }
+
+func (pathStep) isPathStep()           {}
+func (sliceIndex) isSliceIndex()       {}
+func (mapIndex) isMapIndex()           {}
+func (typeAssertion) isTypeAssertion() {}
+func (structField) isStructField()     {}
+func (indirect) isIndirect()           {}
+func (transform) isTransform()         {}
+
+var (
+        _ SliceIndex    = sliceIndex{}
+        _ MapIndex      = mapIndex{}
+        _ TypeAssertion = typeAssertion{}
+        _ StructField   = structField{}
+        _ Indirect      = indirect{}
+        _ Transform     = transform{}
+
+        _ PathStep = sliceIndex{}
+        _ PathStep = mapIndex{}
+        _ PathStep = typeAssertion{}
+        _ PathStep = structField{}
+        _ PathStep = indirect{}
+        _ PathStep = transform{}
+)
+
+// isExported reports whether the identifier is exported.
+func isExported(id string) bool {
+        r, _ := utf8.DecodeRuneInString(id)
+        return unicode.IsUpper(r)
+}
+
+// isValid reports whether the identifier is valid.
+// Empty and underscore-only strings are not valid.
+func isValid(id string) bool {
+        ok := id != "" && id != "_"
+        for j, c := range id {
+                ok = ok && (j > 0 || !unicode.IsDigit(c))
+                ok = ok && (c == '_' || unicode.IsLetter(c) || unicode.IsDigit(c))
+        }
+        return ok
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/reporter.go b/vendor/github.com/google/go-cmp/cmp/reporter.go
new file mode 100644
index 0000000..20e9f18
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/reporter.go
@@ -0,0 +1,53 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmp
+
+import (
+        "fmt"
+        "reflect"
+        "strings"
+
+        "github.com/google/go-cmp/cmp/internal/value"
+)
+
+type defaultReporter struct {
+        Option
+        diffs  []string // List of differences, possibly truncated
+        ndiffs int      // Total number of differences
+        nbytes int      // Number of bytes in diffs
+        nlines int      // Number of lines in diffs
+}
+
+var _ reporter = (*defaultReporter)(nil)
+
+func (r *defaultReporter) Report(x, y reflect.Value, eq bool, p Path) {
+        if eq {
+                return // Ignore equal results
+        }
+        const maxBytes = 4096
+        const maxLines = 256
+        r.ndiffs++
+        if r.nbytes < maxBytes && r.nlines < maxLines {
+                sx := value.Format(x, value.FormatConfig{UseStringer: true})
+                sy := value.Format(y, value.FormatConfig{UseStringer: true})
+                if sx == sy {
+                        // Unhelpful output, so use more exact formatting.
+                        sx = value.Format(x, value.FormatConfig{PrintPrimitiveType: true})
+                        sy = value.Format(y, value.FormatConfig{PrintPrimitiveType: true})
+                }
+                s := fmt.Sprintf("%#v:\n\t-: %s\n\t+: %s\n", p, sx, sy)
+                r.diffs = append(r.diffs, s)
+                r.nbytes += len(s)
+                r.nlines += strings.Count(s, "\n")
+        }
+}
+
+func (r *defaultReporter) String() string {
+        s := strings.Join(r.diffs, "")
+        if r.ndiffs == len(r.diffs) {
+                return s
+        }
+        return fmt.Sprintf("%s... %d more differences ...", s, r.ndiffs-len(r.diffs))
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/unsafe_panic.go b/vendor/github.com/google/go-cmp/cmp/unsafe_panic.go
new file mode 100644
index 0000000..d1518eb
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/unsafe_panic.go
@@ -0,0 +1,15 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build purego appengine js
+
+package cmp
+
+import "reflect"
+
+const supportAllowUnexported = false
+
+func unsafeRetrieveField(reflect.Value, reflect.StructField) reflect.Value {
+        panic("unsafeRetrieveField is not implemented")
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/unsafe_reflect.go b/vendor/github.com/google/go-cmp/cmp/unsafe_reflect.go
new file mode 100644
index 0000000..579b655
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/unsafe_reflect.go
@@ -0,0 +1,23 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// +build !purego,!appengine,!js
+
+package cmp
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+const supportAllowUnexported = true
+
+// unsafeRetrieveField uses unsafe to forcibly retrieve any field from a struct
+// such that the value has read-write permissions.
+//
+// The parent struct, v, must be addressable, while f must be a StructField
+// describing the field to retrieve.
+func unsafeRetrieveField(v reflect.Value, f reflect.StructField) reflect.Value {
+        return reflect.NewAt(f.Type, unsafe.Pointer(v.UnsafeAddr()+f.Offset)).Elem()
+}