1 files changed, 0 insertions, 227 deletions
diff --git a/vendor/github.com/smartystreets/assertions/strings.go b/vendor/github.com/smartystreets/assertions/strings.go
deleted file mode 100644
index dbc3f047..00000000
--- a/vendor/github.com/smartystreets/assertions/strings.go
+++ /dev/null
@@ -1,227 +0,0 @@
-package assertions
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-)
-
-// ShouldStartWith receives exactly 2 string parameters and ensures that the first starts with the second.
-func ShouldStartWith(actual interface{}, expected ...interface{}) string {
-	if fail := need(1, expected); fail != success {
-		return fail
-	}
-
-	value, valueIsString := actual.(string)
-	prefix, prefixIsString := expected[0].(string)
-
-	if !valueIsString || !prefixIsString {
-		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
-	}
-
-	return shouldStartWith(value, prefix)
-}
-func shouldStartWith(value, prefix string) string {
-	if !strings.HasPrefix(value, prefix) {
-		shortval := value
-		if len(shortval) > len(prefix) {
-			shortval = shortval[:len(prefix)] + "..."
-		}
-		return serializer.serialize(prefix, shortval, fmt.Sprintf(shouldHaveStartedWith, value, prefix))
-	}
-	return success
-}
-
-// ShouldNotStartWith receives exactly 2 string parameters and ensures that the first does not start with the second.
-func ShouldNotStartWith(actual interface{}, expected ...interface{}) string {
-	if fail := need(1, expected); fail != success {
-		return fail
-	}
-
-	value, valueIsString := actual.(string)
-	prefix, prefixIsString := expected[0].(string)
-
-	if !valueIsString || !prefixIsString {
-		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
-	}
-
-	return shouldNotStartWith(value, prefix)
-}
-func shouldNotStartWith(value, prefix string) string {
-	if strings.HasPrefix(value, prefix) {
-		if value == "" {
-			value = "<empty>"
-		}
-		if prefix == "" {
-			prefix = "<empty>"
-		}
-		return fmt.Sprintf(shouldNotHaveStartedWith, value, prefix)
-	}
-	return success
-}
-
-// ShouldEndWith receives exactly 2 string parameters and ensures that the first ends with the second.
-func ShouldEndWith(actual interface{}, expected ...interface{}) string {
-	if fail := need(1, expected); fail != success {
-		return fail
-	}
-
-	value, valueIsString := actual.(string)
-	suffix, suffixIsString := expected[0].(string)
-
-	if !valueIsString || !suffixIsString {
-		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
-	}
-
-	return shouldEndWith(value, suffix)
-}
-func shouldEndWith(value, suffix string) string {
-	if !strings.HasSuffix(value, suffix) {
-		shortval := value
-		if len(shortval) > len(suffix) {
-			shortval = "..." + shortval[len(shortval)-len(suffix):]
-		}
-		return serializer.serialize(suffix, shortval, fmt.Sprintf(shouldHaveEndedWith, value, suffix))
-	}
-	return success
-}
-
-// ShouldEndWith receives exactly 2 string parameters and ensures that the first does not end with the second.
-func ShouldNotEndWith(actual interface{}, expected ...interface{}) string {
-	if fail := need(1, expected); fail != success {
-		return fail
-	}
-
-	value, valueIsString := actual.(string)
-	suffix, suffixIsString := expected[0].(string)
-
-	if !valueIsString || !suffixIsString {
-		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
-	}
-
-	return shouldNotEndWith(value, suffix)
-}
-func shouldNotEndWith(value, suffix string) string {
-	if strings.HasSuffix(value, suffix) {
-		if value == "" {
-			value = "<empty>"
-		}
-		if suffix == "" {
-			suffix = "<empty>"
-		}
-		return fmt.Sprintf(shouldNotHaveEndedWith, value, suffix)
-	}
-	return success
-}
-
-// ShouldContainSubstring receives exactly 2 string parameters and ensures that the first contains the second as a substring.
-func ShouldContainSubstring(actual interface{}, expected ...interface{}) string {
-	if fail := need(1, expected); fail != success {
-		return fail
-	}
-
-	long, longOk := actual.(string)
-	short, shortOk := expected[0].(string)
-
-	if !longOk || !shortOk {
-		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
-	}
-
-	if !strings.Contains(long, short) {
-		return serializer.serialize(expected[0], actual, fmt.Sprintf(shouldHaveContainedSubstring, long, short))
-	}
-	return success
-}
-
-// ShouldNotContainSubstring receives exactly 2 string parameters and ensures that the first does NOT contain the second as a substring.
-func ShouldNotContainSubstring(actual interface{}, expected ...interface{}) string {
-	if fail := need(1, expected); fail != success {
-		return fail
-	}
-
-	long, longOk := actual.(string)
-	short, shortOk := expected[0].(string)
-
-	if !longOk || !shortOk {
-		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
-	}
-
-	if strings.Contains(long, short) {
-		return fmt.Sprintf(shouldNotHaveContainedSubstring, long, short)
-	}
-	return success
-}
-
-// ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal to "".
-func ShouldBeBlank(actual interface{}, expected ...interface{}) string {
-	if fail := need(0, expected); fail != success {
-		return fail
-	}
-	value, ok := actual.(string)
-	if !ok {
-		return fmt.Sprintf(shouldBeString, reflect.TypeOf(actual))
-	}
-	if value != "" {
-		return serializer.serialize("", value, fmt.Sprintf(shouldHaveBeenBlank, value))
-	}
-	return success
-}
-
-// ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is equal to "".
-func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string {
-	if fail := need(0, expected); fail != success {
-		return fail
-	}
-	value, ok := actual.(string)
-	if !ok {
-		return fmt.Sprintf(shouldBeString, reflect.TypeOf(actual))
-	}
-	if value == "" {
-		return shouldNotHaveBeenBlank
-	}
-	return success
-}
-
-// ShouldEqualWithout receives exactly 3 string parameters and ensures that the first is equal to the second
-// after removing all instances of the third from the first using strings.Replace(first, third, "", -1).
-func ShouldEqualWithout(actual interface{}, expected ...interface{}) string {
-	if fail := need(2, expected); fail != success {
-		return fail
-	}
-	actualString, ok1 := actual.(string)
-	expectedString, ok2 := expected[0].(string)
-	replace, ok3 := expected[1].(string)
-
-	if !ok1 || !ok2 || !ok3 {
-		return fmt.Sprintf(shouldAllBeStrings, []reflect.Type{
-			reflect.TypeOf(actual),
-			reflect.TypeOf(expected[0]),
-			reflect.TypeOf(expected[1]),
-		})
-	}
-
-	replaced := strings.Replace(actualString, replace, "", -1)
-	if replaced == expectedString {
-		return ""
-	}
-
-	return fmt.Sprintf("Expected '%s' to equal '%s' but without any '%s' (but it didn't).", actualString, expectedString, replace)
-}
-
-// ShouldEqualTrimSpace receives exactly 2 string parameters and ensures that the first is equal to the second
-// after removing all leading and trailing whitespace using strings.TrimSpace(first).
-func ShouldEqualTrimSpace(actual interface{}, expected ...interface{}) string {
-	if fail := need(1, expected); fail != success {
-		return fail
-	}
-
-	actualString, valueIsString := actual.(string)
-	_, value2IsString := expected[0].(string)
-
-	if !valueIsString || !value2IsString {
-		return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0]))
-	}
-
-	actualString = strings.TrimSpace(actualString)
-	return ShouldEqual(actualString, expected[0])
-}