func ShouldBeEmpty(actual interface{}, expected ...interface{}) string {
	if fail := need(0, expected); fail != success {
		return fail
	}
	if actual == nil {
		return success
	}
	value := reflect.ValueOf(actual)
	switch value.Kind() {
	case reflect.Slice:
		if value.Len() == 0 {
			return success
		}
	case reflect.Chan:
		if value.Len() == 0 {
			return success
		}
	case reflect.Map:
		if value.Len() == 0 {
			return success
		}
	case reflect.String:
		if value.Len() == 0 {
			return success
		}
	case reflect.Ptr:
		elem := value.Elem()
		kind := elem.Kind()
		if (kind == reflect.Slice || kind == reflect.Array) && elem.Len() == 0 {
			return success
		}
	}
	return fmt.Sprintf(shouldHaveBeenEmpty, actual)
}
ShouldBeEmpty receives a single parameter (actual) and determines whether or not
calling len(actual) would return `0`. It obeys the rules specified by the len
function for determining length: http://golang.org/pkg/builtin/#len
package assertions
import (
	"fmt"
	"reflect"
	"github.com/smartystreets/assertions/internal/oglematchers"
)
func ShouldContain(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	}
	if matchError := oglematchers.Contains(expected[0]).Matches(actual); matchError != nil {
		typeName := reflect.TypeOf(actual)
		if fmt.Sprintf("%v", matchError) == "which is not a slice or array" {
			return fmt.Sprintf(shouldHaveBeenAValidCollection, typeName)
		}
		return fmt.Sprintf(shouldHaveContained, typeName, expected[0])
	}
	return success
}
func ShouldNotContain(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	}
	typeName := reflect.TypeOf(actual)
	if matchError := oglematchers.Contains(expected[0]).Matches(actual); matchError != nil {
		if fmt.Sprintf("%v", matchError) == "which is not a slice or array" {
			return fmt.Sprintf(shouldHaveBeenAValidCollection, typeName)
		}
		return success
	}
	return fmt.Sprintf(shouldNotHaveContained, typeName, expected[0])
}
func ShouldContainKey(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	}
	keys, isMap := mapKeys(actual)
	if !isMap {
		return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual))
	}
	if !keyFound(keys, expected[0]) {
		return fmt.Sprintf(shouldHaveContainedKey, reflect.TypeOf(actual), expected)
	}
	return ""
}
func ShouldNotContainKey(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	}
	keys, isMap := mapKeys(actual)
	if !isMap {
		return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual))
	}
	if keyFound(keys, expected[0]) {
		return fmt.Sprintf(shouldNotHaveContainedKey, reflect.TypeOf(actual), expected)
	}
	return ""
}
func mapKeys(m interface{}) ([]reflect.Value, bool) {
	value := reflect.ValueOf(m)
	if value.Kind() != reflect.Map {
		return nil, false
	}
	return value.MapKeys(), true
}
func keyFound(keys []reflect.Value, expectedKey interface{}) bool {
	found := false
	for _, key := range keys {
		if key.Interface() == expectedKey {
			found = true
		}
	}
	return found
}
func ShouldBeIn(actual interface{}, expected ...interface{}) string {
	if fail := atLeast(1, expected); fail != success {
		return fail
	}
	if len(expected) == 1 {
		return shouldBeIn(actual, expected[0])
	}
	return shouldBeIn(actual, expected)
}
func shouldBeIn(actual interface{}, expected interface{}) string {
	if matchError := oglematchers.Contains(actual).Matches(expected); matchError != nil {
		return fmt.Sprintf(shouldHaveBeenIn, actual, reflect.TypeOf(expected))
	}
	return success
}
func ShouldNotBeIn(actual interface{}, expected ...interface{}) string {
	if fail := atLeast(1, expected); fail != success {
		return fail
	}
	if len(expected) == 1 {
		return shouldNotBeIn(actual, expected[0])
	}
	return shouldNotBeIn(actual, expected)
}
func shouldNotBeIn(actual interface{}, expected interface{}) string {
	if matchError := oglematchers.Contains(actual).Matches(expected); matchError == nil {
		return fmt.Sprintf(shouldNotHaveBeenIn, actual, reflect.TypeOf(expected))
	}
	return success
}