erigontech
diff --git a/‎cmd/evm/blockrunner.go‎
Lines changed: 102 additions & 19 deletions b/‎cmd/evm/blockrunner.go‎
Lines changed: 102 additions & 19 deletions
diff --git a/‎cmd/evm/main.go‎
Lines changed: 5 additions & 1 deletion b/‎cmd/evm/main.go‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎cmd/evm/reporter.go‎
Lines changed: 22 additions & 5 deletions b/‎cmd/evm/reporter.go‎
Lines changed: 22 additions & 5 deletions
@@ -20,14 +20,15 @@
 package main
 
 import (
+	"bufio"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"maps"
 	"os"
 	"path/filepath"
 	"regexp"
 	"slices"
+	"sync"
 
 	"github.com/urfave/cli/v2"
 
@@ -38,19 +39,19 @@ import (
 var blockTestCommand = cli.Command{
 	Action:    blockTestCmd,
 	Name:      "blocktest",
-	Usage:     "Executes the given blockchain tests",
+	Usage:     "Executes the given blockchain tests. Filenames can be fed via standard input (batch mode) or as an argument (one-off execution).",
 	ArgsUsage: "<path>",
 	Flags: []cli.Flag{
 		&DumpFlag,
+		&JSONOutputFlag,
+		&RunFlag,
 		&VerbosityFlag,
+		&WorkersFlag,
 	},
 }
 
 func blockTestCmd(ctx *cli.Context) error {
 	path := ctx.Args().First()
-	if len(path) == 0 {
-		return errors.New("path argument required")
-	}
 
 	// Set up logging
 	if ctx.Int(VerbosityFlag.Name) > 0 {
@@ -59,36 +60,118 @@ func blockTestCmd(ctx *cli.Context) error {
 		log.Root().SetHandler(log.LvlFilterHandler(log.LvlError, log.StderrHandler))
 	}
 
-	var (
-		collected = collectFiles(path)
-		results   []testResult
-	)
-
-	for _, fname := range collected {
-		r, err := runBlockTest(ctx, fname)
+	if len(path) != 0 {
+		collected := collectFiles(path)
+		workers := ctx.Int(WorkersFlag.Name)
+		if workers <= 0 {
+			workers = 1
+		}
+		results, err := runBlockTestsParallel(ctx, collected, workers)
 		if err != nil {
 			return err
 		}
-		results = append(results, r...)
+		report(ctx, results)
+		return nil
+	}
+	// Otherwise, read filenames from stdin and execute back-to-back.
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		fname := scanner.Text()
+		if len(fname) == 0 {
+			return nil
+		}
+		results, err := runBlockTest(ctx, fname)
+		if err != nil {
+			return err
+		}
+		report(ctx, results)
 	}
-
-	report(ctx, results)
 	return nil
 }
 
+// fileResult holds the results from processing a single fixture file.
+type fileResult struct {
+	index   int
+	results []testResult
+	err     error
+}
+
+func runBlockTestsParallel(ctx *cli.Context, files []string, workers int) ([]testResult, error) {
+	if workers == 1 {
+		results := make([]testResult, 0, len(files)*4) // pre-allocate: most files have a few tests
+		for _, fname := range files {
+			r, err := runBlockTest(ctx, fname)
+			if err != nil {
+				return nil, err
+			}
+			results = append(results, r...)
+		}
+		return results, nil
+	}
+	var (
+		wg     sync.WaitGroup
+		fileCh = make(chan struct {
+			index int
+			fname string
+		}, len(files))
+		resultCh = make(chan fileResult, len(files))
+	)
+	for i, fname := range files {
+		fileCh <- struct {
+			index int
+			fname string
+		}{i, fname}
+	}
+	close(fileCh)
+
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for item := range fileCh {
+				r, err := runBlockTest(ctx, item.fname)
+				resultCh <- fileResult{index: item.index, results: r, err: err}
+			}
+		}()
+	}
+	go func() {
+		wg.Wait()
+		close(resultCh)
+	}()
+
+	ordered := make([]fileResult, len(files))
+	for fr := range resultCh {
+		if fr.err != nil {
+			return nil, fr.err
+		}
+		ordered[fr.index] = fr
+	}
+	// Pre-estimate total results
+	total := 0
+	for _, fr := range ordered {
+		total += len(fr.results)
+	}
+	results := make([]testResult, 0, total)
+	for _, fr := range ordered {
+		results = append(results, fr.results...)
+	}
+	return results, nil
+}
+
 // collectFiles walks the given path and returns all JSON files.
 // If path is a file, it returns that file directly.
 func collectFiles(path string) []string {
-	var out []string
 	info, err := os.Stat(path)
 	if err != nil {
-		return out
+		return nil
 	}
 
 	if !info.IsDir() {
 		return []string{path}
 	}
 
+	// Pre-allocate with a reasonable estimate to avoid repeated slice growth
+	out := make([]string, 0, 256)
 	err = filepath.WalkDir(path, func(path string, d os.DirEntry, err error) error {
 		if err != nil {
 			return err
@@ -116,9 +199,9 @@ func runBlockTest(ctx *cli.Context, fname string) ([]testResult, error) {
 		return nil, err
 	}
 
-	re, err := regexp.Compile(".*") // Run all tests by default
+	re, err := regexp.Compile(ctx.String(RunFlag.Name))
 	if err != nil {
-		return nil, fmt.Errorf("invalid regex: %v", err)
+		return nil, fmt.Errorf("invalid regex -%s: %v", RunFlag.Name, err)
 	}
 
 	// Pull out keys to sort and ensure tests are run in order
 
@@ -139,7 +139,11 @@ var (
 	WorkersFlag = cli.IntFlag{
 		Name:  "workers",
 		Value: 0,
-		Usage: "Number of workers to execute tests in parallel (0 means use the command's default)",
+		Usage: "Number of workers to execute tests in parallel (0 means use the command's defaul)",
+	}
+	JSONOutputFlag = cli.BoolFlag{
+		Name:  "jsonout",
+		Usage: "Output results as JSON array instead of human-readable format",
 	}
 )
 
 
@@ -20,8 +20,10 @@
 package main
 
 import (
+	"bufio"
 	"encoding/json"
 	"fmt"
+	"os"
 
 	"github.com/urfave/cli/v2"
 
@@ -40,8 +42,10 @@ type testResult struct {
 	Name  string       `json:"name"`
 	Pass  bool         `json:"pass"`
 	Root  *common.Hash `json:"stateRoot,omitempty"`
-	Error string       `json:"error,omitempty"`
+	Fork  string       `json:"fork,omitempty"`
+	Error string       `json:"error"`
 	State *state.Dump  `json:"state,omitempty"`
+	Stats *execStats   `json:"benchStats,omitempty"`
 }
 
 func (r testResult) String() string {
@@ -55,6 +59,9 @@ func (r testResult) String() string {
 	var extra string
 	if !r.Pass {
 		extra = fmt.Sprintf(", err=%v", r.Error)
+		if r.Fork != "" {
+			extra += fmt.Sprintf(", fork=%s", r.Fork)
+		}
 	}
 
 	out := fmt.Sprintf("%s %s%s", status, r.Name, extra)
@@ -67,17 +74,27 @@ func (r testResult) String() string {
 
 // report prints the after-test summary.
 func report(ctx *cli.Context, results []testResult) {
+	if ctx.Bool(JSONOutputFlag.Name) {
+		// Write directly to stdout via encoder to avoid the intermediate
+		// MarshalIndent -> string -> Println allocation chain.
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		enc.Encode(results) //nolint:errcheck
+		return
+	}
 	pass := 0
 	for _, r := range results {
 		if r.Pass {
 			pass++
 		}
 	}
 
+	// Use buffered writer to reduce syscalls when printing many results
+	w := bufio.NewWriter(os.Stdout)
 	for _, r := range results {
-		fmt.Println(r)
+		fmt.Fprintln(w, r)
 	}
-
-	fmt.Println("--")
-	fmt.Printf("%d tests passed, %d tests failed.\n", pass, len(results)-pass)
+	fmt.Fprintln(w, "--")
+	fmt.Fprintf(w, "%d tests passed, %d tests failed.\n", pass, len(results)-pass)
+	w.Flush()
 }
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,11 @@ var (`
`139`	`139`	`WorkersFlag = cli.IntFlag{`
`140`	`140`	`Name: "workers",`
`141`	`141`	`Value: 0,`
`142`		`- Usage: "Number of workers to execute tests in parallel (0 means use the command's default)",`
	`142`	`+ Usage: "Number of workers to execute tests in parallel (0 means use the command's defaul)",`
	`143`	`+ }`
	`144`	`+ JSONOutputFlag = cli.BoolFlag{`
	`145`	`+ Name: "jsonout",`
	`146`	`+ Usage: "Output results as JSON array instead of human-readable format",`
`143`	`147`	`}`
`144`	`148`	`)`
`145`	`149`