func Re(reg interface{}, capture ...interface{}) 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.MustCompile
, 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 Re godoc.
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
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
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
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
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
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
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
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
func CmpRe(t TestingT, got interface{}, reg interface{}, capture interface{}, args ...interface{}) 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.
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.
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
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
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
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
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
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
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
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
func (t *T) Re(got interface{}, reg interface{}, capture interface{}, args ...interface{}) 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.
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
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
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
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
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
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
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
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