689 lines
16 KiB
Go
689 lines
16 KiB
Go
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)
|
|
}
|