Windows doesn't send pty EOF unless wait is called

helpers.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"errors"
 	"os"
-	"os/exec"
 	"strings"
 	"time"
 )
@@ -23,20 +22,10 @@ type cmdExit struct {
 	Err          error
 }
 
-// waitForCmdExit turns process.wait() into a channel so that it can be used within a select{} statement
-func waitForCmdExit(cmd *exec.Cmd) chan *cmdExit {
-	exit := make(chan *cmdExit, 1)
-	go func() {
-		err := cmd.Wait()
-		exit <- &cmdExit{ProcessState: cmd.ProcessState, Err: err}
-	}()
-	return exit
-}
-
 func waitChan[T any](wait func() T) chan T {
-	done := make(chan T)
+	done := make(chan T, 1)
 	go func() {
-		done <- wait()
+		wait()
 		close(done)
 	}()
 	return done

termtest.go

@@ -23,6 +23,7 @@ type TermTest struct {
 	ptmx           pty.Pty
 	outputProducer *outputProducer
 	listenError    chan error
+	waitError      chan error
 	opts           *Opts
 }
 
@@ -78,6 +79,7 @@ func New(cmd *exec.Cmd, opts ...SetOpt) (*TermTest, error) {
 		cmd:            cmd,
 		outputProducer: newOutputProducer(optv),
 		listenError:    make(chan error, 1),
+		waitError:      make(chan error, 1),
 		opts:           optv,
 	}
 
@@ -227,6 +229,7 @@ func (tt *TermTest) start() (rerr error) {
 	tt.term = vt10x.New(vt10x.WithWriter(ptmx), vt10x.WithSize(tt.opts.Cols, tt.opts.Rows))
 
 	// Start listening for output
+	// We use a waitgroup here to ensure the listener is active before consumers are attached.
 	wg := &sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
@@ -235,6 +238,16 @@ func (tt *TermTest) start() (rerr error) {
 		err := tt.outputProducer.Listen(tt.ptmx, tt.term)
 		tt.listenError <- err
 	}()
+
+	go func() {
+		// We start waiting right away, because on Windows the PTY isn't closed until the process exits, which in turn
+		// can't happen unless we've told the pty we're ready for it to close.
+		// This of course isn't ideal, but until the pty library fixes the cross-platform inconsistencies we have to
+		// work around these limitations.
+		defer tt.opts.Logger.Printf("waitIndefinitely finished")
+		tt.waitError <- tt.waitIndefinitely()
+	}()
+
 	wg.Wait()
 
 	return nil
@@ -247,13 +260,8 @@ func (tt *TermTest) Wait(timeout time.Duration) (rerr error) {
 	tt.opts.Logger.Println("wait called")
 	defer tt.opts.Logger.Println("wait closed")
 
-	errc := make(chan error, 1)
-	go func() {
-		errc <- tt.WaitIndefinitely()
-	}()
-
 	select {
-	case err := <-errc:
+	case err := <-tt.waitError:
 		// WaitIndefinitely already invokes the expect error handler
 		return err
 	case <-time.After(timeout):

termtest_other.go

@@ -12,7 +12,7 @@ func syscallErrorCode(err error) int {
 	return -1
 }
 
-func (tt *TermTest) WaitIndefinitely() error {
+func (tt *TermTest) waitIndefinitely() error {
 	tt.opts.Logger.Println("WaitIndefinitely called")
 	defer tt.opts.Logger.Println("WaitIndefinitely closed")
 

termtest_windows.go

@@ -16,10 +16,10 @@ func syscallErrorCode(err error) int {
 	return 0
 }
 
-// WaitIndefinitely on Windows has to work around a Windows PTY bug where the PTY will NEVER exit by itself:
+// waitIndefinitely on Windows has to work around a Windows PTY bug where the PTY will NEVER exit by itself:
 // https://github.com/photostorm/pty/issues/3
 // Instead we wait for the process itself to exit, and after a grace period will shut down the pty.
-func (tt *TermTest) WaitIndefinitely() error {
+func (tt *TermTest) waitIndefinitely() error {
 	tt.opts.Logger.Println("WaitIndefinitely called")
 	defer tt.opts.Logger.Println("WaitIndefinitely closed")