add vendor

vendor/github.com/smartystreets/assertions/internal/oglematchers/identical_to.go

@@ -0,0 +1,134 @@
+// Copyright 2012 Aaron Jacobs. All Rights Reserved.
+// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package oglematchers
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Is the type comparable according to the definition here?
+//
+//     http://weekly.golang.org/doc/go_spec.html#Comparison_operators
+//
+func isComparable(t reflect.Type) bool {
+	switch t.Kind() {
+	case reflect.Array:
+		return isComparable(t.Elem())
+
+	case reflect.Struct:
+		for i := 0; i < t.NumField(); i++ {
+			if !isComparable(t.Field(i).Type) {
+				return false
+			}
+		}
+
+		return true
+
+	case reflect.Slice, reflect.Map, reflect.Func:
+		return false
+	}
+
+	return true
+}
+
+// Should the supplied type be allowed as an argument to IdenticalTo?
+func isLegalForIdenticalTo(t reflect.Type) (bool, error) {
+	// Allow the zero type.
+	if t == nil {
+		return true, nil
+	}
+
+	// Reference types are always okay; we compare pointers.
+	switch t.Kind() {
+	case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan:
+		return true, nil
+	}
+
+	// Reject other non-comparable types.
+	if !isComparable(t) {
+		return false, errors.New(fmt.Sprintf("%v is not comparable", t))
+	}
+
+	return true, nil
+}
+
+// IdenticalTo(x) returns a matcher that matches values v with type identical
+// to x such that:
+//
+//  1. If v and x are of a reference type (slice, map, function, channel), then
+//     they are either both nil or are references to the same object.
+//
+//  2. Otherwise, if v and x are not of a reference type but have a valid type,
+//     then v == x.
+//
+// If v and x are both the invalid type (which results from the predeclared nil
+// value, or from nil interface variables), then the matcher is satisfied.
+//
+// This function will panic if x is of a value type that is not comparable. For
+// example, x cannot be an array of functions.
+func IdenticalTo(x interface{}) Matcher {
+	t := reflect.TypeOf(x)
+
+	// Reject illegal arguments.
+	if ok, err := isLegalForIdenticalTo(t); !ok {
+		panic("IdenticalTo: " + err.Error())
+	}
+
+	return &identicalToMatcher{x}
+}
+
+type identicalToMatcher struct {
+	x interface{}
+}
+
+func (m *identicalToMatcher) Description() string {
+	t := reflect.TypeOf(m.x)
+	return fmt.Sprintf("identical to <%v> %v", t, m.x)
+}
+
+func (m *identicalToMatcher) Matches(c interface{}) error {
+	// Make sure the candidate's type is correct.
+	t := reflect.TypeOf(m.x)
+	if ct := reflect.TypeOf(c); t != ct {
+		return NewFatalError(fmt.Sprintf("which is of type %v", ct))
+	}
+
+	// Special case: two values of the invalid type are always identical.
+	if t == nil {
+		return nil
+	}
+
+	// Handle reference types.
+	switch t.Kind() {
+	case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan:
+		xv := reflect.ValueOf(m.x)
+		cv := reflect.ValueOf(c)
+		if xv.Pointer() == cv.Pointer() {
+			return nil
+		}
+
+		return errors.New("which is not an identical reference")
+	}
+
+	// Are the values equal?
+	if m.x == c {
+		return nil
+	}
+
+	return errors.New("")
+}