Re
func Re(reg any, capture ...any) TestDeep
Re operator allows to apply a regexp on a string (or convertible),
[]byte, error or fmt.Stringer interface (error interface is tested
before fmt.Stringer.)
reg is the regexp. It can be a string that is automatically
compiled using regexp.Compile, or a *regexp.Regexp.
Optional capture parameter can be used to match the contents of
regexp groups. Groups are presented as a []string or [][]byte
depending the original matched data. Note that an other operator
can be used here.
td.Cmp(t, "foobar zip!", td.Re(`^foobar`)) // succeeds
td.Cmp(t, "John Doe",
td.Re(`^(\w+) (\w+)`, []string{"John", "Doe"})) // succeeds
td.Cmp(t, "John Doe",
td.Re(`^(\w+) (\w+)`, td.Bag("Doe", "John"))) // succeeds
See also ReAll.
See also Re godoc.
Examples
Base example
t := &testing.T{}
got := "foo bar"
ok := td.Cmp(t, got, td.Re("(zip|bar)$"), "checks value %s", got)
fmt.Println(ok)
got = "bar foo"
ok = td.Cmp(t, got, td.Re("(zip|bar)$"), "checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
Stringer example
t := &testing.T{}
// bytes.Buffer implements fmt.Stringer
got := bytes.NewBufferString("foo bar")
ok := td.Cmp(t, got, td.Re("(zip|bar)$"), "checks value %s", got)
fmt.Println(ok)
// Output:
// true
Error example
t := &testing.T{}
got := errors.New("foo bar")
ok := td.Cmp(t, got, td.Re("(zip|bar)$"), "checks value %s", got)
fmt.Println(ok)
// Output:
// true
Capture example
t := &testing.T{}
got := "foo bar biz"
ok := td.Cmp(t, got, td.Re(`^(\w+) (\w+) (\w+)$`, td.Set("biz", "foo", "bar")),
"checks value %s", got)
fmt.Println(ok)
got = "foo bar! biz"
ok = td.Cmp(t, got, td.Re(`^(\w+) (\w+) (\w+)$`, td.Set("biz", "foo", "bar")),
"checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
Compiled example
t := &testing.T{}
expected := regexp.MustCompile("(zip|bar)$")
got := "foo bar"
ok := td.Cmp(t, got, td.Re(expected), "checks value %s", got)
fmt.Println(ok)
got = "bar foo"
ok = td.Cmp(t, got, td.Re(expected), "checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
CompiledStringer example
t := &testing.T{}
expected := regexp.MustCompile("(zip|bar)$")
// bytes.Buffer implements fmt.Stringer
got := bytes.NewBufferString("foo bar")
ok := td.Cmp(t, got, td.Re(expected), "checks value %s", got)
fmt.Println(ok)
// Output:
// true
CompiledError example
t := &testing.T{}
expected := regexp.MustCompile("(zip|bar)$")
got := errors.New("foo bar")
ok := td.Cmp(t, got, td.Re(expected), "checks value %s", got)
fmt.Println(ok)
// Output:
// true
CompiledCapture example
t := &testing.T{}
expected := regexp.MustCompile(`^(\w+) (\w+) (\w+)$`)
got := "foo bar biz"
ok := td.Cmp(t, got, td.Re(expected, td.Set("biz", "foo", "bar")),
"checks value %s", got)
fmt.Println(ok)
got = "foo bar! biz"
ok = td.Cmp(t, got, td.Re(expected, td.Set("biz", "foo", "bar")),
"checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
CmpRe shortcut
func CmpRe(t TestingT, got, reg , capture any, args ...any) bool
CmpRe is a shortcut for:
td.Cmp(t, got, td.Re(reg, capture), args...)
See above for details.
Re optional parameter capture is here mandatory.
nil value should be passed to mimic its absence in
original Re call.
Returns true if the test is OK, false if it fails.
If t is a *T then its Config field is inherited.
args… are optional and allow to name the test. This name is
used in case of failure to qualify the test. If len(args) > 1 and
the first item of args is a string and contains a ‘%’ rune then
fmt.Fprintf is used to compose the name, else args are passed to
fmt.Fprint. Do not forget it is the name of the test, not the
reason of a potential failure.
See also CmpRe godoc.
Examples
Base example
t := &testing.T{}
got := "foo bar"
ok := td.CmpRe(t, got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
got = "bar foo"
ok = td.CmpRe(t, got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
Stringer example
t := &testing.T{}
// bytes.Buffer implements fmt.Stringer
got := bytes.NewBufferString("foo bar")
ok := td.CmpRe(t, got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
Error example
t := &testing.T{}
got := errors.New("foo bar")
ok := td.CmpRe(t, got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
Capture example
t := &testing.T{}
got := "foo bar biz"
ok := td.CmpRe(t, got, `^(\w+) (\w+) (\w+)$`, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
got = "foo bar! biz"
ok = td.CmpRe(t, got, `^(\w+) (\w+) (\w+)$`, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
Compiled example
t := &testing.T{}
expected := regexp.MustCompile("(zip|bar)$")
got := "foo bar"
ok := td.CmpRe(t, got, expected, nil, "checks value %s", got)
fmt.Println(ok)
got = "bar foo"
ok = td.CmpRe(t, got, expected, nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
CompiledStringer example
t := &testing.T{}
expected := regexp.MustCompile("(zip|bar)$")
// bytes.Buffer implements fmt.Stringer
got := bytes.NewBufferString("foo bar")
ok := td.CmpRe(t, got, expected, nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
CompiledError example
t := &testing.T{}
expected := regexp.MustCompile("(zip|bar)$")
got := errors.New("foo bar")
ok := td.CmpRe(t, got, expected, nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
CompiledCapture example
t := &testing.T{}
expected := regexp.MustCompile(`^(\w+) (\w+) (\w+)$`)
got := "foo bar biz"
ok := td.CmpRe(t, got, expected, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
got = "foo bar! biz"
ok = td.CmpRe(t, got, expected, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
T.Re shortcut
func (t *T) Re(got, reg , capture any, args ...any) bool
Re is a shortcut for:
t.Cmp(got, td.Re(reg, capture), args...)
See above for details.
Re optional parameter capture is here mandatory.
nil value should be passed to mimic its absence in
original Re call.
Returns true if the test is OK, false if it fails.
args… are optional and allow to name the test. This name is
used in case of failure to qualify the test. If len(args) > 1 and
the first item of args is a string and contains a ‘%’ rune then
fmt.Fprintf is used to compose the name, else args are passed to
fmt.Fprint. Do not forget it is the name of the test, not the
reason of a potential failure.
See also T.Re godoc.
Examples
Base example
t := td.NewT(&testing.T{})
got := "foo bar"
ok := t.Re(got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
got = "bar foo"
ok = t.Re(got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
Stringer example
t := td.NewT(&testing.T{})
// bytes.Buffer implements fmt.Stringer
got := bytes.NewBufferString("foo bar")
ok := t.Re(got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
Error example
t := td.NewT(&testing.T{})
got := errors.New("foo bar")
ok := t.Re(got, "(zip|bar)$", nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
Capture example
t := td.NewT(&testing.T{})
got := "foo bar biz"
ok := t.Re(got, `^(\w+) (\w+) (\w+)$`, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
got = "foo bar! biz"
ok = t.Re(got, `^(\w+) (\w+) (\w+)$`, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
Compiled example
t := td.NewT(&testing.T{})
expected := regexp.MustCompile("(zip|bar)$")
got := "foo bar"
ok := t.Re(got, expected, nil, "checks value %s", got)
fmt.Println(ok)
got = "bar foo"
ok = t.Re(got, expected, nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false
CompiledStringer example
t := td.NewT(&testing.T{})
expected := regexp.MustCompile("(zip|bar)$")
// bytes.Buffer implements fmt.Stringer
got := bytes.NewBufferString("foo bar")
ok := t.Re(got, expected, nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
CompiledError example
t := td.NewT(&testing.T{})
expected := regexp.MustCompile("(zip|bar)$")
got := errors.New("foo bar")
ok := t.Re(got, expected, nil, "checks value %s", got)
fmt.Println(ok)
// Output:
// true
CompiledCapture example
t := td.NewT(&testing.T{})
expected := regexp.MustCompile(`^(\w+) (\w+) (\w+)$`)
got := "foo bar biz"
ok := t.Re(got, expected, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
got = "foo bar! biz"
ok = t.Re(got, expected, td.Set("biz", "foo", "bar"),
"checks value %s", got)
fmt.Println(ok)
// Output:
// true
// false