Goでプロパティベーステストを書きたい人のためのgopterとrapidの比較

func TestRapid(t *testing.T) {
	fmt.Println("------- String ---------")
	for i := 0; i < 10; i++ {
		fmt.Println(rapid.String().Example(i))
	}

	fmt.Println("------- Int ---------")
	for i := 0; i < 10; i++ {
		fmt.Println(rapid.Int().Example(i))
	}

	fmt.Println("------- Int(1-10) ---------")
	for i := 0; i < 10; i++ {
		fmt.Println(rapid.IntRange(1, 10).Example(i))
	}

	fmt.Println("------- Slice(Bool) ---------")
	for i := 0; i < 10; i++ {
		fmt.Println(rapid.SliceOf(rapid.Bool()).Example(i))
	}
}

------- String ---------

A�֍
 𑨳
A＄؃ᾢ
+^#.[#৲

01ဴ
@
࢐#

'

------- Int ---------
-3
-186981
4
-2
43
-14606682
-86204
6
-1877643
861
------- Int(1-10) ---------
1
5
1
2
1
10
6
3
5
4
------- Slice(Bool) ---------
[true]
[false false false true true]
[true]
[false false true false true false false false true false true]
[]
[true]
[true true]
[false true false false]
[true true]
[]

func TestRapid(t *testing.T) {
	rapid.Check(t, func(t *rapid.T) {
		str := rapid.String().
			Filter(func(v string) bool { return len([]rune(v)) > 0 }).
			Draw(t, "str")

		if str == "" {
			t.Fatal("expected not empty literal, but empty")
		}
	})
}

go get pgregory.net/rapid

go get github.com/leanovate/gopter

func TestGopter(t *testing.T) {
	stringGen := gen.AlphaString()
	timeGen := gen.Time()
	sliceGen := gen.SliceOfN(2, gen.Bool())

	fmt.Println("------ string -------")
	for i := 0; i < 5; i++ {
		str, _ := stringGen.Sample()
		fmt.Println(str)
	}

	fmt.Println("------ time -------")
	for i := 0; i < 5; i++ {
		t, _ := timeGen.Sample()
		fmt.Println(t)
	}

        fmt.Println("------ slice(Bool) -------")
	for i := 0; i < 5; i++ {
		s, _ := sliceGen.Sample()
		fmt.Println(s)
	}
}

------ string -------
kcsygsobwzfrividzqeyegD
Xj
vgvKtuwfmuCqfjmnpwkaamPwkvykyvzrguldtuNswyluyvibtmviswBbcolnotziXdt
taqhkmqxZryedkHuqbNlfvujKwylpzpudnlywAddkfjqnahThXyWGhiyvrvjatkeaupicglsdcgIs

------ time -------
5845-06-14 14:55:40.605595782 +0900 JST
4655-04-11 06:34:30.816573137 +0900 JST
2320-10-12 06:43:53.665961844 +0900 JST
9401-02-21 14:12:43.164492282 +0900 JST
6416-03-03 04:54:23.205822636 +0900 JST
------ slice(Bool) -------
[true false]
[false false]
[true true]
[false true]
[false false]

func TestGopter(t *testing.T) {
	properties := gopter.NewProperties(nil)

	properties.Property("default generators", prop.ForAll(
		func(str string) bool {
			return str != ""
		},
		gen.AnyString().SuchThat(func(v interface{}) bool {
			return len([]rune(v.(string))) != 0
		}),
	))

	properties.TestingRun(t)
}

-rapid.failfile="testdata/rapid/TestRapid/TestRapid-20240108002942-85532.fail"

# テストが失敗するとseedがログに出力される
failed with initial seed: 1704681296217176000

func TestGopter(t *testing.T) {
	properties := gopter.NewProperties(gopter.DefaultTestParametersWithSeed(1704681296217176000))

	properties.Property("default generators", prop.ForAll(
		func(str string) bool {
			return str == ""
		},
		gen.AnyString().SuchThat(func(v interface{}) bool {
			return len([]rune(v.(string))) != 0
		}),
	))

	properties.TestingRun(t)
}

// Queue implements integer queue with a fixed maximum size.
type Queue struct {
	buf []int
	in  int
	out int
}

func NewQueue(n int) *Queue {
	return &Queue{
		buf: make([]int, n+1),
	}
}

// Precondition: Size() > 0.
func (q *Queue) Get() int {
	i := q.buf[q.out]
	q.out = (q.out + 1) % len(q.buf)
	return i
}

// Precondition: Size() < n.
func (q *Queue) Put(i int) {
	q.buf[q.in] = i
	q.in = (q.in + 1) % len(q.buf)
}

func (q *Queue) Size() int {
	return (q.in - q.out) % len(q.buf)
}

func testQueue(t *rapid.T) {
	n := rapid.IntRange(1, 1000).Draw(t, "n") // maximum queue size
	q := NewQueue(n)                          // queue being tested
	var state []int                           // model of the queue

	t.Repeat(map[string]func(*rapid.T){
		"get": func(t *rapid.T) {
			if q.Size() == 0 {
				t.Skip("queue empty")
			}

			i := q.Get()
			if i != state[0] {
				t.Fatalf("got invalid value: %v vs expected %v", i, state[0])
			}
			state = state[1:]
		},
		"put": func(t *rapid.T) {
			if q.Size() == n {
				t.Skip("queue full")
			}

			i := rapid.Int().Draw(t, "i")
			q.Put(i)
			state = append(state, i)
		},
		"": func(t *rapid.T) {
			if q.Size() != len(state) {
				t.Fatalf("queue size mismatch: %v vs expected %v", q.Size(), len(state))
			}
		},
	})
}

// Rename to TestQueue(t *testing.T) to make an actual (failing) test.
func ExampleT_Repeat_queue() {
	var t *testing.T
	rapid.Check(t, testQueue)
}

if q.Size() == 0 {
	t.Skip("queue empty")
}

if i != state[0] {
	t.Fatalf("got invalid value: %v vs expected %v", i, state[0])
}

最後にstateの更新。

```go
state = state[1:]

func TestQueueWithGopter(t *testing.T) {
	properties := gopter.NewProperties(gopter.DefaultTestParameters())

	cmds := &commands.ProtoCommands{
		// テスト対象の作成　ここではQueueを初期stateから作成している
		NewSystemUnderTestFunc: func(initialState commands.State) commands.SystemUnderTest {
			s := initialState.(*cbState)
			q := NewQueue(s.size)
			for e := range s.elements {
				q.Put(e)
			}
			return q
		},
		// 初期stateの作成
		InitialStateGen: gen.IntRange(1, 30).Map(func(size int) *cbState {
			return &cbState{
				size:     size,
				elements: make([]int, 0, size),
			}
		}),
		// コマンドジェネレーターの指定
		GenCommandFunc: func(state commands.State) gopter.Gen {
			return gen.OneGenOf(genGetCommand, genPutCommand)
		},
	}

	properties.Property("queue PBT", commands.Prop(cmds))

	properties.TestingRun(t)
}