eiac/xterm.js
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
a9eb1de4b4e0037993f3a4d4ffe1c4fbc4c08885
xterm.js/src/common/InputHandler.test.ts
T

1808 lines
86 KiB
TypeScript
Raw Blame History

/**
* Copyright (c) 2017 The xterm.js authors. All rights reserved.
* @license MIT
*/
import { assert } from 'chai';
import { InputHandler } from 'common/InputHandler';
import { IBufferLine, IAttributeData, IAnsiColorChangeEvent } from 'common/Types';
import { DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine';
import { CellData } from 'common/buffer/CellData';
import { Attributes, UnderlineStyle } from 'common/buffer/Constants';
import { AttributeData } from 'common/buffer/AttributeData';
import { Params } from 'common/parser/Params';
import { MockCoreService, MockBufferService, MockDirtyRowService, MockOptionsService, MockLogService, MockCoreMouseService, MockCharsetService, MockUnicodeService } from 'common/TestUtils.test';
import { IBufferService, ICoreService } from 'common/services/Services';
import { DEFAULT_OPTIONS } from 'common/services/OptionsService';
import { clone } from 'common/Clone';
import { BufferService } from 'common/services/BufferService';
import { CoreService } from 'common/services/CoreService';
function getCursor(bufferService: IBufferService): number[] {
return [
bufferService.buffer.x,
bufferService.buffer.y
];
}
function getLines(bufferService: IBufferService, limit: number = bufferService.rows): string[] {
const res: string[] = [];
for (let i = 0; i < limit; ++i) {
const line = bufferService.buffer.lines.get(i);
if (line) {
res.push(line.translateToString(true));
}
}
return res;
}
class TestInputHandler extends InputHandler {
public get curAttrData(): IAttributeData { return (this as any)._curAttrData; }
public get windowTitleStack(): string[] { return this._windowTitleStack; }
public get iconNameStack(): string[] { return this._iconNameStack; }
public parseAnsiColorChange(data: string): IAnsiColorChangeEvent | null { return this._parseAnsiColorChange(data); }
/**
* Promise based parse call to await the full resolve of given input data.
* This is useful to test async handlers in inputhandler directly.
*/
public async parseP(data: string | Uint8Array): Promise<void> {
let result: Promise<boolean> | void;
let prev: boolean | undefined;
while (result = this.parse(data, prev)) {
prev = await result;
}
}
}
describe('InputHandler', () => {
let bufferService: IBufferService;
let coreService: ICoreService;
let optionsService: MockOptionsService;
let inputHandler: TestInputHandler;
beforeEach(() => {
optionsService = new MockOptionsService();
bufferService = new BufferService(optionsService);
bufferService.resize(80, 30);
coreService = new CoreService(() => {}, bufferService, new MockLogService(), optionsService);
inputHandler = new TestInputHandler(bufferService, new MockCharsetService(), coreService, new MockDirtyRowService(), new MockLogService(), optionsService, new MockCoreMouseService(), new MockUnicodeService());
});
it('save and restore cursor', () => {
bufferService.buffer.x = 1;
bufferService.buffer.y = 2;
bufferService.buffer.ybase = 0;
inputHandler.curAttrData.fg = 3;
// Save cursor position
inputHandler.saveCursor();
assert.equal(bufferService.buffer.x, 1);
assert.equal(bufferService.buffer.y, 2);
assert.equal(inputHandler.curAttrData.fg, 3);
// Change cursor position
bufferService.buffer.x = 10;
bufferService.buffer.y = 20;
inputHandler.curAttrData.fg = 30;
// Restore cursor position
inputHandler.restoreCursor();
assert.equal(bufferService.buffer.x, 1);
assert.equal(bufferService.buffer.y, 2);
assert.equal(inputHandler.curAttrData.fg, 3);
});
describe('setCursorStyle', () => {
it('should call Terminal.setOption with correct params', () => {
inputHandler.setCursorStyle(Params.fromArray([0]));
assert.equal(optionsService.options['cursorStyle'], 'block');
assert.equal(optionsService.options['cursorBlink'], true);
optionsService.options = clone(DEFAULT_OPTIONS);
inputHandler.setCursorStyle(Params.fromArray([1]));
assert.equal(optionsService.options['cursorStyle'], 'block');
assert.equal(optionsService.options['cursorBlink'], true);
optionsService.options = clone(DEFAULT_OPTIONS);
inputHandler.setCursorStyle(Params.fromArray([2]));
assert.equal(optionsService.options['cursorStyle'], 'block');
assert.equal(optionsService.options['cursorBlink'], false);
optionsService.options = clone(DEFAULT_OPTIONS);
inputHandler.setCursorStyle(Params.fromArray([3]));
assert.equal(optionsService.options['cursorStyle'], 'underline');
assert.equal(optionsService.options['cursorBlink'], true);
optionsService.options = clone(DEFAULT_OPTIONS);
inputHandler.setCursorStyle(Params.fromArray([4]));
assert.equal(optionsService.options['cursorStyle'], 'underline');
assert.equal(optionsService.options['cursorBlink'], false);
optionsService.options = clone(DEFAULT_OPTIONS);
inputHandler.setCursorStyle(Params.fromArray([5]));
assert.equal(optionsService.options['cursorStyle'], 'bar');
assert.equal(optionsService.options['cursorBlink'], true);
optionsService.options = clone(DEFAULT_OPTIONS);
inputHandler.setCursorStyle(Params.fromArray([6]));
assert.equal(optionsService.options['cursorStyle'], 'bar');
assert.equal(optionsService.options['cursorBlink'], false);
});
});
describe('setMode', () => {
it('should toggle bracketedPasteMode', () => {
const coreService = new MockCoreService();
const inputHandler = new TestInputHandler(new MockBufferService(80, 30), new MockCharsetService(), coreService, new MockDirtyRowService(), new MockLogService(), new MockOptionsService(), new MockCoreMouseService(), new MockUnicodeService());
// Set bracketed paste mode
inputHandler.setModePrivate(Params.fromArray([2004]));
assert.equal(coreService.decPrivateModes.bracketedPasteMode, true);
// Reset bracketed paste mode
inputHandler.resetModePrivate(Params.fromArray([2004]));
assert.equal(coreService.decPrivateModes.bracketedPasteMode, false);
});
});
describe('regression tests', function(): void {
function termContent(bufferService: IBufferService, trim: boolean): string[] {
const result = [];
for (let i = 0; i < bufferService.rows; ++i) result.push(bufferService.buffer.lines.get(i)!.translateToString(trim));
return result;
}
it('insertChars', async () => {
const bufferService = new MockBufferService(80, 30);
const inputHandler = new TestInputHandler(
bufferService,
new MockCharsetService(),
new MockCoreService(),
new MockDirtyRowService(),
new MockLogService(),
new MockOptionsService(),
new MockCoreMouseService(),
new MockUnicodeService()
);
// insert some data in first and second line
await inputHandler.parseP(Array(bufferService.cols - 9).join('a'));
await inputHandler.parseP('1234567890');
await inputHandler.parseP(Array(bufferService.cols - 9).join('a'));
await inputHandler.parseP('1234567890');
const line1: IBufferLine = bufferService.buffer.lines.get(0)!;
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + '1234567890');
// insert one char from params = [0]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.insertChars(Params.fromArray([0]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + ' 123456789');
// insert one char from params = [1]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.insertChars(Params.fromArray([1]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + ' 12345678');
// insert two chars from params = [2]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.insertChars(Params.fromArray([2]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + ' 123456');
// insert 10 chars from params = [10]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.insertChars(Params.fromArray([10]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + ' ');
assert.equal(line1.translateToString(true), Array(bufferService.cols - 9).join('a'));
});
it('deleteChars', async () => {
const bufferService = new MockBufferService(80, 30);
const inputHandler = new TestInputHandler(
bufferService,
new MockCharsetService(),
new MockCoreService(),
new MockDirtyRowService(),
new MockLogService(),
new MockOptionsService(),
new MockCoreMouseService(),
new MockUnicodeService()
);
// insert some data in first and second line
await inputHandler.parseP(Array(bufferService.cols - 9).join('a'));
await inputHandler.parseP('1234567890');
await inputHandler.parseP(Array(bufferService.cols - 9).join('a'));
await inputHandler.parseP('1234567890');
const line1: IBufferLine = bufferService.buffer.lines.get(0)!;
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + '1234567890');
// delete one char from params = [0]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.deleteChars(Params.fromArray([0]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + '234567890 ');
assert.equal(line1.translateToString(true), Array(bufferService.cols - 9).join('a') + '234567890');
// insert one char from params = [1]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.deleteChars(Params.fromArray([1]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + '34567890 ');
assert.equal(line1.translateToString(true), Array(bufferService.cols - 9).join('a') + '34567890');
// insert two chars from params = [2]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.deleteChars(Params.fromArray([2]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + '567890 ');
assert.equal(line1.translateToString(true), Array(bufferService.cols - 9).join('a') + '567890');
// insert 10 chars from params = [10]
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.deleteChars(Params.fromArray([10]));
assert.equal(line1.translateToString(false), Array(bufferService.cols - 9).join('a') + ' ');
assert.equal(line1.translateToString(true), Array(bufferService.cols - 9).join('a'));
});
it('eraseInLine', async () => {
const bufferService = new MockBufferService(80, 30);
const inputHandler = new TestInputHandler(
bufferService,
new MockCharsetService(),
new MockCoreService(),
new MockDirtyRowService(),
new MockLogService(),
new MockOptionsService(),
new MockCoreMouseService(),
new MockUnicodeService()
);
// fill 6 lines to test 3 different states
await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
// params[0] - right erase
bufferService.buffer.y = 0;
bufferService.buffer.x = 70;
inputHandler.eraseInLine(Params.fromArray([0]));
assert.equal(bufferService.buffer.lines.get(0)!.translateToString(false), Array(71).join('a') + ' ');
// params[1] - left erase
bufferService.buffer.y = 1;
bufferService.buffer.x = 70;
inputHandler.eraseInLine(Params.fromArray([1]));
assert.equal(bufferService.buffer.lines.get(1)!.translateToString(false), Array(71).join(' ') + ' aaaaaaaaa');
// params[1] - left erase
bufferService.buffer.y = 2;
bufferService.buffer.x = 70;
inputHandler.eraseInLine(Params.fromArray([2]));
assert.equal(bufferService.buffer.lines.get(2)!.translateToString(false), Array(bufferService.cols + 1).join(' '));
});
it('eraseInDisplay', async () => {
const bufferService = new MockBufferService(80, 7);
const inputHandler = new TestInputHandler(
bufferService,
new MockCharsetService(),
new MockCoreService(),
new MockDirtyRowService(),
new MockLogService(),
new MockOptionsService(),
new MockCoreMouseService(),
new MockUnicodeService()
);
// fill display with a's
for (let i = 0; i < bufferService.rows; ++i) await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
// params [0] - right and below erase
bufferService.buffer.y = 5;
bufferService.buffer.x = 40;
inputHandler.eraseInDisplay(Params.fromArray([0]));
assert.deepEqual(termContent(bufferService, false), [
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(40 + 1).join('a') + Array(bufferService.cols - 40 + 1).join(' '),
Array(bufferService.cols + 1).join(' ')
]);
assert.deepEqual(termContent(bufferService, true), [
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(bufferService.cols + 1).join('a'),
Array(40 + 1).join('a'),
''
]);
// reset
bufferService.buffer.y = 0;
bufferService.buffer.x = 0;
for (let i = 0; i < bufferService.rows; ++i) await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
// params [1] - left and above
bufferService.buffer.y = 5;
bufferService.buffer.x = 40;
inputHandler.eraseInDisplay(Params.fromArray([1]));
assert.deepEqual(termContent(bufferService, false), [
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(41 + 1).join(' ') + Array(bufferService.cols - 41 + 1).join('a'),
Array(bufferService.cols + 1).join('a')
]);
assert.deepEqual(termContent(bufferService, true), [
'',
'',
'',
'',
'',
Array(41 + 1).join(' ') + Array(bufferService.cols - 41 + 1).join('a'),
Array(bufferService.cols + 1).join('a')
]);
// reset
bufferService.buffer.y = 0;
bufferService.buffer.x = 0;
for (let i = 0; i < bufferService.rows; ++i) await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
// params [2] - whole screen
bufferService.buffer.y = 5;
bufferService.buffer.x = 40;
inputHandler.eraseInDisplay(Params.fromArray([2]));
assert.deepEqual(termContent(bufferService, false), [
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' '),
Array(bufferService.cols + 1).join(' ')
]);
assert.deepEqual(termContent(bufferService, true), [
'',
'',
'',
'',
'',
'',
''
]);
// reset and add a wrapped line
bufferService.buffer.y = 0;
bufferService.buffer.x = 0;
await inputHandler.parseP(Array(bufferService.cols + 1).join('a')); // line 0
await inputHandler.parseP(Array(bufferService.cols + 10).join('a')); // line 1 and 2
for (let i = 3; i < bufferService.rows; ++i) await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
// params[1] left and above with wrap
// confirm precondition that line 2 is wrapped
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
bufferService.buffer.y = 2;
bufferService.buffer.x = 40;
inputHandler.eraseInDisplay(Params.fromArray([1]));
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
// reset and add a wrapped line
bufferService.buffer.y = 0;
bufferService.buffer.x = 0;
await inputHandler.parseP(Array(bufferService.cols + 1).join('a')); // line 0
await inputHandler.parseP(Array(bufferService.cols + 10).join('a')); // line 1 and 2
for (let i = 3; i < bufferService.rows; ++i) await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
// params[1] left and above with wrap
// confirm precondition that line 2 is wrapped
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
bufferService.buffer.y = 1;
bufferService.buffer.x = 90; // Cursor is beyond last column
inputHandler.eraseInDisplay(Params.fromArray([1]));
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
});
});
describe('print', () => {
it('should not cause an infinite loop (regression test)', () => {
const inputHandler = new TestInputHandler(
new MockBufferService(80, 30),
new MockCharsetService(),
new MockCoreService(),
new MockDirtyRowService(),
new MockLogService(),
new MockOptionsService(),
new MockCoreMouseService(),
new MockUnicodeService()
);
const container = new Uint32Array(10);
container[0] = 0x200B;
inputHandler.print(container, 0, 1);
});
it('should clear cells to the right on early wrap-around', async () => {
bufferService.resize(5, 5);
optionsService.options.scrollback = 1;
await inputHandler.parseP('12345');
bufferService.buffer.x = 0;
await inputHandler.parseP('￥￥￥');
assert.deepEqual(getLines(bufferService, 2), ['￥￥', '￥']);
});
});
describe('alt screen', () => {
let bufferService: IBufferService;
let handler: TestInputHandler;
beforeEach(() => {
bufferService = new MockBufferService(80, 30);
handler = new TestInputHandler(bufferService, new MockCharsetService(), new MockCoreService(), new MockDirtyRowService(), new MockLogService(), new MockOptionsService(), new MockCoreMouseService(), new MockUnicodeService());
});
it('should handle DECSET/DECRST 47 (alt screen buffer)', async () => {
await handler.parseP('\x1b[?47h\r\n\x1b[31mJUNK\x1b[?47lTEST');
assert.equal(bufferService.buffer.translateBufferLineToString(0, true), '');
assert.equal(bufferService.buffer.translateBufferLineToString(1, true), ' TEST');
// Text color of 'TEST' should be red
assert.equal((bufferService.buffer.lines.get(1)!.loadCell(4, new CellData()).getFgColor()), 1);
});
it('should handle DECSET/DECRST 1047 (alt screen buffer)', async () => {
await handler.parseP('\x1b[?1047h\r\n\x1b[31mJUNK\x1b[?1047lTEST');
assert.equal(bufferService.buffer.translateBufferLineToString(0, true), '');
assert.equal(bufferService.buffer.translateBufferLineToString(1, true), ' TEST');
// Text color of 'TEST' should be red
assert.equal((bufferService.buffer.lines.get(1)!.loadCell(4, new CellData()).getFgColor()), 1);
});
it('should handle DECSET/DECRST 1048 (alt screen cursor)', async () => {
await handler.parseP('\x1b[?1048h\r\n\x1b[31mJUNK\x1b[?1048lTEST');
assert.equal(bufferService.buffer.translateBufferLineToString(0, true), 'TEST');
assert.equal(bufferService.buffer.translateBufferLineToString(1, true), 'JUNK');
// Text color of 'TEST' should be default
assert.equal(bufferService.buffer.lines.get(0)!.loadCell(0, new CellData()).fg, DEFAULT_ATTR_DATA.fg);
// Text color of 'JUNK' should be red
assert.equal((bufferService.buffer.lines.get(1)!.loadCell(0, new CellData()).getFgColor()), 1);
});
it('should handle DECSET/DECRST 1049 (alt screen buffer+cursor)', async () => {
await handler.parseP('\x1b[?1049h\r\n\x1b[31mJUNK\x1b[?1049lTEST');
assert.equal(bufferService.buffer.translateBufferLineToString(0, true), 'TEST');
assert.equal(bufferService.buffer.translateBufferLineToString(1, true), '');
// Text color of 'TEST' should be default
assert.equal(bufferService.buffer.lines.get(0)!.loadCell(0, new CellData()).fg, DEFAULT_ATTR_DATA.fg);
});
it('should handle DECSET/DECRST 1049 - maintains saved cursor for alt buffer', async () => {
await handler.parseP('\x1b[?1049h\r\n\x1b[31m\x1b[s\x1b[?1049lTEST');
assert.equal(bufferService.buffer.translateBufferLineToString(0, true), 'TEST');
// Text color of 'TEST' should be default
assert.equal(bufferService.buffer.lines.get(0)!.loadCell(0, new CellData()).fg, DEFAULT_ATTR_DATA.fg);
await handler.parseP('\x1b[?1049h\x1b[uTEST');
assert.equal(bufferService.buffer.translateBufferLineToString(1, true), 'TEST');
// Text color of 'TEST' should be red
assert.equal((bufferService.buffer.lines.get(1)!.loadCell(0, new CellData()).getFgColor()), 1);
});
it('should handle DECSET/DECRST 1049 - clears alt buffer with erase attributes', async () => {
await handler.parseP('\x1b[42m\x1b[?1049h');
// Buffer should be filled with green background
assert.equal(bufferService.buffer.lines.get(20)!.loadCell(10, new CellData()).getBgColor(), 2);
});
});
describe('text attributes', () => {
it('bold', async () => {
await inputHandler.parseP('\x1b[1m');
assert.equal(!!inputHandler.curAttrData.isBold(), true);
await inputHandler.parseP('\x1b[22m');
assert.equal(!!inputHandler.curAttrData.isBold(), false);
});
it('dim', async () => {
await inputHandler.parseP('\x1b[2m');
assert.equal(!!inputHandler.curAttrData.isDim(), true);
await inputHandler.parseP('\x1b[22m');
assert.equal(!!inputHandler.curAttrData.isDim(), false);
});
it('italic', async () => {
await inputHandler.parseP('\x1b[3m');
assert.equal(!!inputHandler.curAttrData.isItalic(), true);
await inputHandler.parseP('\x1b[23m');
assert.equal(!!inputHandler.curAttrData.isItalic(), false);
});
it('underline', async () => {
await inputHandler.parseP('\x1b[4m');
assert.equal(!!inputHandler.curAttrData.isUnderline(), true);
await inputHandler.parseP('\x1b[24m');
assert.equal(!!inputHandler.curAttrData.isUnderline(), false);
});
it('blink', async () => {
await inputHandler.parseP('\x1b[5m');
assert.equal(!!inputHandler.curAttrData.isBlink(), true);
await inputHandler.parseP('\x1b[25m');
assert.equal(!!inputHandler.curAttrData.isBlink(), false);
});
it('inverse', async () => {
await inputHandler.parseP('\x1b[7m');
assert.equal(!!inputHandler.curAttrData.isInverse(), true);
await inputHandler.parseP('\x1b[27m');
assert.equal(!!inputHandler.curAttrData.isInverse(), false);
});
it('invisible', async () => {
await inputHandler.parseP('\x1b[8m');
assert.equal(!!inputHandler.curAttrData.isInvisible(), true);
await inputHandler.parseP('\x1b[28m');
assert.equal(!!inputHandler.curAttrData.isInvisible(), false);
});
it('colormode palette 16', async () => {
assert.equal(inputHandler.curAttrData.getFgColorMode(), 0); // DEFAULT
assert.equal(inputHandler.curAttrData.getBgColorMode(), 0); // DEFAULT
// lower 8 colors
for (let i = 0; i < 8; ++i) {
await inputHandler.parseP(`\x1b[${i + 30};${i + 40}m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), Attributes.CM_P16);
assert.equal(inputHandler.curAttrData.getFgColor(), i);
assert.equal(inputHandler.curAttrData.getBgColorMode(), Attributes.CM_P16);
assert.equal(inputHandler.curAttrData.getBgColor(), i);
}
// reset to DEFAULT
await inputHandler.parseP(`\x1b[39;49m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), 0);
assert.equal(inputHandler.curAttrData.getBgColorMode(), 0);
});
it('colormode palette 256', async () => {
assert.equal(inputHandler.curAttrData.getFgColorMode(), 0); // DEFAULT
assert.equal(inputHandler.curAttrData.getBgColorMode(), 0); // DEFAULT
// lower 8 colors
for (let i = 0; i < 256; ++i) {
await inputHandler.parseP(`\x1b[38;5;${i};48;5;${i}m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.getFgColor(), i);
assert.equal(inputHandler.curAttrData.getBgColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.getBgColor(), i);
}
// reset to DEFAULT
await inputHandler.parseP(`\x1b[39;49m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), 0);
assert.equal(inputHandler.curAttrData.getFgColor(), -1);
assert.equal(inputHandler.curAttrData.getBgColorMode(), 0);
assert.equal(inputHandler.curAttrData.getBgColor(), -1);
});
it('colormode RGB', async () => {
assert.equal(inputHandler.curAttrData.getFgColorMode(), 0); // DEFAULT
assert.equal(inputHandler.curAttrData.getBgColorMode(), 0); // DEFAULT
await inputHandler.parseP(`\x1b[38;2;1;2;3;48;2;4;5;6m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), Attributes.CM_RGB);
assert.equal(inputHandler.curAttrData.getFgColor(), 1 << 16 | 2 << 8 | 3);
assert.deepEqual(AttributeData.toColorRGB(inputHandler.curAttrData.getFgColor()), [1, 2, 3]);
assert.equal(inputHandler.curAttrData.getBgColorMode(), Attributes.CM_RGB);
assert.deepEqual(AttributeData.toColorRGB(inputHandler.curAttrData.getBgColor()), [4, 5, 6]);
// reset to DEFAULT
await inputHandler.parseP(`\x1b[39;49m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), 0);
assert.equal(inputHandler.curAttrData.getFgColor(), -1);
assert.equal(inputHandler.curAttrData.getBgColorMode(), 0);
assert.equal(inputHandler.curAttrData.getBgColor(), -1);
});
it('colormode transition RGB to 256', async () => {
// enter RGB for FG and BG
await inputHandler.parseP(`\x1b[38;2;1;2;3;48;2;4;5;6m`);
// enter 256 for FG and BG
await inputHandler.parseP(`\x1b[38;5;255;48;5;255m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.getFgColor(), 255);
assert.equal(inputHandler.curAttrData.getBgColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.getBgColor(), 255);
});
it('colormode transition RGB to 16', async () => {
// enter RGB for FG and BG
await inputHandler.parseP(`\x1b[38;2;1;2;3;48;2;4;5;6m`);
// enter 16 for FG and BG
await inputHandler.parseP(`\x1b[37;47m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), Attributes.CM_P16);
assert.equal(inputHandler.curAttrData.getFgColor(), 7);
assert.equal(inputHandler.curAttrData.getBgColorMode(), Attributes.CM_P16);
assert.equal(inputHandler.curAttrData.getBgColor(), 7);
});
it('colormode transition 16 to 256', async () => {
// enter 16 for FG and BG
await inputHandler.parseP(`\x1b[37;47m`);
// enter 256 for FG and BG
await inputHandler.parseP(`\x1b[38;5;255;48;5;255m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.getFgColor(), 255);
assert.equal(inputHandler.curAttrData.getBgColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.getBgColor(), 255);
});
it('colormode transition 256 to 16', async () => {
// enter 256 for FG and BG
await inputHandler.parseP(`\x1b[38;5;255;48;5;255m`);
// enter 16 for FG and BG
await inputHandler.parseP(`\x1b[37;47m`);
assert.equal(inputHandler.curAttrData.getFgColorMode(), Attributes.CM_P16);
assert.equal(inputHandler.curAttrData.getFgColor(), 7);
assert.equal(inputHandler.curAttrData.getBgColorMode(), Attributes.CM_P16);
assert.equal(inputHandler.curAttrData.getBgColor(), 7);
});
it('should zero missing RGB values', async () => {
await inputHandler.parseP(`\x1b[38;2;1;2;3m`);
await inputHandler.parseP(`\x1b[38;2;5m`);
assert.deepEqual(AttributeData.toColorRGB(inputHandler.curAttrData.getFgColor()), [5, 0, 0]);
});
});
describe('colon notation', () => {
let inputHandler2: TestInputHandler;
beforeEach(() => {
inputHandler2 = new TestInputHandler(bufferService, new MockCharsetService(), coreService, new MockDirtyRowService(), new MockLogService(), optionsService, new MockCoreMouseService(), new MockUnicodeService());
});
describe('should equal to semicolon', () => {
it('CSI 38:2::50:100:150 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2;50;100;150m');
await inputHandler.parseP('\x1b[38:2::50:100:150m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 150);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38:2::50:100: m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2;50;100;m');
await inputHandler.parseP('\x1b[38:2::50:100:m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38:2::50:: m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2;50;;m');
await inputHandler.parseP('\x1b[38:2::50::m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 0 << 8 | 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38:2:::: m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2;;;m');
await inputHandler.parseP('\x1b[38:2::::m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 0 << 16 | 0 << 8 | 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38;2::50:100:150 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2;50;100;150m');
await inputHandler.parseP('\x1b[38;2::50:100:150m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 150);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38;2;50:100:150 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2;50;100;150m');
await inputHandler.parseP('\x1b[38;2;50:100:150m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 150);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38;2;50;100:150 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2;50;100;150m');
await inputHandler.parseP('\x1b[38;2;50;100:150m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 150);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38:5:50 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;5;50m');
await inputHandler.parseP('\x1b[38:5:50m');
assert.equal(inputHandler2.curAttrData.fg & 0xFF, 50);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38:5: m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;5;m');
await inputHandler.parseP('\x1b[38:5:m');
assert.equal(inputHandler2.curAttrData.fg & 0xFF, 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38;5:50 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;5;50m');
await inputHandler.parseP('\x1b[38;5:50m');
assert.equal(inputHandler2.curAttrData.fg & 0xFF, 50);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
});
describe('should fill early sequence end with default of 0', () => {
it('CSI 38:2 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;2m');
await inputHandler.parseP('\x1b[38:2m');
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 0 << 16 | 0 << 8 | 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 38:5 m', async () => {
inputHandler.curAttrData.fg = 0xFFFFFFFF;
inputHandler2.curAttrData.fg = 0xFFFFFFFF;
await inputHandler2.parseP('\x1b[38;5m');
await inputHandler.parseP('\x1b[38:5m');
assert.equal(inputHandler2.curAttrData.fg & 0xFF, 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
});
describe('should not interfere with leading/following SGR attrs', () => {
it('CSI 1 ; 38:2::50:100:150 ; 4 m', async () => {
await inputHandler2.parseP('\x1b[1;38;2;50;100;150;4m');
await inputHandler.parseP('\x1b[1;38:2::50:100:150;4m');
assert.equal(!!inputHandler2.curAttrData.isBold(), true);
assert.equal(!!inputHandler2.curAttrData.isUnderline(), true);
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 150);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 1 ; 38:2::50:100: ; 4 m', async () => {
await inputHandler2.parseP('\x1b[1;38;2;50;100;;4m');
await inputHandler.parseP('\x1b[1;38:2::50:100:;4m');
assert.equal(!!inputHandler2.curAttrData.isBold(), true);
assert.equal(!!inputHandler2.curAttrData.isUnderline(), true);
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 1 ; 38:2::50:100 ; 4 m', async () => {
await inputHandler2.parseP('\x1b[1;38;2;50;100;;4m');
await inputHandler.parseP('\x1b[1;38:2::50:100;4m');
assert.equal(!!inputHandler2.curAttrData.isBold(), true);
assert.equal(!!inputHandler2.curAttrData.isUnderline(), true);
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 50 << 16 | 100 << 8 | 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 1 ; 38:2:: ; 4 m', async () => {
await inputHandler2.parseP('\x1b[1;38;2;;;;4m');
await inputHandler.parseP('\x1b[1;38:2::;4m');
assert.equal(!!inputHandler2.curAttrData.isBold(), true);
assert.equal(!!inputHandler2.curAttrData.isUnderline(), true);
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
it('CSI 1 ; 38;2:: ; 4 m', async () => {
await inputHandler2.parseP('\x1b[1;38;2;;;;4m');
await inputHandler.parseP('\x1b[1;38;2::;4m');
assert.equal(!!inputHandler2.curAttrData.isBold(), true);
assert.equal(!!inputHandler2.curAttrData.isUnderline(), true);
assert.equal(inputHandler2.curAttrData.fg & 0xFFFFFF, 0);
assert.equal(inputHandler.curAttrData.fg, inputHandler2.curAttrData.fg);
});
});
});
describe('cursor positioning', () => {
beforeEach(() => {
bufferService.resize(10, 10);
});
it('cursor forward (CUF)', async () => {
await inputHandler.parseP('\x1b[C');
assert.deepEqual(getCursor(bufferService), [1, 0]);
await inputHandler.parseP('\x1b[1C');
assert.deepEqual(getCursor(bufferService), [2, 0]);
await inputHandler.parseP('\x1b[4C');
assert.deepEqual(getCursor(bufferService), [6, 0]);
await inputHandler.parseP('\x1b[100C');
assert.deepEqual(getCursor(bufferService), [9, 0]);
// should not change y
bufferService.buffer.x = 8;
bufferService.buffer.y = 4;
await inputHandler.parseP('\x1b[C');
assert.deepEqual(getCursor(bufferService), [9, 4]);
});
it('cursor backward (CUB)', async () => {
await inputHandler.parseP('\x1b[D');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[1D');
assert.deepEqual(getCursor(bufferService), [0, 0]);
// place cursor at end of first line
await inputHandler.parseP('\x1b[100C');
await inputHandler.parseP('\x1b[D');
assert.deepEqual(getCursor(bufferService), [8, 0]);
await inputHandler.parseP('\x1b[1D');
assert.deepEqual(getCursor(bufferService), [7, 0]);
await inputHandler.parseP('\x1b[4D');
assert.deepEqual(getCursor(bufferService), [3, 0]);
await inputHandler.parseP('\x1b[100D');
assert.deepEqual(getCursor(bufferService), [0, 0]);
// should not change y
bufferService.buffer.x = 4;
bufferService.buffer.y = 4;
await inputHandler.parseP('\x1b[D');
assert.deepEqual(getCursor(bufferService), [3, 4]);
});
it('cursor down (CUD)', async () => {
await inputHandler.parseP('\x1b[B');
assert.deepEqual(getCursor(bufferService), [0, 1]);
await inputHandler.parseP('\x1b[1B');
assert.deepEqual(getCursor(bufferService), [0, 2]);
await inputHandler.parseP('\x1b[4B');
assert.deepEqual(getCursor(bufferService), [0, 6]);
await inputHandler.parseP('\x1b[100B');
assert.deepEqual(getCursor(bufferService), [0, 9]);
// should not change x
bufferService.buffer.x = 8;
bufferService.buffer.y = 0;
await inputHandler.parseP('\x1b[B');
assert.deepEqual(getCursor(bufferService), [8, 1]);
});
it('cursor up (CUU)', async () => {
await inputHandler.parseP('\x1b[A');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[1A');
assert.deepEqual(getCursor(bufferService), [0, 0]);
// place cursor at beginning of last row
await inputHandler.parseP('\x1b[100B');
await inputHandler.parseP('\x1b[A');
assert.deepEqual(getCursor(bufferService), [0, 8]);
await inputHandler.parseP('\x1b[1A');
assert.deepEqual(getCursor(bufferService), [0, 7]);
await inputHandler.parseP('\x1b[4A');
assert.deepEqual(getCursor(bufferService), [0, 3]);
await inputHandler.parseP('\x1b[100A');
assert.deepEqual(getCursor(bufferService), [0, 0]);
// should not change x
bufferService.buffer.x = 8;
bufferService.buffer.y = 9;
await inputHandler.parseP('\x1b[A');
assert.deepEqual(getCursor(bufferService), [8, 8]);
});
it('cursor next line (CNL)', async () => {
await inputHandler.parseP('\x1b[E');
assert.deepEqual(getCursor(bufferService), [0, 1]);
await inputHandler.parseP('\x1b[1E');
assert.deepEqual(getCursor(bufferService), [0, 2]);
await inputHandler.parseP('\x1b[4E');
assert.deepEqual(getCursor(bufferService), [0, 6]);
await inputHandler.parseP('\x1b[100E');
assert.deepEqual(getCursor(bufferService), [0, 9]);
// should reset x to zero
bufferService.buffer.x = 8;
bufferService.buffer.y = 0;
await inputHandler.parseP('\x1b[E');
assert.deepEqual(getCursor(bufferService), [0, 1]);
});
it('cursor previous line (CPL)', async () => {
await inputHandler.parseP('\x1b[F');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[1F');
assert.deepEqual(getCursor(bufferService), [0, 0]);
// place cursor at beginning of last row
await inputHandler.parseP('\x1b[100E');
await inputHandler.parseP('\x1b[F');
assert.deepEqual(getCursor(bufferService), [0, 8]);
await inputHandler.parseP('\x1b[1F');
assert.deepEqual(getCursor(bufferService), [0, 7]);
await inputHandler.parseP('\x1b[4F');
assert.deepEqual(getCursor(bufferService), [0, 3]);
await inputHandler.parseP('\x1b[100F');
assert.deepEqual(getCursor(bufferService), [0, 0]);
// should reset x to zero
bufferService.buffer.x = 8;
bufferService.buffer.y = 9;
await inputHandler.parseP('\x1b[F');
assert.deepEqual(getCursor(bufferService), [0, 8]);
});
it('cursor character absolute (CHA)', async () => {
await inputHandler.parseP('\x1b[G');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[1G');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[2G');
assert.deepEqual(getCursor(bufferService), [1, 0]);
await inputHandler.parseP('\x1b[5G');
assert.deepEqual(getCursor(bufferService), [4, 0]);
await inputHandler.parseP('\x1b[100G');
assert.deepEqual(getCursor(bufferService), [9, 0]);
});
it('cursor position (CUP)', async () => {
bufferService.buffer.x = 5;
bufferService.buffer.y = 5;
await inputHandler.parseP('\x1b[H');
assert.deepEqual(getCursor(bufferService), [0, 0]);
bufferService.buffer.x = 5;
bufferService.buffer.y = 5;
await inputHandler.parseP('\x1b[1H');
assert.deepEqual(getCursor(bufferService), [0, 0]);
bufferService.buffer.x = 5;
bufferService.buffer.y = 5;
await inputHandler.parseP('\x1b[1;1H');
assert.deepEqual(getCursor(bufferService), [0, 0]);
bufferService.buffer.x = 5;
bufferService.buffer.y = 5;
await inputHandler.parseP('\x1b[8H');
assert.deepEqual(getCursor(bufferService), [0, 7]);
bufferService.buffer.x = 5;
bufferService.buffer.y = 5;
await inputHandler.parseP('\x1b[;8H');
assert.deepEqual(getCursor(bufferService), [7, 0]);
bufferService.buffer.x = 5;
bufferService.buffer.y = 5;
await inputHandler.parseP('\x1b[100;100H');
assert.deepEqual(getCursor(bufferService), [9, 9]);
});
it('horizontal position absolute (HPA)', async () => {
await inputHandler.parseP('\x1b[`');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[1`');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[2`');
assert.deepEqual(getCursor(bufferService), [1, 0]);
await inputHandler.parseP('\x1b[5`');
assert.deepEqual(getCursor(bufferService), [4, 0]);
await inputHandler.parseP('\x1b[100`');
assert.deepEqual(getCursor(bufferService), [9, 0]);
});
it('horizontal position relative (HPR)', async () => {
await inputHandler.parseP('\x1b[a');
assert.deepEqual(getCursor(bufferService), [1, 0]);
await inputHandler.parseP('\x1b[1a');
assert.deepEqual(getCursor(bufferService), [2, 0]);
await inputHandler.parseP('\x1b[4a');
assert.deepEqual(getCursor(bufferService), [6, 0]);
await inputHandler.parseP('\x1b[100a');
assert.deepEqual(getCursor(bufferService), [9, 0]);
// should not change y
bufferService.buffer.x = 8;
bufferService.buffer.y = 4;
await inputHandler.parseP('\x1b[a');
assert.deepEqual(getCursor(bufferService), [9, 4]);
});
it('vertical position absolute (VPA)', async () => {
await inputHandler.parseP('\x1b[d');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[1d');
assert.deepEqual(getCursor(bufferService), [0, 0]);
await inputHandler.parseP('\x1b[2d');
assert.deepEqual(getCursor(bufferService), [0, 1]);
await inputHandler.parseP('\x1b[5d');
assert.deepEqual(getCursor(bufferService), [0, 4]);
await inputHandler.parseP('\x1b[100d');
assert.deepEqual(getCursor(bufferService), [0, 9]);
// should not change x
bufferService.buffer.x = 8;
bufferService.buffer.y = 4;
await inputHandler.parseP('\x1b[d');
assert.deepEqual(getCursor(bufferService), [8, 0]);
});
it('vertical position relative (VPR)', async () => {
await inputHandler.parseP('\x1b[e');
assert.deepEqual(getCursor(bufferService), [0, 1]);
await inputHandler.parseP('\x1b[1e');
assert.deepEqual(getCursor(bufferService), [0, 2]);
await inputHandler.parseP('\x1b[4e');
assert.deepEqual(getCursor(bufferService), [0, 6]);
await inputHandler.parseP('\x1b[100e');
assert.deepEqual(getCursor(bufferService), [0, 9]);
// should not change x
bufferService.buffer.x = 8;
bufferService.buffer.y = 4;
await inputHandler.parseP('\x1b[e');
assert.deepEqual(getCursor(bufferService), [8, 5]);
});
describe('should clamp cursor into addressible range', () => {
it('CUF', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[C');
assert.deepEqual(getCursor(bufferService), [9, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[C');
assert.deepEqual(getCursor(bufferService), [1, 0]);
});
it('CUB', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[D');
assert.deepEqual(getCursor(bufferService), [8, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[D');
assert.deepEqual(getCursor(bufferService), [0, 0]);
});
it('CUD', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[B');
assert.deepEqual(getCursor(bufferService), [9, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[B');
assert.deepEqual(getCursor(bufferService), [0, 1]);
});
it('CUU', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[A');
assert.deepEqual(getCursor(bufferService), [9, 8]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[A');
assert.deepEqual(getCursor(bufferService), [0, 0]);
});
it('CNL', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[E');
assert.deepEqual(getCursor(bufferService), [0, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[E');
assert.deepEqual(getCursor(bufferService), [0, 1]);
});
it('CPL', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[F');
assert.deepEqual(getCursor(bufferService), [0, 8]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[F');
assert.deepEqual(getCursor(bufferService), [0, 0]);
});
it('CHA', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[5G');
assert.deepEqual(getCursor(bufferService), [4, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[5G');
assert.deepEqual(getCursor(bufferService), [4, 0]);
});
it('CUP', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[5;5H');
assert.deepEqual(getCursor(bufferService), [4, 4]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[5;5H');
assert.deepEqual(getCursor(bufferService), [4, 4]);
});
it('HPA', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[5`');
assert.deepEqual(getCursor(bufferService), [4, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[5`');
assert.deepEqual(getCursor(bufferService), [4, 0]);
});
it('HPR', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[a');
assert.deepEqual(getCursor(bufferService), [9, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[a');
assert.deepEqual(getCursor(bufferService), [1, 0]);
});
it('VPA', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[5d');
assert.deepEqual(getCursor(bufferService), [9, 4]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[5d');
assert.deepEqual(getCursor(bufferService), [0, 4]);
});
it('VPR', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[e');
assert.deepEqual(getCursor(bufferService), [9, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[e');
assert.deepEqual(getCursor(bufferService), [0, 1]);
});
it('DCH', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[P');
assert.deepEqual(getCursor(bufferService), [9, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[P');
assert.deepEqual(getCursor(bufferService), [0, 0]);
});
it('DCH - should delete last cell', async () => {
await inputHandler.parseP('0123456789\x1b[P');
assert.equal(bufferService.buffer.lines.get(0)!.translateToString(false), '012345678 ');
});
it('ECH', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[X');
assert.deepEqual(getCursor(bufferService), [9, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[X');
assert.deepEqual(getCursor(bufferService), [0, 0]);
});
it('ECH - should delete last cell', async () => {
await inputHandler.parseP('0123456789\x1b[X');
assert.equal(bufferService.buffer.lines.get(0)!.translateToString(false), '012345678 ');
});
it('ICH', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[@');
assert.deepEqual(getCursor(bufferService), [9, 9]);
bufferService.buffer.x = -10000;
bufferService.buffer.y = -10000;
await inputHandler.parseP('\x1b[@');
assert.deepEqual(getCursor(bufferService), [0, 0]);
});
it('ICH - should delete last cell', async () => {
await inputHandler.parseP('0123456789\x1b[@');
assert.equal(bufferService.buffer.lines.get(0)!.translateToString(false), '012345678 ');
});
});
});
describe('DECSTBM - scroll margins', () => {
beforeEach(() => {
bufferService.resize(10, 10);
});
it('should default to whole viewport', async () => {
await inputHandler.parseP('\x1b[r');
assert.equal(bufferService.buffer.scrollTop, 0);
assert.equal(bufferService.buffer.scrollBottom, 9);
await inputHandler.parseP('\x1b[3;7r');
assert.equal(bufferService.buffer.scrollTop, 2);
assert.equal(bufferService.buffer.scrollBottom, 6);
await inputHandler.parseP('\x1b[0;0r');
assert.equal(bufferService.buffer.scrollTop, 0);
assert.equal(bufferService.buffer.scrollBottom, 9);
});
it('should clamp bottom', async () => {
await inputHandler.parseP('\x1b[3;1000r');
assert.equal(bufferService.buffer.scrollTop, 2);
assert.equal(bufferService.buffer.scrollBottom, 9);
});
it('should only apply for top < bottom', async () => {
await inputHandler.parseP('\x1b[7;2r');
assert.equal(bufferService.buffer.scrollTop, 0);
assert.equal(bufferService.buffer.scrollBottom, 9);
});
it('should home cursor', async () => {
bufferService.buffer.x = 10000;
bufferService.buffer.y = 10000;
await inputHandler.parseP('\x1b[2;7r');
assert.deepEqual(getCursor(bufferService), [0, 0]);
});
});
describe('scroll margins', () => {
beforeEach(() => {
bufferService.resize(10, 10);
});
it('scrollUp', async () => {
await inputHandler.parseP('0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\x1b[2;4r\x1b[2Sm');
assert.deepEqual(getLines(bufferService), ['m', '3', '', '', '4', '5', '6', '7', '8', '9']);
});
it('scrollDown', async () => {
await inputHandler.parseP('0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\x1b[2;4r\x1b[2Tm');
assert.deepEqual(getLines(bufferService), ['m', '', '', '1', '4', '5', '6', '7', '8', '9']);
});
it('insertLines - out of margins', async () => {
await inputHandler.parseP('0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\x1b[3;6r');
assert.equal(bufferService.buffer.scrollTop, 2);
assert.equal(bufferService.buffer.scrollBottom, 5);
await inputHandler.parseP('\x1b[2Lm');
assert.deepEqual(getLines(bufferService), ['m', '1', '2', '3', '4', '5', '6', '7', '8', '9']);
await inputHandler.parseP('\x1b[2H\x1b[2Ln');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', '6', '7', '8', '9']);
// skip below scrollbottom
await inputHandler.parseP('\x1b[7H\x1b[2Lo');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', 'o', '7', '8', '9']);
await inputHandler.parseP('\x1b[8H\x1b[2Lp');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', 'o', 'p', '8', '9']);
await inputHandler.parseP('\x1b[100H\x1b[2Lq');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', 'o', 'p', '8', 'q']);
});
it('insertLines - within margins', async () => {
await inputHandler.parseP('0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\x1b[3;6r');
assert.equal(bufferService.buffer.scrollTop, 2);
assert.equal(bufferService.buffer.scrollBottom, 5);
await inputHandler.parseP('\x1b[3H\x1b[2Lm');
assert.deepEqual(getLines(bufferService), ['0', '1', 'm', '', '2', '3', '6', '7', '8', '9']);
await inputHandler.parseP('\x1b[6H\x1b[2Ln');
assert.deepEqual(getLines(bufferService), ['0', '1', 'm', '', '2', 'n', '6', '7', '8', '9']);
});
it('deleteLines - out of margins', async () => {
await inputHandler.parseP('0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\x1b[3;6r');
assert.equal(bufferService.buffer.scrollTop, 2);
assert.equal(bufferService.buffer.scrollBottom, 5);
await inputHandler.parseP('\x1b[2Mm');
assert.deepEqual(getLines(bufferService), ['m', '1', '2', '3', '4', '5', '6', '7', '8', '9']);
await inputHandler.parseP('\x1b[2H\x1b[2Mn');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', '6', '7', '8', '9']);
// skip below scrollbottom
await inputHandler.parseP('\x1b[7H\x1b[2Mo');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', 'o', '7', '8', '9']);
await inputHandler.parseP('\x1b[8H\x1b[2Mp');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', 'o', 'p', '8', '9']);
await inputHandler.parseP('\x1b[100H\x1b[2Mq');
assert.deepEqual(getLines(bufferService), ['m', 'n', '2', '3', '4', '5', 'o', 'p', '8', 'q']);
});
it('deleteLines - within margins', async () => {
await inputHandler.parseP('0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\x1b[3;6r');
assert.equal(bufferService.buffer.scrollTop, 2);
assert.equal(bufferService.buffer.scrollBottom, 5);
await inputHandler.parseP('\x1b[6H\x1b[2Mm');
assert.deepEqual(getLines(bufferService), ['0', '1', '2', '3', '4', 'm', '6', '7', '8', '9']);
await inputHandler.parseP('\x1b[3H\x1b[2Mn');
assert.deepEqual(getLines(bufferService), ['0', '1', 'n', 'm', '', '', '6', '7', '8', '9']);
});
});
it('should parse big chunks in smaller subchunks', async () => {
// max single chunk size is hardcoded as 131072
const calls: any[] = [];
bufferService.resize(10, 10);
(inputHandler as any)._parser.parse = (data: Uint32Array, length: number) => {
calls.push([data.length, length]);
};
await inputHandler.parseP('12345');
await inputHandler.parseP('a'.repeat(10000));
await inputHandler.parseP('a'.repeat(200000));
await inputHandler.parseP('a'.repeat(300000));
assert.deepEqual(calls, [
[4096, 5],
[10000, 10000],
[131072, 131072], [131072, 200000 - 131072],
[131072, 131072], [131072, 131072], [131072, 300000 - 131072 - 131072]
]);
});
describe('windowOptions', () => {
it('all should be disabled by default and not report', async () => {
bufferService.resize(10, 10);
const stack: string[] = [];
coreService.onData(data => stack.push(data));
await inputHandler.parseP('\x1b[14t');
await inputHandler.parseP('\x1b[16t');
await inputHandler.parseP('\x1b[18t');
await inputHandler.parseP('\x1b[20t');
await inputHandler.parseP('\x1b[21t');
assert.deepEqual(stack, []);
});
it('14 - GetWinSizePixels', async () => {
bufferService.resize(10, 10);
optionsService.options.windowOptions.getWinSizePixels = true;
const stack: string[] = [];
coreService.onData(data => stack.push(data));
await inputHandler.parseP('\x1b[14t');
// does not report in test terminal due to missing renderer
assert.deepEqual(stack, []);
});
it('16 - GetCellSizePixels', async () => {
bufferService.resize(10, 10);
optionsService.options.windowOptions.getCellSizePixels = true;
const stack: string[] = [];
coreService.onData(data => stack.push(data));
await inputHandler.parseP('\x1b[16t');
// does not report in test terminal due to missing renderer
assert.deepEqual(stack, []);
});
it('18 - GetWinSizeChars', async () => {
bufferService.resize(10, 10);
optionsService.options.windowOptions.getWinSizeChars = true;
const stack: string[] = [];
coreService.onData(data => stack.push(data));
await inputHandler.parseP('\x1b[18t');
assert.deepEqual(stack, ['\x1b[8;10;10t']);
bufferService.resize(50, 20);
await inputHandler.parseP('\x1b[18t');
assert.deepEqual(stack, ['\x1b[8;10;10t', '\x1b[8;20;50t']);
});
it('22/23 - PushTitle/PopTitle', async () => {
bufferService.resize(10, 10);
optionsService.options.windowOptions.pushTitle = true;
optionsService.options.windowOptions.popTitle = true;
const stack: string[] = [];
inputHandler.onTitleChange(data => stack.push(data));
await inputHandler.parseP('\x1b]0;1\x07');
await inputHandler.parseP('\x1b[22t');
await inputHandler.parseP('\x1b]0;2\x07');
await inputHandler.parseP('\x1b[22t');
await inputHandler.parseP('\x1b]0;3\x07');
await inputHandler.parseP('\x1b[22t');
assert.deepEqual(inputHandler.windowTitleStack, ['1', '2', '3']);
assert.deepEqual(inputHandler.iconNameStack, ['1', '2', '3']);
assert.deepEqual(stack, ['1', '2', '3']);
await inputHandler.parseP('\x1b[23t');
await inputHandler.parseP('\x1b[23t');
await inputHandler.parseP('\x1b[23t');
await inputHandler.parseP('\x1b[23t'); // one more to test "overflow"
assert.deepEqual(inputHandler.windowTitleStack, []);
assert.deepEqual(inputHandler.iconNameStack, []);
assert.deepEqual(stack, ['1', '2', '3', '3', '2', '1']);
});
it('22/23 - PushTitle/PopTitle with ;1', async () => {
bufferService.resize(10, 10);
optionsService.options.windowOptions.pushTitle = true;
optionsService.options.windowOptions.popTitle = true;
const stack: string[] = [];
inputHandler.onTitleChange(data => stack.push(data));
await inputHandler.parseP('\x1b]0;1\x07');
await inputHandler.parseP('\x1b[22;1t');
await inputHandler.parseP('\x1b]0;2\x07');
await inputHandler.parseP('\x1b[22;1t');
await inputHandler.parseP('\x1b]0;3\x07');
await inputHandler.parseP('\x1b[22;1t');
assert.deepEqual(inputHandler.windowTitleStack, []);
assert.deepEqual(inputHandler.iconNameStack, ['1', '2', '3']);
assert.deepEqual(stack, ['1', '2', '3']);
await inputHandler.parseP('\x1b[23;1t');
await inputHandler.parseP('\x1b[23;1t');
await inputHandler.parseP('\x1b[23;1t');
await inputHandler.parseP('\x1b[23;1t'); // one more to test "overflow"
assert.deepEqual(inputHandler.windowTitleStack, []);
assert.deepEqual(inputHandler.iconNameStack, []);
assert.deepEqual(stack, ['1', '2', '3']);
});
it('22/23 - PushTitle/PopTitle with ;2', async () => {
bufferService.resize(10, 10);
optionsService.options.windowOptions.pushTitle = true;
optionsService.options.windowOptions.popTitle = true;
const stack: string[] = [];
inputHandler.onTitleChange(data => stack.push(data));
await inputHandler.parseP('\x1b]0;1\x07');
await inputHandler.parseP('\x1b[22;2t');
await inputHandler.parseP('\x1b]0;2\x07');
await inputHandler.parseP('\x1b[22;2t');
await inputHandler.parseP('\x1b]0;3\x07');
await inputHandler.parseP('\x1b[22;2t');
assert.deepEqual(inputHandler.windowTitleStack, ['1', '2', '3']);
assert.deepEqual(inputHandler.iconNameStack, []);
assert.deepEqual(stack, ['1', '2', '3']);
await inputHandler.parseP('\x1b[23;2t');
await inputHandler.parseP('\x1b[23;2t');
await inputHandler.parseP('\x1b[23;2t');
await inputHandler.parseP('\x1b[23;2t'); // one more to test "overflow"
assert.deepEqual(inputHandler.windowTitleStack, []);
assert.deepEqual(inputHandler.iconNameStack, []);
assert.deepEqual(stack, ['1', '2', '3', '3', '2', '1']);
});
it('DECCOLM - should only work with "SetWinLines" (24) enabled', async () => {
// disabled
bufferService.resize(10, 10);
await inputHandler.parseP('\x1b[?3l');
assert.equal(bufferService.cols, 10);
await inputHandler.parseP('\x1b[?3h');
assert.equal(bufferService.cols, 10);
// enabled
inputHandler.reset();
optionsService.options.windowOptions.setWinLines = true;
await inputHandler.parseP('\x1b[?3l');
assert.equal(bufferService.cols, 80);
await inputHandler.parseP('\x1b[?3h');
assert.equal(bufferService.cols, 132);
});
});
describe('should correctly reset cells taken by wide chars', () => {
beforeEach(async () => {
bufferService.resize(10, 5);
optionsService.options.scrollback = 1;
await inputHandler.parseP('￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥');
});
it('print', async () => {
await inputHandler.parseP('\x1b[H#');
assert.deepEqual(getLines(bufferService), ['# ￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[1;6H######');
assert.deepEqual(getLines(bufferService), ['# ￥ #####', '# ￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('#');
assert.deepEqual(getLines(bufferService), ['# ￥ #####', '##￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('#');
assert.deepEqual(getLines(bufferService), ['# ￥ #####', '### ￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[3;9H#');
assert.deepEqual(getLines(bufferService), ['# ￥ #####', '### ￥￥￥', '￥￥￥￥#', '￥￥￥￥￥', '']);
await inputHandler.parseP('#');
assert.deepEqual(getLines(bufferService), ['# ￥ #####', '### ￥￥￥', '￥￥￥￥##', '￥￥￥￥￥', '']);
await inputHandler.parseP('#');
assert.deepEqual(getLines(bufferService), ['# ￥ #####', '### ￥￥￥', '￥￥￥￥##', '# ￥￥￥￥', '']);
await inputHandler.parseP('\x1b[4;10H#');
assert.deepEqual(getLines(bufferService), ['# ￥ #####', '### ￥￥￥', '￥￥￥￥##', '# ￥￥￥ #', '']);
});
it('EL', async () => {
await inputHandler.parseP('\x1b[1;6H\x1b[K#');
assert.deepEqual(getLines(bufferService), ['￥￥ #', '￥￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[2;5H\x1b[1K');
assert.deepEqual(getLines(bufferService), ['￥￥ #', ' ￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[3;6H\x1b[1K');
assert.deepEqual(getLines(bufferService), ['￥￥ #', ' ￥￥', ' ￥￥', '￥￥￥￥￥', '']);
});
it('ICH', async () => {
await inputHandler.parseP('\x1b[1;6H\x1b[@');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥', '￥￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[2;4H\x1b[2@');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥', '￥ ￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[3;4H\x1b[3@');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥', '￥ ￥￥', '￥ ￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[4;4H\x1b[4@');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥', '￥ ￥￥', '￥ ￥', '￥ ￥', '']);
});
it('DCH', async () => {
await inputHandler.parseP('\x1b[1;6H\x1b[P');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[2;6H\x1b[2P');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥￥', '￥￥ ￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[3;6H\x1b[3P');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥￥', '￥￥ ￥', '￥￥ ￥', '￥￥￥￥￥', '']);
});
it('ECH', async () => {
await inputHandler.parseP('\x1b[1;6H\x1b[X');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[2;6H\x1b[2X');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥￥', '￥￥ ￥', '￥￥￥￥￥', '￥￥￥￥￥', '']);
await inputHandler.parseP('\x1b[3;6H\x1b[3X');
assert.deepEqual(getLines(bufferService), ['￥￥ ￥￥', '￥￥ ￥', '￥￥ ￥', '￥￥￥￥￥', '']);
});
});
describe('BS with reverseWraparound set/unset', () => {
const ttyBS = '\x08 \x08'; // tty ICANON sends <BS SP BS> on pressing BS
beforeEach(() => {
bufferService.resize(5, 5);
optionsService.options.scrollback = 1;
});
describe('reverseWraparound unset (default)', () => {
it('cannot delete last cell', async () => {
await inputHandler.parseP('12345');
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 1), ['123 5']);
await inputHandler.parseP(ttyBS.repeat(10));
assert.deepEqual(getLines(bufferService, 1), [' 5']);
});
it('cannot access prev line', async () => {
await inputHandler.parseP('12345'.repeat(2));
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), ['12345', '123 5']);
await inputHandler.parseP(ttyBS.repeat(10));
assert.deepEqual(getLines(bufferService, 2), ['12345', ' 5']);
});
});
describe('reverseWraparound set', () => {
it('can delete last cell', async () => {
await inputHandler.parseP('\x1b[?45h');
await inputHandler.parseP('12345');
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 1), ['1234 ']);
await inputHandler.parseP(ttyBS.repeat(7));
assert.deepEqual(getLines(bufferService, 1), [' ']);
});
it('can access prev line if wrapped', async () => {
await inputHandler.parseP('\x1b[?45h');
await inputHandler.parseP('12345'.repeat(2));
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), ['12345', '1234 ']);
await inputHandler.parseP(ttyBS.repeat(7));
assert.deepEqual(getLines(bufferService, 2), ['12 ', ' ']);
});
it('should lift isWrapped', async () => {
await inputHandler.parseP('\x1b[?45h');
await inputHandler.parseP('12345'.repeat(2));
assert.equal(bufferService.buffer.lines.get(1)?.isWrapped, true);
await inputHandler.parseP(ttyBS.repeat(7));
assert.equal(bufferService.buffer.lines.get(1)?.isWrapped, false);
});
it('stops at hard NLs', async () => {
await inputHandler.parseP('\x1b[?45h');
await inputHandler.parseP('12345\r\n');
await inputHandler.parseP('12345'.repeat(2));
await inputHandler.parseP(ttyBS.repeat(50));
assert.deepEqual(getLines(bufferService, 3), ['12345', ' ', ' ']);
assert.equal(bufferService.buffer.x, 0);
assert.equal(bufferService.buffer.y, 1);
});
it('handles wide chars correctly', async () => {
await inputHandler.parseP('\x1b[?45h');
await inputHandler.parseP('￥￥￥');
assert.deepEqual(getLines(bufferService, 2), ['￥￥', '￥']);
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), ['￥￥', ' ']);
assert.equal(bufferService.buffer.x, 1);
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), ['￥￥', ' ']);
assert.equal(bufferService.buffer.x, 0);
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), ['￥ ', ' ']);
assert.equal(bufferService.buffer.x, 3); // x=4 skipped due to early wrap-around
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), ['￥ ', ' ']);
assert.equal(bufferService.buffer.x, 2);
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), [' ', ' ']);
assert.equal(bufferService.buffer.x, 1);
await inputHandler.parseP(ttyBS);
assert.deepEqual(getLines(bufferService, 2), [' ', ' ']);
assert.equal(bufferService.buffer.x, 0);
});
});
});
describe('extended underline style support (SGR 4)', () => {
beforeEach(() => {
bufferService.resize(10, 5);
});
it('4 | 24', async () => {
await inputHandler.parseP('\x1b[4m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.SINGLE);
await inputHandler.parseP('\x1b[24m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
});
it('21 | 24', async () => {
await inputHandler.parseP('\x1b[21m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DOUBLE);
await inputHandler.parseP('\x1b[24m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
});
it('4:1 | 4:0', async () => {
await inputHandler.parseP('\x1b[4:1m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.SINGLE);
await inputHandler.parseP('\x1b[4:0m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
await inputHandler.parseP('\x1b[4:1m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.SINGLE);
await inputHandler.parseP('\x1b[24m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
});
it('4:2 | 4:0', async () => {
await inputHandler.parseP('\x1b[4:2m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DOUBLE);
await inputHandler.parseP('\x1b[4:0m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
await inputHandler.parseP('\x1b[4:2m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DOUBLE);
await inputHandler.parseP('\x1b[24m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
});
it('4:3 | 4:0', async () => {
await inputHandler.parseP('\x1b[4:3m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.CURLY);
await inputHandler.parseP('\x1b[4:0m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
await inputHandler.parseP('\x1b[4:3m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.CURLY);
await inputHandler.parseP('\x1b[24m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
});
it('4:4 | 4:0', async () => {
await inputHandler.parseP('\x1b[4:4m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DOTTED);
await inputHandler.parseP('\x1b[4:0m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
await inputHandler.parseP('\x1b[4:4m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DOTTED);
await inputHandler.parseP('\x1b[24m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
});
it('4:5 | 4:0', async () => {
await inputHandler.parseP('\x1b[4:5m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DASHED);
await inputHandler.parseP('\x1b[4:0m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
await inputHandler.parseP('\x1b[4:5m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DASHED);
await inputHandler.parseP('\x1b[24m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.NONE);
});
it('4:x --> 4 should revert to single underline', async () => {
await inputHandler.parseP('\x1b[4:5m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.DASHED);
await inputHandler.parseP('\x1b[4m');
assert.equal(inputHandler.curAttrData.getUnderlineStyle(), UnderlineStyle.SINGLE);
});
});
describe('underline colors (SGR 58 & SGR 59)', () => {
beforeEach(() => {
bufferService.resize(10, 5);
});
it('defaults to FG color', async () => {
for (const s of ['', '\x1b[30m', '\x1b[38;510m', '\x1b[38;2;1;2;3m']) {
await inputHandler.parseP(s);
assert.equal(inputHandler.curAttrData.getUnderlineColor(), inputHandler.curAttrData.getFgColor());
assert.equal(inputHandler.curAttrData.getUnderlineColorMode(), inputHandler.curAttrData.getFgColorMode());
assert.equal(inputHandler.curAttrData.isUnderlineColorRGB(), inputHandler.curAttrData.isFgRGB());
assert.equal(inputHandler.curAttrData.isUnderlineColorPalette(), inputHandler.curAttrData.isFgPalette());
assert.equal(inputHandler.curAttrData.isUnderlineColorDefault(), inputHandler.curAttrData.isFgDefault());
}
});
it('correctly sets P256/RGB colors', async () => {
await inputHandler.parseP('\x1b[4m');
await inputHandler.parseP('\x1b[58;5;123m');
assert.equal(inputHandler.curAttrData.getUnderlineColor(), 123);
assert.equal(inputHandler.curAttrData.getUnderlineColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.isUnderlineColorRGB(), false);
assert.equal(inputHandler.curAttrData.isUnderlineColorPalette(), true);
assert.equal(inputHandler.curAttrData.isUnderlineColorDefault(), false);
await inputHandler.parseP('\x1b[58;2::1:2:3m');
assert.equal(inputHandler.curAttrData.getUnderlineColor(), (1 << 16) | (2 << 8) | 3);
assert.equal(inputHandler.curAttrData.getUnderlineColorMode(), Attributes.CM_RGB);
assert.equal(inputHandler.curAttrData.isUnderlineColorRGB(), true);
assert.equal(inputHandler.curAttrData.isUnderlineColorPalette(), false);
assert.equal(inputHandler.curAttrData.isUnderlineColorDefault(), false);
});
it('P256/RGB persistence', async () => {
const cell = new CellData();
await inputHandler.parseP('\x1b[4m');
await inputHandler.parseP('\x1b[58;5;123m');
assert.equal(inputHandler.curAttrData.getUnderlineColor(), 123);
assert.equal(inputHandler.curAttrData.getUnderlineColorMode(), Attributes.CM_P256);
assert.equal(inputHandler.curAttrData.isUnderlineColorRGB(), false);
assert.equal(inputHandler.curAttrData.isUnderlineColorPalette(), true);
assert.equal(inputHandler.curAttrData.isUnderlineColorDefault(), false);
await inputHandler.parseP('ab');
bufferService.buffer!.lines.get(0)!.loadCell(1, cell);
assert.equal(cell.getUnderlineColor(), 123);
assert.equal(cell.getUnderlineColorMode(), Attributes.CM_P256);
assert.equal(cell.isUnderlineColorRGB(), false);
assert.equal(cell.isUnderlineColorPalette(), true);
assert.equal(cell.isUnderlineColorDefault(), false);
await inputHandler.parseP('\x1b[4:0m');
assert.equal(inputHandler.curAttrData.getUnderlineColor(), inputHandler.curAttrData.getFgColor());
assert.equal(inputHandler.curAttrData.getUnderlineColorMode(), inputHandler.curAttrData.getFgColorMode());
assert.equal(inputHandler.curAttrData.isUnderlineColorRGB(), inputHandler.curAttrData.isFgRGB());
assert.equal(inputHandler.curAttrData.isUnderlineColorPalette(), inputHandler.curAttrData.isFgPalette());
assert.equal(inputHandler.curAttrData.isUnderlineColorDefault(), inputHandler.curAttrData.isFgDefault());
await inputHandler.parseP('a');
bufferService.buffer!.lines.get(0)!.loadCell(1, cell);
assert.equal(cell.getUnderlineColor(), 123);
assert.equal(cell.getUnderlineColorMode(), Attributes.CM_P256);
assert.equal(cell.isUnderlineColorRGB(), false);
assert.equal(cell.isUnderlineColorPalette(), true);
assert.equal(cell.isUnderlineColorDefault(), false);
bufferService.buffer!.lines.get(0)!.loadCell(2, cell);
assert.equal(cell.getUnderlineColor(), inputHandler.curAttrData.getFgColor());
assert.equal(cell.getUnderlineColorMode(), inputHandler.curAttrData.getFgColorMode());
assert.equal(cell.isUnderlineColorRGB(), inputHandler.curAttrData.isFgRGB());
assert.equal(cell.isUnderlineColorPalette(), inputHandler.curAttrData.isFgPalette());
assert.equal(cell.isUnderlineColorDefault(), inputHandler.curAttrData.isFgDefault());
await inputHandler.parseP('\x1b[4m');
await inputHandler.parseP('\x1b[58;2::1:2:3m');
assert.equal(inputHandler.curAttrData.getUnderlineColor(), (1 << 16) | (2 << 8) | 3);
assert.equal(inputHandler.curAttrData.getUnderlineColorMode(), Attributes.CM_RGB);
assert.equal(inputHandler.curAttrData.isUnderlineColorRGB(), true);
assert.equal(inputHandler.curAttrData.isUnderlineColorPalette(), false);
assert.equal(inputHandler.curAttrData.isUnderlineColorDefault(), false);
await inputHandler.parseP('a');
await inputHandler.parseP('\x1b[24m');
bufferService.buffer!.lines.get(0)!.loadCell(1, cell);
assert.equal(cell.getUnderlineColor(), 123);
assert.equal(cell.getUnderlineColorMode(), Attributes.CM_P256);
assert.equal(cell.isUnderlineColorRGB(), false);
assert.equal(cell.isUnderlineColorPalette(), true);
assert.equal(cell.isUnderlineColorDefault(), false);
bufferService.buffer!.lines.get(0)!.loadCell(3, cell);
assert.equal(cell.getUnderlineColor(), (1 << 16) | (2 << 8) | 3);
assert.equal(cell.getUnderlineColorMode(), Attributes.CM_RGB);
assert.equal(cell.isUnderlineColorRGB(), true);
assert.equal(cell.isUnderlineColorPalette(), false);
assert.equal(cell.isUnderlineColorDefault(), false);
// eAttrs in buffer pos 0 and 1 should be the same object
assert.equal(
(bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[0],
(bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[1]
);
// should not have written eAttr for pos 2 in the buffer
assert.equal((bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[2], undefined);
// eAttrs in buffer pos 1 and pos 3 must be different objs
assert.notEqual(
(bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[1],
(bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[3]
);
});
});
describe('DECSTR', () => {
beforeEach(async () => {
bufferService.resize(10, 5);
optionsService.options.scrollback = 1;
await inputHandler.parseP('01234567890123');
});
it('should reset IRM', async () => {
await inputHandler.parseP('\x1b[4h');
assert.equal(coreService.modes.insertMode, true);
await inputHandler.parseP('\x1b[!p');
assert.equal(coreService.modes.insertMode, false);
});
it('should reset cursor visibility', async () => {
await inputHandler.parseP('\x1b[?25l');
assert.equal(coreService.isCursorHidden, true);
await inputHandler.parseP('\x1b[!p');
assert.equal(coreService.isCursorHidden, false);
});
it('should reset scroll margins', async () => {
await inputHandler.parseP('\x1b[2;4r');
assert.equal(bufferService.buffer.scrollTop, 1);
assert.equal(bufferService.buffer.scrollBottom, 3);
await inputHandler.parseP('\x1b[!p');
assert.equal(bufferService.buffer.scrollTop, 0);
assert.equal(bufferService.buffer.scrollBottom, bufferService.rows - 1);
});
it('should reset text attributes', async () => {
await inputHandler.parseP('\x1b[1;2;32;43m');
assert.equal(!!inputHandler.curAttrData.isBold(), true);
await inputHandler.parseP('\x1b[!p');
assert.equal(!!inputHandler.curAttrData.isBold(), false);
assert.equal(inputHandler.curAttrData.fg, 0);
assert.equal(inputHandler.curAttrData.bg, 0);
});
it('should reset DECSC data', async () => {
await inputHandler.parseP('\x1b7');
assert.equal(bufferService.buffer.savedX, 4);
assert.equal(bufferService.buffer.savedY, 1);
await inputHandler.parseP('\x1b[!p');
assert.equal(bufferService.buffer.savedX, 0);
assert.equal(bufferService.buffer.savedY, 0);
});
it('should reset DECOM', async () => {
await inputHandler.parseP('\x1b[?6h');
assert.equal(coreService.decPrivateModes.origin, true);
await inputHandler.parseP('\x1b[!p');
assert.equal(coreService.decPrivateModes.origin, false);
});
});
describe('OSC', () => {
it('4: should parse correct Ansi color change data', () => {
// this is testing a private method
const event = inputHandler.parseAnsiColorChange('19;rgb:a1/b2/c3');
assert.isNotNull(event);
assert.deepEqual(event!.colors[0], { colorIndex: 19, red: 0xa1, green: 0xb2, blue: 0xc3 });
}),
it('4: should ignore incorrect Ansi color change data', () => {
// this is testing a private method
assert.isNull(inputHandler.parseAnsiColorChange('17;rgb:a/b/c'));
assert.isNull(inputHandler.parseAnsiColorChange('17;rgb:#aabbcc'));
assert.isNull(inputHandler.parseAnsiColorChange('17;rgba:aa/bb/cc'));
assert.isNull(inputHandler.parseAnsiColorChange('rgb:aa/bb/cc'));
});
it('4: should parse a list of Ansi color changes', () => {
// this is testing a private method
const event = inputHandler.parseAnsiColorChange('19;rgb:a1/b2/c3;17;rgb:00/11/22;255;rgb:01/ef/2d');
assert.isNotNull(event);
assert.equal(event!.colors.length, 3);
assert.deepEqual(event!.colors[0], { colorIndex: 19, red: 0xa1, green: 0xb2, blue: 0xc3 });
assert.deepEqual(event!.colors[1], { colorIndex: 17, red: 0x00, green: 0x11, blue: 0x22 });
assert.deepEqual(event!.colors[2], { colorIndex: 255, red: 0x01, green: 0xef, blue: 0x2d });
});
it('4: should ignore incorrect colors in a list of Ansi color changes', () => {
// this is testing a private method
const event = inputHandler.parseAnsiColorChange('19;rgb:a1/b2/c3;17;rgb:WR/ON/G;255;rgb:01/ef/2d');
assert.equal(event!.colors.length, 2);
assert.deepEqual(event!.colors[0], { colorIndex: 19, red: 0xa1, green: 0xb2, blue: 0xc3 });
assert.deepEqual(event!.colors[1], { colorIndex: 255, red: 0x01, green: 0xef, blue: 0x2d });
});
it('4: should be case insensitive when parsing Ansi color changes', () => {
// this is testing a private method
const event = inputHandler.parseAnsiColorChange('19;rGb:A1/b2/C3');
assert.equal(event!.colors.length, 1);
assert.deepEqual(event!.colors[0], { colorIndex: 19, red: 0xa1, green: 0xb2, blue: 0xc3 });
});
it('4: should fire event on Ansi color change', async () => {
return new Promise(async r => {
inputHandler.onAnsiColorChange(e => {
assert.isNotNull(e);
assert.isNotNull(e!.colors);
assert.deepEqual(e!.colors[0], { colorIndex: 17, red: 0x1a, green: 0x2b, blue: 0x3c });
assert.deepEqual(e!.colors[1], { colorIndex: 12, red: 0x11, green: 0x22, blue: 0x33 });
r();
});
await inputHandler.parseP('\x1b]4;17;rgb:1a/2b/3c;12;rgb:11/22/33\x1b\\');
});
});
});
});
Reference in New Issue View Git Blame Copy Permalink