aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/gotest.tools/v3/internal/assert/assert.go
diff options
context:
space:
mode:
authorEugene Triguba <eugenetriguba@gmail.com>2024-01-06 16:23:02 -0500
committerEugene Triguba <eugenetriguba@gmail.com>2024-01-06 16:23:02 -0500
commit263ce3e4b368a50efee1a53af11a76a12af0a119 (patch)
tree8917754f3b43830604f6ad4c7115934ed633f1d8 /vendor/gotest.tools/v3/internal/assert/assert.go
parentFix syntax (diff)
downloadcli-263ce3e4b368a50efee1a53af11a76a12af0a119.zip
Break up migration repo into fs and db with a service
Diffstat (limited to 'vendor/gotest.tools/v3/internal/assert/assert.go')
-rw-r--r--vendor/gotest.tools/v3/internal/assert/assert.go161
1 files changed, 161 insertions, 0 deletions
diff --git a/vendor/gotest.tools/v3/internal/assert/assert.go b/vendor/gotest.tools/v3/internal/assert/assert.go
new file mode 100644
index 0000000..2dd8025
--- /dev/null
+++ b/vendor/gotest.tools/v3/internal/assert/assert.go
@@ -0,0 +1,161 @@
+// Package assert provides internal utilties for assertions.
+package assert
+
+import (
+ "fmt"
+ "go/ast"
+ "go/token"
+ "reflect"
+
+ "gotest.tools/v3/assert/cmp"
+ "gotest.tools/v3/internal/format"
+ "gotest.tools/v3/internal/source"
+)
+
+// LogT is the subset of testing.T used by the assert package.
+type LogT interface {
+ Log(args ...interface{})
+}
+
+type helperT interface {
+ Helper()
+}
+
+const failureMessage = "assertion failed: "
+
+// Eval the comparison and print a failure messages if the comparison has failed.
+func Eval(
+ t LogT,
+ argSelector argSelector,
+ comparison interface{},
+ msgAndArgs ...interface{},
+) bool {
+ if ht, ok := t.(helperT); ok {
+ ht.Helper()
+ }
+ var success bool
+ switch check := comparison.(type) {
+ case bool:
+ if check {
+ return true
+ }
+ logFailureFromBool(t, msgAndArgs...)
+
+ // Undocumented legacy comparison without Result type
+ case func() (success bool, message string):
+ success = runCompareFunc(t, check, msgAndArgs...)
+
+ case nil:
+ return true
+
+ case error:
+ msg := failureMsgFromError(check)
+ t.Log(format.WithCustomMessage(failureMessage+msg, msgAndArgs...))
+
+ case cmp.Comparison:
+ success = RunComparison(t, argSelector, check, msgAndArgs...)
+
+ case func() cmp.Result:
+ success = RunComparison(t, argSelector, check, msgAndArgs...)
+
+ default:
+ t.Log(fmt.Sprintf("invalid Comparison: %v (%T)", check, check))
+ }
+ return success
+}
+
+func runCompareFunc(
+ t LogT,
+ f func() (success bool, message string),
+ msgAndArgs ...interface{},
+) bool {
+ if ht, ok := t.(helperT); ok {
+ ht.Helper()
+ }
+ if success, message := f(); !success {
+ t.Log(format.WithCustomMessage(failureMessage+message, msgAndArgs...))
+ return false
+ }
+ return true
+}
+
+func logFailureFromBool(t LogT, msgAndArgs ...interface{}) {
+ if ht, ok := t.(helperT); ok {
+ ht.Helper()
+ }
+ const stackIndex = 3 // Assert()/Check(), assert(), logFailureFromBool()
+ args, err := source.CallExprArgs(stackIndex)
+ if err != nil {
+ t.Log(err.Error())
+ return
+ }
+
+ const comparisonArgIndex = 1 // Assert(t, comparison)
+ if len(args) <= comparisonArgIndex {
+ t.Log(failureMessage + "but assert failed to find the expression to print")
+ return
+ }
+
+ msg, err := boolFailureMessage(args[comparisonArgIndex])
+ if err != nil {
+ t.Log(err.Error())
+ msg = "expression is false"
+ }
+
+ t.Log(format.WithCustomMessage(failureMessage+msg, msgAndArgs...))
+}
+
+func failureMsgFromError(err error) string {
+ // Handle errors with non-nil types
+ v := reflect.ValueOf(err)
+ if v.Kind() == reflect.Ptr && v.IsNil() {
+ return fmt.Sprintf("error is not nil: error has type %T", err)
+ }
+ return "error is not nil: " + err.Error()
+}
+
+func boolFailureMessage(expr ast.Expr) (string, error) {
+ if binaryExpr, ok := expr.(*ast.BinaryExpr); ok {
+ x, err := source.FormatNode(binaryExpr.X)
+ if err != nil {
+ return "", err
+ }
+ y, err := source.FormatNode(binaryExpr.Y)
+ if err != nil {
+ return "", err
+ }
+
+ switch binaryExpr.Op {
+ case token.NEQ:
+ return x + " is " + y, nil
+ case token.EQL:
+ return x + " is not " + y, nil
+ case token.GTR:
+ return x + " is <= " + y, nil
+ case token.LSS:
+ return x + " is >= " + y, nil
+ case token.GEQ:
+ return x + " is less than " + y, nil
+ case token.LEQ:
+ return x + " is greater than " + y, nil
+ }
+ }
+
+ if unaryExpr, ok := expr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.NOT {
+ x, err := source.FormatNode(unaryExpr.X)
+ if err != nil {
+ return "", err
+ }
+ return x + " is true", nil
+ }
+
+ if ident, ok := expr.(*ast.Ident); ok {
+ return ident.Name + " is false", nil
+ }
+
+ formatted, err := source.FormatNode(expr)
+ if err != nil {
+ return "", err
+ }
+ return "expression is false: " + formatted, nil
+}