1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
package combinator
import (
"testing"
)
func TestCombinator(t *testing.T) {
type Data struct {
Color string
Number int
Enabled bool
// DataTests ignore this field
Untouched bool
}
type DataTests struct {
Color []string
Number []int
Enabled []bool
// DataTests ignore this field
Untouched []bool
}
td := DataTests{
Color: []string{"red", "green", "blue"},
Number: []int{0, 1},
Enabled: []bool{false, true},
// DataTests ignore this field
Untouched: []bool{},
}
tdl := len(td.Color) * len(td.Number) * len(td.Enabled)
// initialize check matrix
matrix := map[string]map[int]map[bool]bool{}
for ci := 0; ci < len(td.Color); ci++ {
matrix[td.Color[ci]] = map[int]map[bool]bool{}
for ni := 0; ni < len(td.Number); ni++ {
matrix[td.Color[ci]][td.Number[ni]] = map[bool]bool{}
for bi := 0; bi < len(td.Enabled); bi++ {
matrix[td.Color[ci]][td.Number[ni]][td.Enabled[bi]] = false
}
}
}
var data []Data
err := Generate(&data, td)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(data) != tdl {
t.Errorf("expected %d permutations, got %d", tdl, len(data))
}
for _, v := range data {
// fmt.Println(i, v)
cmatrix, ok := matrix[v.Color]
if !ok {
t.Errorf("unexpected value %s", v.Color)
continue
}
nmatrix, ok := cmatrix[v.Number]
if !ok {
t.Errorf("unexpected value %s %d", v.Color, v.Number)
continue
}
_, ok = nmatrix[v.Enabled]
if !ok {
t.Errorf("unexpected value %s %d %v", v.Color, v.Number, v.Enabled)
continue
}
// flag combination as found
matrix[v.Color][v.Number][v.Enabled] = true
}
// check all combinations have been found
for ck, cv := range matrix {
for nk, nv := range cv {
for bk, bv := range nv {
if !bv {
t.Errorf("combination not found: %s %d %v", ck, nk, bk)
}
}
}
}
}
func TestConstValue(t *testing.T) {
type Data struct {
Number int
Enabled bool
}
type DataTests struct {
Number []int
Enabled bool
}
td := DataTests{
Number: []int{0, 1},
Enabled: true,
}
var data []Data
err := Generate(&data, td)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
for _, v := range data {
if !v.Enabled {
t.Fatalf("expected enabled to be set to true")
}
}
}
func TestUnmatchedField(t *testing.T) {
type Data struct {
Number int
}
type DataTests struct {
Number []int
// Data does not actually contain this field
Unmatched []bool
}
td := DataTests{
Number: []int{0, 1},
// Data does not actually contain this field
Unmatched: []bool{false},
}
var data []Data
err := Generate(&data, td)
if err == nil {
t.Errorf("expected error for unmatched fields in data, got nil")
}
}
func TestInvalidType(t *testing.T) {
td := struct {
Number []int
}{}
var s string
err := Generate(s, td)
if err == nil {
t.Errorf("expected error for non-pointer type, got nil")
}
err = Generate(&s, td)
if err == nil {
t.Errorf("expected error for invalid type, got nil")
}
err = Generate(&[]string{}, "")
if err == nil {
t.Errorf("expected error for invalid type, got nil")
}
}
|
