use errgroup

gnovm/cmd/gno/doctest.go

@@ -10,6 +10,7 @@ import (
 
 	dt "github.com/gnolang/gno/gnovm/pkg/doctest"
 	"github.com/gnolang/gno/tm2/pkg/commands"
+	"golang.org/x/sync/errgroup"
 )
 
 type doctestCfg struct {
@@ -68,32 +69,32 @@ func execDoctest(cfg *doctestCfg, _ []string, io commands.IO) error {
 	ctx, cancel := context.WithTimeout(context.Background(), cfg.timeout)
 	defer cancel()
 
-	resultChan := make(chan []string)
-	errChan := make(chan error)
+	g, gctx := errgroup.WithContext(ctx)
 
-	go func() {
-		results, err := dt.ExecuteMatchingCodeBlock(ctx, content, cfg.runPattern)
+	var results []string
+	g.Go(func() error {
+		res, err := dt.ExecuteMatchingCodeBlock(gctx, content, cfg.runPattern)
 		if err != nil {
-			errChan <- err
-		} else {
-			resultChan <- results
+			return err
 		}
-	}()
+		results = res
+		return nil
+	})
 
-	select {
-	case results := <-resultChan:
-		if len(results) == 0 {
-			io.Println("No code blocks matched the pattern")
-			return nil
+	if err := g.Wait(); err != nil {
+		if ctx.Err() == context.DeadlineExceeded {
+			return fmt.Errorf("execution timed out after %v", cfg.timeout)
 		}
-		io.Println("Execution Result:")
-		io.Println(strings.Join(results, "\n\n"))
-	case err := <-errChan:
 		return fmt.Errorf("failed to execute code block: %w", err)
-	case <-ctx.Done():
-		return fmt.Errorf("execution timed out after %v", cfg.timeout)
 	}
 
+	if len(results) == 0 {
+		io.Println("No code blocks matched the pattern")
+		return nil
+	}
+
+	io.Println("Execution Result:")
+	io.Println(strings.Join(results, "\n\n"))
 	return nil
 }
 

gnovm/cmd/gno/doctest_test.go

@@ -88,8 +88,8 @@ func main() {
 			stdoutShouldContain: "=== StringReversal ===\n\n!oG ,olleH",
 		},
 		{
-			args:                []string{"doctest", "-path", mdFilePath, "-run", "StdPackage"},
-			stdoutShouldContain: "=== StdPackage ===\n\ng14ch5q26mhx3jk5cxl88t278nper264ces4m8nt",
+			args:              []string{"doctest", "-path", mdFilePath, "-run", "StdPackage"},
+			stdoutShouldMatch: `g[a-z0-9]+\n`,
 		},
 	}
 

gnovm/cmd/gno/main_test.go

@@ -35,6 +35,7 @@ type testMainCase struct {
 	stderrShouldContain  string
 	stdoutShouldBe       string
 	stdoutShouldContain  string
+	stdoutShouldMatch    string
 	stderrShouldBe       string
 	recoverShouldContain string
 	recoverShouldBe      string
@@ -48,7 +49,7 @@ func testMainCaseRun(t *testing.T, tc []testMainCase) {
 
 	for _, test := range tc {
 		errShouldBeEmpty := test.errShouldContain == "" && test.errShouldBe == ""
-		stdoutShouldBeEmpty := test.stdoutShouldContain == "" && test.stdoutShouldBe == ""
+		stdoutShouldBeEmpty := test.stdoutShouldContain == "" && test.stdoutShouldBe == "" && test.stdoutShouldMatch == ""
 		stderrShouldBeEmpty := test.stderrShouldContain == "" && test.stderrShouldBe == ""
 		recoverShouldBeEmpty := test.recoverShouldContain == "" && test.recoverShouldBe == ""
 
@@ -73,6 +74,9 @@ func testMainCaseRun(t *testing.T, tc []testMainCase) {
 					if test.stdoutShouldContain != "" {
 						require.Contains(t, mockOut.String(), test.stdoutShouldContain, "stdout should contain")
 					}
+					if test.stdoutShouldMatch != "" {
+						require.Regexp(t, test.stdoutShouldMatch, mockOut.String(), "stdout should match pattern")
+					}
 					if test.stdoutShouldBe != "" {
 						require.Equal(t, test.stdoutShouldBe, mockOut.String(), "stdout should be")
 					}

gnovm/pkg/doctest/exec.go

@@ -13,7 +13,7 @@ import (
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
 	"github.com/gnolang/gno/gnovm"
 	bft "github.com/gnolang/gno/tm2/pkg/bft/types"
-	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/crypto/ed25519"
 	"github.com/gnolang/gno/tm2/pkg/db/memdb"
 	"github.com/gnolang/gno/tm2/pkg/log"
 	"github.com/gnolang/gno/tm2/pkg/sdk"
@@ -38,7 +38,7 @@ var (
 	cache      = newCache(maxCacheSize)
 	regexCache = make(map[string]*regexp.Regexp)
 
-	addrRegex = regexp.MustCompile(`gno\.land/r/g[a-z0-9]+/[a-z.]+`)
+	addrRegex = regexp.MustCompile(`gno\.land/r/[a-z0-9]+/[a-z_/.]+`)
 )
 
 // ExecuteCodeBlock executes a parsed code block and executes it in a gno VM.
@@ -66,7 +66,9 @@ func ExecuteCodeBlock(c codeBlock, stdlibDir string) (string, error) {
 		{Name: fmt.Sprintf("%d.%s", c.index, lang), Body: c.content},
 	}
 
-	addr := crypto.AddressFromPreimage([]byte("addr1"))
+	// create a freash account for the code block
+	privKey := ed25519.GenPrivKey()
+	addr := privKey.PubKey().Address()
 	acc := acck.NewAccountWithAddress(ctx, addr)
 	acck.SetAccount(ctx, acc)
 
@@ -128,6 +130,11 @@ func ExecuteMatchingCodeBlock(
 	return results, nil
 }
 
+// setupEnv creates and initializes the execution environment for running extracted code blocks.
+// It sets up necessary keepers (account, bank, VM), initializes a test chain context,
+// and loads standard libraries. The function returns the context, keepers, and stdlib context
+// needed for code execution.
+//
 // ref: gno.land/pkg/sdk/vm/common_test.go
 func setupEnv() (
 	sdk.Context,
@@ -155,14 +162,14 @@ func setupEnv() (
 	prmk := paramsm.NewParamsKeeper(iavlKey, "params")
 	acck := authm.NewAccountKeeper(iavlKey, prmk, std.ProtoBaseAccount)
 	bank := bankm.NewBankKeeper(acck)
-	stdlibsDir := GetStdlibsDir()
-	vmk := vm.NewVMKeeper(baseKey, iavlKey, acck, bank, prmk)
 
 	mcw := ms.MultiCacheWrap()
 
+	vmk := vm.NewVMKeeper(baseKey, iavlKey, acck, bank, prmk)
 	vmk.Initialize(log.NewNoopLogger(), mcw)
 
 	stdlibCtx := vmk.MakeGnoTransactionStore(ctx.WithMultiStore(mcw))
+	stdlibsDir := GetStdlibsDir()
 	vmk.LoadStdlib(stdlibCtx, stdlibsDir)
 	vmk.CommitGnoTransactionStore(stdlibCtx)