1f349/voidterm
4
0
Fork 0
mirror of https://github.com/1f349/voidterm.git synced 2024-11-09 22:52:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
ab00b45d05
voidterm/termutil/buffer_test.go

689 lines
16 KiB
Go
Raw Blame History

package termutil
import (
"image/color"
"strings"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/assert"
)
func writeRaw(buf *Buffer, runes ...rune) {
for _, r := range runes {
buf.write(MeasuredRune{Rune: r, Width: 1})
}
}
func TestBufferCreation(t *testing.T) {
b := makeBufferForTesting(10, 20)
assert.Equal(t, uint16(10), b.Width())
assert.Equal(t, uint16(20), b.ViewHeight())
assert.Equal(t, uint16(0), b.CursorColumn())
assert.Equal(t, uint16(0), b.CursorLine())
assert.NotNil(t, b.lines)
}
func TestNewLine(t *testing.T) {
b := makeBufferForTesting(30, 3)
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("goodbye")...)
b.carriageReturn()
b.newLine()
expected := `
hello
goodbye
`
lines := b.GetVisibleLines()
strs := []string{}
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(strings.Join(strs, "\n")))
}
func TestTabbing(t *testing.T) {
b := makeBufferForTesting(30, 3)
writeRaw(b, []rune("hello")...)
b.tab()
writeRaw(b, []rune("x")...)
b.tab()
writeRaw(b, []rune("goodbye")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hell")...)
b.tab()
writeRaw(b, []rune("xxx")...)
b.tab()
writeRaw(b, []rune("good")...)
b.carriageReturn()
b.newLine()
expected := `
hello x goodbye
hell xxx good
`
lines := b.GetVisibleLines()
strs := []string{}
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(strings.Join(strs, "\n")))
}
func TestOffsets(t *testing.T) {
b := makeBufferForTesting(10, 3)
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello")...)
assert.Equal(t, uint16(10), b.ViewWidth())
assert.Equal(t, uint16(10), b.Width())
assert.Equal(t, uint16(3), b.ViewHeight())
assert.Equal(t, 5, b.Height())
}
func TestBufferWriteIncrementsCursorCorrectly(t *testing.T) {
b := makeBufferForTesting(5, 4)
/*01234
|-----
0|xxxxx
1|
2|
3|
|-----
*/
writeRaw(b, 'x')
require.Equal(t, uint16(1), b.CursorColumn())
require.Equal(t, uint16(0), b.CursorLine())
writeRaw(b, 'x')
require.Equal(t, uint16(2), b.CursorColumn())
require.Equal(t, uint16(0), b.CursorLine())
writeRaw(b, 'x')
require.Equal(t, uint16(3), b.CursorColumn())
require.Equal(t, uint16(0), b.CursorLine())
writeRaw(b, 'x')
require.Equal(t, uint16(4), b.CursorColumn())
require.Equal(t, uint16(0), b.CursorLine())
writeRaw(b, 'x')
require.Equal(t, uint16(5), b.CursorColumn())
require.Equal(t, uint16(0), b.CursorLine())
writeRaw(b, 'x')
require.Equal(t, uint16(1), b.CursorColumn())
require.Equal(t, uint16(1), b.CursorLine())
writeRaw(b, 'x')
require.Equal(t, uint16(2), b.CursorColumn())
require.Equal(t, uint16(1), b.CursorLine())
lines := b.GetVisibleLines()
require.Equal(t, 2, len(lines))
assert.Equal(t, "xxxxx", lines[0].String())
assert.Equal(t, "xx", lines[1].String())
}
func TestWritingNewLineAsFirstRuneOnWrappedLine(t *testing.T) {
b := makeBufferForTesting(3, 20)
b.modes.LineFeedMode = false
writeRaw(b, 'a', 'b', 'c')
assert.Equal(t, uint16(3), b.cursorPosition.Col)
assert.Equal(t, uint64(0), b.cursorPosition.Line)
b.newLine()
assert.Equal(t, uint16(0), b.cursorPosition.Col)
assert.Equal(t, uint64(1), b.cursorPosition.Line)
writeRaw(b, 'd', 'e', 'f')
assert.Equal(t, uint16(3), b.cursorPosition.Col)
assert.Equal(t, uint64(1), b.cursorPosition.Line)
b.newLine()
assert.Equal(t, uint16(0), b.cursorPosition.Col)
assert.Equal(t, uint64(2), b.cursorPosition.Line)
require.Equal(t, 3, len(b.lines))
assert.Equal(t, "abc", b.lines[0].String())
assert.Equal(t, "def", b.lines[1].String())
}
func TestWritingNewLineAsSecondRuneOnWrappedLine(t *testing.T) {
b := makeBufferForTesting(3, 20)
b.modes.LineFeedMode = false
/*
|abc
|d
|ef
|
|
|z
*/
writeRaw(b, 'a', 'b', 'c', 'd')
b.newLine()
writeRaw(b, 'e', 'f')
b.newLine()
b.newLine()
b.newLine()
writeRaw(b, 'z')
assert.Equal(t, "abc", b.lines[0].String())
assert.Equal(t, "d", b.lines[1].String())
assert.Equal(t, "ef", b.lines[2].String())
assert.Equal(t, "", b.lines[3].String())
assert.Equal(t, "", b.lines[4].String())
assert.Equal(t, "z", b.lines[5].String())
}
func TestSetPosition(t *testing.T) {
b := makeBufferForTesting(120, 80)
assert.Equal(t, 0, int(b.CursorColumn()))
assert.Equal(t, 0, int(b.CursorLine()))
b.setPosition(60, 10)
assert.Equal(t, 60, int(b.CursorColumn()))
assert.Equal(t, 10, int(b.CursorLine()))
b.setPosition(0, 0)
assert.Equal(t, 0, int(b.CursorColumn()))
assert.Equal(t, 0, int(b.CursorLine()))
b.setPosition(120, 90)
assert.Equal(t, 119, int(b.CursorColumn()))
assert.Equal(t, 79, int(b.CursorLine()))
}
func TestMovePosition(t *testing.T) {
b := makeBufferForTesting(120, 80)
assert.Equal(t, 0, int(b.CursorColumn()))
assert.Equal(t, 0, int(b.CursorLine()))
b.movePosition(-1, -1)
assert.Equal(t, 0, int(b.CursorColumn()))
assert.Equal(t, 0, int(b.CursorLine()))
b.movePosition(30, 20)
assert.Equal(t, 30, int(b.CursorColumn()))
assert.Equal(t, 20, int(b.CursorLine()))
b.movePosition(30, 20)
assert.Equal(t, 60, int(b.CursorColumn()))
assert.Equal(t, 40, int(b.CursorLine()))
b.movePosition(-1, -1)
assert.Equal(t, 59, int(b.CursorColumn()))
assert.Equal(t, 39, int(b.CursorLine()))
b.movePosition(100, 100)
assert.Equal(t, 119, int(b.CursorColumn()))
assert.Equal(t, 79, int(b.CursorLine()))
}
func TestVisibleLines(t *testing.T) {
b := makeBufferForTesting(80, 10)
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 2")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 3")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 4")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 5")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 6")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 7")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 8")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 9")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 10")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 11")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 12")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 13")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 14")...)
lines := b.GetVisibleLines()
require.Equal(t, 10, len(lines))
assert.Equal(t, "hello 5", lines[0].String())
assert.Equal(t, "hello 14", lines[9].String())
}
func TestClearWithoutFullView(t *testing.T) {
b := makeBufferForTesting(80, 10)
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.clear()
lines := b.GetVisibleLines()
for _, line := range lines {
assert.Equal(t, "", line.String())
}
}
func TestClearWithFullView(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("hello 1")...)
b.clear()
lines := b.GetVisibleLines()
for _, line := range lines {
assert.Equal(t, "", line.String())
}
}
func TestCarriageReturn(t *testing.T) {
b := makeBufferForTesting(80, 20)
writeRaw(b, []rune("hello!")...)
b.carriageReturn()
writeRaw(b, []rune("secret")...)
lines := b.GetVisibleLines()
assert.Equal(t, "secret", lines[0].String())
}
func TestCarriageReturnOnFullLine(t *testing.T) {
b := makeBufferForTesting(20, 20)
writeRaw(b, []rune("abcdeabcdeabcdeabcde")...)
b.carriageReturn()
writeRaw(b, []rune("xxxxxxxxxxxxxxxxxxxx")...)
lines := b.GetVisibleLines()
assert.Equal(t, "xxxxxxxxxxxxxxxxxxxx", lines[0].String())
}
func TestCarriageReturnOnFullLastLine(t *testing.T) {
b := makeBufferForTesting(20, 2)
b.newLine()
writeRaw(b, []rune("abcdeabcdeabcdeabcde")...)
b.carriageReturn()
writeRaw(b, []rune("xxxxxxxxxxxxxxxxxxxx")...)
lines := b.GetVisibleLines()
assert.Equal(t, "", lines[0].String())
assert.Equal(t, "xxxxxxxxxxxxxxxxxxxx", lines[1].String())
}
func TestCarriageReturnOnWrappedLine(t *testing.T) {
b := makeBufferForTesting(80, 6)
writeRaw(b, []rune("hello!")...)
b.carriageReturn()
writeRaw(b, []rune("secret")...)
lines := b.GetVisibleLines()
assert.Equal(t, "secret", lines[0].String())
}
func TestCarriageReturnOnLineThatDoesntExist(t *testing.T) {
b := makeBufferForTesting(6, 10)
b.cursorPosition.Line = 3
b.carriageReturn()
assert.Equal(t, uint16(0), b.cursorPosition.Col)
assert.Equal(t, uint64(3), b.cursorPosition.Line)
}
func TestGetCell(t *testing.T) {
b := makeBufferForTesting(80, 20)
writeRaw(b, []rune("Hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("there")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("something...")...)
cell := b.GetCell(8, 2)
require.NotNil(t, cell)
assert.Equal(t, 'g', cell.Rune().Rune)
}
func TestGetCellWithHistory(t *testing.T) {
b := makeBufferForTesting(80, 2)
writeRaw(b, []rune("Hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("there")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("something...")...)
cell := b.GetCell(8, 1)
require.NotNil(t, cell)
assert.Equal(t, 'g', cell.Rune().Rune)
}
func TestGetCellWithBadCursor(t *testing.T) {
b := makeBufferForTesting(80, 2)
writeRaw(b, []rune("Hello\r\nthere\r\nsomething...")...)
require.Nil(t, b.GetCell(8, 3))
require.Nil(t, b.GetCell(90, 0))
}
func TestCursorPositionQuerying(t *testing.T) {
b := makeBufferForTesting(80, 20)
b.cursorPosition.Col = 17
b.cursorPosition.Line = 9
assert.Equal(t, b.cursorPosition.Col, b.CursorColumn())
assert.Equal(t, b.convertRawLineToViewLine(b.cursorPosition.Line), b.CursorLine())
}
// CSI 2 K
func TestEraseLine(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello, this is a test")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("this line should be deleted")...)
b.eraseLine()
assert.Equal(t, "hello, this is a test", b.lines[0].String())
assert.Equal(t, "", b.lines[1].String())
}
// CSI 1 K
func TestEraseLineToCursor(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello, this is a test")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("deleted")...)
b.movePosition(-3, 0)
b.eraseLineToCursor()
assert.Equal(t, "hello, this is a test", b.lines[0].String())
assert.Equal(t, "\x00\x00\x00\x00\x00ed", b.lines[1].String())
}
// CSI 0 K
func TestEraseLineAfterCursor(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello, this is a test")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("deleted")...)
b.movePosition(-3, 0)
b.eraseLineFromCursor()
assert.Equal(t, "hello, this is a test", b.lines[0].String())
assert.Equal(t, "dele", b.lines[1].String())
}
func TestEraseDisplay(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("asdasd")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("thing")...)
b.movePosition(2, 1)
b.eraseDisplay()
lines := b.GetVisibleLines()
for _, line := range lines {
assert.Equal(t, "", line.String())
}
}
func TestEraseDisplayToCursor(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("asdasd")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("thing")...)
b.movePosition(-2, 0)
b.eraseDisplayToCursor()
lines := b.GetVisibleLines()
assert.Equal(t, "", lines[0].String())
assert.Equal(t, "", lines[1].String())
assert.Equal(t, "\x00\x00\x00\x00g", lines[2].String())
}
func TestEraseDisplayFromCursor(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("asdasd")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("things")...)
b.movePosition(-3, -1)
b.eraseDisplayFromCursor()
lines := b.GetVisibleLines()
assert.Equal(t, "hello", lines[0].String())
assert.Equal(t, "asd", lines[1].String())
assert.Equal(t, "", lines[2].String())
}
func TestBackspace(t *testing.T) {
b := makeBufferForTesting(80, 5)
writeRaw(b, []rune("hello")...)
b.backspace()
b.backspace()
writeRaw(b, []rune("p")...)
lines := b.GetVisibleLines()
assert.Equal(t, "helpo", lines[0].String())
}
func TestHorizontalResizeView(t *testing.T) {
b := makeBufferForTesting(80, 10)
// 60 characters
writeRaw(b, []rune(`hellohellohellohellohellohellohellohellohellohellohellohello`)...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune(`goodbyegoodbye`)...)
require.Equal(t, uint16(14), b.cursorPosition.Col)
require.Equal(t, uint64(1), b.cursorPosition.Line)
b.resizeView(40, 10)
expected := `hellohellohellohellohellohellohellohello
hellohellohellohello
goodbyegoodbye`
require.Equal(t, uint16(14), b.cursorPosition.Col)
require.Equal(t, uint64(2), b.cursorPosition.Line)
lines := b.GetVisibleLines()
strs := []string{}
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, expected, strings.Join(strs, "\n"))
b.resizeView(20, 10)
expected = `hellohellohellohello
hellohellohellohello
hellohellohellohello
goodbyegoodbye`
lines = b.GetVisibleLines()
strs = []string{}
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, expected, strings.Join(strs, "\n"))
b.resizeView(10, 10)
expected = `hellohello
hellohello
hellohello
hellohello
hellohello
hellohello
goodbyegoo
dbye`
lines = b.GetVisibleLines()
strs = []string{}
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, expected, strings.Join(strs, "\n"))
b.resizeView(80, 20)
expected = `hellohellohellohellohellohellohellohellohellohellohellohello
goodbyegoodbye`
lines = b.GetVisibleLines()
strs = []string{}
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, expected, strings.Join(strs, "\n"))
require.Equal(t, uint16(4), b.cursorPosition.Col)
require.Equal(t, uint64(1), b.cursorPosition.Line)
}
func TestBufferMaxLines(t *testing.T) {
b := NewBuffer(80, 2, 2, color.White, color.Black)
b.modes.LineFeedMode = false
writeRaw(b, []rune("hello")...)
b.newLine()
writeRaw(b, []rune("funny")...)
b.newLine()
writeRaw(b, []rune("world")...)
assert.Equal(t, 2, len(b.lines))
assert.Equal(t, "funny", b.lines[0].String())
assert.Equal(t, "world", b.lines[1].String())
}
func TestShrinkingThenGrowing(t *testing.T) {
b := makeBufferForTesting(30, 100)
writeRaw(b, []rune("hellohellohellohellohello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("01234567890123456789")...)
b.carriageReturn()
b.newLine()
b.resizeView(25, 100)
b.resizeView(24, 100)
b.resizeView(30, 100)
expected := `hellohellohellohellohello
01234567890123456789
`
lines := b.GetVisibleLines()
var strs []string
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, expected, strings.Join(strs, "\n"))
}
func TestShrinkingThenRestoring(t *testing.T) {
b := makeBufferForTesting(30, 100)
writeRaw(b, []rune("hellohellohellohellohello")...)
b.carriageReturn()
b.newLine()
writeRaw(b, []rune("01234567890123456789")...)
b.carriageReturn()
b.newLine()
b.cursorPosition.Line = 2
for i := uint16(29); i > 5; i-- {
b.resizeView(i, 100)
}
for i := uint16(15); i < 30; i++ {
b.resizeView(i, 100)
}
expected := `hellohellohellohellohello
01234567890123456789
`
lines := b.GetVisibleLines()
var strs []string
for _, l := range lines {
strs = append(strs, l.String())
}
require.Equal(t, expected, strings.Join(strs, "\n"))
}
func makeBufferForTesting(cols, rows uint16) *Buffer {
return NewBuffer(cols, rows, 100, color.White, color.Black)
}
Reference in New Issue View Git Blame Copy Permalink