Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
56 changes: 46 additions & 10 deletions pkg/gocui/gui.go
Original file line number Diff line number Diff line change
Expand Up @@ -125,8 +125,11 @@ type clickInfo struct {
// and keybindings.
type Gui struct {
RecordingConfig
// ReplayedEvents is for passing pre-recorded input events, for the purposes of testing
ReplayedEvents replayedEvents
// replayedEvents is for passing simulated input events, for the purposes
// of testing. Events must be submitted through the Replay* methods, which
// attach a task to each event; pushing into the channels directly would
// bypass the busy-tracking that integration tests rely on.
replayedEvents replayedEvents
playRecording bool

tabClickBindings []*tabClickBinding
Expand Down Expand Up @@ -255,7 +258,7 @@ func NewGui(opts NewGuiOpts) (*Gui, error) {
g.taskManager = newTaskManager()

if opts.PlayRecording {
g.ReplayedEvents = replayedEvents{
g.replayedEvents = replayedEvents{
Keys: make(chan *TcellKeyEventWrapper),
Resizes: make(chan *TcellResizeEventWrapper),
MouseEvents: make(chan *TcellMouseEventWrapper),
Expand Down Expand Up @@ -291,6 +294,30 @@ func (g *Gui) NewBackgroundTask() *TaskImpl {
return g.taskManager.NewTask(true)
}

// ReplayKeyEvent simulates a key press, as if the user had typed it. It's used
// by integration tests. The event carries a task, so that the program counts
// as busy from before the event is submitted until the main loop has fully
// processed it; the test driver relies on this when it waits for the program
// to go idle after submitting an event. (If the task were only created once
// the main loop picks the event up, there would be a window in which the event
// is still in flight but nothing counts as busy.)
func (g *Gui) ReplayKeyEvent(ev *TcellKeyEventWrapper) {
ev.task = g.NewTask()
g.replayedEvents.Keys <- ev
}

// ReplayMouseEvent is like ReplayKeyEvent, but for mouse events.
func (g *Gui) ReplayMouseEvent(ev *TcellMouseEventWrapper) {
ev.task = g.NewTask()
g.replayedEvents.MouseEvents <- ev
}

// ReplayFocusEvent is like ReplayKeyEvent, but for focus events.
func (g *Gui) ReplayFocusEvent(ev *TcellFocusEventWrapper) {
ev.task = g.NewTask()
g.replayedEvents.FocusEvents <- ev
}

// Busy reports whether any foreground work is in flight, ignoring the event
// currently being processed on the main goroutine (see currentTask). Background
// routines (auto-fetch etc.) don't count. It's used to decide whether it's safe
Expand All @@ -299,11 +326,11 @@ func (g *Gui) Busy() bool {
return g.taskManager.hasBusyForegroundTaskExcept(g.currentTask)
}

// An idle listener listens for when the program is idle. This is useful for
// integration tests which can wait for the program to be idle before taking
// the next step in the test.
func (g *Gui) AddIdleListener(c chan struct{}) {
g.taskManager.addIdleListener(c)
// WaitUntilIdle blocks until the program is idle (no busy tasks). This is
// useful for integration tests which want to wait for the program to finish
// processing before taking the next step in the test.
func (g *Gui) WaitUntilIdle() {
g.taskManager.WaitUntilIdle()
}

// Close finalizes the library. It should be called after a successful
Expand Down Expand Up @@ -948,7 +975,12 @@ func (g *Gui) processEvent() error {
// are always the primary event here.
select {
case ev := <-g.gEvents:
task := g.NewTask()
// Replayed test events already carry their task (see ReplayKeyEvent);
// organic events get theirs here.
task := ev.task
if task == nil {
task = g.NewTask()
}
g.currentTask = task
defer func() { g.currentTask = nil; task.Done() }()

Expand Down Expand Up @@ -992,7 +1024,11 @@ func (g *Gui) processRemainingEvents() (bool, error) {
select {
case ev := <-g.gEvents:
contentOnly = false
if err := g.handleError(g.handleEvent(&ev)); err != nil {
err := g.handleError(g.handleEvent(&ev))
if ev.task != nil {
ev.task.Done()
}
if err != nil {
return false, err
}
default:
Expand Down
52 changes: 34 additions & 18 deletions pkg/gocui/task_manager.go
Original file line number Diff line number Diff line change
Expand Up @@ -6,20 +6,23 @@ import "sync"
// the main goroutine or a worker goroutine). Used by integration tests
// to wait until the program is idle before progressing.
type TaskManager struct {
// each of these listeners will be notified when the program goes from busy to idle
idleListeners []chan struct{}
tasks map[int]Task
tasks map[int]Task
// auto-incrementing id for new tasks
nextId int

mutex sync.Mutex
// signalled whenever the program transitions from busy to idle; used by
// WaitUntilIdle
idleCond *sync.Cond
}

func newTaskManager() *TaskManager {
return &TaskManager{
tasks: make(map[int]Task),
idleListeners: []chan struct{}{},
self := &TaskManager{
tasks: make(map[int]Task),
}
self.idleCond = sync.NewCond(&self.mutex)

return self
}

func (self *TaskManager) NewTask(background bool) *TaskImpl {
Expand Down Expand Up @@ -58,27 +61,40 @@ func (self *TaskManager) hasBusyForegroundTaskExcept(ignore Task) bool {
return false
}

func (self *TaskManager) addIdleListener(c chan struct{}) {
self.idleListeners = append(self.idleListeners, c)
}

func (self *TaskManager) withMutex(f func()) {
// WaitUntilIdle blocks until no task is busy. Integration tests use it to wait
// for the program to finish processing before taking the next step.
func (self *TaskManager) WaitUntilIdle() {
self.mutex.Lock()
defer self.mutex.Unlock()

f()
for self.hasBusyTask() {
self.idleCond.Wait()
}
}

// Check if all tasks are done
// caller must hold self.mutex
func (self *TaskManager) hasBusyTask() bool {
for _, task := range self.tasks {
if task.isBusy() {
return
return true
}
}

// If we get here, all tasks are done, so
// notify listeners that the program is idle
for _, listener := range self.idleListeners {
listener <- struct{}{}
return false
}

func (self *TaskManager) withMutex(f func()) {
self.mutex.Lock()
defer self.mutex.Unlock()

f()

// Wake up any goroutine blocked in WaitUntilIdle. This must not block on
// the waiter (we hold the mutex, and the waiter may itself be trying to
// acquire it, e.g. by creating a task, before it next waits) — which is
// exactly what Broadcast guarantees.
if !self.hasBusyTask() {
self.idleCond.Broadcast()
}
}

Expand Down
66 changes: 66 additions & 0 deletions pkg/gocui/task_manager_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@ package gocui

import (
"testing"
"time"

"github.com/stretchr/testify/assert"
)
Expand Down Expand Up @@ -61,3 +62,68 @@ func TestTaskManagerHasBusyForegroundTaskExcept(t *testing.T) {
assert.False(t, tm.hasBusyForegroundTaskExcept(current))
})
}

func TestTaskManagerWaitUntilIdle(t *testing.T) {
// returnsWithin reports whether f returns within the given duration.
returnsWithin := func(d time.Duration, f func()) bool {
done := make(chan struct{})
go func() {
f()
close(done)
}()
select {
case <-done:
return true
case <-time.After(d):
return false
}
}

t.Run("returns immediately when no task was ever created", func(t *testing.T) {
tm := newTaskManager()
assert.True(t, returnsWithin(time.Second, tm.WaitUntilIdle))
})

t.Run("blocks while a task is busy", func(t *testing.T) {
tm := newTaskManager()
tm.NewTask(false)
assert.False(t, returnsWithin(50*time.Millisecond, tm.WaitUntilIdle))
})

t.Run("wakes up when the last busy task completes", func(t *testing.T) {
tm := newTaskManager()
task := tm.NewTask(false)
go func() {
time.Sleep(10 * time.Millisecond)
task.Done()
}()
assert.True(t, returnsWithin(time.Second, tm.WaitUntilIdle))
})

t.Run("a paused task counts as idle", func(t *testing.T) {
tm := newTaskManager()
task := tm.NewTask(false)
task.Pause()
assert.True(t, returnsWithin(time.Second, tm.WaitUntilIdle))
})

t.Run("a task completing while nobody waits must not block", func(t *testing.T) {
// This is the deadlock case: the waiter (the integration-test runner)
// is between waits, and itself needs the task manager's mutex (it
// creates a task whenever it enqueues work) before it waits again. The
// idle notification must neither block the completing task while it
// holds the mutex, nor get lost.
tm := newTaskManager()
assert.True(t, returnsWithin(time.Second, func() {
// the program goes idle with nobody waiting...
tm.NewTask(true).Done()

// ...and creating and completing more tasks afterwards must still
// be possible
task := tm.NewTask(false)
tm.NewTask(false).Done()
task.Done()
}))
assert.True(t, returnsWithin(time.Second, tm.WaitUntilIdle))
})
}
30 changes: 26 additions & 4 deletions pkg/gocui/tcell_driver.go
Original file line number Diff line number Diff line change
Expand Up @@ -172,6 +172,12 @@ type GocuiEvent struct {
Focused bool
Start bool
N int

// task tracks the processing of this event for idle detection. Events
// replayed by integration tests carry a task from the moment they are
// submitted (see Gui.ReplayKeyEvent); for organic events it is nil, and
// the main loop creates a task when it picks the event up.
task Task
}

// Event types.
Expand Down Expand Up @@ -208,6 +214,8 @@ type TcellKeyEventWrapper struct {
Mod tcell.ModMask
Key tcell.Key
Ch string

task Task // see GocuiEvent.task
}

func NewTcellKeyEventWrapper(event *tcell.EventKey, timestamp int64) *TcellKeyEventWrapper {
Expand All @@ -229,6 +237,8 @@ type TcellMouseEventWrapper struct {
Y int
ButtonMask tcell.ButtonMask
ModMask tcell.ModMask

task Task // see GocuiEvent.task
}

func NewTcellMouseEventWrapper(event *tcell.EventMouse, timestamp int64) *TcellMouseEventWrapper {
Expand Down Expand Up @@ -269,6 +279,8 @@ func (wrapper TcellResizeEventWrapper) toTcellEvent() tcell.Event {
type TcellFocusEventWrapper struct {
Timestamp int64
Focused bool

task Task // see GocuiEvent.task
}

func NewTcellFocusEventWrapper(event *tcell.EventFocus, timestamp int64) *TcellFocusEventWrapper {
Expand All @@ -285,21 +297,31 @@ func (wrapper TcellFocusEventWrapper) toTcellEvent() tcell.Event {
// pollEvent get tcell.Event and transform it into gocuiEvent
func (g *Gui) pollEvent() GocuiEvent {
var tev tcell.Event
var task Task
if g.playRecording {
select {
case ev := <-g.ReplayedEvents.Keys:
case ev := <-g.replayedEvents.Keys:
tev = (ev).toTcellEvent()
case ev := <-g.ReplayedEvents.Resizes:
task = ev.task
case ev := <-g.replayedEvents.Resizes:
tev = (ev).toTcellEvent()
case ev := <-g.ReplayedEvents.MouseEvents:
case ev := <-g.replayedEvents.MouseEvents:
tev = (ev).toTcellEvent()
case ev := <-g.ReplayedEvents.FocusEvents:
task = ev.task
case ev := <-g.replayedEvents.FocusEvents:
tev = (ev).toTcellEvent()
task = ev.task
}
} else {
tev = <-Screen.EventQ()
}

event := gocuiEventFromTcellEvent(tev)
event.task = task
return event
}

func gocuiEventFromTcellEvent(tev tcell.Event) GocuiEvent {
switch tev := tev.(type) {
case *tcell.EventInterrupt:
return GocuiEvent{Type: eventInterrupt}
Expand Down
Loading
Loading