Testing

Author: jakebailey

internal/core/concurrency.go

@@ -23,10 +23,10 @@ func ParseConcurrency(options *CompilerOptions) Concurrency {
 	return parseConcurrency(options.Concurrency)
 }
 
-func parseConcurrency(v string) Concurrency {
+func parseConcurrency(s string) Concurrency {
 	checkerCount := 4
 
-	switch strings.ToLower(v) {
+	switch strings.ToLower(s) {
 	case "default", "auto", "true", "yes", "on":
 		break
 	case "single", "none", "false", "no", "off":
@@ -38,8 +38,10 @@ func parseConcurrency(v string) Concurrency {
 	case "checker-per-file":
 		checkerCount = -1
 	default:
-		if v, err := strconv.Atoi(v); err == nil && v > 0 {
-			checkerCount = v
+		if s != "" {
+			if v, err := strconv.Atoi(s); err == nil && v > 0 {
+				checkerCount = v
+			}
 		}
 	}
 
@@ -53,9 +55,11 @@ func (c Concurrency) SingleThreaded() bool {
 }
 
 func (c Concurrency) CheckerCount(numFiles int) int {
-	checkerCount := min(c.checkerCount, numFiles)
-	checkerCount = max(1, checkerCount)
-	return checkerCount
+	checkerCount := c.checkerCount
+	if c.checkerCount == -1 {
+		return max(1, numFiles)
+	}
+	return min(max(1, checkerCount), numFiles)
 }
 
 var testProgramConcurrency = sync.OnceValues(func() (concurrency Concurrency, raw string) {

internal/core/concurrency_test.go

@@ -0,0 +1,53 @@
+package core
+
+import (
+	"runtime"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestConcurrency(t *testing.T) {
+	tests := []struct {
+		name           string
+		opts           *CompilerOptions
+		numFiles       int
+		singleThreaded bool
+		checkerCount   int
+	}{
+		{"defaults", &CompilerOptions{}, 100, false, 4},
+		{"default", &CompilerOptions{Concurrency: "default"}, 100, false, 4},
+		{"auto", &CompilerOptions{Concurrency: "true"}, 100, false, 4},
+		{"true", &CompilerOptions{Concurrency: "true"}, 100, false, 4},
+		{"yes", &CompilerOptions{Concurrency: "yes"}, 100, false, 4},
+		{"on", &CompilerOptions{Concurrency: "on"}, 100, false, 4},
+		{"singleThreaded", &CompilerOptions{SingleThreaded: TSTrue}, 100, true, 1},
+		{"single", &CompilerOptions{Concurrency: "single"}, 100, true, 1},
+		{"none", &CompilerOptions{Concurrency: "none"}, 100, true, 1},
+		{"false", &CompilerOptions{Concurrency: "false"}, 100, true, 1},
+		{"no", &CompilerOptions{Concurrency: "no"}, 100, true, 1},
+		{"off", &CompilerOptions{Concurrency: "off"}, 100, true, 1},
+		{"max", &CompilerOptions{Concurrency: "max"}, 1000, false, runtime.GOMAXPROCS(0)},
+		{"half", &CompilerOptions{Concurrency: "half"}, 1000, false, runtime.GOMAXPROCS(0) / 2},
+		{"checker-per-file", &CompilerOptions{Concurrency: "checker-per-file"}, 100, false, 100},
+		{"more than files", &CompilerOptions{Concurrency: "1000"}, 100, false, 100},
+		{"10", &CompilerOptions{Concurrency: "10"}, 100, false, 10},
+		{"1", &CompilerOptions{Concurrency: "1"}, 100, true, 1},
+		{"invalid", &CompilerOptions{Concurrency: "i dunno"}, 100, false, 4},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := ParseConcurrency(tt.opts)
+			singleThreaded := c.SingleThreaded()
+			checkerCount := c.CheckerCount(tt.numFiles)
+			assert.Equal(t, singleThreaded, tt.singleThreaded)
+			assert.Equal(t, checkerCount, tt.checkerCount)
+		})
+	}
+
+	t.Run("TestProgramConcurrency", func(t *testing.T) {
+		c, _ := TestProgramConcurrency()
+		assert.Assert(t, c.CheckerCount(10000) > 0)
+	})
+}