gitea/vendor/github.com/smartystreets/assertions/quantity.go

package assertions

import (
	"fmt"

	"github.com/smartystreets/assertions/internal/oglematchers"
)

// ShouldBeGreaterThan receives exactly two parameters and ensures that the first is greater than the second.
func ShouldBeGreaterThan(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	}

	if matchError := oglematchers.GreaterThan(expected[0]).Matches(actual); matchError != nil {
		return fmt.Sprintf(shouldHaveBeenGreater, actual, expected[0])
	}
	return success
}

// ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that the first is greater than or equal to the second.
func ShouldBeGreaterThanOrEqualTo(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	} else if matchError := oglematchers.GreaterOrEqual(expected[0]).Matches(actual); matchError != nil {
		return fmt.Sprintf(shouldHaveBeenGreaterOrEqual, actual, expected[0])
	}
	return success
}

// ShouldBeLessThan receives exactly two parameters and ensures that the first is less than the second.
func ShouldBeLessThan(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	} else if matchError := oglematchers.LessThan(expected[0]).Matches(actual); matchError != nil {
		return fmt.Sprintf(shouldHaveBeenLess, actual, expected[0])
	}
	return success
}

// ShouldBeLessThan receives exactly two parameters and ensures that the first is less than or equal to the second.
func ShouldBeLessThanOrEqualTo(actual interface{}, expected ...interface{}) string {
	if fail := need(1, expected); fail != success {
		return fail
	} else if matchError := oglematchers.LessOrEqual(expected[0]).Matches(actual); matchError != nil {
		return fmt.Sprintf(shouldHaveBeenLessOrEqual, actual, expected[0])
	}
	return success
}

// ShouldBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound.
// It ensures that the actual value is between both bounds (but not equal to either of them).
func ShouldBeBetween(actual interface{}, expected ...interface{}) string {
	if fail := need(2, expected); fail != success {
		return fail
	}
	lower, upper, fail := deriveBounds(expected)

	if fail != success {
		return fail
	} else if !isBetween(actual, lower, upper) {
		return fmt.Sprintf(shouldHaveBeenBetween, actual, lower, upper)
	}
	return success
}

// ShouldNotBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound.
// It ensures that the actual value is NOT between both bounds.
func ShouldNotBeBetween(actual interface{}, expected ...interface{}) string {
	if fail := need(2, expected); fail != success {
		return fail
	}
	lower, upper, fail := deriveBounds(expected)

	if fail != success {
		return fail
	} else if isBetween(actual, lower, upper) {
		return fmt.Sprintf(shouldNotHaveBeenBetween, actual, lower, upper)
	}
	return success
}
func deriveBounds(values []interface{}) (lower interface{}, upper interface{}, fail string) {
	lower = values[0]
	upper = values[1]

	if ShouldNotEqual(lower, upper) != success {
		return nil, nil, fmt.Sprintf(shouldHaveDifferentUpperAndLower, lower)
	} else if ShouldBeLessThan(lower, upper) != success {
		lower, upper = upper, lower
	}
	return lower, upper, success
}
func isBetween(value, lower, upper interface{}) bool {
	if ShouldBeGreaterThan(value, lower) != success {
		return false
	} else if ShouldBeLessThan(value, upper) != success {
		return false
	}
	return true
}

// ShouldBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound.
// It ensures that the actual value is between both bounds or equal to one of them.
func ShouldBeBetweenOrEqual(actual interface{}, expected ...interface{}) string {
	if fail := need(2, expected); fail != success {
		return fail
	}
	lower, upper, fail := deriveBounds(expected)

	if fail != success {
		return fail
	} else if !isBetweenOrEqual(actual, lower, upper) {
		return fmt.Sprintf(shouldHaveBeenBetweenOrEqual, actual, lower, upper)
	}
	return success
}

// ShouldNotBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound.
// It ensures that the actual value is nopt between the bounds nor equal to either of them.
func ShouldNotBeBetweenOrEqual(actual interface{}, expected ...interface{}) string {
	if fail := need(2, expected); fail != success {
		return fail
	}
	lower, upper, fail := deriveBounds(expected)

	if fail != success {
		return fail
	} else if isBetweenOrEqual(actual, lower, upper) {
		return fmt.Sprintf(shouldNotHaveBeenBetweenOrEqual, actual, lower, upper)
	}
	return success
}

func isBetweenOrEqual(value, lower, upper interface{}) bool {
	if ShouldBeGreaterThanOrEqualTo(value, lower) != success {
		return false
	} else if ShouldBeLessThanOrEqualTo(value, upper) != success {
		return false
	}
	return true
}