diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs
index 3bc381313..f16e59e3e 100755
--- a/.github/scripts/coverage.mjs
+++ b/.github/scripts/coverage.mjs
@@ -6,9 +6,7 @@ const exclude = [
'checker/mock', // Mocks only used for testing.
'vm/func_types', // Generated files.
'vm/runtime/helpers', // Generated files.
- 'internal/difflib', // Test dependency. This is vendored dependency, and ideally we also have good tests for it.
'internal/spew', // Test dependency.
- 'internal/testify', // Test dependency.
'patcher/value', // Contains a lot of repeating code. Ideally we should have a test for it.
'pro', // Expr Pro is not a part of the main codebase.
]
diff --git a/ast/find_test.go b/ast/find_test.go
index e4894c48f..74f3d999b 100644
--- a/ast/find_test.go
+++ b/ast/find_test.go
@@ -3,7 +3,7 @@ package ast_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/ast"
)
diff --git a/ast/print_test.go b/ast/print_test.go
index bcdad782c..b55184813 100644
--- a/ast/print_test.go
+++ b/ast/print_test.go
@@ -3,8 +3,8 @@ package ast_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/ast"
"github.com/expr-lang/expr/parser"
diff --git a/ast/visitor_test.go b/ast/visitor_test.go
index 4fd8d825c..3e45b3f42 100644
--- a/ast/visitor_test.go
+++ b/ast/visitor_test.go
@@ -3,7 +3,7 @@ package ast_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
+ "github.com/stretchr/testify/assert"
"github.com/expr-lang/expr/ast"
)
diff --git a/bench_test.go b/bench_test.go
index 99fd4aabf..d239b1a3d 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -3,7 +3,7 @@ package expr_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/vm"
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
index 0d0dec357..3969ca625 100644
--- a/builtin/builtin_test.go
+++ b/builtin/builtin_test.go
@@ -7,8 +7,8 @@ import (
"testing"
"time"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/builtin"
diff --git a/checker/checker_test.go b/checker/checker_test.go
index 7a581612a..332b2fed3 100644
--- a/checker/checker_test.go
+++ b/checker/checker_test.go
@@ -8,8 +8,8 @@ import (
"strings"
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/types"
"github.com/expr-lang/expr"
diff --git a/checker/info_test.go b/checker/info_test.go
index d10476b52..6b0a042c2 100644
--- a/checker/info_test.go
+++ b/checker/info_test.go
@@ -5,7 +5,7 @@ import (
"testing"
"time"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/checker"
"github.com/expr-lang/expr/test/mock"
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
index 6efce686f..ffe65304d 100644
--- a/compiler/compiler_test.go
+++ b/compiler/compiler_test.go
@@ -5,8 +5,8 @@ import (
"reflect"
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/test/mock"
diff --git a/docgen/docgen_test.go b/docgen/docgen_test.go
index 2532a0c76..8219a4108 100644
--- a/docgen/docgen_test.go
+++ b/docgen/docgen_test.go
@@ -5,8 +5,8 @@ import (
"testing"
"time"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
. "github.com/expr-lang/expr/docgen"
)
diff --git a/expr_test.go b/expr_test.go
index 4a34f0c45..196c13e89 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -12,8 +12,8 @@ import (
"time"
"github.com/expr-lang/expr/conf"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/types"
"github.com/expr-lang/expr/vm"
diff --git a/go.mod b/go.mod
index 348e7cfd6..e088ccf98 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,7 @@
module github.com/expr-lang/expr
go 1.18
+
+require github.com/stretchr/testify v1.12.1
+
+require go.yaml.in/yaml/v3 v3.0.5 // indirect
diff --git a/go.sum b/go.sum
new file mode 100644
index 000000000..c2336837e
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,4 @@
+github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
+github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
+go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
+go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
diff --git a/internal/deref/deref_test.go b/internal/deref/deref_test.go
index d7896b33b..87a4f8252 100644
--- a/internal/deref/deref_test.go
+++ b/internal/deref/deref_test.go
@@ -4,7 +4,7 @@ import (
"reflect"
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
+ "github.com/stretchr/testify/assert"
"github.com/expr-lang/expr/internal/deref"
)
diff --git a/internal/difflib/difflib.go b/internal/difflib/difflib.go
deleted file mode 100644
index 2a73737af..000000000
--- a/internal/difflib/difflib.go
+++ /dev/null
@@ -1,775 +0,0 @@
-// Package difflib is a partial port of Python difflib module.
-//
-// It provides tools to compare sequences of strings and generate textual diffs.
-//
-// The following class and functions have been ported:
-//
-// - SequenceMatcher
-//
-// - unified_diff
-//
-// - context_diff
-//
-// Getting unified diffs was the main goal of the port. Keep in mind this code
-// is mostly suitable to output text differences in a human friendly way, there
-// are no guarantees generated diffs are consumable by patch(1).
-package difflib
-
-import (
- "bufio"
- "bytes"
- "fmt"
- "io"
- "strings"
-)
-
-func min(a, b int) int {
- if a < b {
- return a
- }
- return b
-}
-
-func max(a, b int) int {
- if a > b {
- return a
- }
- return b
-}
-
-func calculateRatio(matches, length int) float64 {
- if length > 0 {
- return 2.0 * float64(matches) / float64(length)
- }
- return 1.0
-}
-
-type Match struct {
- A int
- B int
- Size int
-}
-
-type OpCode struct {
- Tag byte
- I1 int
- I2 int
- J1 int
- J2 int
-}
-
-// SequenceMatcher compares sequence of strings. The basic
-// algorithm predates, and is a little fancier than, an algorithm
-// published in the late 1980's by Ratcliff and Obershelp under the
-// hyperbolic name "gestalt pattern matching". The basic idea is to find
-// the longest contiguous matching subsequence that contains no "junk"
-// elements (R-O doesn't address junk). The same idea is then applied
-// recursively to the pieces of the sequences to the left and to the right
-// of the matching subsequence. This does not yield minimal edit
-// sequences, but does tend to yield matches that "look right" to people.
-//
-// SequenceMatcher tries to compute a "human-friendly diff" between two
-// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the
-// longest *contiguous* & junk-free matching subsequence. That's what
-// catches peoples' eyes. The Windows(tm) windiff has another interesting
-// notion, pairing up elements that appear uniquely in each sequence.
-// That, and the method here, appear to yield more intuitive difference
-// reports than does diff. This method appears to be the least vulnerable
-// to synching up on blocks of "junk lines", though (like blank lines in
-// ordinary text files, or maybe "
" lines in HTML files). That may be
-// because this is the only method of the 3 that has a *concept* of
-// "junk" .
-//
-// Timing: Basic R-O is cubic time worst case and quadratic time expected
-// case. SequenceMatcher is quadratic time for the worst case and has
-// expected-case behavior dependent in a complicated way on how many
-// elements the sequences have in common; best case time is linear.
-type SequenceMatcher struct {
- a []string
- b []string
- b2j map[string][]int
- IsJunk func(string) bool
- autoJunk bool
- bJunk map[string]struct{}
- matchingBlocks []Match
- fullBCount map[string]int
- bPopular map[string]struct{}
- opCodes []OpCode
-}
-
-func NewMatcher(a, b []string) *SequenceMatcher {
- m := SequenceMatcher{autoJunk: true}
- m.SetSeqs(a, b)
- return &m
-}
-
-func NewMatcherWithJunk(a, b []string, autoJunk bool,
- isJunk func(string) bool) *SequenceMatcher {
-
- m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
- m.SetSeqs(a, b)
- return &m
-}
-
-// Set two sequences to be compared.
-func (m *SequenceMatcher) SetSeqs(a, b []string) {
- m.SetSeq1(a)
- m.SetSeq2(b)
-}
-
-// Set the first sequence to be compared. The second sequence to be compared is
-// not changed.
-//
-// SequenceMatcher computes and caches detailed information about the second
-// sequence, so if you want to compare one sequence S against many sequences,
-// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
-// sequences.
-//
-// See also SetSeqs() and SetSeq2().
-func (m *SequenceMatcher) SetSeq1(a []string) {
- if &a == &m.a {
- return
- }
- m.a = a
- m.matchingBlocks = nil
- m.opCodes = nil
-}
-
-// Set the second sequence to be compared. The first sequence to be compared is
-// not changed.
-func (m *SequenceMatcher) SetSeq2(b []string) {
- if &b == &m.b {
- return
- }
- m.b = b
- m.matchingBlocks = nil
- m.opCodes = nil
- m.fullBCount = nil
- m.chainB()
-}
-
-func (m *SequenceMatcher) chainB() {
- // Populate line -> index mapping
- b2j := map[string][]int{}
- for i, s := range m.b {
- indices := b2j[s]
- indices = append(indices, i)
- b2j[s] = indices
- }
-
- // Purge junk elements
- m.bJunk = map[string]struct{}{}
- if m.IsJunk != nil {
- junk := m.bJunk
- for s, _ := range b2j {
- if m.IsJunk(s) {
- junk[s] = struct{}{}
- }
- }
- for s, _ := range junk {
- delete(b2j, s)
- }
- }
-
- // Purge remaining popular elements
- popular := map[string]struct{}{}
- n := len(m.b)
- if m.autoJunk && n >= 200 {
- ntest := n/100 + 1
- for s, indices := range b2j {
- if len(indices) > ntest {
- popular[s] = struct{}{}
- }
- }
- for s, _ := range popular {
- delete(b2j, s)
- }
- }
- m.bPopular = popular
- m.b2j = b2j
-}
-
-func (m *SequenceMatcher) isBJunk(s string) bool {
- _, ok := m.bJunk[s]
- return ok
-}
-
-// Find longest matching block in a[alo:ahi] and b[blo:bhi].
-//
-// If IsJunk is not defined:
-//
-// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
-//
-// alo <= i <= i+k <= ahi
-// blo <= j <= j+k <= bhi
-//
-// and for all (i',j',k') meeting those conditions,
-//
-// k >= k'
-// i <= i'
-// and if i == i', j <= j'
-//
-// In other words, of all maximal matching blocks, return one that
-// starts earliest in a, and of all those maximal matching blocks that
-// start earliest in a, return the one that starts earliest in b.
-//
-// If IsJunk is defined, first the longest matching block is
-// determined as above, but with the additional restriction that no
-// junk element appears in the block. Then that block is extended as
-// far as possible by matching (only) junk elements on both sides. So
-// the resulting block never matches on junk except as identical junk
-// happens to be adjacent to an "interesting" match.
-//
-// If no blocks match, return (alo, blo, 0).
-func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
- // CAUTION: stripping common prefix or suffix would be incorrect.
- // E.g.,
- // ab
- // acab
- // Longest matching block is "ab", but if common prefix is
- // stripped, it's "a" (tied with "b"). UNIX(tm) diff does so
- // strip, so ends up claiming that ab is changed to acab by
- // inserting "ca" in the middle. That's minimal but unintuitive:
- // "it's obvious" that someone inserted "ac" at the front.
- // Windiff ends up at the same place as diff, but by pairing up
- // the unique 'b's and then matching the first two 'a's.
- besti, bestj, bestsize := alo, blo, 0
-
- // find longest junk-free match
- // during an iteration of the loop, j2len[j] = length of longest
- // junk-free match ending with a[i-1] and b[j]
- j2len := map[int]int{}
- for i := alo; i != ahi; i++ {
- // look at all instances of a[i] in b; note that because
- // b2j has no junk keys, the loop is skipped if a[i] is junk
- newj2len := map[int]int{}
- for _, j := range m.b2j[m.a[i]] {
- // a[i] matches b[j]
- if j < blo {
- continue
- }
- if j >= bhi {
- break
- }
- k := j2len[j-1] + 1
- newj2len[j] = k
- if k > bestsize {
- besti, bestj, bestsize = i-k+1, j-k+1, k
- }
- }
- j2len = newj2len
- }
-
- // Extend the best by non-junk elements on each end. In particular,
- // "popular" non-junk elements aren't in b2j, which greatly speeds
- // the inner loop above, but also means "the best" match so far
- // doesn't contain any junk *or* popular non-junk elements.
- for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
- m.a[besti-1] == m.b[bestj-1] {
- besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
- }
- for besti+bestsize < ahi && bestj+bestsize < bhi &&
- !m.isBJunk(m.b[bestj+bestsize]) &&
- m.a[besti+bestsize] == m.b[bestj+bestsize] {
- bestsize += 1
- }
-
- // Now that we have a wholly interesting match (albeit possibly
- // empty!), we may as well suck up the matching junk on each
- // side of it too. Can't think of a good reason not to, and it
- // saves post-processing the (possibly considerable) expense of
- // figuring out what to do with it. In the case of an empty
- // interesting match, this is clearly the right thing to do,
- // because no other kind of match is possible in the regions.
- for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
- m.a[besti-1] == m.b[bestj-1] {
- besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
- }
- for besti+bestsize < ahi && bestj+bestsize < bhi &&
- m.isBJunk(m.b[bestj+bestsize]) &&
- m.a[besti+bestsize] == m.b[bestj+bestsize] {
- bestsize += 1
- }
-
- return Match{A: besti, B: bestj, Size: bestsize}
-}
-
-// Return list of triples describing matching subsequences.
-//
-// Each triple is of the form (i, j, n), and means that
-// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in
-// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
-// adjacent triples in the list, and the second is not the last triple in the
-// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
-// adjacent equal blocks.
-//
-// The last triple is a dummy, (len(a), len(b), 0), and is the only
-// triple with n==0.
-func (m *SequenceMatcher) GetMatchingBlocks() []Match {
- if m.matchingBlocks != nil {
- return m.matchingBlocks
- }
-
- var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
- matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
- match := m.findLongestMatch(alo, ahi, blo, bhi)
- i, j, k := match.A, match.B, match.Size
- if match.Size > 0 {
- if alo < i && blo < j {
- matched = matchBlocks(alo, i, blo, j, matched)
- }
- matched = append(matched, match)
- if i+k < ahi && j+k < bhi {
- matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
- }
- }
- return matched
- }
- matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
-
- // It's possible that we have adjacent equal blocks in the
- // matching_blocks list now.
- nonAdjacent := []Match{}
- i1, j1, k1 := 0, 0, 0
- for _, b := range matched {
- // Is this block adjacent to i1, j1, k1?
- i2, j2, k2 := b.A, b.B, b.Size
- if i1+k1 == i2 && j1+k1 == j2 {
- // Yes, so collapse them -- this just increases the length of
- // the first block by the length of the second, and the first
- // block so lengthened remains the block to compare against.
- k1 += k2
- } else {
- // Not adjacent. Remember the first block (k1==0 means it's
- // the dummy we started with), and make the second block the
- // new block to compare against.
- if k1 > 0 {
- nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
- }
- i1, j1, k1 = i2, j2, k2
- }
- }
- if k1 > 0 {
- nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
- }
-
- nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
- m.matchingBlocks = nonAdjacent
- return m.matchingBlocks
-}
-
-// Return list of 5-tuples describing how to turn a into b.
-//
-// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple
-// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
-// tuple preceding it, and likewise for j1 == the previous j2.
-//
-// The tags are characters, with these meanings:
-//
-// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2]
-//
-// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case.
-//
-// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
-//
-// 'e' (equal): a[i1:i2] == b[j1:j2]
-func (m *SequenceMatcher) GetOpCodes() []OpCode {
- if m.opCodes != nil {
- return m.opCodes
- }
- i, j := 0, 0
- matching := m.GetMatchingBlocks()
- opCodes := make([]OpCode, 0, len(matching))
- for _, m := range matching {
- // invariant: we've pumped out correct diffs to change
- // a[:i] into b[:j], and the next matching block is
- // a[ai:ai+size] == b[bj:bj+size]. So we need to pump
- // out a diff to change a[i:ai] into b[j:bj], pump out
- // the matching block, and move (i,j) beyond the match
- ai, bj, size := m.A, m.B, m.Size
- tag := byte(0)
- if i < ai && j < bj {
- tag = 'r'
- } else if i < ai {
- tag = 'd'
- } else if j < bj {
- tag = 'i'
- }
- if tag > 0 {
- opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
- }
- i, j = ai+size, bj+size
- // the list of matching blocks is terminated by a
- // sentinel with size 0
- if size > 0 {
- opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
- }
- }
- m.opCodes = opCodes
- return m.opCodes
-}
-
-// Isolate change clusters by eliminating ranges with no changes.
-//
-// Return a generator of groups with up to n lines of context.
-// Each group is in the same format as returned by GetOpCodes().
-func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
- if n < 0 {
- n = 3
- }
- codes := m.GetOpCodes()
- if len(codes) == 0 {
- codes = []OpCode{OpCode{'e', 0, 1, 0, 1}}
- }
- // Fixup leading and trailing groups if they show no changes.
- if codes[0].Tag == 'e' {
- c := codes[0]
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
- }
- if codes[len(codes)-1].Tag == 'e' {
- c := codes[len(codes)-1]
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
- }
- nn := n + n
- groups := [][]OpCode{}
- group := []OpCode{}
- for _, c := range codes {
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- // End the current group and start a new one whenever
- // there is a large range with no changes.
- if c.Tag == 'e' && i2-i1 > nn {
- group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
- j1, min(j2, j1+n)})
- groups = append(groups, group)
- group = []OpCode{}
- i1, j1 = max(i1, i2-n), max(j1, j2-n)
- }
- group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
- }
- if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
- groups = append(groups, group)
- }
- return groups
-}
-
-// Return a measure of the sequences' similarity (float in [0,1]).
-//
-// Where T is the total number of elements in both sequences, and
-// M is the number of matches, this is 2.0*M / T.
-// Note that this is 1 if the sequences are identical, and 0 if
-// they have nothing in common.
-//
-// .Ratio() is expensive to compute if you haven't already computed
-// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
-// want to try .QuickRatio() or .RealQuickRation() first to get an
-// upper bound.
-func (m *SequenceMatcher) Ratio() float64 {
- matches := 0
- for _, m := range m.GetMatchingBlocks() {
- matches += m.Size
- }
- return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() relatively quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute.
-func (m *SequenceMatcher) QuickRatio() float64 {
- // viewing a and b as multisets, set matches to the cardinality
- // of their intersection; this counts the number of matches
- // without regard to order, so is clearly an upper bound
- if m.fullBCount == nil {
- m.fullBCount = map[string]int{}
- for _, s := range m.b {
- m.fullBCount[s] = m.fullBCount[s] + 1
- }
- }
-
- // avail[x] is the number of times x appears in 'b' less the
- // number of times we've seen it in 'a' so far ... kinda
- avail := map[string]int{}
- matches := 0
- for _, s := range m.a {
- n, ok := avail[s]
- if !ok {
- n = m.fullBCount[s]
- }
- avail[s] = n - 1
- if n > 0 {
- matches += 1
- }
- }
- return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() very quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute than either .Ratio() or .QuickRatio().
-func (m *SequenceMatcher) RealQuickRatio() float64 {
- la, lb := len(m.a), len(m.b)
- return calculateRatio(min(la, lb), la+lb)
-}
-
-// Convert range to the "ed" format
-func formatRangeUnified(start, stop int) string {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- beginning := start + 1 // lines start numbering with one
- length := stop - start
- if length == 1 {
- return fmt.Sprintf("%d", beginning)
- }
- if length == 0 {
- beginning -= 1 // empty ranges begin at line just before the range
- }
- return fmt.Sprintf("%d,%d", beginning, length)
-}
-
-// Unified diff parameters
-type UnifiedDiff struct {
- A []string // First sequence lines
- FromFile string // First file name
- FromDate string // First file time
- B []string // Second sequence lines
- ToFile string // Second file name
- ToDate string // Second file time
- Eol string // Headers end of line, defaults to LF
- Context int // Number of context lines
-}
-
-// Compare two sequences of lines; generate the delta as a unified diff.
-//
-// Unified diffs are a compact way of showing line changes and a few
-// lines of context. The number of context lines is set by 'n' which
-// defaults to three.
-//
-// By default, the diff control lines (those with ---, +++, or @@) are
-// created with a trailing newline. This is helpful so that inputs
-// created from file.readlines() result in diffs that are suitable for
-// file.writelines() since both the inputs and outputs have trailing
-// newlines.
-//
-// For inputs that do not have trailing newlines, set the lineterm
-// argument to "" so that the output will be uniformly newline free.
-//
-// The unidiff format normally has a header for filenames and modification
-// times. Any or all of these may be specified using strings for
-// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
-// The modification times are normally expressed in the ISO 8601 format.
-func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
- buf := bufio.NewWriter(writer)
- defer buf.Flush()
- wf := func(format string, args ...interface{}) error {
- _, err := buf.WriteString(fmt.Sprintf(format, args...))
- return err
- }
- ws := func(s string) error {
- _, err := buf.WriteString(s)
- return err
- }
-
- if len(diff.Eol) == 0 {
- diff.Eol = "\n"
- }
-
- started := false
- m := NewMatcher(diff.A, diff.B)
- for _, g := range m.GetGroupedOpCodes(diff.Context) {
- if !started {
- started = true
- fromDate := ""
- if len(diff.FromDate) > 0 {
- fromDate = "\t" + diff.FromDate
- }
- toDate := ""
- if len(diff.ToDate) > 0 {
- toDate = "\t" + diff.ToDate
- }
- if diff.FromFile != "" || diff.ToFile != "" {
- err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
- if err != nil {
- return err
- }
- err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
- if err != nil {
- return err
- }
- }
- }
- first, last := g[0], g[len(g)-1]
- range1 := formatRangeUnified(first.I1, last.I2)
- range2 := formatRangeUnified(first.J1, last.J2)
- if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
- return err
- }
- for _, c := range g {
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- if c.Tag == 'e' {
- for _, line := range diff.A[i1:i2] {
- if err := ws(" " + line); err != nil {
- return err
- }
- }
- continue
- }
- if c.Tag == 'r' || c.Tag == 'd' {
- for _, line := range diff.A[i1:i2] {
- if err := ws("-" + line); err != nil {
- return err
- }
- }
- }
- if c.Tag == 'r' || c.Tag == 'i' {
- for _, line := range diff.B[j1:j2] {
- if err := ws("+" + line); err != nil {
- return err
- }
- }
- }
- }
- }
- return nil
-}
-
-// Like WriteUnifiedDiff but returns the diff a string.
-func GetUnifiedDiffString(diff UnifiedDiff) (string, error) {
- w := &bytes.Buffer{}
- err := WriteUnifiedDiff(w, diff)
- return string(w.Bytes()), err
-}
-
-// Convert range to the "ed" format.
-func formatRangeContext(start, stop int) string {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- beginning := start + 1 // lines start numbering with one
- length := stop - start
- if length == 0 {
- beginning -= 1 // empty ranges begin at line just before the range
- }
- if length <= 1 {
- return fmt.Sprintf("%d", beginning)
- }
- return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
-}
-
-type ContextDiff UnifiedDiff
-
-// Compare two sequences of lines; generate the delta as a context diff.
-//
-// Context diffs are a compact way of showing line changes and a few
-// lines of context. The number of context lines is set by diff.Context
-// which defaults to three.
-//
-// By default, the diff control lines (those with *** or ---) are
-// created with a trailing newline.
-//
-// For inputs that do not have trailing newlines, set the diff.Eol
-// argument to "" so that the output will be uniformly newline free.
-//
-// The context diff format normally has a header for filenames and
-// modification times. Any or all of these may be specified using
-// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
-// The modification times are normally expressed in the ISO 8601 format.
-// If not specified, the strings default to blanks.
-func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
- buf := bufio.NewWriter(writer)
- defer buf.Flush()
- var diffErr error
- wf := func(format string, args ...interface{}) {
- _, err := buf.WriteString(fmt.Sprintf(format, args...))
- if diffErr == nil && err != nil {
- diffErr = err
- }
- }
- ws := func(s string) {
- _, err := buf.WriteString(s)
- if diffErr == nil && err != nil {
- diffErr = err
- }
- }
-
- if len(diff.Eol) == 0 {
- diff.Eol = "\n"
- }
-
- prefix := map[byte]string{
- 'i': "+ ",
- 'd': "- ",
- 'r': "! ",
- 'e': " ",
- }
-
- started := false
- m := NewMatcher(diff.A, diff.B)
- for _, g := range m.GetGroupedOpCodes(diff.Context) {
- if !started {
- started = true
- fromDate := ""
- if len(diff.FromDate) > 0 {
- fromDate = "\t" + diff.FromDate
- }
- toDate := ""
- if len(diff.ToDate) > 0 {
- toDate = "\t" + diff.ToDate
- }
- if diff.FromFile != "" || diff.ToFile != "" {
- wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
- wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
- }
- }
-
- first, last := g[0], g[len(g)-1]
- ws("***************" + diff.Eol)
-
- range1 := formatRangeContext(first.I1, last.I2)
- wf("*** %s ****%s", range1, diff.Eol)
- for _, c := range g {
- if c.Tag == 'r' || c.Tag == 'd' {
- for _, cc := range g {
- if cc.Tag == 'i' {
- continue
- }
- for _, line := range diff.A[cc.I1:cc.I2] {
- ws(prefix[cc.Tag] + line)
- }
- }
- break
- }
- }
-
- range2 := formatRangeContext(first.J1, last.J2)
- wf("--- %s ----%s", range2, diff.Eol)
- for _, c := range g {
- if c.Tag == 'r' || c.Tag == 'i' {
- for _, cc := range g {
- if cc.Tag == 'd' {
- continue
- }
- for _, line := range diff.B[cc.J1:cc.J2] {
- ws(prefix[cc.Tag] + line)
- }
- }
- break
- }
- }
- }
- return diffErr
-}
-
-// Like WriteContextDiff but returns the diff a string.
-func GetContextDiffString(diff ContextDiff) (string, error) {
- w := &bytes.Buffer{}
- err := WriteContextDiff(w, diff)
- return string(w.Bytes()), err
-}
-
-// Split a string on "\n" while preserving them. The output can be used
-// as input for UnifiedDiff and ContextDiff structures.
-func SplitLines(s string) []string {
- lines := strings.SplitAfter(s, "\n")
- lines[len(lines)-1] += "\n"
- return lines
-}
diff --git a/internal/difflib/difflib_test.go b/internal/difflib/difflib_test.go
deleted file mode 100644
index 60fb1f9cb..000000000
--- a/internal/difflib/difflib_test.go
+++ /dev/null
@@ -1,426 +0,0 @@
-package difflib
-
-import (
- "bytes"
- "fmt"
- "math"
- "reflect"
- "strings"
- "testing"
-)
-
-func assertAlmostEqual(t *testing.T, a, b float64, places int) {
- if math.Abs(a-b) > math.Pow10(-places) {
- t.Errorf("%.7f != %.7f", a, b)
- }
-}
-
-func assertEqual(t *testing.T, a, b interface{}) {
- if !reflect.DeepEqual(a, b) {
- t.Errorf("%v != %v", a, b)
- }
-}
-
-func splitChars(s string) []string {
- chars := make([]string, 0, len(s))
- // Assume ASCII inputs
- for i := 0; i != len(s); i++ {
- chars = append(chars, string(s[i]))
- }
- return chars
-}
-
-func TestSequenceMatcherRatio(t *testing.T) {
- s := NewMatcher(splitChars("abcd"), splitChars("bcde"))
- assertEqual(t, s.Ratio(), 0.75)
- assertEqual(t, s.QuickRatio(), 0.75)
- assertEqual(t, s.RealQuickRatio(), 1.0)
-}
-
-func TestGetOptCodes(t *testing.T) {
- a := "qabxcd"
- b := "abycdf"
- s := NewMatcher(splitChars(a), splitChars(b))
- w := &bytes.Buffer{}
- for _, op := range s.GetOpCodes() {
- fmt.Fprintf(w, "%s a[%d:%d], (%s) b[%d:%d] (%s)\n", string(op.Tag),
- op.I1, op.I2, a[op.I1:op.I2], op.J1, op.J2, b[op.J1:op.J2])
- }
- result := string(w.Bytes())
- expected := `d a[0:1], (q) b[0:0] ()
-e a[1:3], (ab) b[0:2] (ab)
-r a[3:4], (x) b[2:3] (y)
-e a[4:6], (cd) b[3:5] (cd)
-i a[6:6], () b[5:6] (f)
-`
- if expected != result {
- t.Errorf("unexpected op codes: \n%s", result)
- }
-}
-
-func TestGroupedOpCodes(t *testing.T) {
- a := []string{}
- for i := 0; i != 39; i++ {
- a = append(a, fmt.Sprintf("%02d", i))
- }
- b := []string{}
- b = append(b, a[:8]...)
- b = append(b, " i")
- b = append(b, a[8:19]...)
- b = append(b, " x")
- b = append(b, a[20:22]...)
- b = append(b, a[27:34]...)
- b = append(b, " y")
- b = append(b, a[35:]...)
- s := NewMatcher(a, b)
- w := &bytes.Buffer{}
- for _, g := range s.GetGroupedOpCodes(-1) {
- fmt.Fprintf(w, "group\n")
- for _, op := range g {
- fmt.Fprintf(w, " %s, %d, %d, %d, %d\n", string(op.Tag),
- op.I1, op.I2, op.J1, op.J2)
- }
- }
- result := string(w.Bytes())
- expected := `group
- e, 5, 8, 5, 8
- i, 8, 8, 8, 9
- e, 8, 11, 9, 12
-group
- e, 16, 19, 17, 20
- r, 19, 20, 20, 21
- e, 20, 22, 21, 23
- d, 22, 27, 23, 23
- e, 27, 30, 23, 26
-group
- e, 31, 34, 27, 30
- r, 34, 35, 30, 31
- e, 35, 38, 31, 34
-`
- if expected != result {
- t.Errorf("unexpected op codes: \n%s", result)
- }
-}
-
-func ExampleGetUnifiedDiffString() {
- a := `one
-two
-three
-four
-fmt.Printf("%s,%T",a,b)`
- b := `zero
-one
-three
-four`
- diff := UnifiedDiff{
- A: SplitLines(a),
- B: SplitLines(b),
- FromFile: "Original",
- FromDate: "2005-01-26 23:30:50",
- ToFile: "Current",
- ToDate: "2010-04-02 10:20:52",
- Context: 3,
- }
- result, _ := GetUnifiedDiffString(diff)
- fmt.Println(strings.Replace(result, "\t", " ", -1))
- // Output:
- // --- Original 2005-01-26 23:30:50
- // +++ Current 2010-04-02 10:20:52
- // @@ -1,5 +1,4 @@
- // +zero
- // one
- // -two
- // three
- // four
- // -fmt.Printf("%s,%T",a,b)
-}
-
-func ExampleGetContextDiffString() {
- a := `one
-two
-three
-four
-fmt.Printf("%s,%T",a,b)`
- b := `zero
-one
-tree
-four`
- diff := ContextDiff{
- A: SplitLines(a),
- B: SplitLines(b),
- FromFile: "Original",
- ToFile: "Current",
- Context: 3,
- Eol: "\n",
- }
- result, _ := GetContextDiffString(diff)
- fmt.Print(strings.Replace(result, "\t", " ", -1))
- // Output:
- // *** Original
- // --- Current
- // ***************
- // *** 1,5 ****
- // one
- // ! two
- // ! three
- // four
- // - fmt.Printf("%s,%T",a,b)
- // --- 1,4 ----
- // + zero
- // one
- // ! tree
- // four
-}
-
-func ExampleGetContextDiffString_second() {
- a := `one
-two
-three
-four`
- b := `zero
-one
-tree
-four`
- diff := ContextDiff{
- A: SplitLines(a),
- B: SplitLines(b),
- FromFile: "Original",
- ToFile: "Current",
- Context: 3,
- Eol: "\n",
- }
- result, _ := GetContextDiffString(diff)
- fmt.Printf(strings.Replace(result, "\t", " ", -1))
- // Output:
- // *** Original
- // --- Current
- // ***************
- // *** 1,4 ****
- // one
- // ! two
- // ! three
- // four
- // --- 1,4 ----
- // + zero
- // one
- // ! tree
- // four
-}
-
-func rep(s string, count int) string {
- return strings.Repeat(s, count)
-}
-
-func TestWithAsciiOneInsert(t *testing.T) {
- sm := NewMatcher(splitChars(rep("b", 100)),
- splitChars("a"+rep("b", 100)))
- assertAlmostEqual(t, sm.Ratio(), 0.995, 3)
- assertEqual(t, sm.GetOpCodes(),
- []OpCode{{'i', 0, 0, 0, 1}, {'e', 0, 100, 1, 101}})
- assertEqual(t, len(sm.bPopular), 0)
-
- sm = NewMatcher(splitChars(rep("b", 100)),
- splitChars(rep("b", 50)+"a"+rep("b", 50)))
- assertAlmostEqual(t, sm.Ratio(), 0.995, 3)
- assertEqual(t, sm.GetOpCodes(),
- []OpCode{{'e', 0, 50, 0, 50}, {'i', 50, 50, 50, 51}, {'e', 50, 100, 51, 101}})
- assertEqual(t, len(sm.bPopular), 0)
-}
-
-func TestWithAsciiOnDelete(t *testing.T) {
- sm := NewMatcher(splitChars(rep("a", 40)+"c"+rep("b", 40)),
- splitChars(rep("a", 40)+rep("b", 40)))
- assertAlmostEqual(t, sm.Ratio(), 0.994, 3)
- assertEqual(t, sm.GetOpCodes(),
- []OpCode{{'e', 0, 40, 0, 40}, {'d', 40, 41, 40, 40}, {'e', 41, 81, 40, 80}})
-}
-
-func TestWithAsciiBJunk(t *testing.T) {
- isJunk := func(s string) bool {
- return s == " "
- }
- sm := NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
- splitChars(rep("a", 44)+rep("b", 40)), true, isJunk)
- assertEqual(t, sm.bJunk, map[string]struct{}{})
-
- sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
- splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk)
- assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}})
-
- isJunk = func(s string) bool {
- return s == " " || s == "b"
- }
- sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
- splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk)
- assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}, "b": struct{}{}})
-}
-
-func TestSFBugsRatioForNullSeqn(t *testing.T) {
- sm := NewMatcher(nil, nil)
- assertEqual(t, sm.Ratio(), 1.0)
- assertEqual(t, sm.QuickRatio(), 1.0)
- assertEqual(t, sm.RealQuickRatio(), 1.0)
-}
-
-func TestSFBugsComparingEmptyLists(t *testing.T) {
- groups := NewMatcher(nil, nil).GetGroupedOpCodes(-1)
- assertEqual(t, len(groups), 0)
- diff := UnifiedDiff{
- FromFile: "Original",
- ToFile: "Current",
- Context: 3,
- }
- result, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, result, "")
-}
-
-func TestOutputFormatRangeFormatUnified(t *testing.T) {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- //
- // Each field shall be of the form:
- // %1d", if the range contains exactly one line,
- // and:
- // "%1d,%1d", , otherwise.
- // If a range is empty, its beginning line number shall be the number of
- // the line just before the range, or 0 if the empty range starts the file.
- fm := formatRangeUnified
- assertEqual(t, fm(3, 3), "3,0")
- assertEqual(t, fm(3, 4), "4")
- assertEqual(t, fm(3, 5), "4,2")
- assertEqual(t, fm(3, 6), "4,3")
- assertEqual(t, fm(0, 0), "0,0")
-}
-
-func TestOutputFormatRangeFormatContext(t *testing.T) {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- //
- // The range of lines in file1 shall be written in the following format
- // if the range contains two or more lines:
- // "*** %d,%d ****\n", ,
- // and the following format otherwise:
- // "*** %d ****\n",
- // The ending line number of an empty range shall be the number of the preceding line,
- // or 0 if the range is at the start of the file.
- //
- // Next, the range of lines in file2 shall be written in the following format
- // if the range contains two or more lines:
- // "--- %d,%d ----\n", ,
- // and the following format otherwise:
- // "--- %d ----\n",
- fm := formatRangeContext
- assertEqual(t, fm(3, 3), "3")
- assertEqual(t, fm(3, 4), "4")
- assertEqual(t, fm(3, 5), "4,5")
- assertEqual(t, fm(3, 6), "4,6")
- assertEqual(t, fm(0, 0), "0")
-}
-
-func TestOutputFormatTabDelimiter(t *testing.T) {
- diff := UnifiedDiff{
- A: splitChars("one"),
- B: splitChars("two"),
- FromFile: "Original",
- FromDate: "2005-01-26 23:30:50",
- ToFile: "Current",
- ToDate: "2010-04-12 10:20:52",
- Eol: "\n",
- }
- ud, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(ud)[:2], []string{
- "--- Original\t2005-01-26 23:30:50\n",
- "+++ Current\t2010-04-12 10:20:52\n",
- })
- cd, err := GetContextDiffString(ContextDiff(diff))
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(cd)[:2], []string{
- "*** Original\t2005-01-26 23:30:50\n",
- "--- Current\t2010-04-12 10:20:52\n",
- })
-}
-
-func TestOutputFormatNoTrailingTabOnEmptyFiledate(t *testing.T) {
- diff := UnifiedDiff{
- A: splitChars("one"),
- B: splitChars("two"),
- FromFile: "Original",
- ToFile: "Current",
- Eol: "\n",
- }
- ud, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(ud)[:2], []string{"--- Original\n", "+++ Current\n"})
-
- cd, err := GetContextDiffString(ContextDiff(diff))
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(cd)[:2], []string{"*** Original\n", "--- Current\n"})
-}
-
-func TestOmitFilenames(t *testing.T) {
- diff := UnifiedDiff{
- A: SplitLines("o\nn\ne\n"),
- B: SplitLines("t\nw\no\n"),
- Eol: "\n",
- }
- ud, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(ud), []string{
- "@@ -0,0 +1,2 @@\n",
- "+t\n",
- "+w\n",
- "@@ -2,2 +3,0 @@\n",
- "-n\n",
- "-e\n",
- "\n",
- })
-
- cd, err := GetContextDiffString(ContextDiff(diff))
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(cd), []string{
- "***************\n",
- "*** 0 ****\n",
- "--- 1,2 ----\n",
- "+ t\n",
- "+ w\n",
- "***************\n",
- "*** 2,3 ****\n",
- "- n\n",
- "- e\n",
- "--- 3 ----\n",
- "\n",
- })
-}
-
-func TestSplitLines(t *testing.T) {
- allTests := []struct {
- input string
- want []string
- }{
- {"foo", []string{"foo\n"}},
- {"foo\nbar", []string{"foo\n", "bar\n"}},
- {"foo\nbar\n", []string{"foo\n", "bar\n", "\n"}},
- }
- for _, test := range allTests {
- assertEqual(t, SplitLines(test.input), test.want)
- }
-}
-
-func benchmarkSplitLines(b *testing.B, count int) {
- str := strings.Repeat("foo\n", count)
-
- b.ResetTimer()
-
- n := 0
- for i := 0; i < b.N; i++ {
- n += len(SplitLines(str))
- }
-}
-
-func BenchmarkSplitLines100(b *testing.B) {
- benchmarkSplitLines(b, 100)
-}
-
-func BenchmarkSplitLines10000(b *testing.B) {
- benchmarkSplitLines(b, 10000)
-}
diff --git a/internal/testify/assert/assertion_compare.go b/internal/testify/assert/assertion_compare.go
deleted file mode 100644
index 7e19eba09..000000000
--- a/internal/testify/assert/assertion_compare.go
+++ /dev/null
@@ -1,489 +0,0 @@
-package assert
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "time"
-)
-
-// Deprecated: CompareType has only ever been for internal use and has accidentally been published since v1.6.0. Do not use it.
-type CompareType = compareResult
-
-type compareResult int
-
-const (
- compareLess compareResult = iota - 1
- compareEqual
- compareGreater
-)
-
-var (
- intType = reflect.TypeOf(int(1))
- int8Type = reflect.TypeOf(int8(1))
- int16Type = reflect.TypeOf(int16(1))
- int32Type = reflect.TypeOf(int32(1))
- int64Type = reflect.TypeOf(int64(1))
-
- uintType = reflect.TypeOf(uint(1))
- uint8Type = reflect.TypeOf(uint8(1))
- uint16Type = reflect.TypeOf(uint16(1))
- uint32Type = reflect.TypeOf(uint32(1))
- uint64Type = reflect.TypeOf(uint64(1))
-
- uintptrType = reflect.TypeOf(uintptr(1))
-
- float32Type = reflect.TypeOf(float32(1))
- float64Type = reflect.TypeOf(float64(1))
-
- stringType = reflect.TypeOf("")
-
- timeType = reflect.TypeOf(time.Time{})
- bytesType = reflect.TypeOf([]byte{})
-)
-
-func compare(obj1, obj2 interface{}, kind reflect.Kind) (compareResult, bool) {
- obj1Value := reflect.ValueOf(obj1)
- obj2Value := reflect.ValueOf(obj2)
-
- // throughout this switch we try and avoid calling .Convert() if possible,
- // as this has a pretty big performance impact
- switch kind {
- case reflect.Int:
- {
- intobj1, ok := obj1.(int)
- if !ok {
- intobj1 = obj1Value.Convert(intType).Interface().(int)
- }
- intobj2, ok := obj2.(int)
- if !ok {
- intobj2 = obj2Value.Convert(intType).Interface().(int)
- }
- if intobj1 > intobj2 {
- return compareGreater, true
- }
- if intobj1 == intobj2 {
- return compareEqual, true
- }
- if intobj1 < intobj2 {
- return compareLess, true
- }
- }
- case reflect.Int8:
- {
- int8obj1, ok := obj1.(int8)
- if !ok {
- int8obj1 = obj1Value.Convert(int8Type).Interface().(int8)
- }
- int8obj2, ok := obj2.(int8)
- if !ok {
- int8obj2 = obj2Value.Convert(int8Type).Interface().(int8)
- }
- if int8obj1 > int8obj2 {
- return compareGreater, true
- }
- if int8obj1 == int8obj2 {
- return compareEqual, true
- }
- if int8obj1 < int8obj2 {
- return compareLess, true
- }
- }
- case reflect.Int16:
- {
- int16obj1, ok := obj1.(int16)
- if !ok {
- int16obj1 = obj1Value.Convert(int16Type).Interface().(int16)
- }
- int16obj2, ok := obj2.(int16)
- if !ok {
- int16obj2 = obj2Value.Convert(int16Type).Interface().(int16)
- }
- if int16obj1 > int16obj2 {
- return compareGreater, true
- }
- if int16obj1 == int16obj2 {
- return compareEqual, true
- }
- if int16obj1 < int16obj2 {
- return compareLess, true
- }
- }
- case reflect.Int32:
- {
- int32obj1, ok := obj1.(int32)
- if !ok {
- int32obj1 = obj1Value.Convert(int32Type).Interface().(int32)
- }
- int32obj2, ok := obj2.(int32)
- if !ok {
- int32obj2 = obj2Value.Convert(int32Type).Interface().(int32)
- }
- if int32obj1 > int32obj2 {
- return compareGreater, true
- }
- if int32obj1 == int32obj2 {
- return compareEqual, true
- }
- if int32obj1 < int32obj2 {
- return compareLess, true
- }
- }
- case reflect.Int64:
- {
- int64obj1, ok := obj1.(int64)
- if !ok {
- int64obj1 = obj1Value.Convert(int64Type).Interface().(int64)
- }
- int64obj2, ok := obj2.(int64)
- if !ok {
- int64obj2 = obj2Value.Convert(int64Type).Interface().(int64)
- }
- if int64obj1 > int64obj2 {
- return compareGreater, true
- }
- if int64obj1 == int64obj2 {
- return compareEqual, true
- }
- if int64obj1 < int64obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint:
- {
- uintobj1, ok := obj1.(uint)
- if !ok {
- uintobj1 = obj1Value.Convert(uintType).Interface().(uint)
- }
- uintobj2, ok := obj2.(uint)
- if !ok {
- uintobj2 = obj2Value.Convert(uintType).Interface().(uint)
- }
- if uintobj1 > uintobj2 {
- return compareGreater, true
- }
- if uintobj1 == uintobj2 {
- return compareEqual, true
- }
- if uintobj1 < uintobj2 {
- return compareLess, true
- }
- }
- case reflect.Uint8:
- {
- uint8obj1, ok := obj1.(uint8)
- if !ok {
- uint8obj1 = obj1Value.Convert(uint8Type).Interface().(uint8)
- }
- uint8obj2, ok := obj2.(uint8)
- if !ok {
- uint8obj2 = obj2Value.Convert(uint8Type).Interface().(uint8)
- }
- if uint8obj1 > uint8obj2 {
- return compareGreater, true
- }
- if uint8obj1 == uint8obj2 {
- return compareEqual, true
- }
- if uint8obj1 < uint8obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint16:
- {
- uint16obj1, ok := obj1.(uint16)
- if !ok {
- uint16obj1 = obj1Value.Convert(uint16Type).Interface().(uint16)
- }
- uint16obj2, ok := obj2.(uint16)
- if !ok {
- uint16obj2 = obj2Value.Convert(uint16Type).Interface().(uint16)
- }
- if uint16obj1 > uint16obj2 {
- return compareGreater, true
- }
- if uint16obj1 == uint16obj2 {
- return compareEqual, true
- }
- if uint16obj1 < uint16obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint32:
- {
- uint32obj1, ok := obj1.(uint32)
- if !ok {
- uint32obj1 = obj1Value.Convert(uint32Type).Interface().(uint32)
- }
- uint32obj2, ok := obj2.(uint32)
- if !ok {
- uint32obj2 = obj2Value.Convert(uint32Type).Interface().(uint32)
- }
- if uint32obj1 > uint32obj2 {
- return compareGreater, true
- }
- if uint32obj1 == uint32obj2 {
- return compareEqual, true
- }
- if uint32obj1 < uint32obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint64:
- {
- uint64obj1, ok := obj1.(uint64)
- if !ok {
- uint64obj1 = obj1Value.Convert(uint64Type).Interface().(uint64)
- }
- uint64obj2, ok := obj2.(uint64)
- if !ok {
- uint64obj2 = obj2Value.Convert(uint64Type).Interface().(uint64)
- }
- if uint64obj1 > uint64obj2 {
- return compareGreater, true
- }
- if uint64obj1 == uint64obj2 {
- return compareEqual, true
- }
- if uint64obj1 < uint64obj2 {
- return compareLess, true
- }
- }
- case reflect.Float32:
- {
- float32obj1, ok := obj1.(float32)
- if !ok {
- float32obj1 = obj1Value.Convert(float32Type).Interface().(float32)
- }
- float32obj2, ok := obj2.(float32)
- if !ok {
- float32obj2 = obj2Value.Convert(float32Type).Interface().(float32)
- }
- if float32obj1 > float32obj2 {
- return compareGreater, true
- }
- if float32obj1 == float32obj2 {
- return compareEqual, true
- }
- if float32obj1 < float32obj2 {
- return compareLess, true
- }
- }
- case reflect.Float64:
- {
- float64obj1, ok := obj1.(float64)
- if !ok {
- float64obj1 = obj1Value.Convert(float64Type).Interface().(float64)
- }
- float64obj2, ok := obj2.(float64)
- if !ok {
- float64obj2 = obj2Value.Convert(float64Type).Interface().(float64)
- }
- if float64obj1 > float64obj2 {
- return compareGreater, true
- }
- if float64obj1 == float64obj2 {
- return compareEqual, true
- }
- if float64obj1 < float64obj2 {
- return compareLess, true
- }
- }
- case reflect.String:
- {
- stringobj1, ok := obj1.(string)
- if !ok {
- stringobj1 = obj1Value.Convert(stringType).Interface().(string)
- }
- stringobj2, ok := obj2.(string)
- if !ok {
- stringobj2 = obj2Value.Convert(stringType).Interface().(string)
- }
- if stringobj1 > stringobj2 {
- return compareGreater, true
- }
- if stringobj1 == stringobj2 {
- return compareEqual, true
- }
- if stringobj1 < stringobj2 {
- return compareLess, true
- }
- }
- // Check for known struct types we can check for compare results.
- case reflect.Struct:
- {
- // All structs enter here. We're not interested in most types.
- if !obj1Value.CanConvert(timeType) {
- break
- }
-
- // time.Time can be compared!
- timeObj1, ok := obj1.(time.Time)
- if !ok {
- timeObj1 = obj1Value.Convert(timeType).Interface().(time.Time)
- }
-
- timeObj2, ok := obj2.(time.Time)
- if !ok {
- timeObj2 = obj2Value.Convert(timeType).Interface().(time.Time)
- }
-
- if timeObj1.Before(timeObj2) {
- return compareLess, true
- }
- if timeObj1.Equal(timeObj2) {
- return compareEqual, true
- }
- return compareGreater, true
- }
- case reflect.Slice:
- {
- // We only care about the []byte type.
- if !obj1Value.CanConvert(bytesType) {
- break
- }
-
- // []byte can be compared!
- bytesObj1, ok := obj1.([]byte)
- if !ok {
- bytesObj1 = obj1Value.Convert(bytesType).Interface().([]byte)
-
- }
- bytesObj2, ok := obj2.([]byte)
- if !ok {
- bytesObj2 = obj2Value.Convert(bytesType).Interface().([]byte)
- }
-
- return compareResult(bytes.Compare(bytesObj1, bytesObj2)), true
- }
- case reflect.Uintptr:
- {
- uintptrObj1, ok := obj1.(uintptr)
- if !ok {
- uintptrObj1 = obj1Value.Convert(uintptrType).Interface().(uintptr)
- }
- uintptrObj2, ok := obj2.(uintptr)
- if !ok {
- uintptrObj2 = obj2Value.Convert(uintptrType).Interface().(uintptr)
- }
- if uintptrObj1 > uintptrObj2 {
- return compareGreater, true
- }
- if uintptrObj1 == uintptrObj2 {
- return compareEqual, true
- }
- if uintptrObj1 < uintptrObj2 {
- return compareLess, true
- }
- }
- }
-
- return compareEqual, false
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// assert.Greater(t, 2, 1)
-// assert.Greater(t, float64(2), float64(1))
-// assert.Greater(t, "b", "a")
-func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []compareResult{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqual(t, 2, 1)
-// assert.GreaterOrEqual(t, 2, 2)
-// assert.GreaterOrEqual(t, "b", "a")
-// assert.GreaterOrEqual(t, "b", "b")
-func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []compareResult{compareGreater, compareEqual}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
-}
-
-// Less asserts that the first element is less than the second
-//
-// assert.Less(t, 1, 2)
-// assert.Less(t, float64(1), float64(2))
-// assert.Less(t, "a", "b")
-func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []compareResult{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqual(t, 1, 2)
-// assert.LessOrEqual(t, 2, 2)
-// assert.LessOrEqual(t, "a", "b")
-// assert.LessOrEqual(t, "b", "b")
-func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []compareResult{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
-}
-
-// Positive asserts that the specified element is positive
-//
-// assert.Positive(t, 1)
-// assert.Positive(t, 1.23)
-func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- zero := reflect.Zero(reflect.TypeOf(e))
- return compareTwoValues(t, e, zero.Interface(), []compareResult{compareGreater}, "\"%v\" is not positive", msgAndArgs...)
-}
-
-// Negative asserts that the specified element is negative
-//
-// assert.Negative(t, -1)
-// assert.Negative(t, -1.23)
-func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- zero := reflect.Zero(reflect.TypeOf(e))
- return compareTwoValues(t, e, zero.Interface(), []compareResult{compareLess}, "\"%v\" is not negative", msgAndArgs...)
-}
-
-func compareTwoValues(t TestingT, e1 interface{}, e2 interface{}, allowedComparesResults []compareResult, failMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- e1Kind := reflect.ValueOf(e1).Kind()
- e2Kind := reflect.ValueOf(e2).Kind()
- if e1Kind != e2Kind {
- return Fail(t, "Elements should be the same type", msgAndArgs...)
- }
-
- compareResult, isComparable := compare(e1, e2, e1Kind)
- if !isComparable {
- return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
- }
-
- if !containsValue(allowedComparesResults, compareResult) {
- return Fail(t, fmt.Sprintf(failMessage, e1, e2), msgAndArgs...)
- }
-
- return true
-}
-
-func containsValue(values []compareResult, value compareResult) bool {
- for _, v := range values {
- if v == value {
- return true
- }
- }
-
- return false
-}
diff --git a/internal/testify/assert/assertion_compare_test.go b/internal/testify/assert/assertion_compare_test.go
deleted file mode 100644
index bac3d7463..000000000
--- a/internal/testify/assert/assertion_compare_test.go
+++ /dev/null
@@ -1,472 +0,0 @@
-package assert
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "runtime"
- "testing"
- "time"
-)
-
-func TestCompare(t *testing.T) {
- type customString string
- type customInt int
- type customInt8 int8
- type customInt16 int16
- type customInt32 int32
- type customInt64 int64
- type customUInt uint
- type customUInt8 uint8
- type customUInt16 uint16
- type customUInt32 uint32
- type customUInt64 uint64
- type customFloat32 float32
- type customFloat64 float64
- type customUintptr uintptr
- type customTime time.Time
- type customBytes []byte
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- cType string
- }{
- {less: customString("a"), greater: customString("b"), cType: "string"},
- {less: "a", greater: "b", cType: "string"},
- {less: customInt(1), greater: customInt(2), cType: "int"},
- {less: int(1), greater: int(2), cType: "int"},
- {less: customInt8(1), greater: customInt8(2), cType: "int8"},
- {less: int8(1), greater: int8(2), cType: "int8"},
- {less: customInt16(1), greater: customInt16(2), cType: "int16"},
- {less: int16(1), greater: int16(2), cType: "int16"},
- {less: customInt32(1), greater: customInt32(2), cType: "int32"},
- {less: int32(1), greater: int32(2), cType: "int32"},
- {less: customInt64(1), greater: customInt64(2), cType: "int64"},
- {less: int64(1), greater: int64(2), cType: "int64"},
- {less: customUInt(1), greater: customUInt(2), cType: "uint"},
- {less: uint8(1), greater: uint8(2), cType: "uint8"},
- {less: customUInt8(1), greater: customUInt8(2), cType: "uint8"},
- {less: uint16(1), greater: uint16(2), cType: "uint16"},
- {less: customUInt16(1), greater: customUInt16(2), cType: "uint16"},
- {less: uint32(1), greater: uint32(2), cType: "uint32"},
- {less: customUInt32(1), greater: customUInt32(2), cType: "uint32"},
- {less: uint64(1), greater: uint64(2), cType: "uint64"},
- {less: customUInt64(1), greater: customUInt64(2), cType: "uint64"},
- {less: float32(1.23), greater: float32(2.34), cType: "float32"},
- {less: customFloat32(1.23), greater: customFloat32(2.23), cType: "float32"},
- {less: float64(1.23), greater: float64(2.34), cType: "float64"},
- {less: customFloat64(1.23), greater: customFloat64(2.34), cType: "float64"},
- {less: uintptr(1), greater: uintptr(2), cType: "uintptr"},
- {less: customUintptr(1), greater: customUintptr(2), cType: "uint64"},
- {less: time.Now(), greater: time.Now().Add(time.Hour), cType: "time.Time"},
- {less: time.Date(2024, 0, 0, 0, 0, 0, 0, time.Local), greater: time.Date(2263, 0, 0, 0, 0, 0, 0, time.Local), cType: "time.Time"},
- {less: customTime(time.Now()), greater: customTime(time.Now().Add(time.Hour)), cType: "time.Time"},
- {less: []byte{1, 1}, greater: []byte{1, 2}, cType: "[]byte"},
- {less: customBytes([]byte{1, 1}), greater: customBytes([]byte{1, 2}), cType: "[]byte"},
- } {
- resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object should be comparable for type " + currCase.cType)
- }
-
- if resLess != compareLess {
- t.Errorf("object less (%v) should be less than greater (%v) for type "+currCase.cType,
- currCase.less, currCase.greater)
- }
-
- resGreater, isComparable := compare(currCase.greater, currCase.less, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object are comparable for type " + currCase.cType)
- }
-
- if resGreater != compareGreater {
- t.Errorf("object greater should be greater than less for type " + currCase.cType)
- }
-
- resEqual, isComparable := compare(currCase.less, currCase.less, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object are comparable for type " + currCase.cType)
- }
-
- if resEqual != 0 {
- t.Errorf("objects should be equal for type " + currCase.cType)
- }
- }
-}
-
-type outputT struct {
- buf *bytes.Buffer
- helpers map[string]struct{}
-}
-
-// Implements TestingT
-func (t *outputT) Errorf(format string, args ...interface{}) {
- s := fmt.Sprintf(format, args...)
- t.buf.WriteString(s)
-}
-
-func (t *outputT) Helper() {
- if t.helpers == nil {
- t.helpers = make(map[string]struct{})
- }
- t.helpers[callerName(1)] = struct{}{}
-}
-
-// callerName gives the function name (qualified with a package path)
-// for the caller after skip frames (where 0 means the current function).
-func callerName(skip int) string {
- // Make room for the skip PC.
- var pc [1]uintptr
- n := runtime.Callers(skip+2, pc[:]) // skip + runtime.Callers + callerName
- if n == 0 {
- panic("testing: zero callers found")
- }
- frames := runtime.CallersFrames(pc[:n])
- frame, _ := frames.Next()
- return frame.Function
-}
-
-func TestGreater(t *testing.T) {
- mockT := new(testing.T)
-
- if !Greater(mockT, 2, 1) {
- t.Error("Greater should return true")
- }
-
- if Greater(mockT, 1, 1) {
- t.Error("Greater should return false")
- }
-
- if Greater(mockT, 1, 2) {
- t.Error("Greater should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"a" is not greater than "b"`},
- {less: int(1), greater: int(2), msg: `"1" is not greater than "2"`},
- {less: int8(1), greater: int8(2), msg: `"1" is not greater than "2"`},
- {less: int16(1), greater: int16(2), msg: `"1" is not greater than "2"`},
- {less: int32(1), greater: int32(2), msg: `"1" is not greater than "2"`},
- {less: int64(1), greater: int64(2), msg: `"1" is not greater than "2"`},
- {less: uint8(1), greater: uint8(2), msg: `"1" is not greater than "2"`},
- {less: uint16(1), greater: uint16(2), msg: `"1" is not greater than "2"`},
- {less: uint32(1), greater: uint32(2), msg: `"1" is not greater than "2"`},
- {less: uint64(1), greater: uint64(2), msg: `"1" is not greater than "2"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than "2.34"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than "2.34"`},
- {less: uintptr(1), greater: uintptr(2), msg: `"1" is not greater than "2"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than "0001-01-01 01:00:00 +0000 UTC"`},
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than "[1 2]"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Greater(out, currCase.less, currCase.greater))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Greater")
- }
-}
-
-func TestGreaterOrEqual(t *testing.T) {
- mockT := new(testing.T)
-
- if !GreaterOrEqual(mockT, 2, 1) {
- t.Error("GreaterOrEqual should return true")
- }
-
- if !GreaterOrEqual(mockT, 1, 1) {
- t.Error("GreaterOrEqual should return true")
- }
-
- if GreaterOrEqual(mockT, 1, 2) {
- t.Error("GreaterOrEqual should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"a" is not greater than or equal to "b"`},
- {less: int(1), greater: int(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int8(1), greater: int8(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int16(1), greater: int16(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int32(1), greater: int32(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int64(1), greater: int64(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint8(1), greater: uint8(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint16(1), greater: uint16(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint32(1), greater: uint32(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint64(1), greater: uint64(2), msg: `"1" is not greater than or equal to "2"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
- {less: uintptr(1), greater: uintptr(2), msg: `"1" is not greater than or equal to "2"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than or equal to "0001-01-01 01:00:00 +0000 UTC"`},
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than or equal to "[1 2]"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, GreaterOrEqual(out, currCase.less, currCase.greater))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.GreaterOrEqual")
- }
-}
-
-func TestLess(t *testing.T) {
- mockT := new(testing.T)
-
- if !Less(mockT, 1, 2) {
- t.Error("Less should return true")
- }
-
- if Less(mockT, 1, 1) {
- t.Error("Less should return false")
- }
-
- if Less(mockT, 2, 1) {
- t.Error("Less should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"b" is not less than "a"`},
- {less: int(1), greater: int(2), msg: `"2" is not less than "1"`},
- {less: int8(1), greater: int8(2), msg: `"2" is not less than "1"`},
- {less: int16(1), greater: int16(2), msg: `"2" is not less than "1"`},
- {less: int32(1), greater: int32(2), msg: `"2" is not less than "1"`},
- {less: int64(1), greater: int64(2), msg: `"2" is not less than "1"`},
- {less: uint8(1), greater: uint8(2), msg: `"2" is not less than "1"`},
- {less: uint16(1), greater: uint16(2), msg: `"2" is not less than "1"`},
- {less: uint32(1), greater: uint32(2), msg: `"2" is not less than "1"`},
- {less: uint64(1), greater: uint64(2), msg: `"2" is not less than "1"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than "1.23"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than "1.23"`},
- {less: uintptr(1), greater: uintptr(2), msg: `"2" is not less than "1"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than "0001-01-01 00:00:00 +0000 UTC"`},
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than "[1 1]"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Less(out, currCase.greater, currCase.less))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Less")
- }
-}
-
-func TestLessOrEqual(t *testing.T) {
- mockT := new(testing.T)
-
- if !LessOrEqual(mockT, 1, 2) {
- t.Error("LessOrEqual should return true")
- }
-
- if !LessOrEqual(mockT, 1, 1) {
- t.Error("LessOrEqual should return true")
- }
-
- if LessOrEqual(mockT, 2, 1) {
- t.Error("LessOrEqual should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"b" is not less than or equal to "a"`},
- {less: int(1), greater: int(2), msg: `"2" is not less than or equal to "1"`},
- {less: int8(1), greater: int8(2), msg: `"2" is not less than or equal to "1"`},
- {less: int16(1), greater: int16(2), msg: `"2" is not less than or equal to "1"`},
- {less: int32(1), greater: int32(2), msg: `"2" is not less than or equal to "1"`},
- {less: int64(1), greater: int64(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint8(1), greater: uint8(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint16(1), greater: uint16(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint32(1), greater: uint32(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint64(1), greater: uint64(2), msg: `"2" is not less than or equal to "1"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
- {less: uintptr(1), greater: uintptr(2), msg: `"2" is not less than or equal to "1"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than or equal to "0001-01-01 00:00:00 +0000 UTC"`},
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than or equal to "[1 1]"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, LessOrEqual(out, currCase.greater, currCase.less))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.LessOrEqual")
- }
-}
-
-func TestPositive(t *testing.T) {
- mockT := new(testing.T)
-
- if !Positive(mockT, 1) {
- t.Error("Positive should return true")
- }
-
- if !Positive(mockT, 1.23) {
- t.Error("Positive should return true")
- }
-
- if Positive(mockT, -1) {
- t.Error("Positive should return false")
- }
-
- if Positive(mockT, -1.23) {
- t.Error("Positive should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- e interface{}
- msg string
- }{
- {e: int(-1), msg: `"-1" is not positive`},
- {e: int8(-1), msg: `"-1" is not positive`},
- {e: int16(-1), msg: `"-1" is not positive`},
- {e: int32(-1), msg: `"-1" is not positive`},
- {e: int64(-1), msg: `"-1" is not positive`},
- {e: float32(-1.23), msg: `"-1.23" is not positive`},
- {e: float64(-1.23), msg: `"-1.23" is not positive`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Positive(out, currCase.e))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Positive")
- }
-}
-
-func TestNegative(t *testing.T) {
- mockT := new(testing.T)
-
- if !Negative(mockT, -1) {
- t.Error("Negative should return true")
- }
-
- if !Negative(mockT, -1.23) {
- t.Error("Negative should return true")
- }
-
- if Negative(mockT, 1) {
- t.Error("Negative should return false")
- }
-
- if Negative(mockT, 1.23) {
- t.Error("Negative should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- e interface{}
- msg string
- }{
- {e: int(1), msg: `"1" is not negative`},
- {e: int8(1), msg: `"1" is not negative`},
- {e: int16(1), msg: `"1" is not negative`},
- {e: int32(1), msg: `"1" is not negative`},
- {e: int64(1), msg: `"1" is not negative`},
- {e: float32(1.23), msg: `"1.23" is not negative`},
- {e: float64(1.23), msg: `"1.23" is not negative`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Negative(out, currCase.e))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/expr-lang/expr/internal/testify/assert.Negative")
- }
-}
-
-func Test_compareTwoValuesDifferentValuesTypes(t *testing.T) {
- mockT := new(testing.T)
-
- for _, currCase := range []struct {
- v1 interface{}
- v2 interface{}
- compareResult bool
- }{
- {v1: 123, v2: "abc"},
- {v1: "abc", v2: 123456},
- {v1: float64(12), v2: "123"},
- {v1: "float(12)", v2: float64(1)},
- } {
- result := compareTwoValues(mockT, currCase.v1, currCase.v2, []compareResult{compareLess, compareEqual, compareGreater}, "testFailMessage")
- False(t, result)
- }
-}
-
-func Test_compareTwoValuesNotComparableValues(t *testing.T) {
- mockT := new(testing.T)
-
- type CompareStruct struct {
- }
-
- for _, currCase := range []struct {
- v1 interface{}
- v2 interface{}
- }{
- {v1: CompareStruct{}, v2: CompareStruct{}},
- {v1: map[string]int{}, v2: map[string]int{}},
- {v1: make([]int, 5), v2: make([]int, 5)},
- } {
- result := compareTwoValues(mockT, currCase.v1, currCase.v2, []compareResult{compareLess, compareEqual, compareGreater}, "testFailMessage")
- False(t, result)
- }
-}
-
-func Test_compareTwoValuesCorrectCompareResult(t *testing.T) {
- mockT := new(testing.T)
-
- for _, currCase := range []struct {
- v1 interface{}
- v2 interface{}
- allowedResults []compareResult
- }{
- {v1: 1, v2: 2, allowedResults: []compareResult{compareLess}},
- {v1: 1, v2: 2, allowedResults: []compareResult{compareLess, compareEqual}},
- {v1: 2, v2: 2, allowedResults: []compareResult{compareGreater, compareEqual}},
- {v1: 2, v2: 2, allowedResults: []compareResult{compareEqual}},
- {v1: 2, v2: 1, allowedResults: []compareResult{compareEqual, compareGreater}},
- {v1: 2, v2: 1, allowedResults: []compareResult{compareGreater}},
- } {
- result := compareTwoValues(mockT, currCase.v1, currCase.v2, currCase.allowedResults, "testFailMessage")
- True(t, result)
- }
-}
-
-func Test_containsValue(t *testing.T) {
- for _, currCase := range []struct {
- values []compareResult
- value compareResult
- result bool
- }{
- {values: []compareResult{compareGreater}, value: compareGreater, result: true},
- {values: []compareResult{compareGreater, compareLess}, value: compareGreater, result: true},
- {values: []compareResult{compareGreater, compareLess}, value: compareLess, result: true},
- {values: []compareResult{compareGreater, compareLess}, value: compareEqual, result: false},
- } {
- result := containsValue(currCase.values, currCase.value)
- Equal(t, currCase.result, result)
- }
-}
-
-func TestComparingMsgAndArgsForwarding(t *testing.T) {
- msgAndArgs := []interface{}{"format %s %x", "this", 0xc001}
- expectedOutput := "format this c001\n"
- funcs := []func(t TestingT){
- func(t TestingT) { Greater(t, 1, 2, msgAndArgs...) },
- func(t TestingT) { GreaterOrEqual(t, 1, 2, msgAndArgs...) },
- func(t TestingT) { Less(t, 2, 1, msgAndArgs...) },
- func(t TestingT) { LessOrEqual(t, 2, 1, msgAndArgs...) },
- func(t TestingT) { Positive(t, 0, msgAndArgs...) },
- func(t TestingT) { Negative(t, 0, msgAndArgs...) },
- }
- for _, f := range funcs {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- f(out)
- Contains(t, out.buf.String(), expectedOutput)
- }
-}
diff --git a/internal/testify/assert/assertion_format.go b/internal/testify/assert/assertion_format.go
deleted file mode 100644
index dcc01f098..000000000
--- a/internal/testify/assert/assertion_format.go
+++ /dev/null
@@ -1,807 +0,0 @@
-// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
-
-package assert
-
-import (
- http "net/http"
- url "net/url"
- time "time"
-)
-
-// Conditionf uses a Comparison to assert a complex condition.
-func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Condition(t, comp, append([]interface{}{msg}, args...)...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
-func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Contains(t, s, contains, append([]interface{}{msg}, args...)...)
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return DirExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...)
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Emptyf(t, obj, "error message %s", "formatted")
-func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Empty(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-// assert.Equalf(t, 123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Equal(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
-func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...)
-}
-
-// EqualExportedValuesf asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
-// assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
-func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
-func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Errorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Error(t, err, append([]interface{}{msg}, args...)...)
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ErrorAs(t, err, target, append([]interface{}{msg}, args...)...)
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
-func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ErrorContains(t, theError, contains, append([]interface{}{msg}, args...)...)
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
-}
-
-// EventuallyWithTf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func EventuallyWithTf(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return EventuallyWithT(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
-func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Failf reports a failure through
-func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, failureMessage, append([]interface{}{msg}, args...)...)
-}
-
-// FailNowf fails test
-func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-// assert.Falsef(t, myBool, "error message %s", "formatted")
-func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return False(t, value, append([]interface{}{msg}, args...)...)
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return FileExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
-// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
-func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Greater(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
-func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return GreaterOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyNotContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPError(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPRedirect(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPStatusCode(t, handler, method, url, values, statuscode, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPSuccess(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaMapValues(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsDecreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsIncreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsNonDecreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsNonIncreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
-func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Len(t, object, length, append([]interface{}{msg}, args...)...)
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// assert.Lessf(t, 1, 2, "error message %s", "formatted")
-// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
-// assert.Lessf(t, "a", "b", "error message %s", "formatted")
-func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Less(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
-func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return LessOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// Negativef asserts that the specified element is negative
-//
-// assert.Negativef(t, -1, "error message %s", "formatted")
-// assert.Negativef(t, -1.23, "error message %s", "formatted")
-func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Negative(t, e, append([]interface{}{msg}, args...)...)
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Never(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// assert.Nilf(t, err, "error message %s", "formatted")
-func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Nil(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NoDirExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoErrorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NoError(t, err, append([]interface{}{msg}, args...)...)
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NoFileExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
-func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotContains(t, s, contains, append([]interface{}{msg}, args...)...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotEmpty(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
-func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
-}
-
-// NotImplementsf asserts that an object does not implement the specified interface.
-//
-// assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotImplements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// assert.NotNilf(t, err, "error message %s", "formatted")
-func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotNil(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
-func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotPanics(t, f, append([]interface{}{msg}, args...)...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
-func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...)
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotSame(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted")
-// assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
-func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...)
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotZero(t, i, append([]interface{}{msg}, args...)...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
-func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Panics(t, f, append([]interface{}{msg}, args...)...)
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithError(t, errString, f, append([]interface{}{msg}, args...)...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...)
-}
-
-// Positivef asserts that the specified element is positive
-//
-// assert.Positivef(t, 1, "error message %s", "formatted")
-// assert.Positivef(t, 1.23, "error message %s", "formatted")
-func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Positive(t, e, append([]interface{}{msg}, args...)...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
-func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Regexp(t, rx, str, append([]interface{}{msg}, args...)...)
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Same(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted")
-// assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
-func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Subset(t, list, subset, append([]interface{}{msg}, args...)...)
-}
-
-// Truef asserts that the specified value is true.
-//
-// assert.Truef(t, myBool, "error message %s", "formatted")
-func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return True(t, value, append([]interface{}{msg}, args...)...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return WithinRange(t, actual, start, end, append([]interface{}{msg}, args...)...)
-}
-
-// Zerof asserts that i is the zero value for its type.
-func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Zero(t, i, append([]interface{}{msg}, args...)...)
-}
diff --git a/internal/testify/assert/assertion_format.go.tmpl b/internal/testify/assert/assertion_format.go.tmpl
deleted file mode 100644
index d2bb0b817..000000000
--- a/internal/testify/assert/assertion_format.go.tmpl
+++ /dev/null
@@ -1,5 +0,0 @@
-{{.CommentFormat}}
-func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool {
- if h, ok := t.(tHelper); ok { h.Helper() }
- return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}})
-}
diff --git a/internal/testify/assert/assertion_forward.go b/internal/testify/assert/assertion_forward.go
deleted file mode 100644
index c498c9d43..000000000
--- a/internal/testify/assert/assertion_forward.go
+++ /dev/null
@@ -1,1605 +0,0 @@
-// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
-
-package assert
-
-import (
- http "net/http"
- url "net/url"
- time "time"
-)
-
-// Condition uses a Comparison to assert a complex condition.
-func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Condition(a.t, comp, msgAndArgs...)
-}
-
-// Conditionf uses a Comparison to assert a complex condition.
-func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Conditionf(a.t, comp, msg, args...)
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Contains("Hello World", "World")
-// a.Contains(["Hello", "World"], "World")
-// a.Contains({"Hello": "World"}, "Hello")
-func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Contains(a.t, s, contains, msgAndArgs...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Containsf("Hello World", "World", "error message %s", "formatted")
-// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
-// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
-func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Containsf(a.t, s, contains, msg, args...)
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return DirExists(a.t, path, msgAndArgs...)
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return DirExistsf(a.t, path, msg, args...)
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])
-func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ElementsMatch(a.t, listA, listB, msgAndArgs...)
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ElementsMatchf(a.t, listA, listB, msg, args...)
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Empty(obj)
-func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Empty(a.t, object, msgAndArgs...)
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Emptyf(obj, "error message %s", "formatted")
-func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Emptyf(a.t, object, msg, args...)
-}
-
-// Equal asserts that two objects are equal.
-//
-// a.Equal(123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Equal(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualError(err, expectedErrorString)
-func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualError(a.t, theError, errString, msgAndArgs...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
-func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualErrorf(a.t, theError, errString, msg, args...)
-}
-
-// EqualExportedValues asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// a.EqualExportedValues(S{1, 2}, S{1, 3}) => true
-// a.EqualExportedValues(S{1, 2}, S{2, 3}) => false
-func (a *Assertions) EqualExportedValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualExportedValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualExportedValuesf asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// a.EqualExportedValuesf(S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
-// a.EqualExportedValuesf(S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
-func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualExportedValuesf(a.t, expected, actual, msg, args...)
-}
-
-// EqualValues asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// a.EqualValues(uint32(123), int32(123))
-func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
-func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-// a.Equalf(123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Equalf(a.t, expected, actual, msg, args...)
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Error(err) {
-// assert.Equal(t, expectedError, err)
-// }
-func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Error(a.t, err, msgAndArgs...)
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorAs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorAsf(a.t, err, target, msg, args...)
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContains(err, expectedErrorSubString)
-func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorContains(a.t, theError, contains, msgAndArgs...)
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
-func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorContainsf(a.t, theError, contains, msg, args...)
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIs(err error, target error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorIsf(a.t, err, target, msg, args...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Errorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Errorf(a.t, err, msg, args...)
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// EventuallyWithT asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// a.EventuallyWithT(func(c *assert.CollectT) {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func (a *Assertions) EventuallyWithT(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EventuallyWithT(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// EventuallyWithTf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func (a *Assertions) EventuallyWithTf(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EventuallyWithTf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Eventuallyf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// a.Exactly(int32(123), int64(123))
-func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Exactly(a.t, expected, actual, msgAndArgs...)
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
-func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Exactlyf(a.t, expected, actual, msg, args...)
-}
-
-// Fail reports a failure through
-func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Fail(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNow fails test
-func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FailNow(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNowf fails test
-func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FailNowf(a.t, failureMessage, msg, args...)
-}
-
-// Failf reports a failure through
-func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Failf(a.t, failureMessage, msg, args...)
-}
-
-// False asserts that the specified value is false.
-//
-// a.False(myBool)
-func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return False(a.t, value, msgAndArgs...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-// a.Falsef(myBool, "error message %s", "formatted")
-func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Falsef(a.t, value, msg, args...)
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FileExists(a.t, path, msgAndArgs...)
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FileExistsf(a.t, path, msg, args...)
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// a.Greater(2, 1)
-// a.Greater(float64(2), float64(1))
-// a.Greater("b", "a")
-func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Greater(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqual(2, 1)
-// a.GreaterOrEqual(2, 2)
-// a.GreaterOrEqual("b", "a")
-// a.GreaterOrEqual("b", "b")
-func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return GreaterOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
-// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return GreaterOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// a.Greaterf(2, 1, "error message %s", "formatted")
-// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
-// a.Greaterf("b", "a", "error message %s", "formatted")
-func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Greaterf(a.t, e1, e2, msg, args...)
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPError(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPErrorf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPRedirectf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPStatusCode(a.t, handler, method, url, values, statuscode, msgAndArgs...)
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPStatusCodef(a.t, handler, method, url, values, statuscode, msg, args...)
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPSuccessf(a.t, handler, method, url, values, msg, args...)
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// a.Implements((*MyInterface)(nil), new(MyObject))
-func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Implements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Implementsf(a.t, interfaceObject, object, msg, args...)
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// a.InDelta(math.Pi, 22/7.0, 0.01)
-func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDelta(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// a.IsDecreasing([]int{2, 1, 0})
-// a.IsDecreasing([]float{2, 1})
-// a.IsDecreasing([]string{"b", "a"})
-func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
-// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsDecreasingf(a.t, object, msg, args...)
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// a.IsIncreasing([]int{1, 2, 3})
-// a.IsIncreasing([]float{1, 2})
-// a.IsIncreasing([]string{"a", "b"})
-func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
-// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsIncreasingf(a.t, object, msg, args...)
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// a.IsNonDecreasing([]int{1, 1, 2})
-// a.IsNonDecreasing([]float{1, 2})
-// a.IsNonDecreasing([]string{"a", "b"})
-func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonDecreasingf(a.t, object, msg, args...)
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// a.IsNonIncreasing([]int{2, 1, 1})
-// a.IsNonIncreasing([]float{2, 1})
-// a.IsNonIncreasing([]string{"b", "a"})
-func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonIncreasingf(a.t, object, msg, args...)
-}
-
-// IsType asserts that the specified objects are of the same type.
-func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsType(a.t, expectedType, object, msgAndArgs...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsTypef(a.t, expectedType, object, msg, args...)
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return JSONEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return JSONEqf(a.t, expected, actual, msg, args...)
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// a.Len(mySlice, 3)
-func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Len(a.t, object, length, msgAndArgs...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// a.Lenf(mySlice, 3, "error message %s", "formatted")
-func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Lenf(a.t, object, length, msg, args...)
-}
-
-// Less asserts that the first element is less than the second
-//
-// a.Less(1, 2)
-// a.Less(float64(1), float64(2))
-// a.Less("a", "b")
-func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Less(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqual(1, 2)
-// a.LessOrEqual(2, 2)
-// a.LessOrEqual("a", "b")
-// a.LessOrEqual("b", "b")
-func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return LessOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqualf(1, 2, "error message %s", "formatted")
-// a.LessOrEqualf(2, 2, "error message %s", "formatted")
-// a.LessOrEqualf("a", "b", "error message %s", "formatted")
-// a.LessOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return LessOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// a.Lessf(1, 2, "error message %s", "formatted")
-// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
-// a.Lessf("a", "b", "error message %s", "formatted")
-func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Lessf(a.t, e1, e2, msg, args...)
-}
-
-// Negative asserts that the specified element is negative
-//
-// a.Negative(-1)
-// a.Negative(-1.23)
-func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Negative(a.t, e, msgAndArgs...)
-}
-
-// Negativef asserts that the specified element is negative
-//
-// a.Negativef(-1, "error message %s", "formatted")
-// a.Negativef(-1.23, "error message %s", "formatted")
-func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Negativef(a.t, e, msg, args...)
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Never(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Neverf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Nil asserts that the specified object is nil.
-//
-// a.Nil(err)
-func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Nil(a.t, object, msgAndArgs...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// a.Nilf(err, "error message %s", "formatted")
-func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Nilf(a.t, object, msg, args...)
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoDirExists(a.t, path, msgAndArgs...)
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoDirExistsf(a.t, path, msg, args...)
-}
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoError(err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoError(a.t, err, msgAndArgs...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoErrorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoErrorf(a.t, err, msg, args...)
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoFileExists(a.t, path, msgAndArgs...)
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoFileExistsf(a.t, path, msg, args...)
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContains("Hello World", "Earth")
-// a.NotContains(["Hello", "World"], "Earth")
-// a.NotContains({"Hello": "World"}, "Earth")
-func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotContains(a.t, s, contains, msgAndArgs...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
-// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
-// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
-func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotContainsf(a.t, s, contains, msg, args...)
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmpty(obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEmpty(a.t, object, msgAndArgs...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmptyf(obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEmptyf(a.t, object, msg, args...)
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// a.NotEqual(obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqual(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValues(obj1, obj2)
-func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
-func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualf(a.t, expected, actual, msg, args...)
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotErrorIsf(a.t, err, target, msg, args...)
-}
-
-// NotImplements asserts that an object does not implement the specified interface.
-//
-// a.NotImplements((*MyInterface)(nil), new(MyObject))
-func (a *Assertions) NotImplements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotImplements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-// NotImplementsf asserts that an object does not implement the specified interface.
-//
-// a.NotImplementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func (a *Assertions) NotImplementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotImplementsf(a.t, interfaceObject, object, msg, args...)
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// a.NotNil(err)
-func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotNil(a.t, object, msgAndArgs...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// a.NotNilf(err, "error message %s", "formatted")
-func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotNilf(a.t, object, msg, args...)
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanics(func(){ RemainCalm() })
-func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotPanics(a.t, f, msgAndArgs...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
-func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotPanicsf(a.t, f, msg, args...)
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-// a.NotRegexp("^start", "it's not starting")
-func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotRegexp(a.t, rx, str, msgAndArgs...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotRegexpf(a.t, rx, str, msg, args...)
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// a.NotSame(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSame(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSamef(a.t, expected, actual, msg, args...)
-}
-
-// NotSubset asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// a.NotSubset([1, 3, 4], [1, 2])
-// a.NotSubset({"x": 1, "y": 2}, {"z": 3})
-func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSubset(a.t, list, subset, msgAndArgs...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// a.NotSubsetf([1, 3, 4], [1, 2], "error message %s", "formatted")
-// a.NotSubsetf({"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
-func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSubsetf(a.t, list, subset, msg, args...)
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotZero(a.t, i, msgAndArgs...)
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotZerof(a.t, i, msg, args...)
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panics(func(){ GoCrazy() })
-func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Panics(a.t, f, msgAndArgs...)
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithError("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithError(a.t, errString, f, msgAndArgs...)
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithErrorf(a.t, errString, f, msg, args...)
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithValue(a.t, expected, f, msgAndArgs...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithValuef(a.t, expected, f, msg, args...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Panicsf(a.t, f, msg, args...)
-}
-
-// Positive asserts that the specified element is positive
-//
-// a.Positive(1)
-// a.Positive(1.23)
-func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Positive(a.t, e, msgAndArgs...)
-}
-
-// Positivef asserts that the specified element is positive
-//
-// a.Positivef(1, "error message %s", "formatted")
-// a.Positivef(1.23, "error message %s", "formatted")
-func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Positivef(a.t, e, msg, args...)
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// a.Regexp(regexp.MustCompile("start"), "it's starting")
-// a.Regexp("start...$", "it's not starting")
-func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Regexp(a.t, rx, str, msgAndArgs...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Regexpf(a.t, rx, str, msg, args...)
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// a.Same(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Same(a.t, expected, actual, msgAndArgs...)
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// a.Samef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Samef(a.t, expected, actual, msg, args...)
-}
-
-// Subset asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// a.Subset([1, 2, 3], [1, 2])
-// a.Subset({"x": 1, "y": 2}, {"x": 1})
-func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Subset(a.t, list, subset, msgAndArgs...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// a.Subsetf([1, 2, 3], [1, 2], "error message %s", "formatted")
-// a.Subsetf({"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
-func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Subsetf(a.t, list, subset, msg, args...)
-}
-
-// True asserts that the specified value is true.
-//
-// a.True(myBool)
-func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return True(a.t, value, msgAndArgs...)
-}
-
-// Truef asserts that the specified value is true.
-//
-// a.Truef(myBool, "error message %s", "formatted")
-func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Truef(a.t, value, msg, args...)
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
-func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinDurationf(a.t, expected, actual, delta, msg, args...)
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinRange(a.t, actual, start, end, msgAndArgs...)
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinRangef(a.t, actual, start, end, msg, args...)
-}
-
-// Zero asserts that i is the zero value for its type.
-func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Zero(a.t, i, msgAndArgs...)
-}
-
-// Zerof asserts that i is the zero value for its type.
-func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Zerof(a.t, i, msg, args...)
-}
diff --git a/internal/testify/assert/assertion_forward.go.tmpl b/internal/testify/assert/assertion_forward.go.tmpl
deleted file mode 100644
index 188bb9e17..000000000
--- a/internal/testify/assert/assertion_forward.go.tmpl
+++ /dev/null
@@ -1,5 +0,0 @@
-{{.CommentWithoutT "a"}}
-func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool {
- if h, ok := a.t.(tHelper); ok { h.Helper() }
- return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
-}
diff --git a/internal/testify/assert/assertion_order.go b/internal/testify/assert/assertion_order.go
deleted file mode 100644
index 1d2f71824..000000000
--- a/internal/testify/assert/assertion_order.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package assert
-
-import (
- "fmt"
- "reflect"
-)
-
-// isOrdered checks that collection contains orderable elements.
-func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareResult, failMessage string, msgAndArgs ...interface{}) bool {
- objKind := reflect.TypeOf(object).Kind()
- if objKind != reflect.Slice && objKind != reflect.Array {
- return false
- }
-
- objValue := reflect.ValueOf(object)
- objLen := objValue.Len()
-
- if objLen <= 1 {
- return true
- }
-
- value := objValue.Index(0)
- valueInterface := value.Interface()
- firstValueKind := value.Kind()
-
- for i := 1; i < objLen; i++ {
- prevValue := value
- prevValueInterface := valueInterface
-
- value = objValue.Index(i)
- valueInterface = value.Interface()
-
- compareResult, isComparable := compare(prevValueInterface, valueInterface, firstValueKind)
-
- if !isComparable {
- return Fail(t, fmt.Sprintf("Can not compare type \"%s\" and \"%s\"", reflect.TypeOf(value), reflect.TypeOf(prevValue)), msgAndArgs...)
- }
-
- if !containsValue(allowedComparesResults, compareResult) {
- return Fail(t, fmt.Sprintf(failMessage, prevValue, value), msgAndArgs...)
- }
- }
-
- return true
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// assert.IsIncreasing(t, []int{1, 2, 3})
-// assert.IsIncreasing(t, []float{1, 2})
-// assert.IsIncreasing(t, []string{"a", "b"})
-func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []compareResult{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// assert.IsNonIncreasing(t, []int{2, 1, 1})
-// assert.IsNonIncreasing(t, []float{2, 1})
-// assert.IsNonIncreasing(t, []string{"b", "a"})
-func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []compareResult{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// assert.IsDecreasing(t, []int{2, 1, 0})
-// assert.IsDecreasing(t, []float{2, 1})
-// assert.IsDecreasing(t, []string{"b", "a"})
-func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []compareResult{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasing(t, []int{1, 1, 2})
-// assert.IsNonDecreasing(t, []float{1, 2})
-// assert.IsNonDecreasing(t, []string{"a", "b"})
-func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []compareResult{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
-}
diff --git a/internal/testify/assert/assertion_order_test.go b/internal/testify/assert/assertion_order_test.go
deleted file mode 100644
index eefe06127..000000000
--- a/internal/testify/assert/assertion_order_test.go
+++ /dev/null
@@ -1,203 +0,0 @@
-package assert
-
-import (
- "bytes"
- "testing"
-)
-
-func TestIsIncreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsIncreasing(mockT, []int{1, 2}) {
- t.Error("IsIncreasing should return true")
- }
-
- if !IsIncreasing(mockT, []int{1, 2, 3, 4, 5}) {
- t.Error("IsIncreasing should return true")
- }
-
- if IsIncreasing(mockT, []int{1, 1}) {
- t.Error("IsIncreasing should return false")
- }
-
- if IsIncreasing(mockT, []int{2, 1}) {
- t.Error("IsIncreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"b", "a"}, msg: `"b" is not less than "a"`},
- {collection: []int{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int{2, 1, 3, 4, 5, 6, 7}, msg: `"2" is not less than "1"`},
- {collection: []int{-1, 0, 2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int8{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int16{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int32{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int64{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint8{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint16{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint32{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint64{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []float32{2.34, 1.23}, msg: `"2.34" is not less than "1.23"`},
- {collection: []float64{2.34, 1.23}, msg: `"2.34" is not less than "1.23"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsIncreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestIsNonIncreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsNonIncreasing(mockT, []int{2, 1}) {
- t.Error("IsNonIncreasing should return true")
- }
-
- if !IsNonIncreasing(mockT, []int{5, 4, 4, 3, 2, 1}) {
- t.Error("IsNonIncreasing should return true")
- }
-
- if !IsNonIncreasing(mockT, []int{1, 1}) {
- t.Error("IsNonIncreasing should return true")
- }
-
- if IsNonIncreasing(mockT, []int{1, 2}) {
- t.Error("IsNonIncreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"a", "b"}, msg: `"a" is not greater than or equal to "b"`},
- {collection: []int{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int{1, 2, 7, 6, 5, 4, 3}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int{5, 4, 3, 1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int8{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int16{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int32{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int64{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint8{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint16{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint32{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint64{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []float32{1.23, 2.34}, msg: `"1.23" is not greater than or equal to "2.34"`},
- {collection: []float64{1.23, 2.34}, msg: `"1.23" is not greater than or equal to "2.34"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsNonIncreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestIsDecreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsDecreasing(mockT, []int{2, 1}) {
- t.Error("IsDecreasing should return true")
- }
-
- if !IsDecreasing(mockT, []int{5, 4, 3, 2, 1}) {
- t.Error("IsDecreasing should return true")
- }
-
- if IsDecreasing(mockT, []int{1, 1}) {
- t.Error("IsDecreasing should return false")
- }
-
- if IsDecreasing(mockT, []int{1, 2}) {
- t.Error("IsDecreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"a", "b"}, msg: `"a" is not greater than "b"`},
- {collection: []int{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int{1, 2, 7, 6, 5, 4, 3}, msg: `"1" is not greater than "2"`},
- {collection: []int{5, 4, 3, 1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int8{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int16{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int32{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int64{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint8{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint16{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint32{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint64{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []float32{1.23, 2.34}, msg: `"1.23" is not greater than "2.34"`},
- {collection: []float64{1.23, 2.34}, msg: `"1.23" is not greater than "2.34"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsDecreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestIsNonDecreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsNonDecreasing(mockT, []int{1, 2}) {
- t.Error("IsNonDecreasing should return true")
- }
-
- if !IsNonDecreasing(mockT, []int{1, 1, 2, 3, 4, 5}) {
- t.Error("IsNonDecreasing should return true")
- }
-
- if !IsNonDecreasing(mockT, []int{1, 1}) {
- t.Error("IsNonDecreasing should return false")
- }
-
- if IsNonDecreasing(mockT, []int{2, 1}) {
- t.Error("IsNonDecreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"b", "a"}, msg: `"b" is not less than or equal to "a"`},
- {collection: []int{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int{2, 1, 3, 4, 5, 6, 7}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int{-1, 0, 2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int8{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int16{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int32{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int64{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint8{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint16{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint32{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint64{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []float32{2.34, 1.23}, msg: `"2.34" is not less than or equal to "1.23"`},
- {collection: []float64{2.34, 1.23}, msg: `"2.34" is not less than or equal to "1.23"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsNonDecreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestOrderingMsgAndArgsForwarding(t *testing.T) {
- msgAndArgs := []interface{}{"format %s %x", "this", 0xc001}
- expectedOutput := "format this c001\n"
- collection := []int{1, 2, 1}
- funcs := []func(t TestingT){
- func(t TestingT) { IsIncreasing(t, collection, msgAndArgs...) },
- func(t TestingT) { IsNonIncreasing(t, collection, msgAndArgs...) },
- func(t TestingT) { IsDecreasing(t, collection, msgAndArgs...) },
- func(t TestingT) { IsNonDecreasing(t, collection, msgAndArgs...) },
- }
- for _, f := range funcs {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- f(out)
- Contains(t, out.buf.String(), expectedOutput)
- }
-}
diff --git a/internal/testify/assert/assertions.go b/internal/testify/assert/assertions.go
deleted file mode 100644
index 64ab7e6b9..000000000
--- a/internal/testify/assert/assertions.go
+++ /dev/null
@@ -1,2091 +0,0 @@
-package assert
-
-import (
- "bufio"
- "bytes"
- "encoding/json"
- "errors"
- "fmt"
- "math"
- "os"
- "reflect"
- "regexp"
- "runtime"
- "runtime/debug"
- "strings"
- "time"
- "unicode"
- "unicode/utf8"
-
- "github.com/expr-lang/expr/internal/spew"
-
- "github.com/expr-lang/expr/internal/difflib"
-)
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl"
-
-// TestingT is an interface wrapper around *testing.T
-type TestingT interface {
- Errorf(format string, args ...interface{})
-}
-
-// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful
-// for table driven tests.
-type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool
-
-// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful
-// for table driven tests.
-type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool
-
-// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful
-// for table driven tests.
-type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool
-
-// ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful
-// for table driven tests.
-type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool
-
-// PanicAssertionFunc is a common function prototype when validating a panic value. Can be useful
-// for table driven tests.
-type PanicAssertionFunc = func(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool
-
-// Comparison is a custom function that returns true on success and false on failure
-type Comparison func() (success bool)
-
-/*
- Helper functions
-*/
-
-// ObjectsAreEqual determines if two objects are considered equal.
-//
-// This function does no assertion of any kind.
-func ObjectsAreEqual(expected, actual interface{}) bool {
- if expected == nil || actual == nil {
- return expected == actual
- }
-
- exp, ok := expected.([]byte)
- if !ok {
- return reflect.DeepEqual(expected, actual)
- }
-
- act, ok := actual.([]byte)
- if !ok {
- return false
- }
- if exp == nil || act == nil {
- return exp == nil && act == nil
- }
- return bytes.Equal(exp, act)
-}
-
-// copyExportedFields iterates downward through nested data structures and creates a copy
-// that only contains the exported struct fields.
-func copyExportedFields(expected interface{}) interface{} {
- if isNil(expected) {
- return expected
- }
-
- expectedType := reflect.TypeOf(expected)
- expectedKind := expectedType.Kind()
- expectedValue := reflect.ValueOf(expected)
-
- switch expectedKind {
- case reflect.Struct:
- result := reflect.New(expectedType).Elem()
- for i := 0; i < expectedType.NumField(); i++ {
- field := expectedType.Field(i)
- isExported := field.IsExported()
- if isExported {
- fieldValue := expectedValue.Field(i)
- if isNil(fieldValue) || isNil(fieldValue.Interface()) {
- continue
- }
- newValue := copyExportedFields(fieldValue.Interface())
- result.Field(i).Set(reflect.ValueOf(newValue))
- }
- }
- return result.Interface()
-
- case reflect.Ptr:
- result := reflect.New(expectedType.Elem())
- unexportedRemoved := copyExportedFields(expectedValue.Elem().Interface())
- result.Elem().Set(reflect.ValueOf(unexportedRemoved))
- return result.Interface()
-
- case reflect.Array, reflect.Slice:
- var result reflect.Value
- if expectedKind == reflect.Array {
- result = reflect.New(reflect.ArrayOf(expectedValue.Len(), expectedType.Elem())).Elem()
- } else {
- result = reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len())
- }
- for i := 0; i < expectedValue.Len(); i++ {
- index := expectedValue.Index(i)
- if isNil(index) {
- continue
- }
- unexportedRemoved := copyExportedFields(index.Interface())
- result.Index(i).Set(reflect.ValueOf(unexportedRemoved))
- }
- return result.Interface()
-
- case reflect.Map:
- result := reflect.MakeMap(expectedType)
- for _, k := range expectedValue.MapKeys() {
- index := expectedValue.MapIndex(k)
- unexportedRemoved := copyExportedFields(index.Interface())
- result.SetMapIndex(k, reflect.ValueOf(unexportedRemoved))
- }
- return result.Interface()
-
- default:
- return expected
- }
-}
-
-// ObjectsExportedFieldsAreEqual determines if the exported (public) fields of two objects are
-// considered equal. This comparison of only exported fields is applied recursively to nested data
-// structures.
-//
-// This function does no assertion of any kind.
-//
-// Deprecated: Use [EqualExportedValues] instead.
-func ObjectsExportedFieldsAreEqual(expected, actual interface{}) bool {
- expectedCleaned := copyExportedFields(expected)
- actualCleaned := copyExportedFields(actual)
- return ObjectsAreEqualValues(expectedCleaned, actualCleaned)
-}
-
-// ObjectsAreEqualValues gets whether two objects are equal, or if their
-// values are equal.
-func ObjectsAreEqualValues(expected, actual interface{}) bool {
- if ObjectsAreEqual(expected, actual) {
- return true
- }
-
- expectedValue := reflect.ValueOf(expected)
- actualValue := reflect.ValueOf(actual)
- if !expectedValue.IsValid() || !actualValue.IsValid() {
- return false
- }
-
- expectedType := expectedValue.Type()
- actualType := actualValue.Type()
- if !expectedType.ConvertibleTo(actualType) {
- return false
- }
-
- if !isNumericType(expectedType) || !isNumericType(actualType) {
- // Attempt comparison after type conversion
- return reflect.DeepEqual(
- expectedValue.Convert(actualType).Interface(), actual,
- )
- }
-
- // If BOTH values are numeric, there are chances of false positives due
- // to overflow or underflow. So, we need to make sure to always convert
- // the smaller type to a larger type before comparing.
- if expectedType.Size() >= actualType.Size() {
- return actualValue.Convert(expectedType).Interface() == expected
- }
-
- return expectedValue.Convert(actualType).Interface() == actual
-}
-
-// isNumericType returns true if the type is one of:
-// int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64,
-// float32, float64, complex64, complex128
-func isNumericType(t reflect.Type) bool {
- return t.Kind() >= reflect.Int && t.Kind() <= reflect.Complex128
-}
-
-/* CallerInfo is necessary because the assert functions use the testing object
-internally, causing it to print the file:line of the assert method, rather than where
-the problem actually occurred in calling code.*/
-
-// CallerInfo returns an array of strings containing the file and line number
-// of each stack frame leading from the current test to the assert call that
-// failed.
-func CallerInfo() []string {
-
- var pc uintptr
- var ok bool
- var file string
- var line int
- var name string
-
- callers := []string{}
- for i := 0; ; i++ {
- pc, file, line, ok = runtime.Caller(i)
- if !ok {
- // The breaks below failed to terminate the loop, and we ran off the
- // end of the call stack.
- break
- }
-
- // This is a huge edge case, but it will panic if this is the case, see #180
- if file == "" {
- break
- }
-
- f := runtime.FuncForPC(pc)
- if f == nil {
- break
- }
- name = f.Name()
-
- // testing.tRunner is the standard library function that calls
- // tests. Subtests are called directly by tRunner, without going through
- // the Test/Benchmark/Example function that contains the t.Run calls, so
- // with subtests we should break when we hit tRunner, without adding it
- // to the list of callers.
- if name == "testing.tRunner" {
- break
- }
-
- parts := strings.Split(file, "/")
- if len(parts) > 1 {
- filename := parts[len(parts)-1]
- dir := parts[len(parts)-2]
- if (dir != "assert" && dir != "mock" && dir != "require") || filename == "mock_test.go" {
- callers = append(callers, fmt.Sprintf("%s:%d", file, line))
- }
- }
-
- // Drop the package
- segments := strings.Split(name, ".")
- name = segments[len(segments)-1]
- if isTest(name, "Test") ||
- isTest(name, "Benchmark") ||
- isTest(name, "Example") {
- break
- }
- }
-
- return callers
-}
-
-// Stolen from the `go test` tool.
-// isTest tells whether name looks like a test (or benchmark, according to prefix).
-// It is a Test (say) if there is a character after Test that is not a lower-case letter.
-// We don't want TesticularCancer.
-func isTest(name, prefix string) bool {
- if !strings.HasPrefix(name, prefix) {
- return false
- }
- if len(name) == len(prefix) { // "Test" is ok
- return true
- }
- r, _ := utf8.DecodeRuneInString(name[len(prefix):])
- return !unicode.IsLower(r)
-}
-
-func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
- if len(msgAndArgs) == 0 || msgAndArgs == nil {
- return ""
- }
- if len(msgAndArgs) == 1 {
- msg := msgAndArgs[0]
- if msgAsStr, ok := msg.(string); ok {
- return msgAsStr
- }
- return fmt.Sprintf("%+v", msg)
- }
- if len(msgAndArgs) > 1 {
- return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
- }
- return ""
-}
-
-// Aligns the provided message so that all lines after the first line start at the same location as the first line.
-// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab).
-// The longestLabelLen parameter specifies the length of the longest label in the output (required because this is the
-// basis on which the alignment occurs).
-func indentMessageLines(message string, longestLabelLen int) string {
- outBuf := new(bytes.Buffer)
-
- for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
- // no need to align first line because it starts at the correct location (after the label)
- if i != 0 {
- // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab
- outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t")
- }
- outBuf.WriteString(scanner.Text())
- }
-
- return outBuf.String()
-}
-
-type failNower interface {
- FailNow()
-}
-
-// FailNow fails test
-func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- Fail(t, failureMessage, msgAndArgs...)
-
- // We cannot extend TestingT with FailNow() and
- // maintain backwards compatibility, so we fallback
- // to panicking when FailNow is not available in
- // TestingT.
- // See issue #263
-
- if t, ok := t.(failNower); ok {
- t.FailNow()
- } else {
- panic("test failed and t is missing `FailNow()`")
- }
- return false
-}
-
-// Fail reports a failure through
-func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- content := []labeledContent{
- {"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")},
- {"Error", failureMessage},
- }
-
- // Add test name if the Go version supports it
- if n, ok := t.(interface {
- Name() string
- }); ok {
- content = append(content, labeledContent{"Test", n.Name()})
- }
-
- message := messageFromMsgAndArgs(msgAndArgs...)
- if len(message) > 0 {
- content = append(content, labeledContent{"Messages", message})
- }
-
- t.Errorf("\n%s", ""+labeledOutput(content...))
-
- return false
-}
-
-type labeledContent struct {
- label string
- content string
-}
-
-// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner:
-//
-// \t{{label}}:{{align_spaces}}\t{{content}}\n
-//
-// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label.
-// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this
-// alignment is achieved, "\t{{content}}\n" is added for the output.
-//
-// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line.
-func labeledOutput(content ...labeledContent) string {
- longestLabel := 0
- for _, v := range content {
- if len(v.label) > longestLabel {
- longestLabel = len(v.label)
- }
- }
- var output string
- for _, v := range content {
- output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n"
- }
- return output
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
-func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- interfaceType := reflect.TypeOf(interfaceObject).Elem()
-
- if object == nil {
- return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...)
- }
- if !reflect.TypeOf(object).Implements(interfaceType) {
- return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...)
- }
-
- return true
-}
-
-// NotImplements asserts that an object does not implement the specified interface.
-//
-// assert.NotImplements(t, (*MyInterface)(nil), new(MyObject))
-func NotImplements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- interfaceType := reflect.TypeOf(interfaceObject).Elem()
-
- if object == nil {
- return Fail(t, fmt.Sprintf("Cannot check if nil does not implement %v", interfaceType), msgAndArgs...)
- }
- if reflect.TypeOf(object).Implements(interfaceType) {
- return Fail(t, fmt.Sprintf("%T implements %v", object, interfaceType), msgAndArgs...)
- }
-
- return true
-}
-
-// IsType asserts that the specified objects are of the same type.
-func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
- return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
- }
-
- return true
-}
-
-// Equal asserts that two objects are equal.
-//
-// assert.Equal(t, 123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if err := validateEqualArgs(expected, actual); err != nil {
- return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)",
- expected, actual, err), msgAndArgs...)
- }
-
- if !ObjectsAreEqual(expected, actual) {
- diff := diff(expected, actual)
- expected, actual = formatUnequalValues(expected, actual)
- return Fail(t, fmt.Sprintf("Not equal: \n"+
- "expected: %s\n"+
- "actual : %s%s", expected, actual, diff), msgAndArgs...)
- }
-
- return true
-
-}
-
-// validateEqualArgs checks whether provided arguments can be safely used in the
-// Equal/NotEqual functions.
-func validateEqualArgs(expected, actual interface{}) error {
- if expected == nil && actual == nil {
- return nil
- }
-
- if isFunction(expected) || isFunction(actual) {
- return errors.New("cannot take func type as argument")
- }
- return nil
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// assert.Same(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if !samePointers(expected, actual) {
- return Fail(t, fmt.Sprintf("Not same: \n"+
- "expected: %p %#v\n"+
- "actual : %p %#v", expected, expected, actual, actual), msgAndArgs...)
- }
-
- return true
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// assert.NotSame(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if samePointers(expected, actual) {
- return Fail(t, fmt.Sprintf(
- "Expected and actual point to the same object: %p %#v",
- expected, expected), msgAndArgs...)
- }
- return true
-}
-
-// samePointers compares two generic interface objects and returns whether
-// they point to the same object
-func samePointers(first, second interface{}) bool {
- firstPtr, secondPtr := reflect.ValueOf(first), reflect.ValueOf(second)
- if firstPtr.Kind() != reflect.Ptr || secondPtr.Kind() != reflect.Ptr {
- return false
- }
-
- firstType, secondType := reflect.TypeOf(first), reflect.TypeOf(second)
- if firstType != secondType {
- return false
- }
-
- // compare pointer addresses
- return first == second
-}
-
-// formatUnequalValues takes two values of arbitrary types and returns string
-// representations appropriate to be presented to the user.
-//
-// If the values are not of like type, the returned strings will be prefixed
-// with the type name, and the value will be enclosed in parentheses similar
-// to a type conversion in the Go grammar.
-func formatUnequalValues(expected, actual interface{}) (e string, a string) {
- if reflect.TypeOf(expected) != reflect.TypeOf(actual) {
- return fmt.Sprintf("%T(%s)", expected, truncatingFormat(expected)),
- fmt.Sprintf("%T(%s)", actual, truncatingFormat(actual))
- }
- switch expected.(type) {
- case time.Duration:
- return fmt.Sprintf("%v", expected), fmt.Sprintf("%v", actual)
- }
- return truncatingFormat(expected), truncatingFormat(actual)
-}
-
-// truncatingFormat formats the data and truncates it if it's too long.
-//
-// This helps keep formatted error messages lines from exceeding the
-// bufio.MaxScanTokenSize max line length that the go testing framework imposes.
-func truncatingFormat(data interface{}) string {
- value := fmt.Sprintf("%#v", data)
- max := bufio.MaxScanTokenSize - 100 // Give us some space the type info too if needed.
- if len(value) > max {
- value = value[0:max] + "<... truncated>"
- }
- return value
-}
-
-// EqualValues asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// assert.EqualValues(t, uint32(123), int32(123))
-func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if !ObjectsAreEqualValues(expected, actual) {
- diff := diff(expected, actual)
- expected, actual = formatUnequalValues(expected, actual)
- return Fail(t, fmt.Sprintf("Not equal: \n"+
- "expected: %s\n"+
- "actual : %s%s", expected, actual, diff), msgAndArgs...)
- }
-
- return true
-
-}
-
-// EqualExportedValues asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// assert.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
-// assert.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false
-func EqualExportedValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- aType := reflect.TypeOf(expected)
- bType := reflect.TypeOf(actual)
-
- if aType != bType {
- return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
- }
-
- if aType.Kind() == reflect.Ptr {
- aType = aType.Elem()
- }
- if bType.Kind() == reflect.Ptr {
- bType = bType.Elem()
- }
-
- if aType.Kind() != reflect.Struct {
- return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...)
- }
-
- if bType.Kind() != reflect.Struct {
- return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...)
- }
-
- expected = copyExportedFields(expected)
- actual = copyExportedFields(actual)
-
- if !ObjectsAreEqualValues(expected, actual) {
- diff := diff(expected, actual)
- expected, actual = formatUnequalValues(expected, actual)
- return Fail(t, fmt.Sprintf("Not equal (comparing only exported fields): \n"+
- "expected: %s\n"+
- "actual : %s%s", expected, actual, diff), msgAndArgs...)
- }
-
- return true
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// assert.Exactly(t, int32(123), int64(123))
-func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- aType := reflect.TypeOf(expected)
- bType := reflect.TypeOf(actual)
-
- if aType != bType {
- return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
- }
-
- return Equal(t, expected, actual, msgAndArgs...)
-
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// assert.NotNil(t, err)
-func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- if !isNil(object) {
- return true
- }
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "Expected value not to be nil.", msgAndArgs...)
-}
-
-// isNil checks if a specified object is nil or not, without Failing.
-func isNil(object interface{}) bool {
- if object == nil {
- return true
- }
-
- value := reflect.ValueOf(object)
- switch value.Kind() {
- case
- reflect.Chan, reflect.Func,
- reflect.Interface, reflect.Map,
- reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
-
- return value.IsNil()
- }
-
- return false
-}
-
-// Nil asserts that the specified object is nil.
-//
-// assert.Nil(t, err)
-func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- if isNil(object) {
- return true
- }
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
-}
-
-// isEmpty gets whether the specified object is considered empty or not.
-func isEmpty(object interface{}) bool {
-
- // get nil case out of the way
- if object == nil {
- return true
- }
-
- objValue := reflect.ValueOf(object)
-
- switch objValue.Kind() {
- // collection types are empty when they have no element
- case reflect.Chan, reflect.Map, reflect.Slice:
- return objValue.Len() == 0
- // pointers are empty if nil or if the value they point to is empty
- case reflect.Ptr:
- if objValue.IsNil() {
- return true
- }
- deref := objValue.Elem().Interface()
- return isEmpty(deref)
- // for all other types, compare against the zero value
- // array types are empty when they match their zero-initialized state
- default:
- zero := reflect.Zero(objValue.Type())
- return reflect.DeepEqual(object, zero.Interface())
- }
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Empty(t, obj)
-func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- pass := isEmpty(object)
- if !pass {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
- }
-
- return pass
-
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmpty(t, obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- pass := !isEmpty(object)
- if !pass {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...)
- }
-
- return pass
-
-}
-
-// getLen tries to get the length of an object.
-// It returns (0, false) if impossible.
-func getLen(x interface{}) (length int, ok bool) {
- v := reflect.ValueOf(x)
- defer func() {
- ok = recover() == nil
- }()
- return v.Len(), true
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// assert.Len(t, mySlice, 3)
-func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- l, ok := getLen(object)
- if !ok {
- return Fail(t, fmt.Sprintf("\"%v\" could not be applied builtin len()", object), msgAndArgs...)
- }
-
- if l != length {
- return Fail(t, fmt.Sprintf("\"%v\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
- }
- return true
-}
-
-// True asserts that the specified value is true.
-//
-// assert.True(t, myBool)
-func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
- if !value {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "Should be true", msgAndArgs...)
- }
-
- return true
-
-}
-
-// False asserts that the specified value is false.
-//
-// assert.False(t, myBool)
-func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
- if value {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "Should be false", msgAndArgs...)
- }
-
- return true
-
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// assert.NotEqual(t, obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if err := validateEqualArgs(expected, actual); err != nil {
- return Fail(t, fmt.Sprintf("Invalid operation: %#v != %#v (%s)",
- expected, actual, err), msgAndArgs...)
- }
-
- if ObjectsAreEqual(expected, actual) {
- return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
- }
-
- return true
-
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValues(t, obj1, obj2)
-func NotEqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if ObjectsAreEqualValues(expected, actual) {
- return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
- }
-
- return true
-}
-
-// containsElement try loop over the list check if the list includes the element.
-// return (false, false) if impossible.
-// return (true, false) if element was not found.
-// return (true, true) if element was found.
-func containsElement(list interface{}, element interface{}) (ok, found bool) {
-
- listValue := reflect.ValueOf(list)
- listType := reflect.TypeOf(list)
- if listType == nil {
- return false, false
- }
- listKind := listType.Kind()
- defer func() {
- if e := recover(); e != nil {
- ok = false
- found = false
- }
- }()
-
- if listKind == reflect.String {
- elementValue := reflect.ValueOf(element)
- return true, strings.Contains(listValue.String(), elementValue.String())
- }
-
- if listKind == reflect.Map {
- mapKeys := listValue.MapKeys()
- for i := 0; i < len(mapKeys); i++ {
- if ObjectsAreEqual(mapKeys[i].Interface(), element) {
- return true, true
- }
- }
- return true, false
- }
-
- for i := 0; i < listValue.Len(); i++ {
- if ObjectsAreEqual(listValue.Index(i).Interface(), element) {
- return true, true
- }
- }
- return true, false
-
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Contains(t, "Hello World", "World")
-// assert.Contains(t, ["Hello", "World"], "World")
-// assert.Contains(t, {"Hello": "World"}, "Hello")
-func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ok, found := containsElement(s, contains)
- if !ok {
- return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
- }
- if !found {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", s, contains), msgAndArgs...)
- }
-
- return true
-
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContains(t, "Hello World", "Earth")
-// assert.NotContains(t, ["Hello", "World"], "Earth")
-// assert.NotContains(t, {"Hello": "World"}, "Earth")
-func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ok, found := containsElement(s, contains)
- if !ok {
- return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
- }
- if found {
- return Fail(t, fmt.Sprintf("%#v should not contain %#v", s, contains), msgAndArgs...)
- }
-
- return true
-
-}
-
-// Subset asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// assert.Subset(t, [1, 2, 3], [1, 2])
-// assert.Subset(t, {"x": 1, "y": 2}, {"x": 1})
-func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if subset == nil {
- return true // we consider nil to be equal to the nil set
- }
-
- listKind := reflect.TypeOf(list).Kind()
- if listKind != reflect.Array && listKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...)
- }
-
- subsetKind := reflect.TypeOf(subset).Kind()
- if subsetKind != reflect.Array && subsetKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...)
- }
-
- if subsetKind == reflect.Map && listKind == reflect.Map {
- subsetMap := reflect.ValueOf(subset)
- actualMap := reflect.ValueOf(list)
-
- for _, k := range subsetMap.MapKeys() {
- ev := subsetMap.MapIndex(k)
- av := actualMap.MapIndex(k)
-
- if !av.IsValid() {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
- }
- if !ObjectsAreEqual(ev.Interface(), av.Interface()) {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
- }
- }
-
- return true
- }
-
- subsetList := reflect.ValueOf(subset)
- for i := 0; i < subsetList.Len(); i++ {
- element := subsetList.Index(i).Interface()
- ok, found := containsElement(list, element)
- if !ok {
- return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", list), msgAndArgs...)
- }
- if !found {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, element), msgAndArgs...)
- }
- }
-
- return true
-}
-
-// NotSubset asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// assert.NotSubset(t, [1, 3, 4], [1, 2])
-// assert.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
-func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if subset == nil {
- return Fail(t, "nil is the empty set which is a subset of every set", msgAndArgs...)
- }
-
- listKind := reflect.TypeOf(list).Kind()
- if listKind != reflect.Array && listKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...)
- }
-
- subsetKind := reflect.TypeOf(subset).Kind()
- if subsetKind != reflect.Array && subsetKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...)
- }
-
- if subsetKind == reflect.Map && listKind == reflect.Map {
- subsetMap := reflect.ValueOf(subset)
- actualMap := reflect.ValueOf(list)
-
- for _, k := range subsetMap.MapKeys() {
- ev := subsetMap.MapIndex(k)
- av := actualMap.MapIndex(k)
-
- if !av.IsValid() {
- return true
- }
- if !ObjectsAreEqual(ev.Interface(), av.Interface()) {
- return true
- }
- }
-
- return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
- }
-
- subsetList := reflect.ValueOf(subset)
- for i := 0; i < subsetList.Len(); i++ {
- element := subsetList.Index(i).Interface()
- ok, found := containsElement(list, element)
- if !ok {
- return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...)
- }
- if !found {
- return true
- }
- }
-
- return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])
-func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if isEmpty(listA) && isEmpty(listB) {
- return true
- }
-
- if !isList(t, listA, msgAndArgs...) || !isList(t, listB, msgAndArgs...) {
- return false
- }
-
- extraA, extraB := diffLists(listA, listB)
-
- if len(extraA) == 0 && len(extraB) == 0 {
- return true
- }
-
- return Fail(t, formatListDiff(listA, listB, extraA, extraB), msgAndArgs...)
-}
-
-// isList checks that the provided value is array or slice.
-func isList(t TestingT, list interface{}, msgAndArgs ...interface{}) (ok bool) {
- kind := reflect.TypeOf(list).Kind()
- if kind != reflect.Array && kind != reflect.Slice {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s, expecting array or slice", list, kind),
- msgAndArgs...)
- }
- return true
-}
-
-// diffLists diffs two arrays/slices and returns slices of elements that are only in A and only in B.
-// If some element is present multiple times, each instance is counted separately (e.g. if something is 2x in A and
-// 5x in B, it will be 0x in extraA and 3x in extraB). The order of items in both lists is ignored.
-func diffLists(listA, listB interface{}) (extraA, extraB []interface{}) {
- aValue := reflect.ValueOf(listA)
- bValue := reflect.ValueOf(listB)
-
- aLen := aValue.Len()
- bLen := bValue.Len()
-
- // Mark indexes in bValue that we already used
- visited := make([]bool, bLen)
- for i := 0; i < aLen; i++ {
- element := aValue.Index(i).Interface()
- found := false
- for j := 0; j < bLen; j++ {
- if visited[j] {
- continue
- }
- if ObjectsAreEqual(bValue.Index(j).Interface(), element) {
- visited[j] = true
- found = true
- break
- }
- }
- if !found {
- extraA = append(extraA, element)
- }
- }
-
- for j := 0; j < bLen; j++ {
- if visited[j] {
- continue
- }
- extraB = append(extraB, bValue.Index(j).Interface())
- }
-
- return
-}
-
-func formatListDiff(listA, listB interface{}, extraA, extraB []interface{}) string {
- var msg bytes.Buffer
-
- msg.WriteString("elements differ")
- if len(extraA) > 0 {
- msg.WriteString("\n\nextra elements in list A:\n")
- msg.WriteString(spewConfig.Sdump(extraA))
- }
- if len(extraB) > 0 {
- msg.WriteString("\n\nextra elements in list B:\n")
- msg.WriteString(spewConfig.Sdump(extraB))
- }
- msg.WriteString("\n\nlistA:\n")
- msg.WriteString(spewConfig.Sdump(listA))
- msg.WriteString("\n\nlistB:\n")
- msg.WriteString(spewConfig.Sdump(listB))
-
- return msg.String()
-}
-
-// Condition uses a Comparison to assert a complex condition.
-func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- result := comp()
- if !result {
- Fail(t, "Condition failed!", msgAndArgs...)
- }
- return result
-}
-
-// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics
-// methods, and represents a simple func that takes no arguments, and returns nothing.
-type PanicTestFunc func()
-
-// didPanic returns true if the function passed to it panics. Otherwise, it returns false.
-func didPanic(f PanicTestFunc) (didPanic bool, message interface{}, stack string) {
- didPanic = true
-
- defer func() {
- message = recover()
- if didPanic {
- stack = string(debug.Stack())
- }
- }()
-
- // call the target function
- f()
- didPanic = false
-
- return
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panics(t, func(){ GoCrazy() })
-func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if funcDidPanic, panicValue, _ := didPanic(f); !funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
- }
-
- return true
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- funcDidPanic, panicValue, panickedStack := didPanic(f)
- if !funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
- }
- if panicValue != expected {
- return Fail(t, fmt.Sprintf("func %#v should panic with value:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, expected, panicValue, panickedStack), msgAndArgs...)
- }
-
- return true
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- funcDidPanic, panicValue, panickedStack := didPanic(f)
- if !funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
- }
- panicErr, ok := panicValue.(error)
- if !ok || panicErr.Error() != errString {
- return Fail(t, fmt.Sprintf("func %#v should panic with error message:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, errString, panicValue, panickedStack), msgAndArgs...)
- }
-
- return true
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanics(t, func(){ RemainCalm() })
-func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if funcDidPanic, panicValue, panickedStack := didPanic(f); funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should not panic\n\tPanic value:\t%v\n\tPanic stack:\t%s", f, panicValue, panickedStack), msgAndArgs...)
- }
-
- return true
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
-func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- dt := expected.Sub(actual)
- if dt < -delta || dt > delta {
- return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
- }
-
- return true
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func WithinRange(t TestingT, actual, start, end time.Time, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if end.Before(start) {
- return Fail(t, "Start should be before end", msgAndArgs...)
- }
-
- if actual.Before(start) {
- return Fail(t, fmt.Sprintf("Time %v expected to be in time range %v to %v, but is before the range", actual, start, end), msgAndArgs...)
- } else if actual.After(end) {
- return Fail(t, fmt.Sprintf("Time %v expected to be in time range %v to %v, but is after the range", actual, start, end), msgAndArgs...)
- }
-
- return true
-}
-
-func toFloat(x interface{}) (float64, bool) {
- var xf float64
- xok := true
-
- switch xn := x.(type) {
- case uint:
- xf = float64(xn)
- case uint8:
- xf = float64(xn)
- case uint16:
- xf = float64(xn)
- case uint32:
- xf = float64(xn)
- case uint64:
- xf = float64(xn)
- case int:
- xf = float64(xn)
- case int8:
- xf = float64(xn)
- case int16:
- xf = float64(xn)
- case int32:
- xf = float64(xn)
- case int64:
- xf = float64(xn)
- case float32:
- xf = float64(xn)
- case float64:
- xf = xn
- case time.Duration:
- xf = float64(xn)
- default:
- xok = false
- }
-
- return xf, xok
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
-func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- af, aok := toFloat(expected)
- bf, bok := toFloat(actual)
-
- if !aok || !bok {
- return Fail(t, "Parameters must be numerical", msgAndArgs...)
- }
-
- if math.IsNaN(af) && math.IsNaN(bf) {
- return true
- }
-
- if math.IsNaN(af) {
- return Fail(t, "Expected must not be NaN", msgAndArgs...)
- }
-
- if math.IsNaN(bf) {
- return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...)
- }
-
- dt := af - bf
- if dt < -delta || dt > delta {
- return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
- }
-
- return true
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if expected == nil || actual == nil ||
- reflect.TypeOf(actual).Kind() != reflect.Slice ||
- reflect.TypeOf(expected).Kind() != reflect.Slice {
- return Fail(t, "Parameters must be slice", msgAndArgs...)
- }
-
- actualSlice := reflect.ValueOf(actual)
- expectedSlice := reflect.ValueOf(expected)
-
- for i := 0; i < actualSlice.Len(); i++ {
- result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta, msgAndArgs...)
- if !result {
- return result
- }
- }
-
- return true
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if expected == nil || actual == nil ||
- reflect.TypeOf(actual).Kind() != reflect.Map ||
- reflect.TypeOf(expected).Kind() != reflect.Map {
- return Fail(t, "Arguments must be maps", msgAndArgs...)
- }
-
- expectedMap := reflect.ValueOf(expected)
- actualMap := reflect.ValueOf(actual)
-
- if expectedMap.Len() != actualMap.Len() {
- return Fail(t, "Arguments must have the same number of keys", msgAndArgs...)
- }
-
- for _, k := range expectedMap.MapKeys() {
- ev := expectedMap.MapIndex(k)
- av := actualMap.MapIndex(k)
-
- if !ev.IsValid() {
- return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...)
- }
-
- if !av.IsValid() {
- return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...)
- }
-
- if !InDelta(
- t,
- ev.Interface(),
- av.Interface(),
- delta,
- msgAndArgs...,
- ) {
- return false
- }
- }
-
- return true
-}
-
-func calcRelativeError(expected, actual interface{}) (float64, error) {
- af, aok := toFloat(expected)
- bf, bok := toFloat(actual)
- if !aok || !bok {
- return 0, fmt.Errorf("Parameters must be numerical")
- }
- if math.IsNaN(af) && math.IsNaN(bf) {
- return 0, nil
- }
- if math.IsNaN(af) {
- return 0, errors.New("expected value must not be NaN")
- }
- if af == 0 {
- return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error")
- }
- if math.IsNaN(bf) {
- return 0, errors.New("actual value must not be NaN")
- }
-
- return math.Abs(af-bf) / math.Abs(af), nil
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if math.IsNaN(epsilon) {
- return Fail(t, "epsilon must not be NaN", msgAndArgs...)
- }
- actualEpsilon, err := calcRelativeError(expected, actual)
- if err != nil {
- return Fail(t, err.Error(), msgAndArgs...)
- }
- if actualEpsilon > epsilon {
- return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+
- " < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...)
- }
-
- return true
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if expected == nil || actual == nil {
- return Fail(t, "Parameters must be slice", msgAndArgs...)
- }
-
- expectedSlice := reflect.ValueOf(expected)
- actualSlice := reflect.ValueOf(actual)
-
- if expectedSlice.Type().Kind() != reflect.Slice {
- return Fail(t, "Expected value must be slice", msgAndArgs...)
- }
-
- expectedLen := expectedSlice.Len()
- if !IsType(t, expected, actual) || !Len(t, actual, expectedLen) {
- return false
- }
-
- for i := 0; i < expectedLen; i++ {
- if !InEpsilon(t, expectedSlice.Index(i).Interface(), actualSlice.Index(i).Interface(), epsilon, "at index %d", i) {
- return false
- }
- }
-
- return true
-}
-
-/*
- Errors
-*/
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoError(t, err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
- if err != nil {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...)
- }
-
- return true
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Error(t, err) {
-// assert.Equal(t, expectedError, err)
-// }
-func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
- if err == nil {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "An error is expected but got nil.", msgAndArgs...)
- }
-
- return true
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualError(t, err, expectedErrorString)
-func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if !Error(t, theError, msgAndArgs...) {
- return false
- }
- expected := errString
- actual := theError.Error()
- // don't need to use deep equals here, we know they are both strings
- if expected != actual {
- return Fail(t, fmt.Sprintf("Error message not equal:\n"+
- "expected: %q\n"+
- "actual : %q", expected, actual), msgAndArgs...)
- }
- return true
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContains(t, err, expectedErrorSubString)
-func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if !Error(t, theError, msgAndArgs...) {
- return false
- }
-
- actual := theError.Error()
- if !strings.Contains(actual, contains) {
- return Fail(t, fmt.Sprintf("Error %#v does not contain %#v", actual, contains), msgAndArgs...)
- }
-
- return true
-}
-
-// matchRegexp return true if a specified regexp matches a string.
-func matchRegexp(rx interface{}, str interface{}) bool {
-
- var r *regexp.Regexp
- if rr, ok := rx.(*regexp.Regexp); ok {
- r = rr
- } else {
- r = regexp.MustCompile(fmt.Sprint(rx))
- }
-
- return (r.FindStringIndex(fmt.Sprint(str)) != nil)
-
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-// assert.Regexp(t, "start...$", "it's not starting")
-func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- match := matchRegexp(rx, str)
-
- if !match {
- Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...)
- }
-
- return match
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-// assert.NotRegexp(t, "^start", "it's not starting")
-func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- match := matchRegexp(rx, str)
-
- if match {
- Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...)
- }
-
- return !match
-
-}
-
-// Zero asserts that i is the zero value for its type.
-func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
- return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...)
- }
- return true
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
- return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...)
- }
- return true
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- if os.IsNotExist(err) {
- return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...)
- }
- return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...)
- }
- if info.IsDir() {
- return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...)
- }
- return true
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- return true
- }
- if info.IsDir() {
- return true
- }
- return Fail(t, fmt.Sprintf("file %q exists", path), msgAndArgs...)
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- if os.IsNotExist(err) {
- return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...)
- }
- return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...)
- }
- if !info.IsDir() {
- return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...)
- }
- return true
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- if os.IsNotExist(err) {
- return true
- }
- return true
- }
- if !info.IsDir() {
- return true
- }
- return Fail(t, fmt.Sprintf("directory %q exists", path), msgAndArgs...)
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- var expectedJSONAsInterface, actualJSONAsInterface interface{}
-
- if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil {
- return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...)
- }
-
- if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil {
- return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...)
- }
-
- return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...)
-}
-
-func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) {
- t := reflect.TypeOf(v)
- k := t.Kind()
-
- if k == reflect.Ptr {
- t = t.Elem()
- k = t.Kind()
- }
- return t, k
-}
-
-// diff returns a diff of both values as long as both are of the same type and
-// are a struct, map, slice, array or string. Otherwise it returns an empty string.
-func diff(expected interface{}, actual interface{}) string {
- if expected == nil || actual == nil {
- return ""
- }
-
- et, ek := typeAndKind(expected)
- at, _ := typeAndKind(actual)
-
- if et != at {
- return ""
- }
-
- if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String {
- return ""
- }
-
- var e, a string
-
- switch et {
- case reflect.TypeOf(""):
- e = reflect.ValueOf(expected).String()
- a = reflect.ValueOf(actual).String()
- case reflect.TypeOf(time.Time{}):
- e = spewConfigStringerEnabled.Sdump(expected)
- a = spewConfigStringerEnabled.Sdump(actual)
- default:
- e = spewConfig.Sdump(expected)
- a = spewConfig.Sdump(actual)
- }
-
- diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
- A: difflib.SplitLines(e),
- B: difflib.SplitLines(a),
- FromFile: "Expected",
- FromDate: "",
- ToFile: "Actual",
- ToDate: "",
- Context: 1,
- })
-
- return "\n\nDiff:\n" + diff
-}
-
-func isFunction(arg interface{}) bool {
- if arg == nil {
- return false
- }
- return reflect.TypeOf(arg).Kind() == reflect.Func
-}
-
-var spewConfig = spew.ConfigState{
- Indent: " ",
- DisablePointerAddresses: true,
- DisableCapacities: true,
- SortKeys: true,
- DisableMethods: true,
- MaxDepth: 10,
-}
-
-var spewConfigStringerEnabled = spew.ConfigState{
- Indent: " ",
- DisablePointerAddresses: true,
- DisableCapacities: true,
- SortKeys: true,
- MaxDepth: 10,
-}
-
-type tHelper = interface {
- Helper()
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
-func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ch := make(chan bool, 1)
-
- timer := time.NewTimer(waitFor)
- defer timer.Stop()
-
- ticker := time.NewTicker(tick)
- defer ticker.Stop()
-
- for tick := ticker.C; ; {
- select {
- case <-timer.C:
- return Fail(t, "Condition never satisfied", msgAndArgs...)
- case <-tick:
- tick = nil
- go func() { ch <- condition() }()
- case v := <-ch:
- if v {
- return true
- }
- tick = ticker.C
- }
- }
-}
-
-// CollectT implements the TestingT interface and collects all errors.
-type CollectT struct {
- errors []error
-}
-
-// Errorf collects the error.
-func (c *CollectT) Errorf(format string, args ...interface{}) {
- c.errors = append(c.errors, fmt.Errorf(format, args...))
-}
-
-// FailNow panics.
-func (*CollectT) FailNow() {
- panic("Assertion failed")
-}
-
-// Deprecated: That was a method for internal usage that should not have been published. Now just panics.
-func (*CollectT) Reset() {
- panic("Reset() is deprecated")
-}
-
-// Deprecated: That was a method for internal usage that should not have been published. Now just panics.
-func (*CollectT) Copy(TestingT) {
- panic("Copy() is deprecated")
-}
-
-// EventuallyWithT asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// assert.EventuallyWithT(t, func(c *assert.CollectT) {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- var lastFinishedTickErrs []error
- ch := make(chan []error, 1)
-
- timer := time.NewTimer(waitFor)
- defer timer.Stop()
-
- ticker := time.NewTicker(tick)
- defer ticker.Stop()
-
- for tick := ticker.C; ; {
- select {
- case <-timer.C:
- for _, err := range lastFinishedTickErrs {
- t.Errorf("%v", err)
- }
- return Fail(t, "Condition never satisfied", msgAndArgs...)
- case <-tick:
- tick = nil
- go func() {
- collect := new(CollectT)
- defer func() {
- ch <- collect.errors
- }()
- condition(collect)
- }()
- case errs := <-ch:
- if len(errs) == 0 {
- return true
- }
- // Keep the errors from the last ended condition, so that they can be copied to t if timeout is reached.
- lastFinishedTickErrs = errs
- tick = ticker.C
- }
- }
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
-func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ch := make(chan bool, 1)
-
- timer := time.NewTimer(waitFor)
- defer timer.Stop()
-
- ticker := time.NewTicker(tick)
- defer ticker.Stop()
-
- for tick := ticker.C; ; {
- select {
- case <-timer.C:
- return true
- case <-tick:
- tick = nil
- go func() { ch <- condition() }()
- case v := <-ch:
- if v {
- return Fail(t, "Condition satisfied", msgAndArgs...)
- }
- tick = ticker.C
- }
- }
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if errors.Is(err, target) {
- return true
- }
-
- var expectedText string
- if target != nil {
- expectedText = target.Error()
- }
-
- chain := buildErrorChainString(err)
-
- return Fail(t, fmt.Sprintf("Target error should be in err chain:\n"+
- "expected: %q\n"+
- "in chain: %s", expectedText, chain,
- ), msgAndArgs...)
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if !errors.Is(err, target) {
- return true
- }
-
- var expectedText string
- if target != nil {
- expectedText = target.Error()
- }
-
- chain := buildErrorChainString(err)
-
- return Fail(t, fmt.Sprintf("Target error should not be in err chain:\n"+
- "found: %q\n"+
- "in chain: %s", expectedText, chain,
- ), msgAndArgs...)
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if errors.As(err, target) {
- return true
- }
-
- chain := buildErrorChainString(err)
-
- return Fail(t, fmt.Sprintf("Should be in error chain:\n"+
- "expected: %q\n"+
- "in chain: %s", target, chain,
- ), msgAndArgs...)
-}
-
-func buildErrorChainString(err error) string {
- if err == nil {
- return ""
- }
-
- e := errors.Unwrap(err)
- chain := fmt.Sprintf("%q", err.Error())
- for e != nil {
- chain += fmt.Sprintf("\n\t%q", e.Error())
- e = errors.Unwrap(e)
- }
- return chain
-}
diff --git a/internal/testify/assert/assertions_test.go b/internal/testify/assert/assertions_test.go
deleted file mode 100644
index fa004a0a3..000000000
--- a/internal/testify/assert/assertions_test.go
+++ /dev/null
@@ -1,3155 +0,0 @@
-package assert
-
-import (
- "bufio"
- "bytes"
- "encoding/json"
- "errors"
- "fmt"
- "io"
- "math"
- "os"
- "path/filepath"
- "reflect"
- "regexp"
- "runtime"
- "strings"
- "testing"
- "time"
-)
-
-var (
- i interface{}
- zeros = []interface{}{
- false,
- byte(0),
- complex64(0),
- complex128(0),
- float32(0),
- float64(0),
- int(0),
- int8(0),
- int16(0),
- int32(0),
- int64(0),
- rune(0),
- uint(0),
- uint8(0),
- uint16(0),
- uint32(0),
- uint64(0),
- uintptr(0),
- "",
- [0]interface{}{},
- []interface{}(nil),
- struct{ x int }{},
- (*interface{})(nil),
- (func())(nil),
- nil,
- interface{}(nil),
- map[interface{}]interface{}(nil),
- (chan interface{})(nil),
- (<-chan interface{})(nil),
- (chan<- interface{})(nil),
- }
- nonZeros = []interface{}{
- true,
- byte(1),
- complex64(1),
- complex128(1),
- float32(1),
- float64(1),
- int(1),
- int8(1),
- int16(1),
- int32(1),
- int64(1),
- rune(1),
- uint(1),
- uint8(1),
- uint16(1),
- uint32(1),
- uint64(1),
- uintptr(1),
- "s",
- [1]interface{}{1},
- []interface{}{},
- struct{ x int }{1},
- (&i),
- (func() {}),
- interface{}(1),
- map[interface{}]interface{}{},
- (make(chan interface{})),
- (<-chan interface{})(make(chan interface{})),
- (chan<- interface{})(make(chan interface{})),
- }
-)
-
-// AssertionTesterInterface defines an interface to be used for testing assertion methods
-type AssertionTesterInterface interface {
- TestMethod()
-}
-
-// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
-type AssertionTesterConformingObject struct {
-}
-
-func (a *AssertionTesterConformingObject) TestMethod() {
-}
-
-// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
-type AssertionTesterNonConformingObject struct {
-}
-
-func TestObjectsAreEqual(t *testing.T) {
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // cases that are expected to be equal
- {"Hello World", "Hello World", true},
- {123, 123, true},
- {123.5, 123.5, true},
- {[]byte("Hello World"), []byte("Hello World"), true},
- {nil, nil, true},
-
- // cases that are expected not to be equal
- {map[int]int{5: 10}, map[int]int{10: 20}, false},
- {'x', "x", false},
- {"x", 'x', false},
- {0, 0.1, false},
- {0.1, 0, false},
- {time.Now, time.Now, false},
- {func() {}, func() {}, false},
- {uint32(10), int32(10), false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("ObjectsAreEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := ObjectsAreEqual(c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("ObjectsAreEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
-
- })
- }
-}
-
-func TestObjectsAreEqualValues(t *testing.T) {
- now := time.Now()
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- {uint32(10), int32(10), true},
- {0, nil, false},
- {nil, 0, false},
- {now, now.In(time.Local), false}, // should not be time zone independent
- {int(270), int8(14), false}, // should handle overflow/underflow
- {int8(14), int(270), false},
- {[]int{270, 270}, []int8{14, 14}, false},
- {complex128(1e+100 + 1e+100i), complex64(complex(math.Inf(0), math.Inf(0))), false},
- {complex64(complex(math.Inf(0), math.Inf(0))), complex128(1e+100 + 1e+100i), false},
- {complex128(1e+100 + 1e+100i), 270, false},
- {270, complex128(1e+100 + 1e+100i), false},
- {complex128(1e+100 + 1e+100i), 3.14, false},
- {3.14, complex128(1e+100 + 1e+100i), false},
- {complex128(1e+10 + 1e+10i), complex64(1e+10 + 1e+10i), true},
- {complex64(1e+10 + 1e+10i), complex128(1e+10 + 1e+10i), true},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("ObjectsAreEqualValues(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := ObjectsAreEqualValues(c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("ObjectsAreEqualValues(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
- })
- }
-}
-
-type Nested struct {
- Exported interface{}
- notExported interface{}
-}
-
-type S struct {
- Exported1 interface{}
- Exported2 Nested
- notExported1 interface{}
- notExported2 Nested
-}
-
-type S2 struct {
- foo interface{}
-}
-
-type S3 struct {
- Exported1 *Nested
- Exported2 *Nested
-}
-
-type S4 struct {
- Exported1 []*Nested
-}
-
-type S5 struct {
- Exported Nested
-}
-
-type S6 struct {
- Exported string
- unexported string
-}
-
-func TestObjectsExportedFieldsAreEqual(t *testing.T) {
-
- intValue := 1
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, 4, Nested{5, 6}}, true},
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, "a", Nested{5, 6}}, true},
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, 4, Nested{5, "a"}}, true},
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, 3}, 4, Nested{"a", "a"}}, true},
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{2, "a"}, 4, Nested{5, 6}}, true},
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{"a", Nested{2, 3}, 4, Nested{5, 6}}, false},
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S{1, Nested{"a", 3}, 4, Nested{5, 6}}, false},
- {S{1, Nested{2, 3}, 4, Nested{5, 6}}, S2{1}, false},
- {1, S{1, Nested{2, 3}, 4, Nested{5, 6}}, false},
-
- {S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{1, 2}, &Nested{3, 4}}, true},
- {S3{nil, &Nested{3, 4}}, S3{nil, &Nested{3, 4}}, true},
- {S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{1, 2}, &Nested{3, "b"}}, true},
- {S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{1, "a"}, &Nested{3, "b"}}, true},
- {S3{&Nested{1, 2}, &Nested{3, 4}}, S3{&Nested{"a", 2}, &Nested{3, 4}}, false},
- {S3{&Nested{1, 2}, &Nested{3, 4}}, S3{}, false},
- {S3{}, S3{}, true},
-
- {S4{[]*Nested{{1, 2}}}, S4{[]*Nested{{1, 2}}}, true},
- {S4{[]*Nested{{1, 2}}}, S4{[]*Nested{{1, 3}}}, true},
- {S4{[]*Nested{{1, 2}, {3, 4}}}, S4{[]*Nested{{1, "a"}, {3, "b"}}}, true},
- {S4{[]*Nested{{1, 2}, {3, 4}}}, S4{[]*Nested{{1, "a"}, {2, "b"}}}, false},
-
- {Nested{&intValue, 2}, Nested{&intValue, 2}, true},
- {Nested{&Nested{1, 2}, 3}, Nested{&Nested{1, "b"}, 3}, true},
- {Nested{&Nested{1, 2}, 3}, Nested{nil, 3}, false},
-
- {
- Nested{map[interface{}]*Nested{nil: nil}, 2},
- Nested{map[interface{}]*Nested{nil: nil}, 2},
- true,
- },
- {
- Nested{map[interface{}]*Nested{"a": nil}, 2},
- Nested{map[interface{}]*Nested{"a": nil}, 2},
- true,
- },
- {
- Nested{map[interface{}]*Nested{"a": nil}, 2},
- Nested{map[interface{}]*Nested{"a": {1, 2}}, 2},
- false,
- },
- {
- Nested{map[interface{}]Nested{"a": {1, 2}, "b": {3, 4}}, 2},
- Nested{map[interface{}]Nested{"a": {1, 5}, "b": {3, 7}}, 2},
- true,
- },
- {
- Nested{map[interface{}]Nested{"a": {1, 2}, "b": {3, 4}}, 2},
- Nested{map[interface{}]Nested{"a": {2, 2}, "b": {3, 4}}, 2},
- false,
- },
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("ObjectsExportedFieldsAreEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := ObjectsExportedFieldsAreEqual(c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("ObjectsExportedFieldsAreEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
-
- })
- }
-}
-
-func TestCopyExportedFields(t *testing.T) {
- intValue := 1
-
- cases := []struct {
- input interface{}
- expected interface{}
- }{
- {
- input: Nested{"a", "b"},
- expected: Nested{"a", nil},
- },
- {
- input: Nested{&intValue, 2},
- expected: Nested{&intValue, nil},
- },
- {
- input: Nested{nil, 3},
- expected: Nested{nil, nil},
- },
- {
- input: S{1, Nested{2, 3}, 4, Nested{5, 6}},
- expected: S{1, Nested{2, nil}, nil, Nested{}},
- },
- {
- input: S3{},
- expected: S3{},
- },
- {
- input: S3{&Nested{1, 2}, &Nested{3, 4}},
- expected: S3{&Nested{1, nil}, &Nested{3, nil}},
- },
- {
- input: S3{Exported1: &Nested{"a", "b"}},
- expected: S3{Exported1: &Nested{"a", nil}},
- },
- {
- input: S4{[]*Nested{
- nil,
- {1, 2},
- }},
- expected: S4{[]*Nested{
- nil,
- {1, nil},
- }},
- },
- {
- input: S4{[]*Nested{
- {1, 2}},
- },
- expected: S4{[]*Nested{
- {1, nil}},
- },
- },
- {
- input: S4{[]*Nested{
- {1, 2},
- {3, 4},
- }},
- expected: S4{[]*Nested{
- {1, nil},
- {3, nil},
- }},
- },
- {
- input: S5{Exported: Nested{"a", "b"}},
- expected: S5{Exported: Nested{"a", nil}},
- },
- {
- input: S6{"a", "b"},
- expected: S6{"a", ""},
- },
- }
-
- for _, c := range cases {
- t.Run("", func(t *testing.T) {
- output := copyExportedFields(c.input)
- if !ObjectsAreEqualValues(c.expected, output) {
- t.Errorf("%#v, %#v should be equal", c.expected, output)
- }
- })
- }
-}
-
-func TestEqualExportedValues(t *testing.T) {
- cases := []struct {
- value1 interface{}
- value2 interface{}
- expectedEqual bool
- expectedFail string
- }{
- {
- value1: S{1, Nested{2, 3}, 4, Nested{5, 6}},
- value2: S{1, Nested{2, nil}, nil, Nested{}},
- expectedEqual: true,
- },
- {
- value1: S{1, Nested{2, 3}, 4, Nested{5, 6}},
- value2: S{1, Nested{1, nil}, nil, Nested{}},
- expectedEqual: false,
- expectedFail: `
- Diff:
- --- Expected
- +++ Actual
- @@ -3,3 +3,3 @@
- Exported2: (assert.Nested) {
- - Exported: (int) 2,
- + Exported: (int) 1,
- notExported: (interface {}) `,
- },
- {
- value1: S3{&Nested{1, 2}, &Nested{3, 4}},
- value2: S3{&Nested{"a", 2}, &Nested{3, 4}},
- expectedEqual: false,
- expectedFail: `
- Diff:
- --- Expected
- +++ Actual
- @@ -2,3 +2,3 @@
- Exported1: (*assert.Nested)({
- - Exported: (int) 1,
- + Exported: (string) (len=1) "a",
- notExported: (interface {}) `,
- },
- {
- value1: S4{[]*Nested{
- {1, 2},
- {3, 4},
- }},
- value2: S4{[]*Nested{
- {1, "a"},
- {2, "b"},
- }},
- expectedEqual: false,
- expectedFail: `
- Diff:
- --- Expected
- +++ Actual
- @@ -7,3 +7,3 @@
- (*assert.Nested)({
- - Exported: (int) 3,
- + Exported: (int) 2,
- notExported: (interface {}) `,
- },
- {
- value1: S{[2]int{1, 2}, Nested{2, 3}, 4, Nested{5, 6}},
- value2: S{[2]int{1, 2}, Nested{2, nil}, nil, Nested{}},
- expectedEqual: true,
- },
- {
- value1: &S{1, Nested{2, 3}, 4, Nested{5, 6}},
- value2: &S{1, Nested{2, nil}, nil, Nested{}},
- expectedEqual: true,
- },
- {
- value1: &S{1, Nested{2, 3}, 4, Nested{5, 6}},
- value2: &S{1, Nested{1, nil}, nil, Nested{}},
- expectedEqual: false,
- expectedFail: `
- Diff:
- --- Expected
- +++ Actual
- @@ -3,3 +3,3 @@
- Exported2: (assert.Nested) {
- - Exported: (int) 2,
- + Exported: (int) 1,
- notExported: (interface {}) `,
- },
- }
-
- for _, c := range cases {
- t.Run("", func(t *testing.T) {
- mockT := new(mockTestingT)
-
- actual := EqualExportedValues(mockT, c.value1, c.value2)
- if actual != c.expectedEqual {
- t.Errorf("Expected EqualExportedValues to be %t, but was %t", c.expectedEqual, actual)
- }
-
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, c.expectedFail) {
- t.Errorf("Contains failure should include %q but was %q", c.expectedFail, actualFail)
- }
- })
- }
-
-}
-
-func TestImplements(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
- t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
- }
- if Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
- t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
- }
- if Implements(mockT, (*AssertionTesterInterface)(nil), nil) {
- t.Error("Implements method should return false: nil does not implement AssertionTesterInterface")
- }
-
-}
-
-func TestNotImplements(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !NotImplements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
- t.Error("NotImplements method should return true: AssertionTesterNonConformingObject does not implement AssertionTesterInterface")
- }
- if NotImplements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
- t.Error("NotImplements method should return false: AssertionTesterConformingObject implements AssertionTesterInterface")
- }
- if NotImplements(mockT, (*AssertionTesterInterface)(nil), nil) {
- t.Error("NotImplements method should return false: nil can't be checked to be implementing AssertionTesterInterface or not")
- }
-
-}
-
-func TestIsType(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
- t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
- }
- if IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
- t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
- }
-
-}
-
-func TestEqual(t *testing.T) {
- type myType string
-
- mockT := new(testing.T)
- var m map[string]interface{}
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- remark string
- }{
- {"Hello World", "Hello World", true, ""},
- {123, 123, true, ""},
- {123.5, 123.5, true, ""},
- {[]byte("Hello World"), []byte("Hello World"), true, ""},
- {nil, nil, true, ""},
- {int32(123), int32(123), true, ""},
- {uint64(123), uint64(123), true, ""},
- {myType("1"), myType("1"), true, ""},
- {&struct{}{}, &struct{}{}, true, "pointer equality is based on equality of underlying value"},
-
- // Not expected to be equal
- {m["bar"], "something", false, ""},
- {myType("1"), myType("2"), false, ""},
-
- // A case that might be confusing, especially with numeric literals
- {10, uint(10), false, ""},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("Equal(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := Equal(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("Equal(%#v, %#v) should return %#v: %s", c.expected, c.actual, c.result, c.remark)
- }
- })
- }
-}
-
-func ptr(i int) *int {
- return &i
-}
-
-func TestSame(t *testing.T) {
-
- mockT := new(testing.T)
-
- if Same(mockT, ptr(1), ptr(1)) {
- t.Error("Same should return false")
- }
- if Same(mockT, 1, 1) {
- t.Error("Same should return false")
- }
- p := ptr(2)
- if Same(mockT, p, *p) {
- t.Error("Same should return false")
- }
- if !Same(mockT, p, p) {
- t.Error("Same should return true")
- }
-}
-
-func TestNotSame(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !NotSame(mockT, ptr(1), ptr(1)) {
- t.Error("NotSame should return true; different pointers")
- }
- if !NotSame(mockT, 1, 1) {
- t.Error("NotSame should return true; constant inputs")
- }
- p := ptr(2)
- if !NotSame(mockT, p, *p) {
- t.Error("NotSame should return true; mixed-type inputs")
- }
- if NotSame(mockT, p, p) {
- t.Error("NotSame should return false")
- }
-}
-
-func Test_samePointers(t *testing.T) {
- p := ptr(2)
-
- type args struct {
- first interface{}
- second interface{}
- }
- tests := []struct {
- name string
- args args
- assertion BoolAssertionFunc
- }{
- {
- name: "1 != 2",
- args: args{first: 1, second: 2},
- assertion: False,
- },
- {
- name: "1 != 1 (not same ptr)",
- args: args{first: 1, second: 1},
- assertion: False,
- },
- {
- name: "ptr(1) == ptr(1)",
- args: args{first: p, second: p},
- assertion: True,
- },
- {
- name: "int(1) != float32(1)",
- args: args{first: int(1), second: float32(1)},
- assertion: False,
- },
- {
- name: "array != slice",
- args: args{first: [2]int{1, 2}, second: []int{1, 2}},
- assertion: False,
- },
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, samePointers(tt.args.first, tt.args.second))
- })
- }
-}
-
-// bufferT implements TestingT. Its implementation of Errorf writes the output that would be produced by
-// testing.T.Errorf to an internal bytes.Buffer.
-type bufferT struct {
- buf bytes.Buffer
-}
-
-func (t *bufferT) Errorf(format string, args ...interface{}) {
- // implementation of decorate is copied from testing.T
- decorate := func(s string) string {
- _, file, line, ok := runtime.Caller(3) // decorate + log + public function.
- if ok {
- // Truncate file name at last file name separator.
- if index := strings.LastIndex(file, "/"); index >= 0 {
- file = file[index+1:]
- } else if index = strings.LastIndex(file, "\\"); index >= 0 {
- file = file[index+1:]
- }
- } else {
- file = "???"
- line = 1
- }
- buf := new(bytes.Buffer)
- // Every line is indented at least one tab.
- buf.WriteByte('\t')
- fmt.Fprintf(buf, "%s:%d: ", file, line)
- lines := strings.Split(s, "\n")
- if l := len(lines); l > 1 && lines[l-1] == "" {
- lines = lines[:l-1]
- }
- for i, line := range lines {
- if i > 0 {
- // Second and subsequent lines are indented an extra tab.
- buf.WriteString("\n\t\t")
- }
- buf.WriteString(line)
- }
- buf.WriteByte('\n')
- return buf.String()
- }
- t.buf.WriteString(decorate(fmt.Sprintf(format, args...)))
-}
-
-func TestStringEqual(t *testing.T) {
- for i, currCase := range []struct {
- equalWant string
- equalGot string
- msgAndArgs []interface{}
- want string
- }{
- {equalWant: "hi, \nmy name is", equalGot: "what,\nmy name is", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"hi, \\\\nmy name is\"\n\\s+actual\\s+: \"what,\\\\nmy name is\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1,2 \\+1,2 @@\n\\s+-hi, \n\\s+\\+what,\n\\s+my name is"},
- } {
- mockT := &bufferT{}
- Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
- Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
- }
-}
-
-func TestEqualFormatting(t *testing.T) {
- for i, currCase := range []struct {
- equalWant string
- equalGot string
- msgAndArgs []interface{}
- want string
- }{
- {equalWant: "want", equalGot: "got", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n"},
- {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{"hello, %v!", "world"}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+hello, world!\n"},
- {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{123}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+123\n"},
- {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{struct{ a string }{"hello"}}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+{a:hello}\n"},
- } {
- mockT := &bufferT{}
- Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
- Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
- }
-}
-
-func TestFormatUnequalValues(t *testing.T) {
- expected, actual := formatUnequalValues("foo", "bar")
- Equal(t, `"foo"`, expected, "value should not include type")
- Equal(t, `"bar"`, actual, "value should not include type")
-
- expected, actual = formatUnequalValues(123, 123)
- Equal(t, `123`, expected, "value should not include type")
- Equal(t, `123`, actual, "value should not include type")
-
- expected, actual = formatUnequalValues(int64(123), int32(123))
- Equal(t, `int64(123)`, expected, "value should include type")
- Equal(t, `int32(123)`, actual, "value should include type")
-
- expected, actual = formatUnequalValues(int64(123), nil)
- Equal(t, `int64(123)`, expected, "value should include type")
- Equal(t, `()`, actual, "value should include type")
-
- type testStructType struct {
- Val string
- }
-
- expected, actual = formatUnequalValues(&testStructType{Val: "test"}, &testStructType{Val: "test"})
- Equal(t, `&assert.testStructType{Val:"test"}`, expected, "value should not include type annotation")
- Equal(t, `&assert.testStructType{Val:"test"}`, actual, "value should not include type annotation")
-}
-
-func TestNotNil(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !NotNil(mockT, new(AssertionTesterConformingObject)) {
- t.Error("NotNil should return true: object is not nil")
- }
- if NotNil(mockT, nil) {
- t.Error("NotNil should return false: object is nil")
- }
- if NotNil(mockT, (*struct{})(nil)) {
- t.Error("NotNil should return false: object is (*struct{})(nil)")
- }
-
-}
-
-func TestNil(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !Nil(mockT, nil) {
- t.Error("Nil should return true: object is nil")
- }
- if !Nil(mockT, (*struct{})(nil)) {
- t.Error("Nil should return true: object is (*struct{})(nil)")
- }
- if Nil(mockT, new(AssertionTesterConformingObject)) {
- t.Error("Nil should return false: object is not nil")
- }
-
-}
-
-func TestTrue(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !True(mockT, true) {
- t.Error("True should return true")
- }
- if True(mockT, false) {
- t.Error("True should return false")
- }
-
-}
-
-func TestFalse(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !False(mockT, false) {
- t.Error("False should return true")
- }
- if False(mockT, true) {
- t.Error("False should return false")
- }
-
-}
-
-func TestExactly(t *testing.T) {
-
- mockT := new(testing.T)
-
- a := float32(1)
- b := float64(1)
- c := float32(1)
- d := float32(2)
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- {a, b, false},
- {a, d, false},
- {a, c, true},
- {nil, a, false},
- {a, nil, false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("Exactly(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := Exactly(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("Exactly(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
- })
- }
-}
-
-func TestNotEqual(t *testing.T) {
-
- mockT := new(testing.T)
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // cases that are expected not to match
- {"Hello World", "Hello World!", true},
- {123, 1234, true},
- {123.5, 123.55, true},
- {[]byte("Hello World"), []byte("Hello World!"), true},
- {nil, new(AssertionTesterConformingObject), true},
-
- // cases that are expected to match
- {nil, nil, false},
- {"Hello World", "Hello World", false},
- {123, 123, false},
- {123.5, 123.5, false},
- {[]byte("Hello World"), []byte("Hello World"), false},
- {new(AssertionTesterConformingObject), new(AssertionTesterConformingObject), false},
- {&struct{}{}, &struct{}{}, false},
- {func() int { return 23 }, func() int { return 24 }, false},
- // A case that might be confusing, especially with numeric literals
- {int(10), uint(10), true},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("NotEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := NotEqual(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("NotEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
- })
- }
-}
-
-func TestNotEqualValues(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // cases that are expected not to match
- {"Hello World", "Hello World!", true},
- {123, 1234, true},
- {123.5, 123.55, true},
- {[]byte("Hello World"), []byte("Hello World!"), true},
- {nil, new(AssertionTesterConformingObject), true},
-
- // cases that are expected to match
- {nil, nil, false},
- {"Hello World", "Hello World", false},
- {123, 123, false},
- {123.5, 123.5, false},
- {[]byte("Hello World"), []byte("Hello World"), false},
- {new(AssertionTesterConformingObject), new(AssertionTesterConformingObject), false},
- {&struct{}{}, &struct{}{}, false},
-
- // Different behavior from NotEqual()
- {func() int { return 23 }, func() int { return 24 }, true},
- {int(10), int(11), true},
- {int(10), uint(10), false},
-
- {struct{}{}, struct{}{}, false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("NotEqualValues(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := NotEqualValues(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("NotEqualValues(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
- })
- }
-}
-
-func TestContainsNotContains(t *testing.T) {
-
- type A struct {
- Name, Value string
- }
- list := []string{"Foo", "Bar"}
-
- complexList := []*A{
- {"b", "c"},
- {"d", "e"},
- {"g", "h"},
- {"j", "k"},
- }
- simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
- var zeroMap map[interface{}]interface{}
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- {"Hello World", "Hello", true},
- {"Hello World", "Salut", false},
- {list, "Bar", true},
- {list, "Salut", false},
- {complexList, &A{"g", "h"}, true},
- {complexList, &A{"g", "e"}, false},
- {simpleMap, "Foo", true},
- {simpleMap, "Bar", false},
- {zeroMap, "Bar", false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("Contains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- mockT := new(testing.T)
- res := Contains(mockT, c.expected, c.actual)
-
- if res != c.result {
- if res {
- t.Errorf("Contains(%#v, %#v) should return true:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
- } else {
- t.Errorf("Contains(%#v, %#v) should return false:\n\t%#v does not contain %#v", c.expected, c.actual, c.expected, c.actual)
- }
- }
- })
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("NotContains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- mockT := new(testing.T)
- res := NotContains(mockT, c.expected, c.actual)
-
- // NotContains should be inverse of Contains. If it's not, something is wrong
- if res == Contains(mockT, c.expected, c.actual) {
- if res {
- t.Errorf("NotContains(%#v, %#v) should return true:\n\t%#v does not contains %#v", c.expected, c.actual, c.expected, c.actual)
- } else {
- t.Errorf("NotContains(%#v, %#v) should return false:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
- }
- }
- })
- }
-}
-
-func TestContainsNotContainsFailMessage(t *testing.T) {
- mockT := new(mockTestingT)
-
- type nonContainer struct {
- Value string
- }
-
- cases := []struct {
- assertion func(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool
- container interface{}
- instance interface{}
- expected string
- }{
- {
- assertion: Contains,
- container: "Hello World",
- instance: errors.New("Hello"),
- expected: "\"Hello World\" does not contain &errors.errorString{s:\"Hello\"}",
- },
- {
- assertion: Contains,
- container: map[string]int{"one": 1},
- instance: "two",
- expected: "map[string]int{\"one\":1} does not contain \"two\"\n",
- },
- {
- assertion: NotContains,
- container: map[string]int{"one": 1},
- instance: "one",
- expected: "map[string]int{\"one\":1} should not contain \"one\"",
- },
- {
- assertion: Contains,
- container: nonContainer{Value: "Hello"},
- instance: "Hello",
- expected: "assert.nonContainer{Value:\"Hello\"} could not be applied builtin len()\n",
- },
- {
- assertion: NotContains,
- container: nonContainer{Value: "Hello"},
- instance: "Hello",
- expected: "assert.nonContainer{Value:\"Hello\"} could not be applied builtin len()\n",
- },
- }
- for _, c := range cases {
- name := filepath.Base(runtime.FuncForPC(reflect.ValueOf(c.assertion).Pointer()).Name())
- t.Run(fmt.Sprintf("%v(%T, %T)", name, c.container, c.instance), func(t *testing.T) {
- c.assertion(mockT, c.container, c.instance)
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, c.expected) {
- t.Errorf("Contains failure should include %q but was %q", c.expected, actualFail)
- }
- })
- }
-}
-
-func TestContainsNotContainsOnNilValue(t *testing.T) {
- mockT := new(mockTestingT)
-
- Contains(mockT, nil, "key")
- expectedFail := " could not be applied builtin len()"
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, expectedFail) {
- t.Errorf("Contains failure should include %q but was %q", expectedFail, actualFail)
- }
-
- NotContains(mockT, nil, "key")
- if !strings.Contains(actualFail, expectedFail) {
- t.Errorf("Contains failure should include %q but was %q", expectedFail, actualFail)
- }
-}
-
-func TestSubsetNotSubset(t *testing.T) {
- cases := []struct {
- list interface{}
- subset interface{}
- result bool
- message string
- }{
- // cases that are expected to contain
- {[]int{1, 2, 3}, nil, true, `nil is the empty set which is a subset of every set`},
- {[]int{1, 2, 3}, []int{}, true, `[] is a subset of ['\x01' '\x02' '\x03']`},
- {[]int{1, 2, 3}, []int{1, 2}, true, `['\x01' '\x02'] is a subset of ['\x01' '\x02' '\x03']`},
- {[]int{1, 2, 3}, []int{1, 2, 3}, true, `['\x01' '\x02' '\x03'] is a subset of ['\x01' '\x02' '\x03']`},
- {[]string{"hello", "world"}, []string{"hello"}, true, `["hello"] is a subset of ["hello" "world"]`},
- {map[string]string{
- "a": "x",
- "c": "z",
- "b": "y",
- }, map[string]string{
- "a": "x",
- "b": "y",
- }, true, `map["a":"x" "b":"y"] is a subset of map["a":"x" "b":"y" "c":"z"]`},
-
- // cases that are expected not to contain
- {[]string{"hello", "world"}, []string{"hello", "testify"}, false, `[]string{"hello", "world"} does not contain "testify"`},
- {[]int{1, 2, 3}, []int{4, 5}, false, `[]int{1, 2, 3} does not contain 4`},
- {[]int{1, 2, 3}, []int{1, 5}, false, `[]int{1, 2, 3} does not contain 5`},
- {map[string]string{
- "a": "x",
- "c": "z",
- "b": "y",
- }, map[string]string{
- "a": "x",
- "b": "z",
- }, false, `map[string]string{"a":"x", "b":"y", "c":"z"} does not contain map[string]string{"a":"x", "b":"z"}`},
- {map[string]string{
- "a": "x",
- "b": "y",
- }, map[string]string{
- "a": "x",
- "b": "y",
- "c": "z",
- }, false, `map[string]string{"a":"x", "b":"y"} does not contain map[string]string{"a":"x", "b":"y", "c":"z"}`},
- }
-
- for _, c := range cases {
- t.Run("SubSet: "+c.message, func(t *testing.T) {
-
- mockT := new(mockTestingT)
- res := Subset(mockT, c.list, c.subset)
-
- if res != c.result {
- t.Errorf("Subset should return %t: %s", c.result, c.message)
- }
- if !c.result {
- expectedFail := c.message
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, expectedFail) {
- t.Log(actualFail)
- t.Errorf("Subset failure should contain %q but was %q", expectedFail, actualFail)
- }
- }
- })
- }
- for _, c := range cases {
- t.Run("NotSubSet: "+c.message, func(t *testing.T) {
- mockT := new(mockTestingT)
- res := NotSubset(mockT, c.list, c.subset)
-
- // NotSubset should match the inverse of Subset. If it doesn't, something is wrong
- if res == Subset(mockT, c.list, c.subset) {
- t.Errorf("NotSubset should return %t: %s", !c.result, c.message)
- }
- if c.result {
- expectedFail := c.message
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, expectedFail) {
- t.Log(actualFail)
- t.Errorf("NotSubset failure should contain %q but was %q", expectedFail, actualFail)
- }
- }
- })
- }
-}
-
-func TestNotSubsetNil(t *testing.T) {
- mockT := new(testing.T)
- NotSubset(mockT, []string{"foo"}, nil)
- if !mockT.Failed() {
- t.Error("NotSubset on nil set should have failed the test")
- }
-}
-
-func Test_containsElement(t *testing.T) {
-
- list1 := []string{"Foo", "Bar"}
- list2 := []int{1, 2}
- simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
-
- ok, found := containsElement("Hello World", "World")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list1, "Foo")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list1, "Bar")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list2, 1)
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list2, 2)
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list1, "Foo!")
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(list2, 3)
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(list2, "1")
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(simpleMap, "Foo")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(simpleMap, "Bar")
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(1433, "1")
- False(t, ok)
- False(t, found)
-}
-
-func TestElementsMatch(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // matching
- {nil, nil, true},
-
- {nil, nil, true},
- {[]int{}, []int{}, true},
- {[]int{1}, []int{1}, true},
- {[]int{1, 1}, []int{1, 1}, true},
- {[]int{1, 2}, []int{1, 2}, true},
- {[]int{1, 2}, []int{2, 1}, true},
- {[2]int{1, 2}, [2]int{2, 1}, true},
- {[]string{"hello", "world"}, []string{"world", "hello"}, true},
- {[]string{"hello", "hello"}, []string{"hello", "hello"}, true},
- {[]string{"hello", "hello", "world"}, []string{"hello", "world", "hello"}, true},
- {[3]string{"hello", "hello", "world"}, [3]string{"hello", "world", "hello"}, true},
- {[]int{}, nil, true},
-
- // not matching
- {[]int{1}, []int{1, 1}, false},
- {[]int{1, 2}, []int{2, 2}, false},
- {[]string{"hello", "hello"}, []string{"hello"}, false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("ElementsMatch(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := ElementsMatch(mockT, c.actual, c.expected)
-
- if res != c.result {
- t.Errorf("ElementsMatch(%#v, %#v) should return %v", c.actual, c.expected, c.result)
- }
- })
- }
-}
-
-func TestDiffLists(t *testing.T) {
- tests := []struct {
- name string
- listA interface{}
- listB interface{}
- extraA []interface{}
- extraB []interface{}
- }{
- {
- name: "equal empty",
- listA: []string{},
- listB: []string{},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "equal same order",
- listA: []string{"hello", "world"},
- listB: []string{"hello", "world"},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "equal different order",
- listA: []string{"hello", "world"},
- listB: []string{"world", "hello"},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "extra A",
- listA: []string{"hello", "hello", "world"},
- listB: []string{"hello", "world"},
- extraA: []interface{}{"hello"},
- extraB: nil,
- },
- {
- name: "extra A twice",
- listA: []string{"hello", "hello", "hello", "world"},
- listB: []string{"hello", "world"},
- extraA: []interface{}{"hello", "hello"},
- extraB: nil,
- },
- {
- name: "extra B",
- listA: []string{"hello", "world"},
- listB: []string{"hello", "hello", "world"},
- extraA: nil,
- extraB: []interface{}{"hello"},
- },
- {
- name: "extra B twice",
- listA: []string{"hello", "world"},
- listB: []string{"hello", "hello", "world", "hello"},
- extraA: nil,
- extraB: []interface{}{"hello", "hello"},
- },
- {
- name: "integers 1",
- listA: []int{1, 2, 3, 4, 5},
- listB: []int{5, 4, 3, 2, 1},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "integers 2",
- listA: []int{1, 2, 1, 2, 1},
- listB: []int{2, 1, 2, 1, 2},
- extraA: []interface{}{1},
- extraB: []interface{}{2},
- },
- }
- for _, test := range tests {
- test := test
- t.Run(test.name, func(t *testing.T) {
- actualExtraA, actualExtraB := diffLists(test.listA, test.listB)
- Equal(t, test.extraA, actualExtraA, "extra A does not match for listA=%v listB=%v",
- test.listA, test.listB)
- Equal(t, test.extraB, actualExtraB, "extra B does not match for listA=%v listB=%v",
- test.listA, test.listB)
- })
- }
-}
-
-func TestCondition(t *testing.T) {
- mockT := new(testing.T)
-
- if !Condition(mockT, func() bool { return true }, "Truth") {
- t.Error("Condition should return true")
- }
-
- if Condition(mockT, func() bool { return false }, "Lie") {
- t.Error("Condition should return false")
- }
-
-}
-
-func TestDidPanic(t *testing.T) {
-
- const panicMsg = "Panic!"
-
- if funcDidPanic, msg, _ := didPanic(func() {
- panic(panicMsg)
- }); !funcDidPanic || msg != panicMsg {
- t.Error("didPanic should return true, panicMsg")
- }
-
- if funcDidPanic, msg, _ := didPanic(func() {
- panic(nil)
- }); !funcDidPanic || msg != nil {
- t.Error("didPanic should return true, nil")
- }
-
- if funcDidPanic, _, _ := didPanic(func() {
- }); funcDidPanic {
- t.Error("didPanic should return false")
- }
-
-}
-
-func TestPanics(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !Panics(mockT, func() {
- panic("Panic!")
- }) {
- t.Error("Panics should return true")
- }
-
- if Panics(mockT, func() {
- }) {
- t.Error("Panics should return false")
- }
-
-}
-
-func TestPanicsWithValue(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !PanicsWithValue(mockT, "Panic!", func() {
- panic("Panic!")
- }) {
- t.Error("PanicsWithValue should return true")
- }
-
- if !PanicsWithValue(mockT, nil, func() {
- panic(nil)
- }) {
- t.Error("PanicsWithValue should return true")
- }
-
- if PanicsWithValue(mockT, "Panic!", func() {
- }) {
- t.Error("PanicsWithValue should return false")
- }
-
- if PanicsWithValue(mockT, "at the disco", func() {
- panic("Panic!")
- }) {
- t.Error("PanicsWithValue should return false")
- }
-}
-
-func TestPanicsWithError(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !PanicsWithError(mockT, "panic", func() {
- panic(errors.New("panic"))
- }) {
- t.Error("PanicsWithError should return true")
- }
-
- if PanicsWithError(mockT, "Panic!", func() {
- }) {
- t.Error("PanicsWithError should return false")
- }
-
- if PanicsWithError(mockT, "at the disco", func() {
- panic(errors.New("panic"))
- }) {
- t.Error("PanicsWithError should return false")
- }
-
- if PanicsWithError(mockT, "Panic!", func() {
- panic("panic")
- }) {
- t.Error("PanicsWithError should return false")
- }
-}
-
-func TestNotPanics(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !NotPanics(mockT, func() {
- }) {
- t.Error("NotPanics should return true")
- }
-
- if NotPanics(mockT, func() {
- panic("Panic!")
- }) {
- t.Error("NotPanics should return false")
- }
-
-}
-
-func TestNoError(t *testing.T) {
-
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
-
- True(t, NoError(mockT, err), "NoError should return True for nil arg")
-
- // now set an error
- err = errors.New("some error")
-
- False(t, NoError(mockT, err), "NoError with error should return False")
-
- // returning an empty error interface
- err = func() error {
- var err *customError
- return err
- }()
-
- if err == nil { // err is not nil here!
- t.Errorf("Error should be nil due to empty interface: %s", err)
- }
-
- False(t, NoError(mockT, err), "NoError should fail with empty error interface")
-}
-
-type customError struct{}
-
-func (*customError) Error() string { return "fail" }
-
-func TestError(t *testing.T) {
-
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
-
- False(t, Error(mockT, err), "Error should return False for nil arg")
-
- // now set an error
- err = errors.New("some error")
-
- True(t, Error(mockT, err), "Error with error should return True")
-
- // go vet check
- True(t, Errorf(mockT, err, "example with %s", "formatted message"), "Errorf with error should return True")
-
- // returning an empty error interface
- err = func() error {
- var err *customError
- return err
- }()
-
- if err == nil { // err is not nil here!
- t.Errorf("Error should be nil due to empty interface: %s", err)
- }
-
- True(t, Error(mockT, err), "Error should pass with empty error interface")
-}
-
-func TestEqualError(t *testing.T) {
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
- False(t, EqualError(mockT, err, ""),
- "EqualError should return false for nil arg")
-
- // now set an error
- err = errors.New("some error")
- False(t, EqualError(mockT, err, "Not some error"),
- "EqualError should return false for different error string")
- True(t, EqualError(mockT, err, "some error"),
- "EqualError should return true")
-}
-
-func TestErrorContains(t *testing.T) {
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
- False(t, ErrorContains(mockT, err, ""),
- "ErrorContains should return false for nil arg")
-
- // now set an error
- err = errors.New("some error: another error")
- False(t, ErrorContains(mockT, err, "bad error"),
- "ErrorContains should return false for different error string")
- True(t, ErrorContains(mockT, err, "some error"),
- "ErrorContains should return true")
- True(t, ErrorContains(mockT, err, "another error"),
- "ErrorContains should return true")
-}
-
-func Test_isEmpty(t *testing.T) {
-
- chWithValue := make(chan struct{}, 1)
- chWithValue <- struct{}{}
-
- True(t, isEmpty(""))
- True(t, isEmpty(nil))
- True(t, isEmpty([]string{}))
- True(t, isEmpty(0))
- True(t, isEmpty(int32(0)))
- True(t, isEmpty(int64(0)))
- True(t, isEmpty(false))
- True(t, isEmpty(map[string]string{}))
- True(t, isEmpty(new(time.Time)))
- True(t, isEmpty(time.Time{}))
- True(t, isEmpty(make(chan struct{})))
- True(t, isEmpty([1]int{}))
- False(t, isEmpty("something"))
- False(t, isEmpty(errors.New("something")))
- False(t, isEmpty([]string{"something"}))
- False(t, isEmpty(1))
- False(t, isEmpty(true))
- False(t, isEmpty(map[string]string{"Hello": "World"}))
- False(t, isEmpty(chWithValue))
- False(t, isEmpty([1]int{42}))
-}
-
-func TestEmpty(t *testing.T) {
-
- mockT := new(testing.T)
- chWithValue := make(chan struct{}, 1)
- chWithValue <- struct{}{}
- var tiP *time.Time
- var tiNP time.Time
- var s *string
- var f *os.File
- sP := &s
- x := 1
- xP := &x
-
- type TString string
- type TStruct struct {
- x int
- }
-
- True(t, Empty(mockT, ""), "Empty string is empty")
- True(t, Empty(mockT, nil), "Nil is empty")
- True(t, Empty(mockT, []string{}), "Empty string array is empty")
- True(t, Empty(mockT, 0), "Zero int value is empty")
- True(t, Empty(mockT, false), "False value is empty")
- True(t, Empty(mockT, make(chan struct{})), "Channel without values is empty")
- True(t, Empty(mockT, s), "Nil string pointer is empty")
- True(t, Empty(mockT, f), "Nil os.File pointer is empty")
- True(t, Empty(mockT, tiP), "Nil time.Time pointer is empty")
- True(t, Empty(mockT, tiNP), "time.Time is empty")
- True(t, Empty(mockT, TStruct{}), "struct with zero values is empty")
- True(t, Empty(mockT, TString("")), "empty aliased string is empty")
- True(t, Empty(mockT, sP), "ptr to nil value is empty")
- True(t, Empty(mockT, [1]int{}), "array is state")
-
- False(t, Empty(mockT, "something"), "Non Empty string is not empty")
- False(t, Empty(mockT, errors.New("something")), "Non nil object is not empty")
- False(t, Empty(mockT, []string{"something"}), "Non empty string array is not empty")
- False(t, Empty(mockT, 1), "Non-zero int value is not empty")
- False(t, Empty(mockT, true), "True value is not empty")
- False(t, Empty(mockT, chWithValue), "Channel with values is not empty")
- False(t, Empty(mockT, TStruct{x: 1}), "struct with initialized values is empty")
- False(t, Empty(mockT, TString("abc")), "non-empty aliased string is empty")
- False(t, Empty(mockT, xP), "ptr to non-nil value is not empty")
- False(t, Empty(mockT, [1]int{42}), "array is not state")
-}
-
-func TestNotEmpty(t *testing.T) {
-
- mockT := new(testing.T)
- chWithValue := make(chan struct{}, 1)
- chWithValue <- struct{}{}
-
- False(t, NotEmpty(mockT, ""), "Empty string is empty")
- False(t, NotEmpty(mockT, nil), "Nil is empty")
- False(t, NotEmpty(mockT, []string{}), "Empty string array is empty")
- False(t, NotEmpty(mockT, 0), "Zero int value is empty")
- False(t, NotEmpty(mockT, false), "False value is empty")
- False(t, NotEmpty(mockT, make(chan struct{})), "Channel without values is empty")
- False(t, NotEmpty(mockT, [1]int{}), "array is state")
-
- True(t, NotEmpty(mockT, "something"), "Non Empty string is not empty")
- True(t, NotEmpty(mockT, errors.New("something")), "Non nil object is not empty")
- True(t, NotEmpty(mockT, []string{"something"}), "Non empty string array is not empty")
- True(t, NotEmpty(mockT, 1), "Non-zero int value is not empty")
- True(t, NotEmpty(mockT, true), "True value is not empty")
- True(t, NotEmpty(mockT, chWithValue), "Channel with values is not empty")
- True(t, NotEmpty(mockT, [1]int{42}), "array is not state")
-}
-
-func Test_getLen(t *testing.T) {
- falseCases := []interface{}{
- nil,
- 0,
- true,
- false,
- 'A',
- struct{}{},
- }
- for _, v := range falseCases {
- l, ok := getLen(v)
- False(t, ok, "Expected getLen fail to get length of %#v", v)
- Equal(t, 0, l, "getLen should return 0 for %#v", v)
- }
-
- ch := make(chan int, 5)
- ch <- 1
- ch <- 2
- ch <- 3
- trueCases := []struct {
- v interface{}
- l int
- }{
- {[]int{1, 2, 3}, 3},
- {[...]int{1, 2, 3}, 3},
- {"ABC", 3},
- {map[int]int{1: 2, 2: 4, 3: 6}, 3},
- {ch, 3},
-
- {[]int{}, 0},
- {map[int]int{}, 0},
- {make(chan int), 0},
-
- {[]int(nil), 0},
- {map[int]int(nil), 0},
- {(chan int)(nil), 0},
- }
-
- for _, c := range trueCases {
- l, ok := getLen(c.v)
- True(t, ok, "Expected getLen success to get length of %#v", c.v)
- Equal(t, c.l, l)
- }
-}
-
-func TestLen(t *testing.T) {
- mockT := new(testing.T)
-
- False(t, Len(mockT, nil, 0), "nil does not have length")
- False(t, Len(mockT, 0, 0), "int does not have length")
- False(t, Len(mockT, true, 0), "true does not have length")
- False(t, Len(mockT, false, 0), "false does not have length")
- False(t, Len(mockT, 'A', 0), "Rune does not have length")
- False(t, Len(mockT, struct{}{}, 0), "Struct does not have length")
-
- ch := make(chan int, 5)
- ch <- 1
- ch <- 2
- ch <- 3
-
- cases := []struct {
- v interface{}
- l int
- expected1234567 string // message when expecting 1234567 items
- }{
- {[]int{1, 2, 3}, 3, `"[1 2 3]" should have 1234567 item(s), but has 3`},
- {[...]int{1, 2, 3}, 3, `"[1 2 3]" should have 1234567 item(s), but has 3`},
- {"ABC", 3, `"ABC" should have 1234567 item(s), but has 3`},
- {map[int]int{1: 2, 2: 4, 3: 6}, 3, `"map[1:2 2:4 3:6]" should have 1234567 item(s), but has 3`},
- {ch, 3, ""},
-
- {[]int{}, 0, `"[]" should have 1234567 item(s), but has 0`},
- {map[int]int{}, 0, `"map[]" should have 1234567 item(s), but has 0`},
- {make(chan int), 0, ""},
-
- {[]int(nil), 0, `"[]" should have 1234567 item(s), but has 0`},
- {map[int]int(nil), 0, `"map[]" should have 1234567 item(s), but has 0`},
- {(chan int)(nil), 0, `"" should have 1234567 item(s), but has 0`},
- }
-
- for _, c := range cases {
- True(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
- False(t, Len(mockT, c.v, c.l+1), "%#v have %d items", c.v, c.l)
- if c.expected1234567 != "" {
- msgMock := new(mockTestingT)
- Len(msgMock, c.v, 1234567)
- Contains(t, msgMock.errorString(), c.expected1234567)
- }
- }
-}
-
-func TestWithinDuration(t *testing.T) {
-
- mockT := new(testing.T)
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- True(t, WithinDuration(mockT, a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
- True(t, WithinDuration(mockT, b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
-
- False(t, WithinDuration(mockT, a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
- False(t, WithinDuration(mockT, b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
-
- False(t, WithinDuration(mockT, a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
- False(t, WithinDuration(mockT, b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
-
- False(t, WithinDuration(mockT, a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
- False(t, WithinDuration(mockT, b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
-}
-
-func TestWithinRange(t *testing.T) {
-
- mockT := new(testing.T)
- n := time.Now()
- s := n.Add(-time.Second)
- e := n.Add(time.Second)
-
- True(t, WithinRange(mockT, n, n, n), "Exact same actual, start, and end values return true")
-
- True(t, WithinRange(mockT, n, s, e), "Time in range is within the time range")
- True(t, WithinRange(mockT, s, s, e), "The start time is within the time range")
- True(t, WithinRange(mockT, e, s, e), "The end time is within the time range")
-
- False(t, WithinRange(mockT, s.Add(-time.Nanosecond), s, e, "Just before the start time is not within the time range"))
- False(t, WithinRange(mockT, e.Add(time.Nanosecond), s, e, "Just after the end time is not within the time range"))
-
- False(t, WithinRange(mockT, n, e, s, "Just after the end time is not within the time range"))
-}
-
-func TestInDelta(t *testing.T) {
- mockT := new(testing.T)
-
- True(t, InDelta(mockT, 1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
- True(t, InDelta(mockT, 1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
- True(t, InDelta(mockT, 1, 2, 1), "|1 - 2| <= 1")
- False(t, InDelta(mockT, 1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
- False(t, InDelta(mockT, 2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
- False(t, InDelta(mockT, "", nil, 1), "Expected non numerals to fail")
- False(t, InDelta(mockT, 42, math.NaN(), 0.01), "Expected NaN for actual to fail")
- False(t, InDelta(mockT, math.NaN(), 42, 0.01), "Expected NaN for expected to fail")
- True(t, InDelta(mockT, math.NaN(), math.NaN(), 0.01), "Expected NaN for both to pass")
-
- cases := []struct {
- a, b interface{}
- delta float64
- }{
- {uint(2), uint(1), 1},
- {uint8(2), uint8(1), 1},
- {uint16(2), uint16(1), 1},
- {uint32(2), uint32(1), 1},
- {uint64(2), uint64(1), 1},
-
- {int(2), int(1), 1},
- {int8(2), int8(1), 1},
- {int16(2), int16(1), 1},
- {int32(2), int32(1), 1},
- {int64(2), int64(1), 1},
-
- {float32(2), float32(1), 1},
- {float64(2), float64(1), 1},
- }
-
- for _, tc := range cases {
- True(t, InDelta(mockT, tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
- }
-}
-
-func TestInDeltaSlice(t *testing.T) {
- mockT := new(testing.T)
-
- True(t, InDeltaSlice(mockT,
- []float64{1.001, math.NaN(), 0.999},
- []float64{1, math.NaN(), 1},
- 0.1), "{1.001, NaN, 0.009} is element-wise close to {1, NaN, 1} in delta=0.1")
-
- True(t, InDeltaSlice(mockT,
- []float64{1, math.NaN(), 2},
- []float64{0, math.NaN(), 3},
- 1), "{1, NaN, 2} is element-wise close to {0, NaN, 3} in delta=1")
-
- False(t, InDeltaSlice(mockT,
- []float64{1, math.NaN(), 2},
- []float64{0, math.NaN(), 3},
- 0.1), "{1, NaN, 2} is not element-wise close to {0, NaN, 3} in delta=0.1")
-
- False(t, InDeltaSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
-}
-
-func TestInDeltaMapValues(t *testing.T) {
- mockT := new(testing.T)
-
- for _, tc := range []struct {
- title string
- expect interface{}
- actual interface{}
- f func(TestingT, bool, ...interface{}) bool
- delta float64
- }{
- {
- title: "Within delta",
- expect: map[string]float64{
- "foo": 1.0,
- "bar": 2.0,
- "baz": math.NaN(),
- },
- actual: map[string]float64{
- "foo": 1.01,
- "bar": 1.99,
- "baz": math.NaN(),
- },
- delta: 0.1,
- f: True,
- },
- {
- title: "Within delta",
- expect: map[int]float64{
- 1: 1.0,
- 2: 2.0,
- },
- actual: map[int]float64{
- 1: 1.0,
- 2: 1.99,
- },
- delta: 0.1,
- f: True,
- },
- {
- title: "Different number of keys",
- expect: map[int]float64{
- 1: 1.0,
- 2: 2.0,
- },
- actual: map[int]float64{
- 1: 1.0,
- },
- delta: 0.1,
- f: False,
- },
- {
- title: "Within delta with zero value",
- expect: map[string]float64{
- "zero": 0,
- },
- actual: map[string]float64{
- "zero": 0,
- },
- delta: 0.1,
- f: True,
- },
- {
- title: "With missing key with zero value",
- expect: map[string]float64{
- "zero": 0,
- "foo": 0,
- },
- actual: map[string]float64{
- "zero": 0,
- "bar": 0,
- },
- f: False,
- },
- } {
- tc.f(t, InDeltaMapValues(mockT, tc.expect, tc.actual, tc.delta), tc.title+"\n"+diff(tc.expect, tc.actual))
- }
-}
-
-func TestInEpsilon(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), uint16(2), .001},
- {2.1, 2.2, 0.1},
- {2.2, 2.1, 0.1},
- {-2.1, -2.2, 0.1},
- {-2.2, -2.1, 0.1},
- {uint64(100), uint8(101), 0.01},
- {0.1, -0.1, 2},
- {0.1, 0, 2},
- {math.NaN(), math.NaN(), 1},
- {time.Second, time.Second + time.Millisecond, 0.002},
- }
-
- for _, tc := range cases {
- True(t, InEpsilon(t, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon), "test: %q", tc)
- }
-
- cases = []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), int16(-2), .001},
- {uint64(100), uint8(102), 0.01},
- {2.1, 2.2, 0.001},
- {2.2, 2.1, 0.001},
- {2.1, -2.2, 1},
- {2.1, "bla-bla", 0},
- {0.1, -0.1, 1.99},
- {0, 0.1, 2}, // expected must be different to zero
- {time.Second, time.Second + 10*time.Millisecond, 0.002},
- {math.NaN(), 0, 1},
- {0, math.NaN(), 1},
- {0, 0, math.NaN()},
- }
-
- for _, tc := range cases {
- False(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
- }
-
-}
-
-func TestInEpsilonSlice(t *testing.T) {
- mockT := new(testing.T)
-
- True(t, InEpsilonSlice(mockT,
- []float64{2.2, math.NaN(), 2.0},
- []float64{2.1, math.NaN(), 2.1},
- 0.06), "{2.2, NaN, 2.0} is element-wise close to {2.1, NaN, 2.1} in epsilon=0.06")
-
- False(t, InEpsilonSlice(mockT,
- []float64{2.2, 2.0},
- []float64{2.1, 2.1},
- 0.04), "{2.2, 2.0} is not element-wise close to {2.1, 2.1} in epsilon=0.04")
-
- False(t, InEpsilonSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
-}
-
-func TestRegexp(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- rx, str string
- }{
- {"^start", "start of the line"},
- {"end$", "in the end"},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
- }
-
- for _, tc := range cases {
- True(t, Regexp(mockT, tc.rx, tc.str))
- True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- False(t, NotRegexp(mockT, tc.rx, tc.str))
- False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- }
-
- cases = []struct {
- rx, str string
- }{
- {"^asdfastart", "Not the start of the line"},
- {"end$", "in the end."},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
- }
-
- for _, tc := range cases {
- False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
- False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- True(t, NotRegexp(mockT, tc.rx, tc.str))
- True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- }
-}
-
-func testAutogeneratedFunction() {
- defer func() {
- if err := recover(); err == nil {
- panic("did not panic")
- }
- CallerInfo()
- }()
- t := struct {
- io.Closer
- }{}
- c := t
- c.Close()
-}
-
-func TestCallerInfoWithAutogeneratedFunctions(t *testing.T) {
- NotPanics(t, func() {
- testAutogeneratedFunction()
- })
-}
-
-func TestZero(t *testing.T) {
- mockT := new(testing.T)
-
- for _, test := range zeros {
- True(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-
- for _, test := range nonZeros {
- False(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-}
-
-func TestNotZero(t *testing.T) {
- mockT := new(testing.T)
-
- for _, test := range zeros {
- False(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-
- for _, test := range nonZeros {
- True(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-}
-
-func TestFileExists(t *testing.T) {
- mockT := new(testing.T)
- True(t, FileExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- False(t, FileExists(mockT, "random_file"))
-
- mockT = new(testing.T)
- False(t, FileExists(mockT, "../_codegen"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, FileExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_file")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, FileExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func TestNoFileExists(t *testing.T) {
- mockT := new(testing.T)
- False(t, NoFileExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- True(t, NoFileExists(mockT, "non_existent_file"))
-
- mockT = new(testing.T)
- True(t, NoFileExists(mockT, "../_codegen"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, NoFileExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_file")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, NoFileExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func getTempSymlinkPath(file string) (string, error) {
- link := file + "_symlink"
- err := os.Symlink(file, link)
- return link, err
-}
-
-func cleanUpTempFiles(paths []string) []error {
- var res []error
- for _, path := range paths {
- err := os.Remove(path)
- if err != nil {
- res = append(res, err)
- }
- }
- return res
-}
-
-func TestDirExists(t *testing.T) {
- mockT := new(testing.T)
- False(t, DirExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- False(t, DirExists(mockT, "non_existent_dir"))
-
- mockT = new(testing.T)
- True(t, DirExists(mockT, "../assert"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, DirExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_dir")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, DirExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func TestNoDirExists(t *testing.T) {
- mockT := new(testing.T)
- True(t, NoDirExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- True(t, NoDirExists(mockT, "non_existent_dir"))
-
- mockT = new(testing.T)
- False(t, NoDirExists(mockT, "../assert"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, NoDirExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_dir")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, NoDirExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func TestJSONEq_EqualSONString(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`))
-}
-
-func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}"))
-}
-
-func TestJSONEq_Array(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`))
-}
-
-func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`))
-}
-
-func TestJSONEq_HashesNotEquivalent(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestJSONEq_ActualIsNotJSON(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `{"foo": "bar"}`, "Not JSON"))
-}
-
-func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, "Not JSON", "Not JSON"))
-}
-
-func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`))
-}
-
-type diffTestingStruct struct {
- A string
- B int
-}
-
-func (d *diffTestingStruct) String() string {
- return d.A
-}
-
-func TestDiff(t *testing.T) {
- expected := `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,3 +1,3 @@
- (struct { foo string }) {
-- foo: (string) (len=5) "hello"
-+ foo: (string) (len=3) "bar"
- }
-`
- actual := diff(
- struct{ foo string }{"hello"},
- struct{ foo string }{"bar"},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -2,5 +2,5 @@
- (int) 1,
-- (int) 2,
- (int) 3,
-- (int) 4
-+ (int) 5,
-+ (int) 7
- }
-`
- actual = diff(
- []int{1, 2, 3, 4},
- []int{1, 3, 5, 7},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -2,4 +2,4 @@
- (int) 1,
-- (int) 2,
-- (int) 3
-+ (int) 3,
-+ (int) 5
- }
-`
- actual = diff(
- []int{1, 2, 3, 4}[0:3],
- []int{1, 3, 5, 7}[0:3],
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,6 +1,6 @@
- (map[string]int) (len=4) {
-- (string) (len=4) "four": (int) 4,
-+ (string) (len=4) "five": (int) 5,
- (string) (len=3) "one": (int) 1,
-- (string) (len=5) "three": (int) 3,
-- (string) (len=3) "two": (int) 2
-+ (string) (len=5) "seven": (int) 7,
-+ (string) (len=5) "three": (int) 3
- }
-`
-
- actual = diff(
- map[string]int{"one": 1, "two": 2, "three": 3, "four": 4},
- map[string]int{"one": 1, "three": 3, "five": 5, "seven": 7},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,3 +1,3 @@
- (*errors.errorString)({
-- s: (string) (len=19) "some expected error"
-+ s: (string) (len=12) "actual error"
- })
-`
-
- actual = diff(
- errors.New("some expected error"),
- errors.New("actual error"),
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -2,3 +2,3 @@
- A: (string) (len=11) "some string",
-- B: (int) 10
-+ B: (int) 15
- }
-`
-
- actual = diff(
- diffTestingStruct{A: "some string", B: 10},
- diffTestingStruct{A: "some string", B: 15},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,2 +1,2 @@
--(time.Time) 2020-09-24 00:00:00 +0000 UTC
-+(time.Time) 2020-09-25 00:00:00 +0000 UTC
-
-`
-
- actual = diff(
- time.Date(2020, 9, 24, 0, 0, 0, 0, time.UTC),
- time.Date(2020, 9, 25, 0, 0, 0, 0, time.UTC),
- )
- Equal(t, expected, actual)
-}
-
-func TestTimeEqualityErrorFormatting(t *testing.T) {
- mockT := new(mockTestingT)
-
- Equal(mockT, time.Second*2, time.Millisecond)
-
- expectedErr := "\\s+Error Trace:\\s+Error:\\s+Not equal:\\s+\n\\s+expected: 2s\n\\s+actual\\s+: 1ms\n"
- Regexp(t, regexp.MustCompile(expectedErr), mockT.errorString())
-}
-
-func TestDiffEmptyCases(t *testing.T) {
- Equal(t, "", diff(nil, nil))
- Equal(t, "", diff(struct{ foo string }{}, nil))
- Equal(t, "", diff(nil, struct{ foo string }{}))
- Equal(t, "", diff(1, 2))
- Equal(t, "", diff(1, 2))
- Equal(t, "", diff([]int{1}, []bool{true}))
-}
-
-// Ensure there are no data races
-func TestDiffRace(t *testing.T) {
- t.Parallel()
-
- expected := map[string]string{
- "a": "A",
- "b": "B",
- "c": "C",
- }
-
- actual := map[string]string{
- "d": "D",
- "e": "E",
- "f": "F",
- }
-
- // run diffs in parallel simulating tests with t.Parallel()
- numRoutines := 10
- rChans := make([]chan string, numRoutines)
- for idx := range rChans {
- rChans[idx] = make(chan string)
- go func(ch chan string) {
- defer close(ch)
- ch <- diff(expected, actual)
- }(rChans[idx])
- }
-
- for _, ch := range rChans {
- for msg := range ch {
- NotZero(t, msg) // dummy assert
- }
- }
-}
-
-type mockTestingT struct {
- errorFmt string
- args []interface{}
-}
-
-func (m *mockTestingT) errorString() string {
- return fmt.Sprintf(m.errorFmt, m.args...)
-}
-
-func (m *mockTestingT) Errorf(format string, args ...interface{}) {
- m.errorFmt = format
- m.args = args
-}
-
-func (m *mockTestingT) Failed() bool {
- return m.errorFmt != ""
-}
-
-func TestFailNowWithPlainTestingT(t *testing.T) {
- mockT := &mockTestingT{}
-
- Panics(t, func() {
- FailNow(mockT, "failed")
- }, "should panic since mockT is missing FailNow()")
-}
-
-type mockFailNowTestingT struct {
-}
-
-func (m *mockFailNowTestingT) Errorf(format string, args ...interface{}) {}
-
-func (m *mockFailNowTestingT) FailNow() {}
-
-func TestFailNowWithFullTestingT(t *testing.T) {
- mockT := &mockFailNowTestingT{}
-
- NotPanics(t, func() {
- FailNow(mockT, "failed")
- }, "should call mockT.FailNow() rather than panicking")
-}
-
-func TestBytesEqual(t *testing.T) {
- var cases = []struct {
- a, b []byte
- }{
- {make([]byte, 2), make([]byte, 2)},
- {make([]byte, 2), make([]byte, 2, 3)},
- {nil, make([]byte, 0)},
- }
- for i, c := range cases {
- Equal(t, reflect.DeepEqual(c.a, c.b), ObjectsAreEqual(c.a, c.b), "case %d failed", i+1)
- }
-}
-
-func BenchmarkBytesEqual(b *testing.B) {
- const size = 1024 * 8
- s := make([]byte, size)
- for i := range s {
- s[i] = byte(i % 255)
- }
- s2 := make([]byte, size)
- copy(s2, s)
-
- mockT := &mockFailNowTestingT{}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- Equal(mockT, s, s2)
- }
-}
-
-func BenchmarkNotNil(b *testing.B) {
- for i := 0; i < b.N; i++ {
- NotNil(b, b)
- }
-}
-
-func ExampleComparisonAssertionFunc() {
- t := &testing.T{} // provided by test
-
- adder := func(x, y int) int {
- return x + y
- }
-
- type args struct {
- x int
- y int
- }
-
- tests := []struct {
- name string
- args args
- expect int
- assertion ComparisonAssertionFunc
- }{
- {"2+2=4", args{2, 2}, 4, Equal},
- {"2+2!=5", args{2, 2}, 5, NotEqual},
- {"2+3==5", args{2, 3}, 5, Exactly},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y))
- })
- }
-}
-
-func TestComparisonAssertionFunc(t *testing.T) {
- type iface interface {
- Name() string
- }
-
- tests := []struct {
- name string
- expect interface{}
- got interface{}
- assertion ComparisonAssertionFunc
- }{
- {"implements", (*iface)(nil), t, Implements},
- {"isType", (*testing.T)(nil), t, IsType},
- {"equal", t, t, Equal},
- {"equalValues", t, t, EqualValues},
- {"notEqualValues", t, nil, NotEqualValues},
- {"exactly", t, t, Exactly},
- {"notEqual", t, nil, NotEqual},
- {"notContains", []int{1, 2, 3}, 4, NotContains},
- {"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset},
- {"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset},
- {"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch},
- {"regexp", "^t.*y$", "testify", Regexp},
- {"notRegexp", "^t.*y$", "Testify", NotRegexp},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, tt.got)
- })
- }
-}
-
-func ExampleValueAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParse := func(input string) interface{} {
- var x interface{}
- _ = json.Unmarshal([]byte(input), &x)
- return x
- }
-
- tests := []struct {
- name string
- arg string
- assertion ValueAssertionFunc
- }{
- {"true is not nil", "true", NotNil},
- {"empty string is nil", "", Nil},
- {"zero is not nil", "0", NotNil},
- {"zero is zero", "0", Zero},
- {"false is zero", "false", Zero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, dumbParse(tt.arg))
- })
- }
-}
-
-func TestValueAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value interface{}
- assertion ValueAssertionFunc
- }{
- {"notNil", true, NotNil},
- {"nil", nil, Nil},
- {"empty", []int{}, Empty},
- {"notEmpty", []int{1}, NotEmpty},
- {"zero", false, Zero},
- {"notZero", 42, NotZero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleBoolAssertionFunc() {
- t := &testing.T{} // provided by test
-
- isOkay := func(x int) bool {
- return x >= 42
- }
-
- tests := []struct {
- name string
- arg int
- assertion BoolAssertionFunc
- }{
- {"-1 is bad", -1, False},
- {"42 is good", 42, True},
- {"41 is bad", 41, False},
- {"45 is cool", 45, True},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, isOkay(tt.arg))
- })
- }
-}
-
-func TestBoolAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value bool
- assertion BoolAssertionFunc
- }{
- {"true", true, True},
- {"false", false, False},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleErrorAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParseNum := func(input string, v interface{}) error {
- return json.Unmarshal([]byte(input), v)
- }
-
- tests := []struct {
- name string
- arg string
- assertion ErrorAssertionFunc
- }{
- {"1.2 is number", "1.2", NoError},
- {"1.2.3 not number", "1.2.3", Error},
- {"true is not number", "true", Error},
- {"3 is number", "3", NoError},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var x float64
- tt.assertion(t, dumbParseNum(tt.arg, &x))
- })
- }
-}
-
-func TestErrorAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- err error
- assertion ErrorAssertionFunc
- }{
- {"noError", nil, NoError},
- {"error", errors.New("whoops"), Error},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.err)
- })
- }
-}
-
-func ExamplePanicAssertionFunc() {
- t := &testing.T{} // provided by test
-
- tests := []struct {
- name string
- panicFn PanicTestFunc
- assertion PanicAssertionFunc
- }{
- {"with panic", func() { panic(nil) }, Panics},
- {"without panic", func() {}, NotPanics},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.panicFn)
- })
- }
-}
-
-func TestPanicAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- panicFn PanicTestFunc
- assertion PanicAssertionFunc
- }{
- {"not panic", func() {}, NotPanics},
- {"panic", func() { panic(nil) }, Panics},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.panicFn)
- })
- }
-}
-
-func TestEventuallyFalse(t *testing.T) {
- mockT := new(testing.T)
-
- condition := func() bool {
- return false
- }
-
- False(t, Eventually(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-func TestEventuallyTrue(t *testing.T) {
- state := 0
- condition := func() bool {
- defer func() {
- state += 1
- }()
- return state == 2
- }
-
- True(t, Eventually(t, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-// errorsCapturingT is a mock implementation of TestingT that captures errors reported with Errorf.
-type errorsCapturingT struct {
- errors []error
-}
-
-func (t *errorsCapturingT) Errorf(format string, args ...interface{}) {
- t.errors = append(t.errors, fmt.Errorf(format, args...))
-}
-
-func (t *errorsCapturingT) Helper() {}
-
-func TestEventuallyWithTFalse(t *testing.T) {
- mockT := new(errorsCapturingT)
-
- condition := func(collect *CollectT) {
- Fail(collect, "condition fixed failure")
- }
-
- False(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
- Len(t, mockT.errors, 2)
-}
-
-func TestEventuallyWithTTrue(t *testing.T) {
- mockT := new(errorsCapturingT)
-
- state := 0
- condition := func(collect *CollectT) {
- defer func() {
- state += 1
- }()
- True(collect, state == 2)
- }
-
- True(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
- Len(t, mockT.errors, 0)
-}
-
-func TestEventuallyWithT_ConcurrencySafe(t *testing.T) {
- mockT := new(errorsCapturingT)
-
- condition := func(collect *CollectT) {
- Fail(collect, "condition fixed failure")
- }
-
- // To trigger race conditions, we run EventuallyWithT with a nanosecond tick.
- False(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, time.Nanosecond))
- Len(t, mockT.errors, 2)
-}
-
-func TestEventuallyWithT_ReturnsTheLatestFinishedConditionErrors(t *testing.T) {
- // We'll use a channel to control whether a condition should sleep or not.
- mustSleep := make(chan bool, 2)
- mustSleep <- false
- mustSleep <- true
- close(mustSleep)
-
- condition := func(collect *CollectT) {
- if <-mustSleep {
- // Sleep to ensure that the second condition runs longer than timeout.
- time.Sleep(time.Second)
- return
- }
-
- // The first condition will fail. We expect to get this error as a result.
- Fail(collect, "condition fixed failure")
- }
-
- mockT := new(errorsCapturingT)
- False(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
- Len(t, mockT.errors, 2)
-}
-
-func TestNeverFalse(t *testing.T) {
- condition := func() bool {
- return false
- }
-
- True(t, Never(t, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-// TestNeverTrue checks Never with a condition that returns true on second call.
-func TestNeverTrue(t *testing.T) {
- mockT := new(testing.T)
-
- // A list of values returned by condition.
- // Channel protects against concurrent access.
- returns := make(chan bool, 2)
- returns <- false
- returns <- true
- defer close(returns)
-
- // Will return true on second call.
- condition := func() bool {
- return <-returns
- }
-
- False(t, Never(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-// Check that a long running condition doesn't block Eventually.
-// See issue 805 (and its long tail of following issues)
-func TestEventuallyTimeout(t *testing.T) {
- mockT := new(testing.T)
-
- NotPanics(t, func() {
- done, done2 := make(chan struct{}), make(chan struct{})
-
- // A condition function that returns after the Eventually timeout
- condition := func() bool {
- // Wait until Eventually times out and terminates
- <-done
- close(done2)
- return true
- }
-
- False(t, Eventually(mockT, condition, time.Millisecond, time.Microsecond))
-
- close(done)
- <-done2
- })
-}
-
-func Test_validateEqualArgs(t *testing.T) {
- if validateEqualArgs(func() {}, func() {}) == nil {
- t.Error("non-nil functions should error")
- }
-
- if validateEqualArgs(func() {}, func() {}) == nil {
- t.Error("non-nil functions should error")
- }
-
- if validateEqualArgs(nil, nil) != nil {
- t.Error("nil functions are equal")
- }
-}
-
-func Test_truncatingFormat(t *testing.T) {
-
- original := strings.Repeat("a", bufio.MaxScanTokenSize-102)
- result := truncatingFormat(original)
- Equal(t, fmt.Sprintf("%#v", original), result, "string should not be truncated")
-
- original = original + "x"
- result = truncatingFormat(original)
- NotEqual(t, fmt.Sprintf("%#v", original), result, "string should have been truncated.")
-
- if !strings.HasSuffix(result, "<... truncated>") {
- t.Error("truncated string should have <... truncated> suffix")
- }
-}
-
-// parseLabeledOutput does the inverse of labeledOutput - it takes a formatted
-// output string and turns it back into a slice of labeledContent.
-func parseLabeledOutput(output string) []labeledContent {
- labelPattern := regexp.MustCompile(`^\t([^\t]*): *\t(.*)$`)
- contentPattern := regexp.MustCompile(`^\t *\t(.*)$`)
- var contents []labeledContent
- lines := strings.Split(output, "\n")
- i := -1
- for _, line := range lines {
- if line == "" {
- // skip blank lines
- continue
- }
- matches := labelPattern.FindStringSubmatch(line)
- if len(matches) == 3 {
- // a label
- contents = append(contents, labeledContent{
- label: matches[1],
- content: matches[2] + "\n",
- })
- i++
- continue
- }
- matches = contentPattern.FindStringSubmatch(line)
- if len(matches) == 2 {
- // just content
- if i >= 0 {
- contents[i].content += matches[1] + "\n"
- continue
- }
- }
- // Couldn't parse output
- return nil
- }
- return contents
-}
-
-type captureTestingT struct {
- msg string
-}
-
-func (ctt *captureTestingT) Errorf(format string, args ...interface{}) {
- ctt.msg = fmt.Sprintf(format, args...)
-}
-
-func (ctt *captureTestingT) checkResultAndErrMsg(t *testing.T, expectedRes, res bool, expectedErrMsg string) {
- t.Helper()
- if res != expectedRes {
- t.Errorf("Should return %t", expectedRes)
- return
- }
- contents := parseLabeledOutput(ctt.msg)
- if res == true {
- if contents != nil {
- t.Errorf("Should not log an error")
- }
- return
- }
- if contents == nil {
- t.Errorf("Should log an error. Log output: %v", ctt.msg)
- return
- }
- for _, content := range contents {
- if content.label == "Error" {
- if expectedErrMsg == content.content {
- return
- }
- t.Errorf("Logged Error: %v", content.content)
- }
- }
- t.Errorf("Should log Error: %v", expectedErrMsg)
-}
-
-func TestErrorIs(t *testing.T) {
- tests := []struct {
- err error
- target error
- result bool
- resultErrMsg string
- }{
- {
- err: io.EOF,
- target: io.EOF,
- result: true,
- },
- {
- err: fmt.Errorf("wrap: %w", io.EOF),
- target: io.EOF,
- result: true,
- },
- {
- err: io.EOF,
- target: io.ErrClosedPipe,
- result: false,
- resultErrMsg: "" +
- "Target error should be in err chain:\n" +
- "expected: \"io: read/write on closed pipe\"\n" +
- "in chain: \"EOF\"\n",
- },
- {
- err: nil,
- target: io.EOF,
- result: false,
- resultErrMsg: "" +
- "Target error should be in err chain:\n" +
- "expected: \"EOF\"\n" +
- "in chain: \n",
- },
- {
- err: io.EOF,
- target: nil,
- result: false,
- resultErrMsg: "" +
- "Target error should be in err chain:\n" +
- "expected: \"\"\n" +
- "in chain: \"EOF\"\n",
- },
- {
- err: nil,
- target: nil,
- result: true,
- },
- {
- err: fmt.Errorf("abc: %w", errors.New("def")),
- target: io.EOF,
- result: false,
- resultErrMsg: "" +
- "Target error should be in err chain:\n" +
- "expected: \"EOF\"\n" +
- "in chain: \"abc: def\"\n" +
- "\t\"def\"\n",
- },
- }
- for _, tt := range tests {
- tt := tt
- t.Run(fmt.Sprintf("ErrorIs(%#v,%#v)", tt.err, tt.target), func(t *testing.T) {
- mockT := new(captureTestingT)
- res := ErrorIs(mockT, tt.err, tt.target)
- mockT.checkResultAndErrMsg(t, tt.result, res, tt.resultErrMsg)
- })
- }
-}
-
-func TestNotErrorIs(t *testing.T) {
- tests := []struct {
- err error
- target error
- result bool
- resultErrMsg string
- }{
- {
- err: io.EOF,
- target: io.EOF,
- result: false,
- resultErrMsg: "" +
- "Target error should not be in err chain:\n" +
- "found: \"EOF\"\n" +
- "in chain: \"EOF\"\n",
- },
- {
- err: fmt.Errorf("wrap: %w", io.EOF),
- target: io.EOF,
- result: false,
- resultErrMsg: "" +
- "Target error should not be in err chain:\n" +
- "found: \"EOF\"\n" +
- "in chain: \"wrap: EOF\"\n" +
- "\t\"EOF\"\n",
- },
- {
- err: io.EOF,
- target: io.ErrClosedPipe,
- result: true,
- },
- {
- err: nil,
- target: io.EOF,
- result: true,
- },
- {
- err: io.EOF,
- target: nil,
- result: true,
- },
- {
- err: nil,
- target: nil,
- result: false,
- resultErrMsg: "" +
- "Target error should not be in err chain:\n" +
- "found: \"\"\n" +
- "in chain: \n",
- },
- {
- err: fmt.Errorf("abc: %w", errors.New("def")),
- target: io.EOF,
- result: true,
- },
- }
- for _, tt := range tests {
- tt := tt
- t.Run(fmt.Sprintf("NotErrorIs(%#v,%#v)", tt.err, tt.target), func(t *testing.T) {
- mockT := new(captureTestingT)
- res := NotErrorIs(mockT, tt.err, tt.target)
- mockT.checkResultAndErrMsg(t, tt.result, res, tt.resultErrMsg)
- })
- }
-}
-
-func TestErrorAs(t *testing.T) {
- mockT := new(testing.T)
- tests := []struct {
- err error
- result bool
- }{
- {fmt.Errorf("wrap: %w", &customError{}), true},
- {io.EOF, false},
- {nil, false},
- }
- for _, tt := range tests {
- tt := tt
- var target *customError
- t.Run(fmt.Sprintf("ErrorAs(%#v,%#v)", tt.err, target), func(t *testing.T) {
- res := ErrorAs(mockT, tt.err, &target)
- if res != tt.result {
- t.Errorf("ErrorAs(%#v,%#v) should return %t)", tt.err, target, tt.result)
- }
- })
- }
-}
diff --git a/internal/testify/assert/doc.go b/internal/testify/assert/doc.go
deleted file mode 100644
index 78eba795c..000000000
--- a/internal/testify/assert/doc.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
-//
-// # Example Usage
-//
-// The following is a complete example using assert in a standard test function:
-//
-// import (
-// "testing"
-// "github.com/expr-lang/expr/internal/testify/assert"
-// )
-//
-// func TestSomething(t *testing.T) {
-//
-// var a string = "Hello"
-// var b string = "Hello"
-//
-// assert.Equal(t, a, b, "The two words should be the same.")
-//
-// }
-//
-// if you assert many times, use the format below:
-//
-// import (
-// "testing"
-// "github.com/expr-lang/expr/internal/testify/assert"
-// )
-//
-// func TestSomething(t *testing.T) {
-// assert := assert.New(t)
-//
-// var a string = "Hello"
-// var b string = "Hello"
-//
-// assert.Equal(a, b, "The two words should be the same.")
-// }
-//
-// # Assertions
-//
-// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
-// All assertion functions take, as the first argument, the `*testing.T` object provided by the
-// testing framework. This allows the assertion funcs to write the failings and other details to
-// the correct place.
-//
-// Every assertion function also takes an optional string message as the final argument,
-// allowing custom error messages to be appended to the message the assertion method outputs.
-package assert
diff --git a/internal/testify/assert/errors.go b/internal/testify/assert/errors.go
deleted file mode 100644
index ac9dc9d1d..000000000
--- a/internal/testify/assert/errors.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package assert
-
-import (
- "errors"
-)
-
-// AnError is an error instance useful for testing. If the code does not care
-// about error specifics, and only needs to return the error for example, this
-// error should be used to make the test code more readable.
-var AnError = errors.New("assert.AnError general error for testing")
diff --git a/internal/testify/assert/forward_assertions.go b/internal/testify/assert/forward_assertions.go
deleted file mode 100644
index df189d234..000000000
--- a/internal/testify/assert/forward_assertions.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package assert
-
-// Assertions provides assertion methods around the
-// TestingT interface.
-type Assertions struct {
- t TestingT
-}
-
-// New makes a new Assertions object for the specified TestingT.
-func New(t TestingT) *Assertions {
- return &Assertions{
- t: t,
- }
-}
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs"
diff --git a/internal/testify/assert/forward_assertions_test.go b/internal/testify/assert/forward_assertions_test.go
deleted file mode 100644
index c1567a631..000000000
--- a/internal/testify/assert/forward_assertions_test.go
+++ /dev/null
@@ -1,654 +0,0 @@
-package assert
-
-import (
- "errors"
- "regexp"
- "testing"
- "time"
-)
-
-func TestImplementsWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
- t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
- }
- if assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
- t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
- }
-}
-
-func TestIsTypeWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
- t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
- }
- if assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
- t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
- }
-
-}
-
-func TestEqualWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.Equal("Hello World", "Hello World") {
- t.Error("Equal should return true")
- }
- if !assert.Equal(123, 123) {
- t.Error("Equal should return true")
- }
- if !assert.Equal(123.5, 123.5) {
- t.Error("Equal should return true")
- }
- if !assert.Equal([]byte("Hello World"), []byte("Hello World")) {
- t.Error("Equal should return true")
- }
- if !assert.Equal(nil, nil) {
- t.Error("Equal should return true")
- }
-}
-
-func TestEqualValuesWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.EqualValues(uint32(10), int32(10)) {
- t.Error("EqualValues should return true")
- }
-}
-
-func TestNotNilWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.NotNil(new(AssertionTesterConformingObject)) {
- t.Error("NotNil should return true: object is not nil")
- }
- if assert.NotNil(nil) {
- t.Error("NotNil should return false: object is nil")
- }
-
-}
-
-func TestNilWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.Nil(nil) {
- t.Error("Nil should return true: object is nil")
- }
- if assert.Nil(new(AssertionTesterConformingObject)) {
- t.Error("Nil should return false: object is not nil")
- }
-
-}
-
-func TestTrueWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.True(true) {
- t.Error("True should return true")
- }
- if assert.True(false) {
- t.Error("True should return false")
- }
-
-}
-
-func TestFalseWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.False(false) {
- t.Error("False should return true")
- }
- if assert.False(true) {
- t.Error("False should return false")
- }
-
-}
-
-func TestExactlyWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- a := float32(1)
- b := float64(1)
- c := float32(1)
- d := float32(2)
-
- if assert.Exactly(a, b) {
- t.Error("Exactly should return false")
- }
- if assert.Exactly(a, d) {
- t.Error("Exactly should return false")
- }
- if !assert.Exactly(a, c) {
- t.Error("Exactly should return true")
- }
-
- if assert.Exactly(nil, a) {
- t.Error("Exactly should return false")
- }
- if assert.Exactly(a, nil) {
- t.Error("Exactly should return false")
- }
-
-}
-
-func TestNotEqualWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.NotEqual("Hello World", "Hello World!") {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual(123, 1234) {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual(123.5, 123.55) {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual([]byte("Hello World"), []byte("Hello World!")) {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual(nil, new(AssertionTesterConformingObject)) {
- t.Error("NotEqual should return true")
- }
-}
-
-func TestNotEqualValuesWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.NotEqualValues("Hello World", "Hello World!") {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues(123, 1234) {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues(123.5, 123.55) {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues([]byte("Hello World"), []byte("Hello World!")) {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues(nil, new(AssertionTesterConformingObject)) {
- t.Error("NotEqualValues should return true")
- }
- if assert.NotEqualValues(10, uint(10)) {
- t.Error("NotEqualValues should return false")
- }
-}
-
-func TestContainsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
- list := []string{"Foo", "Bar"}
-
- if !assert.Contains("Hello World", "Hello") {
- t.Error("Contains should return true: \"Hello World\" contains \"Hello\"")
- }
- if assert.Contains("Hello World", "Salut") {
- t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"")
- }
-
- if !assert.Contains(list, "Foo") {
- t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
- }
- if assert.Contains(list, "Salut") {
- t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"")
- }
-
-}
-
-func TestNotContainsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
- list := []string{"Foo", "Bar"}
-
- if !assert.NotContains("Hello World", "Hello!") {
- t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"")
- }
- if assert.NotContains("Hello World", "Hello") {
- t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"")
- }
-
- if !assert.NotContains(list, "Foo!") {
- t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"")
- }
- if assert.NotContains(list, "Foo") {
- t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
- }
-
-}
-
-func TestConditionWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.Condition(func() bool { return true }, "Truth") {
- t.Error("Condition should return true")
- }
-
- if assert.Condition(func() bool { return false }, "Lie") {
- t.Error("Condition should return false")
- }
-
-}
-
-func TestDidPanicWrapper(t *testing.T) {
-
- if funcDidPanic, _, _ := didPanic(func() {
- panic("Panic!")
- }); !funcDidPanic {
- t.Error("didPanic should return true")
- }
-
- if funcDidPanic, _, _ := didPanic(func() {
- }); funcDidPanic {
- t.Error("didPanic should return false")
- }
-
-}
-
-func TestPanicsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.Panics(func() {
- panic("Panic!")
- }) {
- t.Error("Panics should return true")
- }
-
- if assert.Panics(func() {
- }) {
- t.Error("Panics should return false")
- }
-
-}
-
-func TestNotPanicsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.NotPanics(func() {
- }) {
- t.Error("NotPanics should return true")
- }
-
- if assert.NotPanics(func() {
- panic("Panic!")
- }) {
- t.Error("NotPanics should return false")
- }
-
-}
-
-func TestNoErrorWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
-
- assert.True(mockAssert.NoError(err), "NoError should return True for nil arg")
-
- // now set an error
- err = errors.New("Some error")
-
- assert.False(mockAssert.NoError(err), "NoError with error should return False")
-
-}
-
-func TestErrorWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
-
- assert.False(mockAssert.Error(err), "Error should return False for nil arg")
-
- // now set an error
- err = errors.New("Some error")
-
- assert.True(mockAssert.Error(err), "Error with error should return True")
-
-}
-
-func TestErrorContainsWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
- assert.False(mockAssert.ErrorContains(err, ""),
- "ErrorContains should return false for nil arg")
-
- // now set an error
- err = errors.New("some error: another error")
- assert.False(mockAssert.ErrorContains(err, "different error"),
- "ErrorContains should return false for different error string")
- assert.True(mockAssert.ErrorContains(err, "some error"),
- "ErrorContains should return true")
- assert.True(mockAssert.ErrorContains(err, "another error"),
- "ErrorContains should return true")
-}
-
-func TestEqualErrorWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
- assert.False(mockAssert.EqualError(err, ""),
- "EqualError should return false for nil arg")
-
- // now set an error
- err = errors.New("some error")
- assert.False(mockAssert.EqualError(err, "Not some error"),
- "EqualError should return false for different error string")
- assert.True(mockAssert.EqualError(err, "some error"),
- "EqualError should return true")
-}
-
-func TestEmptyWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.True(mockAssert.Empty(""), "Empty string is empty")
- assert.True(mockAssert.Empty(nil), "Nil is empty")
- assert.True(mockAssert.Empty([]string{}), "Empty string array is empty")
- assert.True(mockAssert.Empty(0), "Zero int value is empty")
- assert.True(mockAssert.Empty(false), "False value is empty")
-
- assert.False(mockAssert.Empty("something"), "Non Empty string is not empty")
- assert.False(mockAssert.Empty(errors.New("something")), "Non nil object is not empty")
- assert.False(mockAssert.Empty([]string{"something"}), "Non empty string array is not empty")
- assert.False(mockAssert.Empty(1), "Non-zero int value is not empty")
- assert.False(mockAssert.Empty(true), "True value is not empty")
-
-}
-
-func TestNotEmptyWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.False(mockAssert.NotEmpty(""), "Empty string is empty")
- assert.False(mockAssert.NotEmpty(nil), "Nil is empty")
- assert.False(mockAssert.NotEmpty([]string{}), "Empty string array is empty")
- assert.False(mockAssert.NotEmpty(0), "Zero int value is empty")
- assert.False(mockAssert.NotEmpty(false), "False value is empty")
-
- assert.True(mockAssert.NotEmpty("something"), "Non Empty string is not empty")
- assert.True(mockAssert.NotEmpty(errors.New("something")), "Non nil object is not empty")
- assert.True(mockAssert.NotEmpty([]string{"something"}), "Non empty string array is not empty")
- assert.True(mockAssert.NotEmpty(1), "Non-zero int value is not empty")
- assert.True(mockAssert.NotEmpty(true), "True value is not empty")
-
-}
-
-func TestLenWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.False(mockAssert.Len(nil, 0), "nil does not have length")
- assert.False(mockAssert.Len(0, 0), "int does not have length")
- assert.False(mockAssert.Len(true, 0), "true does not have length")
- assert.False(mockAssert.Len(false, 0), "false does not have length")
- assert.False(mockAssert.Len('A', 0), "Rune does not have length")
- assert.False(mockAssert.Len(struct{}{}, 0), "Struct does not have length")
-
- ch := make(chan int, 5)
- ch <- 1
- ch <- 2
- ch <- 3
-
- cases := []struct {
- v interface{}
- l int
- }{
- {[]int{1, 2, 3}, 3},
- {[...]int{1, 2, 3}, 3},
- {"ABC", 3},
- {map[int]int{1: 2, 2: 4, 3: 6}, 3},
- {ch, 3},
-
- {[]int{}, 0},
- {map[int]int{}, 0},
- {make(chan int), 0},
-
- {[]int(nil), 0},
- {map[int]int(nil), 0},
- {(chan int)(nil), 0},
- }
-
- for _, c := range cases {
- assert.True(mockAssert.Len(c.v, c.l), "%#v have %d items", c.v, c.l)
- }
-}
-
-func TestWithinDurationWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- assert.True(mockAssert.WithinDuration(a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
- assert.True(mockAssert.WithinDuration(b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
-
- assert.False(mockAssert.WithinDuration(a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
- assert.False(mockAssert.WithinDuration(b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
-
- assert.False(mockAssert.WithinDuration(a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
- assert.False(mockAssert.WithinDuration(b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
-
- assert.False(mockAssert.WithinDuration(a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
- assert.False(mockAssert.WithinDuration(b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
-}
-
-func TestInDeltaWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- True(t, assert.InDelta(1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
- True(t, assert.InDelta(1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
- True(t, assert.InDelta(1, 2, 1), "|1 - 2| <= 1")
- False(t, assert.InDelta(1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
- False(t, assert.InDelta(2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
- False(t, assert.InDelta("", nil, 1), "Expected non numerals to fail")
-
- cases := []struct {
- a, b interface{}
- delta float64
- }{
- {uint8(2), uint8(1), 1},
- {uint16(2), uint16(1), 1},
- {uint32(2), uint32(1), 1},
- {uint64(2), uint64(1), 1},
-
- {int(2), int(1), 1},
- {int8(2), int8(1), 1},
- {int16(2), int16(1), 1},
- {int32(2), int32(1), 1},
- {int64(2), int64(1), 1},
-
- {float32(2), float32(1), 1},
- {float64(2), float64(1), 1},
- }
-
- for _, tc := range cases {
- True(t, assert.InDelta(tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
- }
-}
-
-func TestInEpsilonWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- cases := []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), uint16(2), .001},
- {2.1, 2.2, 0.1},
- {2.2, 2.1, 0.1},
- {-2.1, -2.2, 0.1},
- {-2.2, -2.1, 0.1},
- {uint64(100), uint8(101), 0.01},
- {0.1, -0.1, 2},
- }
-
- for _, tc := range cases {
- True(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
- }
-
- cases = []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), int16(-2), .001},
- {uint64(100), uint8(102), 0.01},
- {2.1, 2.2, 0.001},
- {2.2, 2.1, 0.001},
- {2.1, -2.2, 1},
- {2.1, "bla-bla", 0},
- {0.1, -0.1, 1.99},
- }
-
- for _, tc := range cases {
- False(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
- }
-}
-
-func TestRegexpWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- cases := []struct {
- rx, str string
- }{
- {"^start", "start of the line"},
- {"end$", "in the end"},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
- }
-
- for _, tc := range cases {
- True(t, assert.Regexp(tc.rx, tc.str))
- True(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
- False(t, assert.NotRegexp(tc.rx, tc.str))
- False(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
- }
-
- cases = []struct {
- rx, str string
- }{
- {"^asdfastart", "Not the start of the line"},
- {"end$", "in the end."},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
- }
-
- for _, tc := range cases {
- False(t, assert.Regexp(tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
- False(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
- True(t, assert.NotRegexp(tc.rx, tc.str))
- True(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
- }
-}
-
-func TestZeroWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- for _, test := range zeros {
- assert.True(mockAssert.Zero(test), "Zero should return true for %v", test)
- }
-
- for _, test := range nonZeros {
- assert.False(mockAssert.Zero(test), "Zero should return false for %v", test)
- }
-}
-
-func TestNotZeroWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- for _, test := range zeros {
- assert.False(mockAssert.NotZero(test), "Zero should return true for %v", test)
- }
-
- for _, test := range nonZeros {
- assert.True(mockAssert.NotZero(test), "Zero should return false for %v", test)
- }
-}
-
-func TestJSONEqWrapper_EqualSONString(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) {
- t.Error("JSONEq should return true")
- }
-
-}
-
-func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
- t.Error("JSONEq should return true")
- }
-
-}
-
-func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}") {
- t.Error("JSONEq should return true")
- }
-}
-
-func TestJSONEqWrapper_Array(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) {
- t.Error("JSONEq should return true")
- }
-
-}
-
-func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`{"foo": "bar"}`, "Not JSON") {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`) {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq("Not JSON", "Not JSON") {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) {
- t.Error("JSONEq should return false")
- }
-}
diff --git a/internal/testify/assert/http_assertions.go b/internal/testify/assert/http_assertions.go
deleted file mode 100644
index 861ed4b7c..000000000
--- a/internal/testify/assert/http_assertions.go
+++ /dev/null
@@ -1,165 +0,0 @@
-package assert
-
-import (
- "fmt"
- "net/http"
- "net/http/httptest"
- "net/url"
- "strings"
-)
-
-// httpCode is a helper that returns HTTP code of the response. It returns -1 and
-// an error if building a new request fails.
-func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) {
- w := httptest.NewRecorder()
- req, err := http.NewRequest(method, url, http.NoBody)
- if err != nil {
- return -1, err
- }
- req.URL.RawQuery = values.Encode()
- handler(w, req)
- return w.Code, nil
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
- }
-
- isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent
- if !isSuccessCode {
- Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
- }
-
- return isSuccessCode
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
- }
-
- isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
- if !isRedirectCode {
- Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
- }
-
- return isRedirectCode
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
- }
-
- isErrorCode := code >= http.StatusBadRequest
- if !isErrorCode {
- Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
- }
-
- return isErrorCode
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
- }
-
- successful := code == statuscode
- if !successful {
- Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code), msgAndArgs...)
- }
-
- return successful
-}
-
-// HTTPBody is a helper that returns HTTP body of the response. It returns
-// empty string if building a new request fails.
-func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
- w := httptest.NewRecorder()
- if len(values) > 0 {
- url += "?" + values.Encode()
- }
- req, err := http.NewRequest(method, url, http.NoBody)
- if err != nil {
- return ""
- }
- handler(w, req)
- return w.Body.String()
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- body := HTTPBody(handler, method, url, values)
-
- contains := strings.Contains(body, fmt.Sprint(str))
- if !contains {
- Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
- }
-
- return contains
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- body := HTTPBody(handler, method, url, values)
-
- contains := strings.Contains(body, fmt.Sprint(str))
- if contains {
- Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
- }
-
- return !contains
-}
diff --git a/internal/testify/assert/http_assertions_test.go b/internal/testify/assert/http_assertions_test.go
deleted file mode 100644
index dd84f02f1..000000000
--- a/internal/testify/assert/http_assertions_test.go
+++ /dev/null
@@ -1,214 +0,0 @@
-package assert
-
-import (
- "fmt"
- "io"
- "net/http"
- "net/url"
- "testing"
-)
-
-func httpOK(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusOK)
-}
-
-func httpReadBody(w http.ResponseWriter, r *http.Request) {
- _, _ = io.Copy(io.Discard, r.Body)
- w.WriteHeader(http.StatusOK)
- _, _ = w.Write([]byte("hello"))
-}
-
-func httpRedirect(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusTemporaryRedirect)
-}
-
-func httpError(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusInternalServerError)
-}
-
-func httpStatusCode(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusSwitchingProtocols)
-}
-
-func TestHTTPSuccess(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT1, httpOK, "GET", "/", nil), true)
- assert.False(mockT1.Failed())
-
- mockT2 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT2, httpRedirect, "GET", "/", nil), false)
- assert.True(mockT2.Failed())
-
- mockT3 := new(mockTestingT)
- assert.Equal(HTTPSuccess(
- mockT3, httpError, "GET", "/", nil,
- "was not expecting a failure here",
- ), false)
- assert.True(mockT3.Failed())
- assert.Contains(mockT3.errorString(), "was not expecting a failure here")
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT4, httpStatusCode, "GET", "/", nil), false)
- assert.True(mockT4.Failed())
-
- mockT5 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT5, httpReadBody, "POST", "/", nil), true)
- assert.False(mockT5.Failed())
-}
-
-func TestHTTPRedirect(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(mockTestingT)
- assert.Equal(HTTPRedirect(
- mockT1, httpOK, "GET", "/", nil,
- "was expecting a 3xx status code. Got 200.",
- ), false)
- assert.True(mockT1.Failed())
- assert.Contains(mockT1.errorString(), "was expecting a 3xx status code. Got 200.")
-
- mockT2 := new(testing.T)
- assert.Equal(HTTPRedirect(mockT2, httpRedirect, "GET", "/", nil), true)
- assert.False(mockT2.Failed())
-
- mockT3 := new(testing.T)
- assert.Equal(HTTPRedirect(mockT3, httpError, "GET", "/", nil), false)
- assert.True(mockT3.Failed())
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPRedirect(mockT4, httpStatusCode, "GET", "/", nil), false)
- assert.True(mockT4.Failed())
-}
-
-func TestHTTPError(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(testing.T)
- assert.Equal(HTTPError(mockT1, httpOK, "GET", "/", nil), false)
- assert.True(mockT1.Failed())
-
- mockT2 := new(mockTestingT)
- assert.Equal(HTTPError(
- mockT2, httpRedirect, "GET", "/", nil,
- "Expected this request to error out. But it didn't",
- ), false)
- assert.True(mockT2.Failed())
- assert.Contains(mockT2.errorString(), "Expected this request to error out. But it didn't")
-
- mockT3 := new(testing.T)
- assert.Equal(HTTPError(mockT3, httpError, "GET", "/", nil), true)
- assert.False(mockT3.Failed())
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPError(mockT4, httpStatusCode, "GET", "/", nil), false)
- assert.True(mockT4.Failed())
-}
-
-func TestHTTPStatusCode(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(testing.T)
- assert.Equal(HTTPStatusCode(mockT1, httpOK, "GET", "/", nil, http.StatusSwitchingProtocols), false)
- assert.True(mockT1.Failed())
-
- mockT2 := new(testing.T)
- assert.Equal(HTTPStatusCode(mockT2, httpRedirect, "GET", "/", nil, http.StatusSwitchingProtocols), false)
- assert.True(mockT2.Failed())
-
- mockT3 := new(mockTestingT)
- assert.Equal(HTTPStatusCode(
- mockT3, httpError, "GET", "/", nil, http.StatusSwitchingProtocols,
- "Expected the status code to be %d", http.StatusSwitchingProtocols,
- ), false)
- assert.True(mockT3.Failed())
- assert.Contains(mockT3.errorString(), "Expected the status code to be 101")
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPStatusCode(mockT4, httpStatusCode, "GET", "/", nil, http.StatusSwitchingProtocols), true)
- assert.False(mockT4.Failed())
-}
-
-func TestHTTPStatusesWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.Equal(mockAssert.HTTPSuccess(httpOK, "GET", "/", nil), true)
- assert.Equal(mockAssert.HTTPSuccess(httpRedirect, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPSuccess(httpError, "GET", "/", nil), false)
-
- assert.Equal(mockAssert.HTTPRedirect(httpOK, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPRedirect(httpRedirect, "GET", "/", nil), true)
- assert.Equal(mockAssert.HTTPRedirect(httpError, "GET", "/", nil), false)
-
- assert.Equal(mockAssert.HTTPError(httpOK, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPError(httpRedirect, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPError(httpError, "GET", "/", nil), true)
-}
-
-func httpHelloName(w http.ResponseWriter, r *http.Request) {
- name := r.FormValue("name")
- _, _ = fmt.Fprintf(w, "Hello, %s!", name)
-}
-
-func TestHTTPRequestWithNoParams(t *testing.T) {
- var got *http.Request
- handler := func(w http.ResponseWriter, r *http.Request) {
- got = r
- w.WriteHeader(http.StatusOK)
- }
-
- True(t, HTTPSuccess(t, handler, "GET", "/url", nil))
-
- Empty(t, got.URL.Query())
- Equal(t, "/url", got.URL.RequestURI())
-}
-
-func TestHTTPRequestWithParams(t *testing.T) {
- var got *http.Request
- handler := func(w http.ResponseWriter, r *http.Request) {
- got = r
- w.WriteHeader(http.StatusOK)
- }
- params := url.Values{}
- params.Add("id", "12345")
-
- True(t, HTTPSuccess(t, handler, "GET", "/url", params))
-
- Equal(t, url.Values{"id": []string{"12345"}}, got.URL.Query())
- Equal(t, "/url?id=12345", got.URL.String())
- Equal(t, "/url?id=12345", got.URL.RequestURI())
-}
-
-func TestHttpBody(t *testing.T) {
- assert := New(t)
- mockT := new(mockTestingT)
-
- assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
- assert.False(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-
- assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.False(HTTPBodyNotContains(
- mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World",
- "Expected the request body to not contain 'World'. But it did.",
- ))
- assert.True(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
- assert.Contains(mockT.errorString(), "Expected the request body to not contain 'World'. But it did.")
-
- assert.True(HTTPBodyContains(mockT, httpReadBody, "GET", "/", nil, "hello"))
-}
-
-func TestHttpBodyWrappers(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
- assert.False(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-
- assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
- assert.True(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-}
diff --git a/internal/testify/assert/internal/unsafetests/doc.go b/internal/testify/assert/internal/unsafetests/doc.go
deleted file mode 100644
index 08172d511..000000000
--- a/internal/testify/assert/internal/unsafetests/doc.go
+++ /dev/null
@@ -1,4 +0,0 @@
-// This package exists just to isolate tests that reference the [unsafe] package.
-//
-// The tests in this package are totally safe.
-package unsafetests
diff --git a/internal/testify/assert/internal/unsafetests/unsafetests_test.go b/internal/testify/assert/internal/unsafetests/unsafetests_test.go
deleted file mode 100644
index 47b66500f..000000000
--- a/internal/testify/assert/internal/unsafetests/unsafetests_test.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package unsafetests_test
-
-import (
- "fmt"
- "testing"
- "unsafe"
-
- "github.com/expr-lang/expr/internal/testify/assert"
-)
-
-type ignoreTestingT struct{}
-
-var _ assert.TestingT = ignoreTestingT{}
-
-func (ignoreTestingT) Helper() {}
-
-func (ignoreTestingT) Errorf(format string, args ...interface{}) {
- // Run the formatting, but ignore the result
- msg := fmt.Sprintf(format, args...)
- _ = msg
-}
-
-func TestUnsafePointers(t *testing.T) {
- var ignore ignoreTestingT
-
- assert.True(t, assert.Nil(t, unsafe.Pointer(nil), "unsafe.Pointer(nil) is nil"))
- assert.False(t, assert.NotNil(ignore, unsafe.Pointer(nil), "unsafe.Pointer(nil) is nil"))
-
- assert.True(t, assert.Nil(t, unsafe.Pointer((*int)(nil)), "unsafe.Pointer((*int)(nil)) is nil"))
- assert.False(t, assert.NotNil(ignore, unsafe.Pointer((*int)(nil)), "unsafe.Pointer((*int)(nil)) is nil"))
-
- assert.False(t, assert.Nil(ignore, unsafe.Pointer(new(int)), "unsafe.Pointer(new(int)) is NOT nil"))
- assert.True(t, assert.NotNil(t, unsafe.Pointer(new(int)), "unsafe.Pointer(new(int)) is NOT nil"))
-}
diff --git a/internal/testify/require/doc.go b/internal/testify/require/doc.go
deleted file mode 100644
index a3a9ccc19..000000000
--- a/internal/testify/require/doc.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Package require implements the same assertions as the `assert` package but
-// stops test execution when a test fails.
-//
-// # Example Usage
-//
-// The following is a complete example using require in a standard test function:
-//
-// import (
-// "testing"
-// "github.com/expr-lang/expr/internal/testify/require"
-// )
-//
-// func TestSomething(t *testing.T) {
-//
-// var a string = "Hello"
-// var b string = "Hello"
-//
-// require.Equal(t, a, b, "The two words should be the same.")
-//
-// }
-//
-// # Assertions
-//
-// The `require` package have same global functions as in the `assert` package,
-// but instead of returning a boolean result they call `t.FailNow()`.
-//
-// Every assertion function also takes an optional string message as the final argument,
-// allowing custom error messages to be appended to the message the assertion method outputs.
-package require
diff --git a/internal/testify/require/forward_requirements.go b/internal/testify/require/forward_requirements.go
deleted file mode 100644
index 1dcb2338c..000000000
--- a/internal/testify/require/forward_requirements.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package require
-
-// Assertions provides assertion methods around the
-// TestingT interface.
-type Assertions struct {
- t TestingT
-}
-
-// New makes a new Assertions object for the specified TestingT.
-func New(t TestingT) *Assertions {
- return &Assertions{
- t: t,
- }
-}
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require_forward.go.tmpl -include-format-funcs"
diff --git a/internal/testify/require/forward_requirements_test.go b/internal/testify/require/forward_requirements_test.go
deleted file mode 100644
index 818ecec6d..000000000
--- a/internal/testify/require/forward_requirements_test.go
+++ /dev/null
@@ -1,397 +0,0 @@
-package require
-
-import (
- "errors"
- "testing"
- "time"
-)
-
-func TestImplementsWrapper(t *testing.T) {
- require := New(t)
-
- require.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestIsTypeWrapper(t *testing.T) {
- require := New(t)
- require.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqualWrapper(t *testing.T) {
- require := New(t)
- require.Equal(1, 1)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Equal(1, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotEqualWrapper(t *testing.T) {
- require := New(t)
- require.NotEqual(1, 2)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotEqual(2, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestExactlyWrapper(t *testing.T) {
- require := New(t)
-
- a := float32(1)
- b := float32(1)
- c := float64(1)
-
- require.Exactly(a, b)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Exactly(a, c)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotNilWrapper(t *testing.T) {
- require := New(t)
- require.NotNil(t, new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotNil(nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNilWrapper(t *testing.T) {
- require := New(t)
- require.Nil(nil)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Nil(new(AssertionTesterConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestTrueWrapper(t *testing.T) {
- require := New(t)
- require.True(true)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.True(false)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestFalseWrapper(t *testing.T) {
- require := New(t)
- require.False(false)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.False(true)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestContainsWrapper(t *testing.T) {
- require := New(t)
- require.Contains("Hello World", "Hello")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Contains("Hello World", "Salut")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotContainsWrapper(t *testing.T) {
- require := New(t)
- require.NotContains("Hello World", "Hello!")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotContains("Hello World", "Hello")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestPanicsWrapper(t *testing.T) {
- require := New(t)
- require.Panics(func() {
- panic("Panic!")
- })
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Panics(func() {})
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotPanicsWrapper(t *testing.T) {
- require := New(t)
- require.NotPanics(func() {})
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotPanics(func() {
- panic("Panic!")
- })
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNoErrorWrapper(t *testing.T) {
- require := New(t)
- require.NoError(nil)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NoError(errors.New("some error"))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestErrorWrapper(t *testing.T) {
- require := New(t)
- require.Error(errors.New("some error"))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Error(nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestErrorContainsWrapper(t *testing.T) {
- require := New(t)
- require.ErrorContains(errors.New("some error: another error"), "some error")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.ErrorContains(errors.New("some error: another error"), "different error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqualErrorWrapper(t *testing.T) {
- require := New(t)
- require.EqualError(errors.New("some error"), "some error")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.EqualError(errors.New("some error"), "Not some error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEmptyWrapper(t *testing.T) {
- require := New(t)
- require.Empty("")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Empty("x")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotEmptyWrapper(t *testing.T) {
- require := New(t)
- require.NotEmpty("x")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotEmpty("")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestWithinDurationWrapper(t *testing.T) {
- require := New(t)
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- require.WithinDuration(a, b, 15*time.Second)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.WithinDuration(a, b, 5*time.Second)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestInDeltaWrapper(t *testing.T) {
- require := New(t)
- require.InDelta(1.001, 1, 0.01)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.InDelta(1, 2, 0.5)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestZeroWrapper(t *testing.T) {
- require := New(t)
- require.Zero(0)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Zero(1)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotZeroWrapper(t *testing.T) {
- require := New(t)
- require.NotZero(1)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotZero(0)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_EqualSONString(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_Array(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"foo": "bar"}`, "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq("Not JSON", "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
diff --git a/internal/testify/require/require.go b/internal/testify/require/require.go
deleted file mode 100644
index fb036865f..000000000
--- a/internal/testify/require/require.go
+++ /dev/null
@@ -1,2039 +0,0 @@
-// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
-
-package require
-
-import (
- http "net/http"
- url "net/url"
- time "time"
-
- assert "github.com/expr-lang/expr/internal/testify/assert"
-)
-
-// Condition uses a Comparison to assert a complex condition.
-func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Condition(t, comp, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Conditionf uses a Comparison to assert a complex condition.
-func Conditionf(t TestingT, comp assert.Comparison, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Conditionf(t, comp, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Contains(t, "Hello World", "World")
-// assert.Contains(t, ["Hello", "World"], "World")
-// assert.Contains(t, {"Hello": "World"}, "Hello")
-func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Contains(t, s, contains, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
-func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Containsf(t, s, contains, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.DirExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.DirExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])
-func ElementsMatch(t TestingT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ElementsMatch(t, listA, listB, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ElementsMatchf(t, listA, listB, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Empty(t, obj)
-func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Empty(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Emptyf(t, obj, "error message %s", "formatted")
-func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Emptyf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Equal asserts that two objects are equal.
-//
-// assert.Equal(t, 123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Equal(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualError(t, err, expectedErrorString)
-func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualError(t, theError, errString, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
-func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualErrorf(t, theError, errString, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// EqualExportedValues asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// assert.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
-// assert.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false
-func EqualExportedValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualExportedValues(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EqualExportedValuesf asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
-// assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
-func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualExportedValuesf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// EqualValues asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// assert.EqualValues(t, uint32(123), int32(123))
-func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualValues(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EqualValuesf asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
-func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualValuesf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Equalf asserts that two objects are equal.
-//
-// assert.Equalf(t, 123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Equalf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Error(t, err) {
-// assert.Equal(t, expectedError, err)
-// }
-func Error(t TestingT, err error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Error(t, err, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorAs(t, err, target, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorAsf(t, err, target, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContains(t, err, expectedErrorSubString)
-func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorContains(t, theError, contains, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
-func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorContainsf(t, theError, contains, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIs(t TestingT, err error, target error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorIs(t, err, target, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorIsf(t, err, target, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Errorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func Errorf(t TestingT, err error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Errorf(t, err, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
-func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Eventually(t, condition, waitFor, tick, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EventuallyWithT asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// assert.EventuallyWithT(t, func(c *assert.CollectT) {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func EventuallyWithT(t TestingT, condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EventuallyWithT(t, condition, waitFor, tick, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EventuallyWithTf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func EventuallyWithTf(t TestingT, condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EventuallyWithTf(t, condition, waitFor, tick, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Eventuallyf(t, condition, waitFor, tick, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// assert.Exactly(t, int32(123), int64(123))
-func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Exactly(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
-func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Exactlyf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Fail reports a failure through
-func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Fail(t, failureMessage, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// FailNow fails test
-func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FailNow(t, failureMessage, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// FailNowf fails test
-func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FailNowf(t, failureMessage, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Failf reports a failure through
-func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Failf(t, failureMessage, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// False asserts that the specified value is false.
-//
-// assert.False(t, myBool)
-func False(t TestingT, value bool, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.False(t, value, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Falsef asserts that the specified value is false.
-//
-// assert.Falsef(t, myBool, "error message %s", "formatted")
-func Falsef(t TestingT, value bool, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Falsef(t, value, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FileExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FileExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// assert.Greater(t, 2, 1)
-// assert.Greater(t, float64(2), float64(1))
-// assert.Greater(t, "b", "a")
-func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Greater(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqual(t, 2, 1)
-// assert.GreaterOrEqual(t, 2, 2)
-// assert.GreaterOrEqual(t, "b", "a")
-// assert.GreaterOrEqual(t, "b", "b")
-func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.GreaterOrEqual(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
-func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.GreaterOrEqualf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
-// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
-func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Greaterf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyContains(t, handler, method, url, values, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyContainsf(t, handler, method, url, values, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyNotContains(t, handler, method, url, values, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyNotContainsf(t, handler, method, url, values, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPError(t, handler, method, url, values, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPErrorf(t, handler, method, url, values, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPRedirect(t, handler, method, url, values, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPRedirectf(t, handler, method, url, values, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPStatusCode(t, handler, method, url, values, statuscode, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPStatusCodef(t, handler, method, url, values, statuscode, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPSuccess(t, handler, method, url, values, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPSuccessf(t, handler, method, url, values, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
-func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Implements(t, interfaceObject, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Implementsf(t, interfaceObject, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
-func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDelta(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValues(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaMapValues(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaMapValuesf(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaSlicef(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaf(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilonSlicef(t, expected, actual, epsilon, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilonf(t, expected, actual, epsilon, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// assert.IsDecreasing(t, []int{2, 1, 0})
-// assert.IsDecreasing(t, []float{2, 1})
-// assert.IsDecreasing(t, []string{"b", "a"})
-func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsDecreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsDecreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// assert.IsIncreasing(t, []int{1, 2, 3})
-// assert.IsIncreasing(t, []float{1, 2})
-// assert.IsIncreasing(t, []string{"a", "b"})
-func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsIncreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsIncreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasing(t, []int{1, 1, 2})
-// assert.IsNonDecreasing(t, []float{1, 2})
-// assert.IsNonDecreasing(t, []string{"a", "b"})
-func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonDecreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonDecreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// assert.IsNonIncreasing(t, []int{2, 1, 1})
-// assert.IsNonIncreasing(t, []float{2, 1})
-// assert.IsNonIncreasing(t, []string{"b", "a"})
-func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonIncreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonIncreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsType asserts that the specified objects are of the same type.
-func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsType(t, expectedType, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsTypef(t, expectedType, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.JSONEq(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.JSONEqf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// assert.Len(t, mySlice, 3)
-func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Len(t, object, length, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
-func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Lenf(t, object, length, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Less asserts that the first element is less than the second
-//
-// assert.Less(t, 1, 2)
-// assert.Less(t, float64(1), float64(2))
-// assert.Less(t, "a", "b")
-func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Less(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqual(t, 1, 2)
-// assert.LessOrEqual(t, 2, 2)
-// assert.LessOrEqual(t, "a", "b")
-// assert.LessOrEqual(t, "b", "b")
-func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.LessOrEqual(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
-func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.LessOrEqualf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// assert.Lessf(t, 1, 2, "error message %s", "formatted")
-// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
-// assert.Lessf(t, "a", "b", "error message %s", "formatted")
-func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Lessf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Negative asserts that the specified element is negative
-//
-// assert.Negative(t, -1)
-// assert.Negative(t, -1.23)
-func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Negative(t, e, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Negativef asserts that the specified element is negative
-//
-// assert.Negativef(t, -1, "error message %s", "formatted")
-// assert.Negativef(t, -1.23, "error message %s", "formatted")
-func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Negativef(t, e, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
-func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Never(t, condition, waitFor, tick, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Neverf(t, condition, waitFor, tick, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Nil asserts that the specified object is nil.
-//
-// assert.Nil(t, err)
-func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Nil(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// assert.Nilf(t, err, "error message %s", "formatted")
-func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Nilf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoDirExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoDirExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoError(t, err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoError(t, err, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoErrorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoErrorf(t TestingT, err error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoErrorf(t, err, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoFileExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoFileExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContains(t, "Hello World", "Earth")
-// assert.NotContains(t, ["Hello", "World"], "Earth")
-// assert.NotContains(t, {"Hello": "World"}, "Earth")
-func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotContains(t, s, contains, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
-func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotContainsf(t, s, contains, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmpty(t, obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEmpty(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEmptyf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// assert.NotEqual(t, obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqual(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValues(t, obj1, obj2)
-func NotEqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqualValues(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
-func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqualValuesf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqualf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIs(t TestingT, err error, target error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotErrorIs(t, err, target, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotErrorIsf(t, err, target, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotImplements asserts that an object does not implement the specified interface.
-//
-// assert.NotImplements(t, (*MyInterface)(nil), new(MyObject))
-func NotImplements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotImplements(t, interfaceObject, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotImplementsf asserts that an object does not implement the specified interface.
-//
-// assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotImplementsf(t, interfaceObject, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// assert.NotNil(t, err)
-func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotNil(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// assert.NotNilf(t, err, "error message %s", "formatted")
-func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotNilf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanics(t, func(){ RemainCalm() })
-func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotPanics(t, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
-func NotPanicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotPanicsf(t, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-// assert.NotRegexp(t, "^start", "it's not starting")
-func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotRegexp(t, rx, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
-func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotRegexpf(t, rx, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// assert.NotSame(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSame(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSame(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSamef(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotSubset asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// assert.NotSubset(t, [1, 3, 4], [1, 2])
-// assert.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
-func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSubset(t, list, subset, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted")
-// assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
-func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSubsetf(t, list, subset, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotZero(t, i, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotZerof(t, i, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panics(t, func(){ GoCrazy() })
-func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Panics(t, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithError(t TestingT, errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithError(t, errString, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithErrorf(t TestingT, errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithErrorf(t, errString, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithValue(t, expected, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithValuef(t TestingT, expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithValuef(t, expected, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
-func Panicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Panicsf(t, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Positive asserts that the specified element is positive
-//
-// assert.Positive(t, 1)
-// assert.Positive(t, 1.23)
-func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Positive(t, e, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Positivef asserts that the specified element is positive
-//
-// assert.Positivef(t, 1, "error message %s", "formatted")
-// assert.Positivef(t, 1.23, "error message %s", "formatted")
-func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Positivef(t, e, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-// assert.Regexp(t, "start...$", "it's not starting")
-func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Regexp(t, rx, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
-func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Regexpf(t, rx, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// assert.Same(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Same(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Same(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Samef(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Subset asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// assert.Subset(t, [1, 2, 3], [1, 2])
-// assert.Subset(t, {"x": 1, "y": 2}, {"x": 1})
-func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Subset(t, list, subset, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Subsetf asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted")
-// assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
-func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Subsetf(t, list, subset, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// True asserts that the specified value is true.
-//
-// assert.True(t, myBool)
-func True(t TestingT, value bool, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.True(t, value, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Truef asserts that the specified value is true.
-//
-// assert.Truef(t, myBool, "error message %s", "formatted")
-func Truef(t TestingT, value bool, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Truef(t, value, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
-func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinDurationf(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func WithinRange(t TestingT, actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinRange(t, actual, start, end, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinRangef(t, actual, start, end, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Zero asserts that i is the zero value for its type.
-func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Zero(t, i, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Zerof asserts that i is the zero value for its type.
-func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Zerof(t, i, msg, args...) {
- return
- }
- t.FailNow()
-}
diff --git a/internal/testify/require/require.go.tmpl b/internal/testify/require/require.go.tmpl
deleted file mode 100644
index 55e42ddeb..000000000
--- a/internal/testify/require/require.go.tmpl
+++ /dev/null
@@ -1,6 +0,0 @@
-{{.Comment}}
-func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
- if h, ok := t.(tHelper); ok { h.Helper() }
- if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return }
- t.FailNow()
-}
diff --git a/internal/testify/require/require_forward.go b/internal/testify/require/require_forward.go
deleted file mode 100644
index 4cf7154f6..000000000
--- a/internal/testify/require/require_forward.go
+++ /dev/null
@@ -1,1607 +0,0 @@
-// Code generated with github.com/expr-lang/expr/internal/_codegen; DO NOT EDIT.
-
-package require
-
-import (
- http "net/http"
- url "net/url"
- time "time"
-
- assert "github.com/expr-lang/expr/internal/testify/assert"
-)
-
-// Condition uses a Comparison to assert a complex condition.
-func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Condition(a.t, comp, msgAndArgs...)
-}
-
-// Conditionf uses a Comparison to assert a complex condition.
-func (a *Assertions) Conditionf(comp assert.Comparison, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Conditionf(a.t, comp, msg, args...)
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Contains("Hello World", "World")
-// a.Contains(["Hello", "World"], "World")
-// a.Contains({"Hello": "World"}, "Hello")
-func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Contains(a.t, s, contains, msgAndArgs...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Containsf("Hello World", "World", "error message %s", "formatted")
-// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
-// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
-func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Containsf(a.t, s, contains, msg, args...)
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- DirExists(a.t, path, msgAndArgs...)
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- DirExistsf(a.t, path, msg, args...)
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])
-func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ElementsMatch(a.t, listA, listB, msgAndArgs...)
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ElementsMatchf(a.t, listA, listB, msg, args...)
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Empty(obj)
-func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Empty(a.t, object, msgAndArgs...)
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Emptyf(obj, "error message %s", "formatted")
-func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Emptyf(a.t, object, msg, args...)
-}
-
-// Equal asserts that two objects are equal.
-//
-// a.Equal(123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Equal(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualError(err, expectedErrorString)
-func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualError(a.t, theError, errString, msgAndArgs...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
-func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualErrorf(a.t, theError, errString, msg, args...)
-}
-
-// EqualExportedValues asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// a.EqualExportedValues(S{1, 2}, S{1, 3}) => true
-// a.EqualExportedValues(S{1, 2}, S{2, 3}) => false
-func (a *Assertions) EqualExportedValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualExportedValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualExportedValuesf asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
-//
-// type S struct {
-// Exported int
-// notExported int
-// }
-// a.EqualExportedValuesf(S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
-// a.EqualExportedValuesf(S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
-func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualExportedValuesf(a.t, expected, actual, msg, args...)
-}
-
-// EqualValues asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// a.EqualValues(uint32(123), int32(123))
-func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertible to the same types
-// and equal.
-//
-// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
-func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-// a.Equalf(123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Equalf(a.t, expected, actual, msg, args...)
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Error(err) {
-// assert.Equal(t, expectedError, err)
-// }
-func (a *Assertions) Error(err error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Error(a.t, err, msgAndArgs...)
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorAs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorAsf(a.t, err, target, msg, args...)
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContains(err, expectedErrorSubString)
-func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorContains(a.t, theError, contains, msgAndArgs...)
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
-func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorContainsf(a.t, theError, contains, msg, args...)
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIs(err error, target error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorIsf(a.t, err, target, msg, args...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Errorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func (a *Assertions) Errorf(err error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Errorf(a.t, err, msg, args...)
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// EventuallyWithT asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// a.EventuallyWithT(func(c *assert.CollectT) {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func (a *Assertions) EventuallyWithT(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EventuallyWithT(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// EventuallyWithTf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick. In contrast to Eventually,
-// it supplies a CollectT to the condition function, so that the condition
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-// externalValue := false
-// go func() {
-// time.Sleep(8*time.Second)
-// externalValue = true
-// }()
-// a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
-// // add assertions as needed; any assertion failure will fail the current tick
-// assert.True(c, externalValue, "expected 'externalValue' to be true")
-// }, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
-func (a *Assertions) EventuallyWithTf(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EventuallyWithTf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Eventuallyf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// a.Exactly(int32(123), int64(123))
-func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Exactly(a.t, expected, actual, msgAndArgs...)
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
-func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Exactlyf(a.t, expected, actual, msg, args...)
-}
-
-// Fail reports a failure through
-func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Fail(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNow fails test
-func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FailNow(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNowf fails test
-func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FailNowf(a.t, failureMessage, msg, args...)
-}
-
-// Failf reports a failure through
-func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Failf(a.t, failureMessage, msg, args...)
-}
-
-// False asserts that the specified value is false.
-//
-// a.False(myBool)
-func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- False(a.t, value, msgAndArgs...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-// a.Falsef(myBool, "error message %s", "formatted")
-func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Falsef(a.t, value, msg, args...)
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FileExists(a.t, path, msgAndArgs...)
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FileExistsf(a.t, path, msg, args...)
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// a.Greater(2, 1)
-// a.Greater(float64(2), float64(1))
-// a.Greater("b", "a")
-func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Greater(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqual(2, 1)
-// a.GreaterOrEqual(2, 2)
-// a.GreaterOrEqual("b", "a")
-// a.GreaterOrEqual("b", "b")
-func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- GreaterOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
-// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- GreaterOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// a.Greaterf(2, 1, "error message %s", "formatted")
-// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
-// a.Greaterf("b", "a", "error message %s", "formatted")
-func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Greaterf(a.t, e1, e2, msg, args...)
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPError(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPErrorf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPRedirectf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPStatusCode(a.t, handler, method, url, values, statuscode, msgAndArgs...)
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPStatusCodef(a.t, handler, method, url, values, statuscode, msg, args...)
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPSuccessf(a.t, handler, method, url, values, msg, args...)
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// a.Implements((*MyInterface)(nil), new(MyObject))
-func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Implements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Implementsf(a.t, interfaceObject, object, msg, args...)
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// a.InDelta(math.Pi, 22/7.0, 0.01)
-func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDelta(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// a.IsDecreasing([]int{2, 1, 0})
-// a.IsDecreasing([]float{2, 1})
-// a.IsDecreasing([]string{"b", "a"})
-func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
-// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsDecreasingf(a.t, object, msg, args...)
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// a.IsIncreasing([]int{1, 2, 3})
-// a.IsIncreasing([]float{1, 2})
-// a.IsIncreasing([]string{"a", "b"})
-func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
-// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsIncreasingf(a.t, object, msg, args...)
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// a.IsNonDecreasing([]int{1, 1, 2})
-// a.IsNonDecreasing([]float{1, 2})
-// a.IsNonDecreasing([]string{"a", "b"})
-func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonDecreasingf(a.t, object, msg, args...)
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// a.IsNonIncreasing([]int{2, 1, 1})
-// a.IsNonIncreasing([]float{2, 1})
-// a.IsNonIncreasing([]string{"b", "a"})
-func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonIncreasingf(a.t, object, msg, args...)
-}
-
-// IsType asserts that the specified objects are of the same type.
-func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsType(a.t, expectedType, object, msgAndArgs...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsTypef(a.t, expectedType, object, msg, args...)
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- JSONEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- JSONEqf(a.t, expected, actual, msg, args...)
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// a.Len(mySlice, 3)
-func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Len(a.t, object, length, msgAndArgs...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// a.Lenf(mySlice, 3, "error message %s", "formatted")
-func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Lenf(a.t, object, length, msg, args...)
-}
-
-// Less asserts that the first element is less than the second
-//
-// a.Less(1, 2)
-// a.Less(float64(1), float64(2))
-// a.Less("a", "b")
-func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Less(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqual(1, 2)
-// a.LessOrEqual(2, 2)
-// a.LessOrEqual("a", "b")
-// a.LessOrEqual("b", "b")
-func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- LessOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqualf(1, 2, "error message %s", "formatted")
-// a.LessOrEqualf(2, 2, "error message %s", "formatted")
-// a.LessOrEqualf("a", "b", "error message %s", "formatted")
-// a.LessOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- LessOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// a.Lessf(1, 2, "error message %s", "formatted")
-// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
-// a.Lessf("a", "b", "error message %s", "formatted")
-func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Lessf(a.t, e1, e2, msg, args...)
-}
-
-// Negative asserts that the specified element is negative
-//
-// a.Negative(-1)
-// a.Negative(-1.23)
-func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Negative(a.t, e, msgAndArgs...)
-}
-
-// Negativef asserts that the specified element is negative
-//
-// a.Negativef(-1, "error message %s", "formatted")
-// a.Negativef(-1.23, "error message %s", "formatted")
-func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Negativef(a.t, e, msg, args...)
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Never(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Neverf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Nil asserts that the specified object is nil.
-//
-// a.Nil(err)
-func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Nil(a.t, object, msgAndArgs...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// a.Nilf(err, "error message %s", "formatted")
-func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Nilf(a.t, object, msg, args...)
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoDirExists(a.t, path, msgAndArgs...)
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoDirExistsf(a.t, path, msg, args...)
-}
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoError(err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoError(a.t, err, msgAndArgs...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoErrorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoErrorf(a.t, err, msg, args...)
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoFileExists(a.t, path, msgAndArgs...)
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoFileExistsf(a.t, path, msg, args...)
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContains("Hello World", "Earth")
-// a.NotContains(["Hello", "World"], "Earth")
-// a.NotContains({"Hello": "World"}, "Earth")
-func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotContains(a.t, s, contains, msgAndArgs...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
-// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
-// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
-func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotContainsf(a.t, s, contains, msg, args...)
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmpty(obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEmpty(a.t, object, msgAndArgs...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmptyf(obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEmptyf(a.t, object, msg, args...)
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// a.NotEqual(obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqual(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValues(obj1, obj2)
-func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
-func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqualf(a.t, expected, actual, msg, args...)
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotErrorIsf(a.t, err, target, msg, args...)
-}
-
-// NotImplements asserts that an object does not implement the specified interface.
-//
-// a.NotImplements((*MyInterface)(nil), new(MyObject))
-func (a *Assertions) NotImplements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotImplements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-// NotImplementsf asserts that an object does not implement the specified interface.
-//
-// a.NotImplementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func (a *Assertions) NotImplementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotImplementsf(a.t, interfaceObject, object, msg, args...)
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// a.NotNil(err)
-func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotNil(a.t, object, msgAndArgs...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// a.NotNilf(err, "error message %s", "formatted")
-func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotNilf(a.t, object, msg, args...)
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanics(func(){ RemainCalm() })
-func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotPanics(a.t, f, msgAndArgs...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
-func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotPanicsf(a.t, f, msg, args...)
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-// a.NotRegexp("^start", "it's not starting")
-func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotRegexp(a.t, rx, str, msgAndArgs...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotRegexpf(a.t, rx, str, msg, args...)
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// a.NotSame(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSame(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSamef(a.t, expected, actual, msg, args...)
-}
-
-// NotSubset asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// a.NotSubset([1, 3, 4], [1, 2])
-// a.NotSubset({"x": 1, "y": 2}, {"z": 3})
-func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSubset(a.t, list, subset, msgAndArgs...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
-//
-// a.NotSubsetf([1, 3, 4], [1, 2], "error message %s", "formatted")
-// a.NotSubsetf({"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
-func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSubsetf(a.t, list, subset, msg, args...)
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotZero(a.t, i, msgAndArgs...)
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotZerof(a.t, i, msg, args...)
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panics(func(){ GoCrazy() })
-func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Panics(a.t, f, msgAndArgs...)
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithError("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithError(a.t, errString, f, msgAndArgs...)
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithErrorf(errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithErrorf(a.t, errString, f, msg, args...)
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithValue(a.t, expected, f, msgAndArgs...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithValuef(a.t, expected, f, msg, args...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Panicsf(a.t, f, msg, args...)
-}
-
-// Positive asserts that the specified element is positive
-//
-// a.Positive(1)
-// a.Positive(1.23)
-func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Positive(a.t, e, msgAndArgs...)
-}
-
-// Positivef asserts that the specified element is positive
-//
-// a.Positivef(1, "error message %s", "formatted")
-// a.Positivef(1.23, "error message %s", "formatted")
-func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Positivef(a.t, e, msg, args...)
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// a.Regexp(regexp.MustCompile("start"), "it's starting")
-// a.Regexp("start...$", "it's not starting")
-func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Regexp(a.t, rx, str, msgAndArgs...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Regexpf(a.t, rx, str, msg, args...)
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// a.Same(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Same(a.t, expected, actual, msgAndArgs...)
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// a.Samef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Samef(a.t, expected, actual, msg, args...)
-}
-
-// Subset asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// a.Subset([1, 2, 3], [1, 2])
-// a.Subset({"x": 1, "y": 2}, {"x": 1})
-func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Subset(a.t, list, subset, msgAndArgs...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
-//
-// a.Subsetf([1, 2, 3], [1, 2], "error message %s", "formatted")
-// a.Subsetf({"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
-func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Subsetf(a.t, list, subset, msg, args...)
-}
-
-// True asserts that the specified value is true.
-//
-// a.True(myBool)
-func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- True(a.t, value, msgAndArgs...)
-}
-
-// Truef asserts that the specified value is true.
-//
-// a.Truef(myBool, "error message %s", "formatted")
-func (a *Assertions) Truef(value bool, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Truef(a.t, value, msg, args...)
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
-func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinDurationf(a.t, expected, actual, delta, msg, args...)
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinRange(a.t, actual, start, end, msgAndArgs...)
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinRangef(a.t, actual, start, end, msg, args...)
-}
-
-// Zero asserts that i is the zero value for its type.
-func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Zero(a.t, i, msgAndArgs...)
-}
-
-// Zerof asserts that i is the zero value for its type.
-func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Zerof(a.t, i, msg, args...)
-}
diff --git a/internal/testify/require/require_forward.go.tmpl b/internal/testify/require/require_forward.go.tmpl
deleted file mode 100644
index 54124df1d..000000000
--- a/internal/testify/require/require_forward.go.tmpl
+++ /dev/null
@@ -1,5 +0,0 @@
-{{.CommentWithoutT "a"}}
-func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) {
- if h, ok := a.t.(tHelper); ok { h.Helper() }
- {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
-}
diff --git a/internal/testify/require/requirements.go b/internal/testify/require/requirements.go
deleted file mode 100644
index 6b7ce929e..000000000
--- a/internal/testify/require/requirements.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package require
-
-// TestingT is an interface wrapper around *testing.T
-type TestingT interface {
- Errorf(format string, args ...interface{})
- FailNow()
-}
-
-type tHelper = interface {
- Helper()
-}
-
-// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful
-// for table driven tests.
-type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{})
-
-// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful
-// for table driven tests.
-type ValueAssertionFunc func(TestingT, interface{}, ...interface{})
-
-// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful
-// for table driven tests.
-type BoolAssertionFunc func(TestingT, bool, ...interface{})
-
-// ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful
-// for table driven tests.
-type ErrorAssertionFunc func(TestingT, error, ...interface{})
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require.go.tmpl -include-format-funcs"
diff --git a/internal/testify/require/requirements_test.go b/internal/testify/require/requirements_test.go
deleted file mode 100644
index 1f6eff463..000000000
--- a/internal/testify/require/requirements_test.go
+++ /dev/null
@@ -1,578 +0,0 @@
-package require
-
-import (
- "encoding/json"
- "errors"
- "testing"
- "time"
-)
-
-// AssertionTesterInterface defines an interface to be used for testing assertion methods
-type AssertionTesterInterface interface {
- TestMethod()
-}
-
-// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
-type AssertionTesterConformingObject struct {
-}
-
-func (a *AssertionTesterConformingObject) TestMethod() {
-}
-
-// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
-type AssertionTesterNonConformingObject struct {
-}
-
-type MockT struct {
- Failed bool
-}
-
-func (t *MockT) FailNow() {
- t.Failed = true
-}
-
-func (t *MockT) Errorf(format string, args ...interface{}) {
- _, _ = format, args
-}
-
-func TestImplements(t *testing.T) {
-
- Implements(t, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestIsType(t *testing.T) {
-
- IsType(t, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqual(t *testing.T) {
-
- Equal(t, 1, 1)
-
- mockT := new(MockT)
- Equal(mockT, 1, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-
-}
-
-func TestNotEqual(t *testing.T) {
-
- NotEqual(t, 1, 2)
- mockT := new(MockT)
- NotEqual(mockT, 2, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestExactly(t *testing.T) {
-
- a := float32(1)
- b := float32(1)
- c := float64(1)
-
- Exactly(t, a, b)
-
- mockT := new(MockT)
- Exactly(mockT, a, c)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotNil(t *testing.T) {
-
- NotNil(t, new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- NotNil(mockT, nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNil(t *testing.T) {
-
- Nil(t, nil)
-
- mockT := new(MockT)
- Nil(mockT, new(AssertionTesterConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestTrue(t *testing.T) {
-
- True(t, true)
-
- mockT := new(MockT)
- True(mockT, false)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestFalse(t *testing.T) {
-
- False(t, false)
-
- mockT := new(MockT)
- False(mockT, true)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestContains(t *testing.T) {
-
- Contains(t, "Hello World", "Hello")
-
- mockT := new(MockT)
- Contains(mockT, "Hello World", "Salut")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotContains(t *testing.T) {
-
- NotContains(t, "Hello World", "Hello!")
-
- mockT := new(MockT)
- NotContains(mockT, "Hello World", "Hello")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestPanics(t *testing.T) {
-
- Panics(t, func() {
- panic("Panic!")
- })
-
- mockT := new(MockT)
- Panics(mockT, func() {})
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotPanics(t *testing.T) {
-
- NotPanics(t, func() {})
-
- mockT := new(MockT)
- NotPanics(mockT, func() {
- panic("Panic!")
- })
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNoError(t *testing.T) {
-
- NoError(t, nil)
-
- mockT := new(MockT)
- NoError(mockT, errors.New("some error"))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestError(t *testing.T) {
-
- Error(t, errors.New("some error"))
-
- mockT := new(MockT)
- Error(mockT, nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestErrorContains(t *testing.T) {
-
- ErrorContains(t, errors.New("some error: another error"), "some error")
-
- mockT := new(MockT)
- ErrorContains(mockT, errors.New("some error"), "different error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqualError(t *testing.T) {
-
- EqualError(t, errors.New("some error"), "some error")
-
- mockT := new(MockT)
- EqualError(mockT, errors.New("some error"), "Not some error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEmpty(t *testing.T) {
-
- Empty(t, "")
-
- mockT := new(MockT)
- Empty(mockT, "x")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotEmpty(t *testing.T) {
-
- NotEmpty(t, "x")
-
- mockT := new(MockT)
- NotEmpty(mockT, "")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestWithinDuration(t *testing.T) {
-
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- WithinDuration(t, a, b, 15*time.Second)
-
- mockT := new(MockT)
- WithinDuration(mockT, a, b, 5*time.Second)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestInDelta(t *testing.T) {
-
- InDelta(t, 1.001, 1, 0.01)
-
- mockT := new(MockT)
- InDelta(mockT, 1, 2, 0.5)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestZero(t *testing.T) {
-
- Zero(t, "")
-
- mockT := new(MockT)
- Zero(mockT, "x")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotZero(t *testing.T) {
-
- NotZero(t, "x")
-
- mockT := new(MockT)
- NotZero(mockT, "")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_EqualSONString(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_Array(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_HashesNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ActualIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"foo": "bar"}`, "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, "Not JSON", "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func ExampleComparisonAssertionFunc() {
- t := &testing.T{} // provided by test
-
- adder := func(x, y int) int {
- return x + y
- }
-
- type args struct {
- x int
- y int
- }
-
- tests := []struct {
- name string
- args args
- expect int
- assertion ComparisonAssertionFunc
- }{
- {"2+2=4", args{2, 2}, 4, Equal},
- {"2+2!=5", args{2, 2}, 5, NotEqual},
- {"2+3==5", args{2, 3}, 5, Exactly},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y))
- })
- }
-}
-
-func TestComparisonAssertionFunc(t *testing.T) {
- type iface interface {
- Name() string
- }
-
- tests := []struct {
- name string
- expect interface{}
- got interface{}
- assertion ComparisonAssertionFunc
- }{
- {"implements", (*iface)(nil), t, Implements},
- {"isType", (*testing.T)(nil), t, IsType},
- {"equal", t, t, Equal},
- {"equalValues", t, t, EqualValues},
- {"exactly", t, t, Exactly},
- {"notEqual", t, nil, NotEqual},
- {"NotEqualValues", t, nil, NotEqualValues},
- {"notContains", []int{1, 2, 3}, 4, NotContains},
- {"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset},
- {"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset},
- {"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch},
- {"regexp", "^t.*y$", "testify", Regexp},
- {"notRegexp", "^t.*y$", "Testify", NotRegexp},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, tt.got)
- })
- }
-}
-
-func ExampleValueAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParse := func(input string) interface{} {
- var x interface{}
- json.Unmarshal([]byte(input), &x)
- return x
- }
-
- tests := []struct {
- name string
- arg string
- assertion ValueAssertionFunc
- }{
- {"true is not nil", "true", NotNil},
- {"empty string is nil", "", Nil},
- {"zero is not nil", "0", NotNil},
- {"zero is zero", "0", Zero},
- {"false is zero", "false", Zero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, dumbParse(tt.arg))
- })
- }
-}
-
-func TestValueAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value interface{}
- assertion ValueAssertionFunc
- }{
- {"notNil", true, NotNil},
- {"nil", nil, Nil},
- {"empty", []int{}, Empty},
- {"notEmpty", []int{1}, NotEmpty},
- {"zero", false, Zero},
- {"notZero", 42, NotZero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleBoolAssertionFunc() {
- t := &testing.T{} // provided by test
-
- isOkay := func(x int) bool {
- return x >= 42
- }
-
- tests := []struct {
- name string
- arg int
- assertion BoolAssertionFunc
- }{
- {"-1 is bad", -1, False},
- {"42 is good", 42, True},
- {"41 is bad", 41, False},
- {"45 is cool", 45, True},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, isOkay(tt.arg))
- })
- }
-}
-
-func TestBoolAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value bool
- assertion BoolAssertionFunc
- }{
- {"true", true, True},
- {"false", false, False},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleErrorAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParseNum := func(input string, v interface{}) error {
- return json.Unmarshal([]byte(input), v)
- }
-
- tests := []struct {
- name string
- arg string
- assertion ErrorAssertionFunc
- }{
- {"1.2 is number", "1.2", NoError},
- {"1.2.3 not number", "1.2.3", Error},
- {"true is not number", "true", Error},
- {"3 is number", "3", NoError},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var x float64
- tt.assertion(t, dumbParseNum(tt.arg, &x))
- })
- }
-}
-
-func TestErrorAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- err error
- assertion ErrorAssertionFunc
- }{
- {"noError", nil, NoError},
- {"error", errors.New("whoops"), Error},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.err)
- })
- }
-}
diff --git a/optimizer/count_any_test.go b/optimizer/count_any_test.go
index 18c608c34..e880158b0 100644
--- a/optimizer/count_any_test.go
+++ b/optimizer/count_any_test.go
@@ -5,8 +5,8 @@ import (
"github.com/expr-lang/expr"
. "github.com/expr-lang/expr/ast"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/optimizer"
"github.com/expr-lang/expr/parser"
"github.com/expr-lang/expr/vm"
diff --git a/optimizer/count_threshold_test.go b/optimizer/count_threshold_test.go
index 3bac6fc3f..a461811f2 100644
--- a/optimizer/count_threshold_test.go
+++ b/optimizer/count_threshold_test.go
@@ -5,8 +5,8 @@ import (
"github.com/expr-lang/expr"
. "github.com/expr-lang/expr/ast"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/optimizer"
"github.com/expr-lang/expr/parser"
"github.com/expr-lang/expr/vm"
diff --git a/optimizer/filter_map_test.go b/optimizer/filter_map_test.go
index b45fbdead..1bc4fe38f 100644
--- a/optimizer/filter_map_test.go
+++ b/optimizer/filter_map_test.go
@@ -4,8 +4,8 @@ import (
"testing"
. "github.com/expr-lang/expr/ast"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/optimizer"
"github.com/expr-lang/expr/parser"
)
diff --git a/optimizer/fold_test.go b/optimizer/fold_test.go
index 026a4f59b..c3e522bf1 100644
--- a/optimizer/fold_test.go
+++ b/optimizer/fold_test.go
@@ -5,8 +5,8 @@ import (
"testing"
"github.com/expr-lang/expr/ast"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/optimizer"
"github.com/expr-lang/expr/parser"
)
diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go
index 03458689f..d3f21689d 100644
--- a/optimizer/optimizer_test.go
+++ b/optimizer/optimizer_test.go
@@ -5,8 +5,8 @@ import (
"strings"
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
diff --git a/optimizer/sum_array_test.go b/optimizer/sum_array_test.go
index 6ff93e350..09286c22b 100644
--- a/optimizer/sum_array_test.go
+++ b/optimizer/sum_array_test.go
@@ -3,8 +3,8 @@ package optimizer_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
diff --git a/optimizer/sum_map_test.go b/optimizer/sum_map_test.go
index 2d0ffeb77..0dd7af9bc 100644
--- a/optimizer/sum_map_test.go
+++ b/optimizer/sum_map_test.go
@@ -3,8 +3,8 @@ package optimizer_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/ast"
"github.com/expr-lang/expr/optimizer"
diff --git a/optimizer/sum_range_test.go b/optimizer/sum_range_test.go
index 87185b227..78c75ad07 100644
--- a/optimizer/sum_range_test.go
+++ b/optimizer/sum_range_test.go
@@ -5,8 +5,8 @@ import (
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/optimizer"
"github.com/expr-lang/expr/parser"
)
diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go
index 6212d066f..42db7caab 100644
--- a/parser/lexer/lexer_test.go
+++ b/parser/lexer/lexer_test.go
@@ -6,8 +6,8 @@ import (
"testing"
"github.com/expr-lang/expr/file"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
. "github.com/expr-lang/expr/parser/lexer"
)
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 963a23050..5da2aa782 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -6,8 +6,8 @@ import (
"testing"
"github.com/expr-lang/expr/conf"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
. "github.com/expr-lang/expr/ast"
"github.com/expr-lang/expr/parser"
diff --git a/patcher/value/bench_test.go b/patcher/value/bench_test.go
index f72ed53e0..d6a1aae89 100644
--- a/patcher/value/bench_test.go
+++ b/patcher/value/bench_test.go
@@ -3,7 +3,7 @@ package value
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/vm"
diff --git a/patcher/value/value_test.go b/patcher/value/value_test.go
index d04a4120a..b98a66643 100644
--- a/patcher/value/value_test.go
+++ b/patcher/value/value_test.go
@@ -3,7 +3,7 @@ package value
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/vm"
diff --git a/patcher/with_context_test.go b/patcher/with_context_test.go
index 278705334..5ce64191f 100644
--- a/patcher/with_context_test.go
+++ b/patcher/with_context_test.go
@@ -4,7 +4,7 @@ import (
"context"
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/patcher"
diff --git a/patcher/with_timezone_test.go b/patcher/with_timezone_test.go
index a1adf9bc9..2cd099f20 100644
--- a/patcher/with_timezone_test.go
+++ b/patcher/with_timezone_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"time"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
)
diff --git a/test/bench/bench_call_test.go b/test/bench/bench_call_test.go
index 9c9c13226..b7a165f75 100644
--- a/test/bench/bench_call_test.go
+++ b/test/bench/bench_call_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/vm"
)
diff --git a/test/coredns/coredns_test.go b/test/coredns/coredns_test.go
index 980a25e77..39b4b863f 100644
--- a/test/coredns/coredns_test.go
+++ b/test/coredns/coredns_test.go
@@ -4,7 +4,7 @@ import (
"context"
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
+ "github.com/stretchr/testify/assert"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/test/coredns"
diff --git a/test/crowdsec/crowdsec_test.go b/test/crowdsec/crowdsec_test.go
index 0ddb54102..34f529d2f 100644
--- a/test/crowdsec/crowdsec_test.go
+++ b/test/crowdsec/crowdsec_test.go
@@ -5,7 +5,7 @@ import (
"os"
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/test/crowdsec"
diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go
index 8df682faf..8194c961d 100644
--- a/test/deref/deref_test.go
+++ b/test/deref/deref_test.go
@@ -5,8 +5,8 @@ import (
"testing"
"time"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
)
diff --git a/test/examples/examples_test.go b/test/examples/examples_test.go
index 86de35d3f..9df411327 100644
--- a/test/examples/examples_test.go
+++ b/test/examples/examples_test.go
@@ -5,7 +5,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
var examples []CodeBlock
diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go
index 4050fc6e9..da3207004 100644
--- a/test/gen/gen_test.go
+++ b/test/gen/gen_test.go
@@ -8,7 +8,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
var updateFlag = flag.Bool("update", false, "Drop failing lines from examples.txt")
diff --git a/test/interface/interface_method_test.go b/test/interface/interface_method_test.go
index a27215035..0e7a10e52 100644
--- a/test/interface/interface_method_test.go
+++ b/test/interface/interface_method_test.go
@@ -3,8 +3,8 @@ package interface_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
)
diff --git a/test/interface/interface_test.go b/test/interface/interface_test.go
index 45ce1c427..58bc41dd9 100644
--- a/test/interface/interface_test.go
+++ b/test/interface/interface_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/assert"
+ "github.com/stretchr/testify/assert"
)
type StoreInterface interface {
diff --git a/test/issues/461/issue_test.go b/test/issues/461/issue_test.go
index 81202562e..a47179b52 100644
--- a/test/issues/461/issue_test.go
+++ b/test/issues/461/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue461(t *testing.T) {
diff --git a/test/issues/567/issue_test.go b/test/issues/567/issue_test.go
index b5c76d83e..015f76aca 100644
--- a/test/issues/567/issue_test.go
+++ b/test/issues/567/issue_test.go
@@ -6,7 +6,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue567(t *testing.T) {
diff --git a/test/issues/688/issue_test.go b/test/issues/688/issue_test.go
index 837978c13..6c38dcd5d 100644
--- a/test/issues/688/issue_test.go
+++ b/test/issues/688/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type Foo interface {
diff --git a/test/issues/723/issue_test.go b/test/issues/723/issue_test.go
index c1dd6585d..f95887dd4 100644
--- a/test/issues/723/issue_test.go
+++ b/test/issues/723/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue723(t *testing.T) {
diff --git a/test/issues/730/issue_test.go b/test/issues/730/issue_test.go
index 864421bc0..18a50758e 100644
--- a/test/issues/730/issue_test.go
+++ b/test/issues/730/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type ModeEnum int
diff --git a/test/issues/739/issue_test.go b/test/issues/739/issue_test.go
index c58633fe8..10978aad9 100644
--- a/test/issues/739/issue_test.go
+++ b/test/issues/739/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue739(t *testing.T) {
diff --git a/test/issues/756/issue_test.go b/test/issues/756/issue_test.go
index 93180a27a..436888703 100644
--- a/test/issues/756/issue_test.go
+++ b/test/issues/756/issue_test.go
@@ -5,7 +5,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type X struct{}
diff --git a/test/issues/785/issue_test.go b/test/issues/785/issue_test.go
index 4e4f9e53d..7a0fd03f0 100644
--- a/test/issues/785/issue_test.go
+++ b/test/issues/785/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue785(t *testing.T) {
diff --git a/test/issues/817/issue_test.go b/test/issues/817/issue_test.go
index f397f9d1b..ac1348a7f 100644
--- a/test/issues/817/issue_test.go
+++ b/test/issues/817/issue_test.go
@@ -5,7 +5,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue817_1(t *testing.T) {
diff --git a/test/issues/819/issue_test.go b/test/issues/819/issue_test.go
index e1ad19084..65e4234f3 100644
--- a/test/issues/819/issue_test.go
+++ b/test/issues/819/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue819(t *testing.T) {
diff --git a/test/issues/823/issue_test.go b/test/issues/823/issue_test.go
index 221267de4..d120e7e69 100644
--- a/test/issues/823/issue_test.go
+++ b/test/issues/823/issue_test.go
@@ -6,7 +6,7 @@ import (
"time"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type env struct {
diff --git a/test/issues/830/issue_test.go b/test/issues/830/issue_test.go
index 96db36933..8ffb12d91 100644
--- a/test/issues/830/issue_test.go
+++ b/test/issues/830/issue_test.go
@@ -4,8 +4,8 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestIssue830(t *testing.T) {
diff --git a/test/issues/836/issue_test.go b/test/issues/836/issue_test.go
index e4ef6b341..f730b1b06 100644
--- a/test/issues/836/issue_test.go
+++ b/test/issues/836/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type InputStruct struct {
diff --git a/test/issues/840/issue_test.go b/test/issues/840/issue_test.go
index abc00c3ad..c70f3dce1 100644
--- a/test/issues/840/issue_test.go
+++ b/test/issues/840/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestEnvFieldMethods(t *testing.T) {
diff --git a/test/issues/844/issue_test.go b/test/issues/844/issue_test.go
index 2993ec82f..2327cf00e 100644
--- a/test/issues/844/issue_test.go
+++ b/test/issues/844/issue_test.go
@@ -7,7 +7,7 @@ import (
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/checker"
"github.com/expr-lang/expr/conf"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/parser"
)
diff --git a/test/issues/854/issue_test.go b/test/issues/854/issue_test.go
index d69b0ee4c..fc17e99de 100644
--- a/test/issues/854/issue_test.go
+++ b/test/issues/854/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/types"
)
diff --git a/test/issues/857/issue_test.go b/test/issues/857/issue_test.go
index 25a8ef109..8203741ba 100644
--- a/test/issues/857/issue_test.go
+++ b/test/issues/857/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue857(t *testing.T) {
diff --git a/test/issues/888/issue_test.go b/test/issues/888/issue_test.go
index 175e34f1e..560729c88 100644
--- a/test/issues/888/issue_test.go
+++ b/test/issues/888/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type Container struct {
diff --git a/test/issues/924/issue_test.go b/test/issues/924/issue_test.go
index 9a953a158..5759741bb 100644
--- a/test/issues/924/issue_test.go
+++ b/test/issues/924/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
func TestIssue924_allow_disabling_builtins_and_providing_fn_at_runtime(t *testing.T) {
diff --git a/test/issues/934/issue_test.go b/test/issues/934/issue_test.go
index 15ac26276..a3d687679 100644
--- a/test/issues/934/issue_test.go
+++ b/test/issues/934/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type Env struct {
diff --git a/test/issues/951/issue_test.go b/test/issues/951/issue_test.go
index 7c7352100..80ce9b55d 100644
--- a/test/issues/951/issue_test.go
+++ b/test/issues/951/issue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"github.com/expr-lang/expr"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type Node interface {
diff --git a/test/operator/issues584/issues584_test.go b/test/operator/issues584/issues584_test.go
index 5ceb2d50c..13c9c66f3 100644
--- a/test/operator/issues584/issues584_test.go
+++ b/test/operator/issues584/issues584_test.go
@@ -3,7 +3,7 @@ package issues584_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
+ "github.com/stretchr/testify/assert"
"github.com/expr-lang/expr"
)
diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go
index ec7da8724..05e2df8f4 100644
--- a/test/operator/operator_test.go
+++ b/test/operator/operator_test.go
@@ -5,8 +5,8 @@ import (
"testing"
"time"
- "github.com/expr-lang/expr/internal/testify/assert"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/test/mock"
diff --git a/test/patch/change_ident_test.go b/test/patch/change_ident_test.go
index 663ccefab..4d23b134a 100644
--- a/test/patch/change_ident_test.go
+++ b/test/patch/change_ident_test.go
@@ -3,7 +3,7 @@ package patch_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
diff --git a/test/patch/patch_count_test.go b/test/patch/patch_count_test.go
index e877de4a2..12b1c05be 100644
--- a/test/patch/patch_count_test.go
+++ b/test/patch/patch_count_test.go
@@ -3,7 +3,7 @@ package patch_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
diff --git a/test/patch/patch_test.go b/test/patch/patch_test.go
index facae7255..86e72e2cf 100644
--- a/test/patch/patch_test.go
+++ b/test/patch/patch_test.go
@@ -3,7 +3,7 @@ package patch_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
diff --git a/test/patch/set_type/set_type_test.go b/test/patch/set_type/set_type_test.go
index b9c831b0d..673698afb 100644
--- a/test/patch/set_type/set_type_test.go
+++ b/test/patch/set_type/set_type_test.go
@@ -4,7 +4,7 @@ import (
"reflect"
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/ast"
diff --git a/test/pipes/pipes_test.go b/test/pipes/pipes_test.go
index 6c38ba1c0..421cbf258 100644
--- a/test/pipes/pipes_test.go
+++ b/test/pipes/pipes_test.go
@@ -4,7 +4,7 @@ import (
"fmt"
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
)
diff --git a/test/time/time_test.go b/test/time/time_test.go
index d010679a8..d173c1b28 100644
--- a/test/time/time_test.go
+++ b/test/time/time_test.go
@@ -5,7 +5,7 @@ import (
"testing"
"time"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/checker"
diff --git a/types/types_test.go b/types/types_test.go
index 15a6ca77a..6337693da 100644
--- a/types/types_test.go
+++ b/types/types_test.go
@@ -3,7 +3,7 @@ package types_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
. "github.com/expr-lang/expr/types"
)
diff --git a/vm/debug_test.go b/vm/debug_test.go
index ca7a28d89..ee10a90f0 100644
--- a/vm/debug_test.go
+++ b/vm/debug_test.go
@@ -6,7 +6,7 @@ package vm_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr/compiler"
"github.com/expr-lang/expr/parser"
diff --git a/vm/runtime/helpers_test.go b/vm/runtime/helpers_test.go
index b0ef5340f..47a1497ca 100644
--- a/vm/runtime/helpers_test.go
+++ b/vm/runtime/helpers_test.go
@@ -3,7 +3,7 @@ package runtime_test
import (
"testing"
- "github.com/expr-lang/expr/internal/testify/assert"
+ "github.com/stretchr/testify/assert"
"github.com/expr-lang/expr/vm/runtime"
)
diff --git a/vm/runtime/runtime_test.go b/vm/runtime/runtime_test.go
index 14fbff5d9..5d86ff2ce 100644
--- a/vm/runtime/runtime_test.go
+++ b/vm/runtime/runtime_test.go
@@ -4,7 +4,7 @@ import (
"reflect"
"testing"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
)
type Namer interface {
diff --git a/vm/vm_test.go b/vm/vm_test.go
index c86183cad..9d2ac4fb0 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -9,7 +9,7 @@ import (
"time"
"github.com/expr-lang/expr/file"
- "github.com/expr-lang/expr/internal/testify/require"
+ "github.com/stretchr/testify/require"
"github.com/expr-lang/expr"
"github.com/expr-lang/expr/checker"