mirror of
https://github.com/beego/bee.git
synced 2024-12-23 11:40:48 +00:00
142 lines
4.8 KiB
Go
142 lines
4.8 KiB
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(shouldHaveBeenLess, 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
|
|
}
|