From 8f42d2dbe628930c01c8be00713a6271171a5077 Mon Sep 17 00:00:00 2001 From: Ayman Bagabas Date: Mon, 14 Nov 2022 18:40:09 -0500 Subject: [PATCH] chore(mouse): add extended sgr mode tests --- mouse.go | 8 +- mouse_test.go | 789 ++++++++++++++++++++++++++++++++++++------------- screen_test.go | 16 +- 3 files changed, 589 insertions(+), 224 deletions(-) diff --git a/mouse.go b/mouse.go index fba95e6a07..43e93d0327 100644 --- a/mouse.go +++ b/mouse.go @@ -8,7 +8,7 @@ import ( "strings" ) -const x10ByteOffset = 32 +const mouseX10ByteOffset = 32 // MouseMsg contains information about a mouse event and are sent to a programs // update function when mouse activity occurs. Note that the mouse must first @@ -281,8 +281,8 @@ func parseX10MouseEvents(buf []byte) ([]MouseEvent, error) { m := parseMouseButton(int(v[0]), false) // (1,1) is the upper left. We subtract 1 to normalize it to (0,0). - m.X = int(v[1]) - x10ByteOffset - 1 - m.Y = int(v[2]) - x10ByteOffset - 1 + m.X = int(v[1]) - mouseX10ByteOffset - 1 + m.Y = int(v[2]) - mouseX10ByteOffset - 1 r = append(r, m) } @@ -296,7 +296,7 @@ func parseMouseButton(b int, isSGR bool) MouseEvent { m.isSGR = isSGR e := b if !isSGR { - e -= x10ByteOffset + e -= mouseX10ByteOffset } const ( diff --git a/mouse_test.go b/mouse_test.go index 06779d9062..2f210e21ac 100644 --- a/mouse_test.go +++ b/mouse_test.go @@ -12,110 +12,176 @@ func TestMouseEvent_String(t *testing.T) { expected string }{ { - name: "unknown", - event: MouseEvent{Type: MouseUnknown}, + name: "unknown", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseUnknown, + }, expected: "unknown", }, { - name: "left", - event: MouseEvent{Type: MouseLeft}, + name: "left", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseLeft, + }, expected: "left", }, { - name: "right", - event: MouseEvent{Type: MouseRight}, + name: "right", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseRight, + }, expected: "right", }, { - name: "middle", - event: MouseEvent{Type: MouseMiddle}, + name: "middle", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseMiddle, + }, expected: "middle", }, { - name: "release", - event: MouseEvent{Type: MouseRelease}, + name: "release", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseRelease, + }, expected: "release", }, { - name: "wheel up", - event: MouseEvent{Type: MouseWheelUp}, + name: "wheel up", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseWheelUp, + }, expected: "wheel up", }, { - name: "wheel down", - event: MouseEvent{Type: MouseWheelDown}, + name: "wheel down", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseWheelDown, + }, expected: "wheel down", }, { - name: "motion", - event: MouseEvent{Type: MouseMotion}, + name: "wheel left", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseWheelLeft, + }, + expected: "wheel left", + }, + { + name: "wheel right", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseWheelRight, + }, + expected: "wheel right", + }, + { + name: "motion", + event: MouseEvent{ + Action: MouseActionPress, + Button: MouseButtonNone, + Type: MouseMotion, + }, expected: "motion", }, { name: "shift+left", event: MouseEvent{ - Type: MouseLeft, - Shift: true, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonNone, + Shift: true, }, expected: "shift+left", }, { name: "ctrl+shift+left", event: MouseEvent{ - Type: MouseLeft, - Shift: true, - Ctrl: true, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonNone, + Shift: true, + Ctrl: true, }, expected: "ctrl+shift+left", }, { name: "alt+left", event: MouseEvent{ - Type: MouseLeft, - Alt: true, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonNone, + Alt: true, }, expected: "alt+left", }, { name: "ctrl+left", event: MouseEvent{ - Type: MouseLeft, - Ctrl: true, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonNone, + Ctrl: true, }, expected: "ctrl+left", }, { name: "ctrl+alt+left", event: MouseEvent{ - Type: MouseLeft, - Alt: true, - Ctrl: true, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonNone, + Alt: true, + Ctrl: true, }, expected: "ctrl+alt+left", }, { name: "ctrl+alt+shift+left", event: MouseEvent{ - Type: MouseLeft, - Alt: true, - Ctrl: true, - Shift: true, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonNone, + Alt: true, + Ctrl: true, + Shift: true, }, expected: "ctrl+alt+shift+left", }, { name: "ignore coordinates", event: MouseEvent{ - X: 100, - Y: 200, - Type: MouseLeft, + X: 100, + Y: 200, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonNone, }, expected: "left", }, { name: "broken type", event: MouseEvent{ - Type: MouseEventType(-1000), + Type: MouseEventType(-100), + Action: MouseActionPress, + Button: MouseButtonNone, }, expected: "", }, @@ -157,23 +223,27 @@ func TestParseX10MouseEvent(t *testing.T) { // Position. { name: "zero position", - buf: encode(0b0010_0000, 0, 0), + buf: encode(0b0000_0000, 0, 0), expected: []MouseEvent{ { - X: 0, - Y: 0, - Type: MouseLeft, + X: 0, + Y: 0, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonLeft, }, }, }, { name: "max position", - buf: encode(0b0010_0000, 222, 222), // Because 255 (max int8) - 32 - 1. + buf: encode(0b0000_0000, 222, 222), // Because 255 (max int8) - 32 - 1. expected: []MouseEvent{ { - X: 222, - Y: 222, - Type: MouseLeft, + X: 222, + Y: 222, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonLeft, }, }, }, @@ -183,9 +253,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0000_0000, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseLeft, + X: 32, + Y: 16, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonLeft, }, }, }, @@ -194,9 +266,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0010_0000, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseLeft, + X: 32, + Y: 16, + Type: MouseLeft, + Action: MouseActionMotion, + Button: MouseButtonLeft, }, }, }, @@ -205,9 +279,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0000_0001, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseMiddle, + X: 32, + Y: 16, + Type: MouseMiddle, + Action: MouseActionPress, + Button: MouseButtonMiddle, }, }, }, @@ -216,9 +292,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0010_0001, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseMiddle, + X: 32, + Y: 16, + Type: MouseMiddle, + Action: MouseActionMotion, + Button: MouseButtonMiddle, }, }, }, @@ -227,9 +305,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0000_0010, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, + X: 32, + Y: 16, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, }, }, }, @@ -238,9 +318,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0010_0010, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, + X: 32, + Y: 16, + Type: MouseRight, + Action: MouseActionMotion, + Button: MouseButtonRight, }, }, }, @@ -249,9 +331,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0010_0011, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseMotion, + X: 32, + Y: 16, + Type: MouseMotion, + Action: MouseActionMotion, + Button: MouseButtonNone, }, }, }, @@ -260,9 +344,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0100_0000, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelUp, + X: 32, + Y: 16, + Type: MouseWheelUp, + Action: MouseActionPress, + Button: MouseButtonWheelUp, }, }, }, @@ -271,9 +357,37 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0100_0001, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, + X: 32, + Y: 16, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, + }, + }, + }, + { + name: "wheel left", + buf: encode(0b0100_0010, 32, 16), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseWheelLeft, + Action: MouseActionPress, + Button: MouseButtonWheelLeft, + }, + }, + }, + { + name: "wheel right", + buf: encode(0b0100_0011, 32, 16), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseWheelRight, + Action: MouseActionPress, + Button: MouseButtonWheelRight, }, }, }, @@ -282,108 +396,178 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0000_0011, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRelease, + X: 32, + Y: 16, + Type: MouseRelease, + Action: MouseActionRelease, + Button: MouseButtonNone, + }, + }, + }, + { + name: "backward", + buf: encode(0b1000_0000, 32, 16), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseBackward, + Action: MouseActionPress, + Button: MouseButtonBackward, + }, + }, + }, + { + name: "forward", + buf: encode(0b1000_0001, 32, 16), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseForward, + Action: MouseActionPress, + Button: MouseButtonForward, + }, + }, + }, + { + name: "button 10", + buf: encode(0b1000_0010, 32, 16), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseBtn10, + Action: MouseActionPress, + Button: MouseButton10, + }, + }, + }, + { + name: "button 11", + buf: encode(0b1000_0011, 32, 16), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseBtn11, + Action: MouseActionPress, + Button: MouseButton11, }, }, }, // Combinations. { name: "alt+right", - buf: encode(0b0010_1010, 32, 16), + buf: encode(0b0000_1010, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, - Alt: true, + X: 32, + Y: 16, + Alt: true, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, }, }, }, { name: "ctrl+right", - buf: encode(0b0011_0010, 32, 16), + buf: encode(0b0001_0010, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, - Ctrl: true, + X: 32, + Y: 16, + Ctrl: true, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, }, }, }, { - name: "ctrl+alt+right", - buf: encode(0b0011_1010, 32, 16), + name: "alt+right in motion", + buf: encode(0b0010_1010, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, - Alt: true, - Ctrl: true, + X: 32, + Y: 16, + Alt: true, + Type: MouseRight, + Action: MouseActionMotion, + Button: MouseButtonRight, }, }, }, { - name: "alt+wheel down", - buf: encode(0b0100_1001, 32, 16), + name: "ctrl+right in motion", + buf: encode(0b0011_0010, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, - Alt: true, + X: 32, + Y: 16, + Ctrl: true, + Type: MouseRight, + Action: MouseActionMotion, + Button: MouseButtonRight, }, }, }, { - name: "ctrl+wheel down", - buf: encode(0b0101_0001, 32, 16), + name: "ctrl+alt+right", + buf: encode(0b0001_1010, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, - Ctrl: true, + X: 32, + Y: 16, + Alt: true, + Ctrl: true, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, }, }, }, { - name: "ctrl+alt+wheel down", - buf: encode(0b0101_1001, 32, 16), + name: "ctrl+wheel up", + buf: encode(0b0101_0000, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, - Alt: true, - Ctrl: true, + X: 32, + Y: 16, + Ctrl: true, + Type: MouseWheelUp, + Action: MouseActionPress, + Button: MouseButtonWheelUp, }, }, }, - // Unknown. { - name: "wheel with unknown bit", - buf: encode(0b0100_0010, 32, 16), + name: "alt+wheel down", + buf: encode(0b0100_1001, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseUnknown, + X: 32, + Y: 16, + Alt: true, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, }, }, }, { - name: "unknown with modifier", - buf: encode(0b0100_1010, 32, 16), + name: "ctrl+alt+wheel down", + buf: encode(0b0101_1001, 32, 16), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseUnknown, - Alt: true, + X: 32, + Y: 16, + Alt: true, + Ctrl: true, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, }, }, }, @@ -393,9 +577,11 @@ func TestParseX10MouseEvent(t *testing.T) { buf: encode(0b0010_0000, 250, 223), // Because 255 (max int8) - 32 - 1. expected: []MouseEvent{ { - X: -6, - Y: -33, - Type: MouseLeft, + X: -6, + Y: -33, + Type: MouseLeft, + Action: MouseActionMotion, + Button: MouseButtonLeft, }, }, }, @@ -405,14 +591,18 @@ func TestParseX10MouseEvent(t *testing.T) { buf: append(encode(0b0010_0000, 32, 16), encode(0b0000_0011, 64, 32)...), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseLeft, + X: 32, + Y: 16, + Type: MouseLeft, + Action: MouseActionMotion, + Button: MouseButtonLeft, }, { - X: 64, - Y: 32, - Type: MouseRelease, + X: 64, + Y: 32, + Type: MouseRelease, + Action: MouseActionRelease, + Button: MouseButtonNone, }, }, }, @@ -497,20 +687,26 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(0, 0, 0, false), expected: []MouseEvent{ { - X: 0, - Y: 0, - Type: MouseLeft, + X: 0, + Y: 0, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonLeft, + isSGR: true, }, }, }, { - name: "222 position", - buf: encode(0, 222, 222, false), + name: "225 position", + buf: encode(0, 225, 225, false), expected: []MouseEvent{ { - X: 222, - Y: 222, - Type: MouseLeft, + X: 225, + Y: 225, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonLeft, + isSGR: true, }, }, }, @@ -520,9 +716,26 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(0, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseLeft, + X: 32, + Y: 16, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonLeft, + isSGR: true, + }, + }, + }, + { + name: "left in motion", + buf: encode(32, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseLeft, + Action: MouseActionMotion, + Button: MouseButtonLeft, + isSGR: true, }, }, }, @@ -531,9 +744,12 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(0, 32, 16, true), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseLeft, + X: 32, + Y: 16, + Type: MouseLeft, + Action: MouseActionRelease, + Button: MouseButtonLeft, + isSGR: true, }, }, }, @@ -542,9 +758,26 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(1, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseMiddle, + X: 32, + Y: 16, + Type: MouseMiddle, + Action: MouseActionPress, + Button: MouseButtonMiddle, + isSGR: true, + }, + }, + }, + { + name: "middle in motion", + buf: encode(33, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseMiddle, + Action: MouseActionMotion, + Button: MouseButtonMiddle, + isSGR: true, }, }, }, @@ -553,9 +786,12 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(1, 32, 16, true), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseMiddle, + X: 32, + Y: 16, + Type: MouseMiddle, + Action: MouseActionRelease, + Button: MouseButtonMiddle, + isSGR: true, }, }, }, @@ -564,9 +800,12 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(2, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, + X: 32, + Y: 16, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, + isSGR: true, }, }, }, @@ -575,9 +814,12 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(2, 32, 16, true), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, + X: 32, + Y: 16, + Type: MouseRight, + Action: MouseActionRelease, + Button: MouseButtonRight, + isSGR: true, }, }, }, @@ -586,9 +828,12 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(35, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseMotion, + X: 32, + Y: 16, + Type: MouseMotion, + Action: MouseActionMotion, + Button: MouseButtonNone, + isSGR: true, }, }, }, @@ -597,9 +842,12 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(64, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelUp, + X: 32, + Y: 16, + Type: MouseWheelUp, + Action: MouseActionPress, + Button: MouseButtonWheelUp, + isSGR: true, }, }, }, @@ -608,9 +856,96 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(65, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, + X: 32, + Y: 16, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, + isSGR: true, + }, + }, + }, + { + name: "wheel left", + buf: encode(66, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseWheelLeft, + Action: MouseActionPress, + Button: MouseButtonWheelLeft, + isSGR: true, + }, + }, + }, + { + name: "wheel right", + buf: encode(67, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseWheelRight, + Action: MouseActionPress, + Button: MouseButtonWheelRight, + isSGR: true, + }, + }, + }, + { + name: "backward", + buf: encode(128, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseBackward, + Action: MouseActionPress, + Button: MouseButtonBackward, + isSGR: true, + }, + }, + }, + { + name: "backward in motion", + buf: encode(160, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseBackward, + Action: MouseActionMotion, + Button: MouseButtonBackward, + isSGR: true, + }, + }, + }, + { + name: "forward", + buf: encode(129, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseForward, + Action: MouseActionPress, + Button: MouseButtonForward, + isSGR: true, + }, + }, + }, + { + name: "forward in motion", + buf: encode(161, 32, 16, false), + expected: []MouseEvent{ + { + X: 32, + Y: 16, + Type: MouseForward, + Action: MouseActionMotion, + Button: MouseButtonForward, + isSGR: true, }, }, }, @@ -620,10 +955,13 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(10, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, - Alt: true, + X: 32, + Y: 16, + Alt: true, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, + isSGR: true, }, }, }, @@ -632,10 +970,13 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(18, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, - Ctrl: true, + X: 32, + Y: 16, + Ctrl: true, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, + isSGR: true, }, }, }, @@ -644,62 +985,77 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(26, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseRight, - Alt: true, - Ctrl: true, + X: 32, + Y: 16, + Alt: true, + Ctrl: true, + Type: MouseRight, + Action: MouseActionPress, + Button: MouseButtonRight, + isSGR: true, }, }, }, { - name: "alt+wheel down", + name: "alt+wheel press", buf: encode(73, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, - Alt: true, + X: 32, + Y: 16, + Alt: true, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, + isSGR: true, }, }, }, { - name: "ctrl+wheel down", + name: "ctrl+wheel press", buf: encode(81, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, - Ctrl: true, + X: 32, + Y: 16, + Ctrl: true, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, + isSGR: true, }, }, }, { - name: "ctrl+alt+wheel down", + name: "ctrl+alt+wheel press", buf: encode(89, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, - Alt: true, - Ctrl: true, + X: 32, + Y: 16, + Alt: true, + Ctrl: true, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, + isSGR: true, }, }, }, { - name: "ctrl+alt+shift+wheel down", + name: "ctrl+alt+shift+wheel press", buf: encode(93, 32, 16, false), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseWheelDown, - Shift: true, - Alt: true, - Ctrl: true, + X: 32, + Y: 16, + Shift: true, + Alt: true, + Ctrl: true, + Type: MouseWheelDown, + Action: MouseActionPress, + Button: MouseButtonWheelDown, + isSGR: true, }, }, }, @@ -709,19 +1065,28 @@ func TestParseSGRMouseEvent(t *testing.T) { buf: encode(0, 32, 16, false) + encode(35, 40, 30, false) + encode(0, 64, 32, true), expected: []MouseEvent{ { - X: 32, - Y: 16, - Type: MouseLeft, + X: 32, + Y: 16, + Type: MouseLeft, + Action: MouseActionPress, + Button: MouseButtonLeft, + isSGR: true, }, { - X: 40, - Y: 30, - Type: MouseMotion, + X: 40, + Y: 30, + Type: MouseMotion, + Action: MouseActionMotion, + Button: MouseButtonNone, + isSGR: true, }, { - X: 64, - Y: 32, - Type: MouseLeft, + X: 64, + Y: 32, + Type: MouseLeft, + Action: MouseActionRelease, + Button: MouseButtonLeft, + isSGR: true, }, }, }, @@ -731,7 +1096,7 @@ func TestParseSGRMouseEvent(t *testing.T) { tc := tt[i] t.Run(tc.name, func(t *testing.T) { - actual, err := parseSGRMouseEvents([]byte(tc.buf)) + actual, err := parseSGRMouseEvents(tc.buf) if err != nil { t.Fatalf("unexpected error for test: %v", err, diff --git a/screen_test.go b/screen_test.go index 2f305e3d15..082984f906 100644 --- a/screen_test.go +++ b/screen_test.go @@ -14,42 +14,42 @@ func TestClearMsg(t *testing.T) { { name: "clear_screen", cmds: []Cmd{ClearScreen}, - expected: "\x1b[?25l\x1b[2J\x1b[1;1H\x1b[1;1Hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l", + expected: "\x1b[?25l\x1b[2J\x1b[1;1H\x1b[1;1Hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l", }, { name: "altscreen", cmds: []Cmd{EnterAltScreen, ExitAltScreen}, - expected: "\x1b[?25l\x1b[?1049h\x1b[2J\x1b[1;1H\x1b[1;1H\x1b[?25l\x1b[?1049l\x1b[?25lsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l", + expected: "\x1b[?25l\x1b[?1049h\x1b[2J\x1b[1;1H\x1b[1;1H\x1b[?25l\x1b[?1049l\x1b[?25lsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l", }, { name: "altscreen_autoexit", cmds: []Cmd{EnterAltScreen}, - expected: "\x1b[?25l\x1b[?1049h\x1b[2J\x1b[1;1H\x1b[1;1H\x1b[?25lsuccess\r\n\x1b[2;0H\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1049l\x1b[?25h", + expected: "\x1b[?25l\x1b[?1049h\x1b[2J\x1b[1;1H\x1b[1;1H\x1b[?25lsuccess\r\n\x1b[2;0H\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l\x1b[?1049l\x1b[?25h", }, { name: "mouse_cellmotion", cmds: []Cmd{EnableMouseCellMotion}, - expected: "\x1b[?25l\x1b[?1002hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l", + expected: "\x1b[?25l\x1b[?1002hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l", }, { name: "mouse_allmotion", cmds: []Cmd{EnableMouseAllMotion}, - expected: "\x1b[?25l\x1b[?1003hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l", + expected: "\x1b[?25l\x1b[?1003hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l", }, { name: "mouse_disable", cmds: []Cmd{EnableMouseAllMotion, DisableMouse}, - expected: "\x1b[?25l\x1b[?1003h\x1b[?1002l\x1b[?1003lsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l", + expected: "\x1b[?25l\x1b[?1003h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016lsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l", }, { name: "cursor_hide", cmds: []Cmd{HideCursor}, - expected: "\x1b[?25l\x1b[?25lsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l", + expected: "\x1b[?25l\x1b[?25lsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l", }, { name: "cursor_hideshow", cmds: []Cmd{HideCursor, ShowCursor}, - expected: "\x1b[?25l\x1b[?25l\x1b[?25hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l", + expected: "\x1b[?25l\x1b[?25l\x1b[?25hsuccess\r\n\x1b[0D\x1b[2K\x1b[?25h\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1016l", }, }