package tea import ( "bytes" "context" "errors" "fmt" "io" "log" "os" "path/filepath" "strings" "sync" "sync/atomic" "testing" "time" "github.com/charmbracelet/x/ansi" ) type ctxImplodeMsg struct { cancel context.CancelFunc } type incrementMsg struct{} type panicMsg struct{} func panicCmd() Msg { panic("testing goroutine panic behavior") } type testModel struct { executed atomic.Value counter atomic.Value } func (m *testModel) Init() Cmd { return nil } func (m *testModel) Update(msg Msg) (Model, Cmd) { switch msg := msg.(type) { case ctxImplodeMsg: msg.cancel() time.Sleep(100 * time.Millisecond) case incrementMsg: i := m.counter.Load() if i == nil { m.counter.Store(1) } else { m.counter.Store(i.(int) + 1) } case KeyPressMsg: switch msg.String() { case "q", "ctrl+c": return m, Quit } case panicMsg: panic("testing panic behavior") } return m, nil } func (m *testModel) View() View { m.executed.Store(true) return NewView("success") } func TestTeaModel(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer in.Write([]byte("q")) ctx, cancel := context.WithTimeout(t.Context(), 3*time.Second) defer cancel() p := NewProgram(&testModel{}, WithContext(ctx), WithInput(&in), WithOutput(&buf), ) if _, err := p.Run(); err != nil { t.Fatal(err) } if buf.Len() == 0 { t.Fatal("no output") } } func TestProgramClosesTraceFile(t *testing.T) { tracePath := filepath.Join(t.TempDir(), "trace.log") t.Setenv("TEA_TRACE", tracePath) p := NewProgram(quitModel{}, WithInput(nil), WithOutput(io.Discard), WithoutRenderer()) if _, err := p.Run(); err != nil { t.Fatal(err) } logger, ok := p.logger.(*log.Logger) if !ok { t.Fatalf("logger has type %T, want *log.Logger", p.logger) } traceFile, ok := logger.Writer().(*os.File) if !ok { t.Fatalf("trace writer has type %T, want *os.File", logger.Writer()) } if _, err := traceFile.Write([]byte("x")); !errors.Is(err, os.ErrClosed) { t.Fatalf("trace file remains open after Run: Write error = %v", err) } } func TestTeaQuit(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { p.Quit() return } } }() if _, err := p.Run(); err != nil { t.Fatal(err) } } func TestTeaWaitQuit(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer progStarted := make(chan struct{}) waitStarted := make(chan struct{}) errChan := make(chan error, 1) m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go func() { _, err := p.Run() errChan <- err }() go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { close(progStarted) <-waitStarted time.Sleep(50 * time.Millisecond) p.Quit() return } } }() <-progStarted var wg sync.WaitGroup for range 5 { wg.Add(1) go func() { p.Wait() wg.Done() }() } close(waitStarted) wg.Wait() err := <-errChan if err != nil { t.Fatalf("Expected nil, got %v", err) } } func TestTeaWaitKill(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer progStarted := make(chan struct{}) waitStarted := make(chan struct{}) errChan := make(chan error, 1) m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go func() { _, err := p.Run() errChan <- err }() go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { close(progStarted) <-waitStarted time.Sleep(50 * time.Millisecond) p.Kill() return } } }() <-progStarted var wg sync.WaitGroup for range 5 { wg.Add(1) go func() { p.Wait() wg.Done() }() } close(waitStarted) wg.Wait() err := <-errChan if !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } } func TestKillDuringStartupRace(t *testing.T) { t.Parallel() for range 100 { p := NewProgram(&testModel{}, WithInput(bytes.NewBuffer(nil)), WithOutput(io.Discard), WithoutSignals(), ) done := make(chan struct{}) go func() { _, _ = p.Run() close(done) }() p.Kill() select { case <-done: case <-time.After(time.Second): t.Fatal("program did not stop") } } } func TestTeaWithFilter(t *testing.T) { for _, preventCount := range []uint32{0, 1, 2} { t.Run(fmt.Sprintf("prevent_%d", preventCount), func(t *testing.T) { t.Parallel() testTeaWithFilter(t, preventCount) }) } } func testTeaWithFilter(t *testing.T, preventCount uint32) { var buf bytes.Buffer var in bytes.Buffer m := &testModel{} shutdowns := uint32(0) p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) p.filter = func(_ Model, msg Msg) Msg { if _, ok := msg.(QuitMsg); !ok { return msg } if shutdowns < preventCount { atomic.AddUint32(&shutdowns, 1) return nil } return msg } go func() { for atomic.LoadUint32(&shutdowns) <= preventCount { time.Sleep(time.Millisecond) p.Quit() } }() if _, err := p.Run(); err != nil { t.Fatal(err) } if shutdowns != preventCount { t.Errorf("Expected %d prevented shutdowns, got %d", preventCount, shutdowns) } } func TestTeaKill(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { p.Kill() return } } }() _, err := p.Run() if !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } if errors.Is(err, context.Canceled) { // The end user should not know about the program's internal context state. // The program should only report external context cancellation as a context error. t.Fatalf("Internal context cancellation was reported as context error!") } } func TestTeaContext(t *testing.T) { t.Parallel() ctx, cancel := context.WithCancel(t.Context()) var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithContext(ctx), WithInput(&in), WithOutput(&buf), ) go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { cancel() return } } }() _, err := p.Run() if !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } if !errors.Is(err, context.Canceled) { // The end user should know that their passed in context caused the kill. t.Fatalf("Expected %v, got %v", context.Canceled, err) } } func TestTeaContextImplodeDeadlock(t *testing.T) { t.Parallel() ctx, cancel := context.WithCancel(t.Context()) var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithContext(ctx), WithInput(&in), WithOutput(&buf), ) go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { p.Send(ctxImplodeMsg{cancel: cancel}) return } } }() if _, err := p.Run(); !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } } func TestTeaContextBatchDeadlock(t *testing.T) { t.Parallel() ctx, cancel := context.WithCancel(t.Context()) var buf bytes.Buffer var in bytes.Buffer inc := func() Msg { cancel() return incrementMsg{} } m := &testModel{} p := NewProgram(m, WithContext(ctx), WithInput(&in), WithOutput(&buf), ) go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { batch := make(BatchMsg, 100) for i := range batch { batch[i] = inc } p.Send(batch) return } } }() if _, err := p.Run(); !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } } func TestTeaBatchMsg(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer inc := func() Msg { return incrementMsg{} } m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go func() { p.Send(BatchMsg{inc, inc}) for { time.Sleep(time.Millisecond) i := m.counter.Load() if i != nil && i.(int) >= 2 { p.Quit() return } } }() if _, err := p.Run(); err != nil { t.Fatal(err) } if m.counter.Load() != 2 { t.Fatalf("counter should be 2, got %d", m.counter.Load()) } } func TestTeaSequenceMsg(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer inc := func() Msg { return incrementMsg{} } m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go p.Send(sequenceMsg{inc, inc, Quit}) if _, err := p.Run(); err != nil { t.Fatal(err) } if m.counter.Load() != 2 { t.Fatalf("counter should be 2, got %d", m.counter.Load()) } } func TestTeaSequenceMsgWithBatchMsg(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer inc := func() Msg { return incrementMsg{} } batch := func() Msg { return BatchMsg{inc, inc} } m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go p.Send(sequenceMsg{batch, inc, Quit}) if _, err := p.Run(); err != nil { t.Fatal(err) } if m.counter.Load() != 3 { t.Fatalf("counter should be 3, got %d", m.counter.Load()) } } func TestTeaNestedSequenceMsg(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer inc := func() Msg { return incrementMsg{} } m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go p.Send(sequenceMsg{inc, Sequence(inc, inc, Batch(inc, inc)), Quit}) if _, err := p.Run(); err != nil { t.Fatal(err) } if m.counter.Load() != 5 { t.Fatalf("counter should be 5, got %d", m.counter.Load()) } } func TestTeaSend(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) // sending before the program is started is a blocking operation go p.Send(Quit()) if _, err := p.Run(); err != nil { t.Fatal(err) } // sending a message after program has quit is a no-op p.Send(Quit()) } func TestProgramPrintAfterExit(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer p := NewProgram(&testModel{}, WithInput(&in), WithOutput(&buf), ) go p.Send(Quit()) if _, err := p.Run(); err != nil { t.Fatal(err) } tests := []struct { name string print func() }{ {"Println", func() { p.Println("after exit") }}, {"Printf", func() { p.Printf("after %s", "exit") }}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { done := make(chan struct{}) go func() { tt.print() close(done) }() select { case <-done: case <-time.After(100 * time.Millisecond): // Receive only after detecting the block. This releases the // direct channel send used before this regression was fixed, // so the test does not leak a goroutine against the old code. <-p.msgs <-done t.Fatal("print blocked after the program exited") } }) } } func TestTeaNoRun(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &testModel{} NewProgram(m, WithInput(&in), WithOutput(&buf), ) } // runTwiceModel waits for a WindowSizeMsg before quitting, and reports whether // that message ever reached Update, so we can tell a real run from a // torn-down one. type runTwiceModel struct { updated atomic.Bool } // Init returns no command on purpose: the program exits from Update once it // has seen a WindowSizeMsg, so the quit is ordered after the observation // rather than racing it. func (m *runTwiceModel) Init() Cmd { return nil } func (m *runTwiceModel) Update(msg Msg) (Model, Cmd) { if _, ok := msg.(WindowSizeMsg); ok { m.updated.Store(true) return m, Quit } return m, nil } func (m *runTwiceModel) View() View { return NewView("hello") } // TestTeaRunTwice is a regression test for running a Program a second time // after the first Run returned. Run resets its per-run state (handlers, // finished channel) at the top of every call, but before the fix the run // context, error channel, and shutdown guard stayed behind: the second run // tore down immediately with ErrProgramKilled and its shutdown was skipped, // leaving the terminal state it changed unrestored. func TestTeaRunTwice(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &runTwiceModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) // The program quits from Update once it has observed a WindowSizeMsg, so // every run returns on its own; a bounded wait keeps a genuinely broken // run from hanging the test instead of failing it. run := func(which string) { t.Helper() done := make(chan error, 1) go func() { _, err := p.Run() done <- err }() select { case err := <-done: if err != nil { t.Fatalf("%s run: unexpected error: %v", which, err) } case <-time.After(30 * time.Second): t.Fatalf("%s run: Run did not return; the program never observed a WindowSizeMsg", which) } } run("first") m.updated.Store(false) run("second") if !m.updated.Load() { t.Error("second run never delivered messages to Update") } } func TestTeaPanic(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { p.Send(panicMsg{}) return } } }() _, err := p.Run() if !errors.Is(err, ErrProgramPanic) { t.Fatalf("Expected %v, got %v", ErrProgramPanic, err) } if !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } } func TestTeaGoroutinePanic(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), ) go func() { for { time.Sleep(time.Millisecond) if m.executed.Load() != nil { batch := make(BatchMsg, 10) for i := 0; i < len(batch); i += 2 { batch[i] = Sequence(panicCmd) batch[i+1] = Batch(panicCmd) } p.Send(batch) return } } }() _, err := p.Run() if !errors.Is(err, ErrProgramPanic) { t.Fatalf("Expected %v, got %v", ErrProgramPanic, err) } if !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } } // flushPanicRenderer panics on every non-closing flush, simulating a renderer // crash inside the ticker goroutine started by startRenderer. type flushPanicRenderer struct { nilRenderer } func (flushPanicRenderer) flush(closing bool) (bool, error) { if !closing { panic("flushPanicRenderer") } return false, nil } // Fixes: https://github.com/charmbracelet/bubbletea/issues/1848 func TestTeaRendererFlushPanic(t *testing.T) { t.Parallel() var buf bytes.Buffer var in bytes.Buffer m := &testModel{} p := NewProgram(m, WithInput(&in), WithOutput(&buf), WithoutSignals(), ) p.renderer = flushPanicRenderer{} _, err := p.Run() if !errors.Is(err, ErrProgramPanic) { t.Fatalf("Expected %v, got %v", ErrProgramPanic, err) } if !errors.Is(err, ErrProgramKilled) { t.Fatalf("Expected %v, got %v", ErrProgramKilled, err) } } type benchModel struct { t testing.TB } func (m benchModel) Init() Cmd { return nil } func (m benchModel) Update(msg Msg) (Model, Cmd) { switch msg := msg.(type) { case KeyPressMsg: switch msg.String() { case "q", "ctrl+c": return m, Quit } } return m, nil } func (m benchModel) View() View { view := strings.Join([]string{ " \x1b[38;5;63m╭─────────────────────────╮\x1b[m", " \x1b[38;5;63m│\x1b[m\x1b[25X\x1b[28G\x1b[38;5;63m│\x1b[m", " \x1b[38;5;63m│\x1b[m \x1b[38;5;231mHello There!\x1b[m \x1b[38;5;63m│\x1b[m", " \x1b[38;5;63m│\x1b[m\x1b[25X\x1b[28G\x1b[38;5;63m│\x1b[m", " \x1b[38;5;63m╰─────────────────────────╯\x1b[m", }, "\n") return NewView(view) } func BenchmarkTeaRun(b *testing.B) { for i := 0; i < b.N; i++ { var buf bytes.Buffer m := benchModel{b} r, w := io.Pipe() p := NewProgram(m, WithInput(r), WithOutput(&buf), ) go func() { for _, input := range "abcdefghijklmnopq" { time.Sleep(10 * time.Millisecond) w.Write([]byte(string(input))) } }() if _, err := p.Run(); err != nil { b.Fatalf("Run failed: %v", err) } _ = r.CloseWithError(io.EOF) } } // quitModel quits as soon as it starts. type quitModel struct{} func (quitModel) Init() Cmd { return Quit } func (quitModel) Update(Msg) (Model, Cmd) { return quitModel{}, nil } func (quitModel) View() View { return NewView("") } // TestTeaNoCapabilityQueryWithoutInput is a regression test for // https://github.com/charmbracelet/gum/issues/1118: programs without input // can't read the terminal's responses to capability queries, so the replies // leak into the shell after the program exits. Don't send the queries when // input is disabled. func TestTeaNoCapabilityQueryWithoutInput(t *testing.T) { t.Parallel() query := ansi.RequestModeSynchronizedOutput + ansi.RequestModeUnicodeCore env := []string{"TERM=xterm-256color", "TERM_PROGRAM=ghostty"} for _, tt := range []struct { name string input io.Reader want bool }{ {name: "input disabled", input: nil, want: false}, {name: "input enabled", input: bytes.NewReader(nil), want: true}, } { t.Run(tt.name, func(t *testing.T) { t.Parallel() var buf bytes.Buffer p := NewProgram(quitModel{}, WithInput(tt.input), WithOutput(&buf), WithEnvironment(env), ) if _, err := p.Run(); err != nil { t.Fatal(err) } // The queued output may not have been flushed if the program // exited before the first tick, so inspect it too. Reading // p.outputBuf here is deliberate: it checks the buffered bytes // that would have been flushed, without depending on flush // timing (and it ties the test to the renderer's buffer, which // is an intentional trade-off). got := buf.String() + p.outputBuf.String() if strings.Contains(got, query) != tt.want { t.Fatalf("capability query present = %v, want %v; output: %q", !tt.want, tt.want, got) } }) } } // terminalQueryCmds lists every command that sends a terminal query whose // reply must be read from the input reader. var terminalQueryCmds = []Cmd{ RequestBackgroundColor, RequestForegroundColor, RequestCursorColor, ReadClipboard, ReadPrimaryClipboard, RequestTerminalVersion, RequestCapability("TN"), RequestCursorPosition, } // queryModel issues every terminal query that needs a reply on the input // reader, then quits once each one has been handled. type queryModel struct { handled int } func (queryModel) Init() Cmd { return Batch(terminalQueryCmds...) } func (m queryModel) Update(msg Msg) (Model, Cmd) { switch msg.(type) { case backgroundColorMsg, foregroundColorMsg, cursorColorMsg, readClipboardMsg, readPrimaryClipboardMsg, terminalVersion, requestCapabilityMsg, requestCursorPosMsg: // Each query is handled by an intermediate reader that turns the // terminal's reply into a message, so Update only sees the request // messages because the event loop passes them through after the // intermediate reads. If that pass-through ever changes, this test // will hang instead of quitting. m.handled++ if m.handled == len(terminalQueryCmds) { return m, Quit } } return m, nil } func (queryModel) View() View { return NewView("") } // TestTeaNoTerminalQueriesWithoutInput is a regression test for // https://github.com/charmbracelet/gum/issues/1118: programs without input // can't read the terminal's responses, so query replies leak into the shell // after the program exits. No input-dependent query should be sent when input // is disabled. func TestTeaNoTerminalQueriesWithoutInput(t *testing.T) { t.Parallel() queries := []string{ ansi.RequestSystemClipboard, ansi.RequestPrimaryClipboard, ansi.RequestBackgroundColor, ansi.RequestForegroundColor, ansi.RequestCursorColor, ansi.RequestNameVersion, ansi.RequestTermcap("TN"), ansi.RequestCursorPositionReport, } env := []string{"TERM=xterm-256color", "TERM_PROGRAM=ghostty"} for _, tt := range []struct { name string input io.Reader want bool }{ {name: "input disabled", input: nil, want: false}, {name: "input enabled", input: bytes.NewReader(nil), want: true}, } { t.Run(tt.name, func(t *testing.T) { t.Parallel() var buf bytes.Buffer p := NewProgram(queryModel{}, WithInput(tt.input), WithOutput(&buf), WithEnvironment(env), ) if _, err := p.Run(); err != nil { t.Fatal(err) } // The queued output may not have been flushed if the program // exited before the first tick, so inspect it too. Reading // p.outputBuf here is deliberate: it checks the buffered bytes // that would have been flushed, without depending on flush // timing (and it ties the test to the renderer's buffer, which // is an intentional trade-off). got := buf.String() + p.outputBuf.String() for _, query := range queries { if strings.Contains(got, query) != tt.want { t.Errorf("query %q present = %v, want %v; output: %q", query, !tt.want, tt.want, got) } } }) } } // TestProgressBarStateStringOutOfRange is a regression test for // https://github.com/charmbracelet/bubbletea/issues/1711: String panicked // with an index-out-of-range error for any ProgressBarState outside the // [ProgressBarNone, ProgressBarWarning] range. Since State is an exported // field on ProgressBar, callers can assign such a value without going // through NewProgressBar. func TestProgressBarStateStringOutOfRange(t *testing.T) { for _, s := range []ProgressBarState{-1, 5, 100} { if got, want := s.String(), "Unknown"; got != want { t.Errorf("ProgressBarState(%d).String() = %q, want %q", int(s), got, want) } } for s := ProgressBarNone; s <= ProgressBarWarning; s++ { if got := s.String(); got == "Unknown" { t.Errorf("ProgressBarState(%d).String() = %q, want a known name", int(s), got) } } } type failWriter struct{} func (failWriter) Write([]byte) (int, error) { return 0, errors.New("disk full") } func TestTeaRunReturnsWriteError(t *testing.T) { t.Parallel() var in bytes.Buffer in.Write([]byte("q")) ctx, cancel := context.WithTimeout(t.Context(), 3*time.Second) defer cancel() p := NewProgram(&testModel{}, WithContext(ctx), WithInput(&in), WithOutput(failWriter{}), ) _, err := p.Run() if err == nil { t.Fatal("Run returned nil although every write to the output failed") } if !strings.Contains(err.Error(), "disk full") { t.Fatalf("Run error does not wrap the write error: %v", err) } if errors.Is(err, ErrProgramKilled) { t.Fatalf("a write error alone should not report a killed program: %v", err) } } // helloQuitModel draws a line and quits as soon as it starts. type helloQuitModel struct{ init Cmd } func (m helloQuitModel) Init() Cmd { return m.init } func (m helloQuitModel) Update(Msg) (Model, Cmd) { return m, nil } func (helloQuitModel) View() View { return NewView("hello") } // A write error belongs to the run it happened in: running the program again // with a working output returns no error. func TestTeaRunWriteErrorDoesNotCarryOver(t *testing.T) { t.Parallel() var buf bytes.Buffer p := NewProgram(helloQuitModel{init: Quit}, WithInput(nil), WithOutput(&buf), WithWindowSize(80, 24)) // Pretend an earlier run failed to write. p.ranOnce = true p.keepWriteErr(errors.New("disk full")) if _, err := p.Run(); err != nil { t.Fatalf("expected no error, got %v", err) } if !strings.Contains(buf.String(), "hello") { t.Fatalf("expected the view to be written, got %q", buf.String()) } } // printFailWriter fails the writes that print a line above the program. type printFailWriter struct{} func (printFailWriter) Write(b []byte) (int, error) { if bytes.Contains(b, []byte("printed line")) { return 0, errors.New("broken pipe") } return len(b), nil } // Failing to print a line above the program is a write error too. func TestTeaRunReturnsPrintWriteError(t *testing.T) { t.Parallel() m := helloQuitModel{init: Sequence(Println("printed line"), Quit)} _, err := NewProgram(m, WithInput(nil), WithOutput(printFailWriter{})).Run() if err == nil || !strings.Contains(err.Error(), "broken pipe") { t.Fatalf("expected the print's write error, got %v", err) } }