How to use ExtraInOut method of got_test Package

1package got_test
2
3import (
4	"testing"
5
6	"github.com/ysmood/got"
7)
8
9func TestEach(t *testing.T) {
10	count := got.Each(t, StructVal{val: 1})
11	got.New(t).Eq(count, 2)
12}
13
14type StructVal struct {
15	got.G
16	val int
17}
18
19func (c StructVal) Normal() {
20	c.Eq(c.val, 1)
21}
22
23func (c StructVal) ExtraInOut(int) int {
24	c.Eq(c.val, 1)
25	return 0
26}
27
28func (c StructVal) TestSkip(got.Skip) {
29}
30
31func TestEachEmbedded(t *testing.T) {
32	got.Each(t, Container{})
33}
34
35type Container struct {
36	Embedded
37}
38
39func (c Container) A() { c.Fail() }
40func (c Container) B() {}
41
42type Embedded struct {
43	*testing.T
44}
45
46func (c Embedded) A() {}
47func (c Embedded) C() { c.Fail() }
48
49func TestEachWithOnly(t *testing.T) {
50	got.Each(t, Only{})
51}
52
53type Only struct {
54	*testing.T
55}
56
57func (c Only) A(got.Only) {}
58func (c Only) B()         { panic("") }
59
60func TestEachErr(t *testing.T) {
61	as := got.New(t)
62	m := &mock{t: t}
63
64	as.Panic(func() {
65		got.Each(m, nil)
66	})
67	m.check("iteratee shouldn't be nil")
68
69	as.Panic(func() {
70		got.Each(m, 1)
71	})
72	m.check("iteratee <int> should be a struct or <func(got.Testable) Ctx>")
73
74	it := func() Err { return Err{} }
75	as.Panic(func() {
76		got.Each(m, it)
77	})
78	m.check("iteratee <func() got_test.Err> should be a struct or <func(got.Testable) Ctx>")
79}
80
81type Err struct {
82}
83
84func (s Err) A(int) {}
85
86func TestPanicAsFailure(t *testing.T) {
87	as := got.New(t)
88
89	m := &mock{t: t}
90	it := func(t *mock) PanicAsFailure { return PanicAsFailure{} }
91	as.Eq(got.Each(m, it), 2)
92	as.True(m.failed)
93	as.Has(m.msg, "[panic] err")
94}
95
96type PanicAsFailure struct {
97}
98
99func (p PanicAsFailure) A() {
100	panic("err")
101}
102
103func (p PanicAsFailure) B() {
104}
105

Source: each_test.go

package got_test

import (
	"testing"

	"github.com/ysmood/got"
)

func TestEach(t *testing.T) {
	count := got.Each(t, StructVal{val: 1})
	got.New(t).Eq(count, 2)
}

type StructVal struct {
	got.G
	val int
}

func (c StructVal) Normal() {
	c.Eq(c.val, 1)
}

func (c StructVal) ExtraInOut(int) int {
	c.Eq(c.val, 1)
	return 0
}

func (c StructVal) TestSkip(got.Skip) {
}

func TestEachEmbedded(t *testing.T) {
	got.Each(t, Container{})
}

type Container struct {
	Embedded
}

func (c Container) A() { c.Fail() }
func (c Container) B() {}

type Embedded struct {
	*testing.T
}

func (c Embedded) A() {}
func (c Embedded) C() { c.Fail() }

func TestEachWithOnly(t *testing.T) {
	got.Each(t, Only{})
}

type Only struct {
	*testing.T
}

func (c Only) A(got.Only) {}
func (c Only) B()         { panic("") }

func TestEachErr(t *testing.T) {
	as := got.New(t)
	m := &mock{t: t}

	as.Panic(func() {
		got.Each(m, nil)
	})
	m.check("iteratee shouldn't be nil")

	as.Panic(func() {
		got.Each(m, 1)
	})
	m.check("iteratee <int> should be a struct or <func(got.Testable) Ctx>")

	it := func() Err { return Err{} }
	as.Panic(func() {
		got.Each(m, it)
	})
	m.check("iteratee <func() got_test.Err> should be a struct or <func(got.Testable) Ctx>")
}

type Err struct {
}

func (s Err) A(int) {}

func TestPanicAsFailure(t *testing.T) {
	as := got.New(t)

	m := &mock{t: t}
	it := func(t *mock) PanicAsFailure { return PanicAsFailure{} }
	as.Eq(got.Each(m, it), 2)
	as.True(m.failed)
	as.Has(m.msg, "[panic] err")
}

type PanicAsFailure struct {
}

func (p PanicAsFailure) A() {
	panic("err")
}

func (p PanicAsFailure) B() {
}