FilesExpand file tree

main

/

workspace_focus_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

72 lines (65 loc) · 2.29 KB

main

/

workspace_focus_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

72 lines (65 loc) · 2.29 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

package tideui

import "testing"

func focusFixture() SolvedLayout {

regions := []SolvedRegion{

{Rect: Rect{X: 0, Y: 0, Width: 40, Height: 10}, PanelIDs: []string{"left"}},

{Rect: Rect{X: 40, Y: 0, Width: 40, Height: 5}, PanelIDs: []string{"topright"}},

{Rect: Rect{X: 40, Y: 5, Width: 40, Height: 5}, PanelIDs: []string{"botright"}},

}

rects := map[string]Rect{}

for _, region := range regions {

for _, id := range region.PanelIDs {

rects[id] = region.Rect

}

}

return SolvedLayout{Width: 80, Height: 10, Regions: regions, Rects: rects}

}

func TestFocusDirectionalPrefersOverlap(t *testing.T) {

solved := focusFixture()

all := func(string) bool { return true }

fm := FocusManager{current: "left"}

if got := fm.Directional(solved, DirRight, all); got != "topright" {

t.Fatalf("right from left = %q, want topright", got)

}

fm = FocusManager{current: "topright"}

if got := fm.Directional(solved, DirDown, all); got != "botright" {

t.Fatalf("down from topright = %q, want botright", got)

}

fm = FocusManager{current: "botright"}

if got := fm.Directional(solved, DirUp, all); got != "topright" {

t.Fatalf("up from botright = %q, want topright", got)

}

fm = FocusManager{current: "botright"}

if got := fm.Directional(solved, DirLeft, all); got != "left" {

t.Fatalf("left from botright = %q, want left", got)

}

}

func TestFocusDirectionalRespectsFocusablePredicate(t *testing.T) {

solved := focusFixture()

fm := FocusManager{current: "left"}

got := fm.Directional(solved, DirRight, func(id string) bool { return id != "topright" })

if got != "botright" {

t.Fatalf("right = %q, want botright when topright is not focusable", got)

}

}

func TestFocusDirectionalReturnsEmptyAtEdge(t *testing.T) {

solved := focusFixture()

fm := FocusManager{current: "topright"}

if got := fm.Directional(solved, DirRight, func(string) bool { return true }); got != "" {

t.Fatalf("right at edge = %q, want empty", got)

}

}

func TestFocusCycle(t *testing.T) {

order := []string{"a", "b", "c"}

fm := FocusManager{current: "b"}

if got := fm.Next(order); got != "c" {

t.Fatalf("next = %q, want c", got)

}

if got := fm.Prev(order); got != "a" {

t.Fatalf("prev = %q, want a", got)

}

fm.Set("missing")

if got := fm.Next(order); got != "b" {

t.Fatalf("next from unknown = %q, want b (wraps from start)", got)

}

}