csource: use reflect to iterate over options

1 files changed, 48 insertions, 97 deletions

diff --git a/csource/csource_test.go b/csource/csource_test.go
index e9ab1d993..7db490444 100644
--- a/csource/csource_test.go
+++ b/csource/csource_test.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"math/rand"
 	"os"
+	"reflect"
 	"testing"
 	"time"
 
@@ -23,89 +24,56 @@ func initTest(t *testing.T) (rand.Source, int) {
 	return rs, iters
 }
 
-func allOptionsSingle() []Options {
-	var options []Options
-	var opt Options
-	for _, opt.Threaded = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.Collide = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.Repeat = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.Procs = range []int{1, 4} {
-		options = append(options, opt)
-	}
-	for _, opt.Sandbox = range []string{"", "none", "setuid", "namespace"} {
-		options = append(options, opt)
-	}
-	for _, opt.Repro = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.Fault = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.EnableTun = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.UseTmpDir = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.HandleSegv = range []bool{false, true} {
-		options = append(options, opt)
-	}
-	for _, opt.WaitRepeat = range []bool{false, true} {
-		options = append(options, opt)
+func enumerateField(opt Options, field int) []Options {
+	var opts []Options
+	s := reflect.ValueOf(&opt).Elem()
+	fldName := s.Type().Field(field).Name
+	fld := s.Field(field)
+	if fldName == "Sandbox" {
+		for _, sandbox := range []string{"", "none", "setuid", "namespace"} {
+			fld.SetString(sandbox)
+			opts = append(opts, opt)
+		}
+	} else if fldName == "Procs" {
+		for _, procs := range []int64{1, 4} {
+			fld.SetInt(procs)
+			opts = append(opts, opt)
+		}
+	} else if fldName == "FaultCall" {
+		opts = append(opts, opt)
+	} else if fldName == "FaultNth" {
+		opts = append(opts, opt)
+	} else if fld.Kind() == reflect.Bool {
+		for _, v := range []bool{false, true} {
+			fld.SetBool(v)
+			opts = append(opts, opt)
+		}
+	} else {
+		panic(fmt.Sprintf("field '%v' is not boolean", fldName))
 	}
-	for _, opt.Debug = range []bool{false, true} {
-		options = append(options, opt)
+	return opts
+}
+
+func allOptionsSingle() []Options {
+	var opts []Options
+	fields := reflect.TypeOf(Options{}).NumField()
+	for i := 0; i < fields; i++ {
+		opts = append(opts, enumerateField(Options{}, i)...)
 	}
-	return options
+	return opts
 }
 
 func allOptionsPermutations() []Options {
-	var options []Options
-	var opt Options
-	for _, opt.Threaded = range []bool{false, true} {
-		for _, opt.Collide = range []bool{false, true} {
-			for _, opt.Repeat = range []bool{false, true} {
-				for _, opt.Procs = range []int{1, 4} {
-					for _, opt.Sandbox = range []string{"", "none", "setuid", "namespace"} {
-						for _, opt.Repro = range []bool{false, true} {
-							for _, opt.Fault = range []bool{false, true} {
-								for _, opt.EnableTun = range []bool{false, true} {
-									for _, opt.UseTmpDir = range []bool{false, true} {
-										for _, opt.HandleSegv = range []bool{false, true} {
-											for _, opt.WaitRepeat = range []bool{false, true} {
-												for _, opt.Debug = range []bool{false, true} {
-													if opt.Collide && !opt.Threaded {
-														continue
-													}
-													if !opt.Repeat && opt.Procs != 1 {
-														continue
-													}
-													if !opt.Repeat && opt.WaitRepeat {
-														continue
-													}
-													if testing.Short() && opt.Procs != 1 {
-														continue
-													}
-													options = append(options, opt)
-												}
-											}
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
+	opts := []Options{ Options{} }
+	fields := reflect.TypeOf(Options{}).NumField()
+	for i := 0; i < fields; i++ {
+		var newOpts []Options
+		for _, opt := range opts {
+			newOpts = append(newOpts, enumerateField(opt, i)...)
 		}
+		opts = newOpts
 	}
-	return options
+	return opts
 }
 
 func TestOne(t *testing.T) {
@@ -122,36 +90,19 @@ func TestOne(t *testing.T) {
 	testOne(t, p, opts)
 }
 
-func TestOptionsSingle(t *testing.T) {
-	rs, _ := initTest(t)
-	syzProg := prog.GenerateAllSyzProg(rs)
-	t.Logf("syz program:\n%s\n", syzProg.Serialize())
-	for i, opts := range allOptionsSingle() {
-		t.Run(fmt.Sprintf("%v", i), func(t *testing.T) {
-			rs, iters := initTest(t)
-			t.Logf("opts: %+v", opts)
-			for i := 0; i < iters; i++ {
-				p := prog.Generate(rs, 10, nil)
-				testOne(t, p, opts)
-			}
-			testOne(t, syzProg, opts)
-		})
-	}
-}
-
-func TestOptionsPermutations(t *testing.T) {
+func TestOptions(t *testing.T) {
 	rs, _ := initTest(t)
 	syzProg := prog.GenerateAllSyzProg(rs)
 	t.Logf("syz program:\n%s\n", syzProg.Serialize())
+	permutations := allOptionsSingle()
 	allPermutations := allOptionsPermutations()
-	var permutations []Options
 	if testing.Short() {
 		r := rand.New(rs)
 		for i := 0; i < 32; i++ {
-			permutations = append(permutations, allPermutations[r.Intn(len(allPermutations)-1)])
+			permutations = append(permutations, allPermutations[r.Intn(len(allPermutations))])
 		}
 	} else {
-		permutations = allPermutations
+		permutations = append(permutations, allPermutations...)
 	}
 	for i, opts := range permutations {
 		t.Run(fmt.Sprintf("%v", i), func(t *testing.T) {