2436 lines
115 KiB
TypeScript
2436 lines
115 KiB
TypeScript
/**
|
|
* Copyright (c) 2017 The xterm.js authors. All rights reserved.
|
|
* @license MIT
|
|
*/
|
|
|
|
import { assert } from 'chai';
|
|
import { InputHandler } from 'common/InputHandler';
|
|
import { IBufferLine, IAttributeData, IColorEvent, ColorRequestType, SpecialColorIndex } from 'common/Types';
|
|
import { DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine';
|
|
import { CellData } from 'common/buffer/CellData';
|
|
import { Attributes, BgFlags, UnderlineStyle } from 'common/buffer/Constants';
|
|
import { AttributeData, ExtendedAttrs } from 'common/buffer/AttributeData';
|
|
import { Params } from 'common/parser/Params';
|
|
import { MockCoreService, MockBufferService, MockOptionsService, MockLogService, MockCoreMouseService, MockCharsetService, MockUnicodeService, MockOscLinkService } from 'common/TestUtils.test';
|
|
import { IBufferService, ICoreService, type IOscLinkService } 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';
|
|
import { OscLinkService } from 'common/services/OscLinkService';
|
|
|
|
|
|
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; }
|
|
|
|
/**
|
|
* 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 oscLinkService: IOscLinkService;
|
|
let inputHandler: TestInputHandler;
|
|
|
|
beforeEach(() => {
|
|
optionsService = new MockOptionsService();
|
|
bufferService = new BufferService(optionsService);
|
|
bufferService.resize(80, 30);
|
|
coreService = new CoreService(bufferService, new MockLogService(), optionsService);
|
|
oscLinkService = new OscLinkService(bufferService);
|
|
|
|
inputHandler = new TestInputHandler(bufferService, new MockCharsetService(), coreService, new MockLogService(), optionsService, oscLinkService, new MockCoreMouseService(), new MockUnicodeService());
|
|
});
|
|
|
|
describe('SL/SR/DECIC/DECDC', () => {
|
|
beforeEach(() => {
|
|
bufferService.resize(5, 5);
|
|
optionsService.options.scrollback = 1;
|
|
bufferService.reset();
|
|
});
|
|
it('SL (scrollLeft)', async () => {
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[ @');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '2345', '2345', '2345', '2345', '2345']);
|
|
await inputHandler.parseP('\x1b[0 @');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '345', '345', '345', '345', '345']);
|
|
await inputHandler.parseP('\x1b[2 @');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '5', '5', '5', '5', '5']);
|
|
});
|
|
it('SR (scrollRight)', async () => {
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[ A');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', ' 1234', ' 1234', ' 1234', ' 1234', ' 1234']);
|
|
await inputHandler.parseP('\x1b[0 A');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', ' 123', ' 123', ' 123', ' 123', ' 123']);
|
|
await inputHandler.parseP('\x1b[2 A');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', ' 1', ' 1', ' 1', ' 1', ' 1']);
|
|
});
|
|
it('insertColumns (DECIC)', async () => {
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[3;3H');
|
|
await inputHandler.parseP('\x1b[\'}');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '12 34', '12 34', '12 34', '12 34', '12 34']);
|
|
bufferService.reset();
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[3;3H');
|
|
await inputHandler.parseP('\x1b[1\'}');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '12 34', '12 34', '12 34', '12 34', '12 34']);
|
|
bufferService.reset();
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[3;3H');
|
|
await inputHandler.parseP('\x1b[2\'}');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '12 3', '12 3', '12 3', '12 3', '12 3']);
|
|
});
|
|
it('deleteColumns (DECDC)', async () => {
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[3;3H');
|
|
await inputHandler.parseP('\x1b[\'~');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '1245', '1245', '1245', '1245', '1245']);
|
|
bufferService.reset();
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[3;3H');
|
|
await inputHandler.parseP('\x1b[1\'~');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '1245', '1245', '1245', '1245', '1245']);
|
|
bufferService.reset();
|
|
await inputHandler.parseP('12345'.repeat(6));
|
|
await inputHandler.parseP('\x1b[3;3H');
|
|
await inputHandler.parseP('\x1b[2\'~');
|
|
assert.deepEqual(getLines(bufferService, 6), ['12345', '125', '125', '125', '125', '125']);
|
|
});
|
|
});
|
|
|
|
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;
|
|
bufferService.reset();
|
|
});
|
|
describe('reverseWraparound set', () => {
|
|
it('should not reverse outside of scroll margins', async () => {
|
|
// prepare buffer content
|
|
await inputHandler.parseP('#####abcdefghijklmnopqrstuvwxy');
|
|
assert.deepEqual(getLines(bufferService, 6), ['#####', 'abcde', 'fghij', 'klmno', 'pqrst', 'uvwxy']);
|
|
assert.equal(bufferService.buffers.active.ydisp, 1);
|
|
assert.equal(bufferService.buffers.active.x, 5);
|
|
assert.equal(bufferService.buffers.active.y, 4);
|
|
await inputHandler.parseP(ttyBS.repeat(100));
|
|
assert.deepEqual(getLines(bufferService, 6), ['#####', 'abcde', 'fghij', 'klmno', 'pqrst', ' y']);
|
|
|
|
await inputHandler.parseP('\x1b[?45h');
|
|
await inputHandler.parseP('uvwxy');
|
|
|
|
// set top/bottom to 1/3 (0-based)
|
|
await inputHandler.parseP('\x1b[2;4r');
|
|
// place cursor below scroll bottom
|
|
bufferService.buffers.active.x = 5;
|
|
bufferService.buffers.active.y = 4;
|
|
await inputHandler.parseP(ttyBS.repeat(100));
|
|
assert.deepEqual(getLines(bufferService, 6), ['#####', 'abcde', 'fghij', 'klmno', 'pqrst', ' ']);
|
|
|
|
await inputHandler.parseP('uvwxy');
|
|
// place cursor within scroll margins
|
|
bufferService.buffers.active.x = 5;
|
|
bufferService.buffers.active.y = 3;
|
|
await inputHandler.parseP(ttyBS.repeat(100));
|
|
assert.deepEqual(getLines(bufferService, 6), ['#####', 'abcde', ' ', ' ', ' ', 'uvwxy']);
|
|
assert.equal(bufferService.buffers.active.x, 0);
|
|
assert.equal(bufferService.buffers.active.y, bufferService.buffers.active.scrollTop); // stops at 0, scrollTop
|
|
|
|
await inputHandler.parseP('fghijklmnopqrst');
|
|
// place cursor above scroll top
|
|
bufferService.buffers.active.x = 5;
|
|
bufferService.buffers.active.y = 0;
|
|
await inputHandler.parseP(ttyBS.repeat(100));
|
|
assert.deepEqual(getLines(bufferService, 6), ['#####', ' ', 'fghij', 'klmno', 'pqrst', 'uvwxy']);
|
|
});
|
|
});
|
|
});
|
|
|
|
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(coreService.decPrivateModes.cursorStyle, undefined);
|
|
assert.equal(coreService.decPrivateModes.cursorBlink, undefined);
|
|
|
|
optionsService.options = clone(DEFAULT_OPTIONS);
|
|
inputHandler.setCursorStyle(Params.fromArray([1]));
|
|
assert.equal(coreService.decPrivateModes.cursorStyle, 'block');
|
|
assert.equal(coreService.decPrivateModes.cursorBlink, true);
|
|
|
|
optionsService.options = clone(DEFAULT_OPTIONS);
|
|
inputHandler.setCursorStyle(Params.fromArray([2]));
|
|
assert.equal(coreService.decPrivateModes.cursorStyle, 'block');
|
|
assert.equal(coreService.decPrivateModes.cursorBlink, false);
|
|
|
|
optionsService.options = clone(DEFAULT_OPTIONS);
|
|
inputHandler.setCursorStyle(Params.fromArray([3]));
|
|
assert.equal(coreService.decPrivateModes.cursorStyle, 'underline');
|
|
assert.equal(coreService.decPrivateModes.cursorBlink, true);
|
|
|
|
optionsService.options = clone(DEFAULT_OPTIONS);
|
|
inputHandler.setCursorStyle(Params.fromArray([4]));
|
|
assert.equal(coreService.decPrivateModes.cursorStyle, 'underline');
|
|
assert.equal(coreService.decPrivateModes.cursorBlink, false);
|
|
|
|
optionsService.options = clone(DEFAULT_OPTIONS);
|
|
inputHandler.setCursorStyle(Params.fromArray([5]));
|
|
assert.equal(coreService.decPrivateModes.cursorStyle, 'bar');
|
|
assert.equal(coreService.decPrivateModes.cursorBlink, true);
|
|
|
|
optionsService.options = clone(DEFAULT_OPTIONS);
|
|
inputHandler.setCursorStyle(Params.fromArray([6]));
|
|
assert.equal(coreService.decPrivateModes.cursorStyle, 'bar');
|
|
assert.equal(coreService.decPrivateModes.cursorBlink, false);
|
|
});
|
|
});
|
|
describe('setMode', () => {
|
|
it('should toggle bracketedPasteMode', () => {
|
|
const coreService = new MockCoreService();
|
|
const inputHandler = new TestInputHandler(new MockBufferService(80, 30), new MockCharsetService(), coreService, new MockLogService(), new MockOptionsService(), new MockOscLinkService(), 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 MockLogService(),
|
|
new MockOptionsService(),
|
|
new MockOscLinkService(),
|
|
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 MockLogService(),
|
|
new MockOptionsService(),
|
|
new MockOscLinkService(),
|
|
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 MockLogService(),
|
|
new MockOptionsService(),
|
|
new MockOscLinkService(),
|
|
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('eraseInLine reflow', async () => {
|
|
const bufferService = new MockBufferService(80, 30);
|
|
const inputHandler = new TestInputHandler(
|
|
bufferService,
|
|
new MockCharsetService(),
|
|
new MockCoreService(),
|
|
new MockLogService(),
|
|
new MockOptionsService(),
|
|
new MockOscLinkService(),
|
|
new MockCoreMouseService(),
|
|
new MockUnicodeService()
|
|
);
|
|
|
|
const resetToBaseState = async (): Promise<void> => {
|
|
// 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'));
|
|
|
|
// confirm precondition that line 2 is wrapped
|
|
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
|
|
};
|
|
|
|
// params[0] - erase from the cursor through the end of the row.
|
|
await resetToBaseState();
|
|
bufferService.buffer.y = 2;
|
|
bufferService.buffer.x = 40;
|
|
inputHandler.eraseInLine(Params.fromArray([0]));
|
|
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
|
|
bufferService.buffer.y = 2;
|
|
bufferService.buffer.x = 0;
|
|
inputHandler.eraseInLine(Params.fromArray([0]));
|
|
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
|
|
|
|
// params[1] - erase from the beginning of the line through the cursor
|
|
await resetToBaseState();
|
|
bufferService.buffer.y = 2;
|
|
bufferService.buffer.x = 40;
|
|
inputHandler.eraseInLine(Params.fromArray([1]));
|
|
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
|
|
|
|
// params[2] - erase complete line
|
|
await resetToBaseState();
|
|
bufferService.buffer.y = 2;
|
|
bufferService.buffer.x = 40;
|
|
inputHandler.eraseInLine(Params.fromArray([2]));
|
|
assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
|
|
});
|
|
it('ED2 with scrollOnEraseInDisplay turned on', async () => {
|
|
const inputHandler = new TestInputHandler(
|
|
bufferService,
|
|
new MockCharsetService(),
|
|
new MockCoreService(),
|
|
new MockLogService(),
|
|
new MockOptionsService({ scrollOnEraseInDisplay: true }),
|
|
new MockOscLinkService(),
|
|
new MockCoreMouseService(),
|
|
new MockUnicodeService()
|
|
);
|
|
const aLine = Array(bufferService.cols + 1).join('a');
|
|
// add 2 full lines of text.
|
|
await inputHandler.parseP(aLine);
|
|
await inputHandler.parseP(aLine);
|
|
|
|
inputHandler.eraseInDisplay(Params.fromArray([2]));
|
|
// those 2 lines should have been pushed to scrollback.
|
|
assert.equal(bufferService.rows + 2, bufferService.buffer.lines.length);
|
|
assert.equal(bufferService.buffer.ybase, 2);
|
|
assert.equal(bufferService.buffer.lines.get(0)?.translateToString(), aLine);
|
|
assert.equal(bufferService.buffer.lines.get(1)?.translateToString(), aLine);
|
|
|
|
// Move to last line and add more text.
|
|
bufferService.buffer.y = bufferService.rows - 1;
|
|
bufferService.buffer.x = 0;
|
|
await inputHandler.parseP(aLine);
|
|
inputHandler.eraseInDisplay(Params.fromArray([2]));
|
|
// Screen should have been scrolled by a full screen size.
|
|
assert.equal(bufferService.rows * 2 + 2, bufferService.buffer.lines.length);
|
|
});
|
|
it('eraseInDisplay', async () => {
|
|
const bufferService = new MockBufferService(80, 7);
|
|
const inputHandler = new TestInputHandler(
|
|
bufferService,
|
|
new MockCharsetService(),
|
|
new MockCoreService(),
|
|
new MockLogService(),
|
|
new MockOptionsService(),
|
|
new MockOscLinkService(),
|
|
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 MockLogService(),
|
|
new MockOptionsService(),
|
|
new MockOscLinkService(),
|
|
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), ['￥￥', '￥']);
|
|
});
|
|
it('should strip soft hyphens (U+00AD)', async () => {
|
|
await inputHandler.parseP('Soft\xadhy\xadphen');
|
|
assert.strictEqual(bufferService.buffer.translateBufferLineToString(0, true), 'Softhyphen');
|
|
assert.strictEqual(bufferService.buffer.x, 10);
|
|
});
|
|
});
|
|
|
|
describe('alt screen', () => {
|
|
let bufferService: IBufferService;
|
|
let handler: TestInputHandler;
|
|
|
|
beforeEach(() => {
|
|
bufferService = new MockBufferService(80, 30);
|
|
handler = new TestInputHandler(bufferService, new MockCharsetService(), new MockCoreService(), new MockLogService(), new MockOptionsService(), new MockOscLinkService(), 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('strikethrough', async () => {
|
|
await inputHandler.parseP('\x1b[9m');
|
|
assert.equal(!!inputHandler.curAttrData.isStrikethrough(), true);
|
|
await inputHandler.parseP('\x1b[29m');
|
|
assert.equal(!!inputHandler.curAttrData.isStrikethrough(), 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 MockLogService(), optionsService, new MockOscLinkService(), 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('XTVERSION (CSI > q, CSI > 0 q)', () => {
|
|
it('should report xterm.js version', async () => {
|
|
const stack: string[] = [];
|
|
coreService.onData(data => stack.push(data));
|
|
await inputHandler.parseP('\x1b[>q');
|
|
assert.strictEqual(stack.length, 1);
|
|
assert.ok(stack[0].match(/^\x1bP>\|xterm\.js\(\d+\.\d+\.\d+(-beta\.\d+)?\)\x1b\\/));
|
|
});
|
|
it('should report xterm.js version for CSI > 0 q', async () => {
|
|
const stack: string[] = [];
|
|
coreService.onData(data => stack.push(data));
|
|
await inputHandler.parseP('\x1b[>0q');
|
|
assert.strictEqual(stack.length, 1);
|
|
assert.ok(stack[0].match(/^\x1bP>\|xterm\.js\(\d+\.\d+\.\d+(-beta\.\d+)?\)\x1b\\/));
|
|
});
|
|
it('should not report for CSI > 1 q', async () => {
|
|
const stack: string[] = [];
|
|
coreService.onData(data => stack.push(data));
|
|
await inputHandler.parseP('\x1b[>1q');
|
|
assert.strictEqual(stack.length, 0);
|
|
});
|
|
});
|
|
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('reset text attributes (SGR 0)', () => {
|
|
it('resets all attributes if there is no url', async () => {
|
|
await inputHandler.parseP('\x1b[30m\x1b[40m\x1b[4m');
|
|
assert.notEqual(inputHandler.curAttrData.fg, 0);
|
|
assert.notEqual(inputHandler.curAttrData.bg, 0);
|
|
assert.isFalse(inputHandler.curAttrData.extended.isEmpty());
|
|
|
|
await inputHandler.parseP('\x1b[m');
|
|
assert.equal(inputHandler.curAttrData.fg, 0);
|
|
assert.equal(inputHandler.curAttrData.bg, 0);
|
|
assert.isTrue(inputHandler.curAttrData.extended.isEmpty());
|
|
});
|
|
|
|
it('resets all attributes except for the url', async () => {
|
|
await inputHandler.parseP('\x1b[30m\x1b[40m\x1b[4m');
|
|
await inputHandler.parseP('\x1b]8;;http://example.com\x1b\\');
|
|
assert.notEqual(inputHandler.curAttrData.fg, 0);
|
|
assert.notEqual(inputHandler.curAttrData.bg, 0);
|
|
assert.notEqual(inputHandler.curAttrData.extended.ext, 0);
|
|
const urlId = inputHandler.curAttrData.extended.urlId;
|
|
assert.notEqual(urlId, 0);
|
|
|
|
await inputHandler.parseP('\x1b[m');
|
|
assert.equal(inputHandler.curAttrData.fg, 0);
|
|
assert.equal(inputHandler.curAttrData.bg, BgFlags.HAS_EXTENDED);
|
|
const expectedExtended = new ExtendedAttrs();
|
|
expectedExtended.urlId = urlId;
|
|
assert.deepEqual(inputHandler.curAttrData.extended, expectedExtended);
|
|
});
|
|
});
|
|
|
|
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: query color events', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
// single color query
|
|
await inputHandler.parseP('\x1b]4;0;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: 0 }]]);
|
|
stack.length = 0;
|
|
await inputHandler.parseP('\x1b]4;123;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: 123 }]]);
|
|
stack.length = 0;
|
|
// multiple queries
|
|
await inputHandler.parseP('\x1b]4;0;?;123;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: 0 }, { type: ColorRequestType.REPORT, index: 123 }]]);
|
|
stack.length = 0;
|
|
});
|
|
it('4: set color events', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
// single color query
|
|
await inputHandler.parseP('\x1b]4;0;rgb:01/02/03\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: 0, color: [1, 2, 3] }]]);
|
|
stack.length = 0;
|
|
await inputHandler.parseP('\x1b]4;123;#aabbcc\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: 123, color: [170, 187, 204] }]]);
|
|
stack.length = 0;
|
|
// multiple queries
|
|
await inputHandler.parseP('\x1b]4;0;rgb:aa/bb/cc;123;#001122\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: 0, color: [170, 187, 204] }, { type: ColorRequestType.SET, index: 123, color: [0, 17, 34] }]]);
|
|
stack.length = 0;
|
|
});
|
|
it('4: should ignore invalid values', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
await inputHandler.parseP('\x1b]4;0;rgb:aa/bb/cc;45;rgb:1/22/333;123;#001122\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: 0, color: [170, 187, 204] }, { type: ColorRequestType.SET, index: 123, color: [0, 17, 34] }]]);
|
|
stack.length = 0;
|
|
});
|
|
it('8: hyperlink with id', async () => {
|
|
await inputHandler.parseP('\x1b]8;id=100;http://localhost:3000\x07');
|
|
assert.notStrictEqual(inputHandler.curAttrData.extended.urlId, 0);
|
|
assert.deepStrictEqual(
|
|
oscLinkService.getLinkData(inputHandler.curAttrData.extended.urlId),
|
|
{
|
|
id: '100',
|
|
uri: 'http://localhost:3000'
|
|
}
|
|
);
|
|
await inputHandler.parseP('\x1b]8;;\x07');
|
|
assert.strictEqual(inputHandler.curAttrData.extended.urlId, 0);
|
|
});
|
|
it('8: hyperlink with semi-colon', async () => {
|
|
await inputHandler.parseP('\x1b]8;;http://localhost:3000;abc=def\x07');
|
|
assert.notStrictEqual(inputHandler.curAttrData.extended.urlId, 0);
|
|
assert.deepStrictEqual(
|
|
oscLinkService.getLinkData(inputHandler.curAttrData.extended.urlId),
|
|
{
|
|
id: undefined,
|
|
uri: 'http://localhost:3000;abc=def'
|
|
}
|
|
);
|
|
await inputHandler.parseP('\x1b]8;;\x07');
|
|
assert.strictEqual(inputHandler.curAttrData.extended.urlId, 0);
|
|
});
|
|
it('104: restore events', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
await inputHandler.parseP('\x1b]104;0\x07\x1b]104;43\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.RESTORE, index: 0 }], [{ type: ColorRequestType.RESTORE, index: 43 }]]);
|
|
stack.length = 0;
|
|
// multiple in one command
|
|
await inputHandler.parseP('\x1b]104;0;43\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.RESTORE, index: 0 }, { type: ColorRequestType.RESTORE, index: 43 }]]);
|
|
stack.length = 0;
|
|
// full ANSI table restore
|
|
await inputHandler.parseP('\x1b]104\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.RESTORE}]]);
|
|
});
|
|
|
|
it('10: FG set & query events', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
// single foreground query --> color undefined
|
|
await inputHandler.parseP('\x1b]10;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: SpecialColorIndex.FOREGROUND }]]);
|
|
stack.length = 0;
|
|
// OSC with multiple values maps to OSC 10 & OSC 11 & OSC 12
|
|
await inputHandler.parseP('\x1b]10;?;?;?;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: SpecialColorIndex.FOREGROUND }], [{ type: ColorRequestType.REPORT, index: SpecialColorIndex.BACKGROUND }], [{ type: ColorRequestType.REPORT, index: SpecialColorIndex.CURSOR }]]);
|
|
stack.length = 0;
|
|
// set foreground color events
|
|
await inputHandler.parseP('\x1b]10;rgb:01/02/03\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: SpecialColorIndex.FOREGROUND, color: [1, 2, 3] }]]);
|
|
stack.length = 0;
|
|
await inputHandler.parseP('\x1b]10;#aabbcc\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: SpecialColorIndex.FOREGROUND, color: [170, 187, 204] }]]);
|
|
stack.length = 0;
|
|
// set FG, BG and cursor color at once
|
|
await inputHandler.parseP('\x1b]10;rgb:aa/bb/cc;#001122;rgb:12/34/56\x07');
|
|
assert.deepEqual(stack, [
|
|
[{ type: ColorRequestType.SET, index: SpecialColorIndex.FOREGROUND, color: [170, 187, 204] }],
|
|
[{ type: ColorRequestType.SET, index: SpecialColorIndex.BACKGROUND, color: [0, 17, 34] }],
|
|
[{ type: ColorRequestType.SET, index: SpecialColorIndex.CURSOR, color: [18, 52, 86] }]
|
|
]);
|
|
});
|
|
it('110: restore FG color', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
await inputHandler.parseP('\x1b]110\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.RESTORE, index: SpecialColorIndex.FOREGROUND }]]);
|
|
});
|
|
it('11: BG set & query events', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
// single background query --> color undefined
|
|
await inputHandler.parseP('\x1b]11;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: SpecialColorIndex.BACKGROUND }]]);
|
|
stack.length = 0;
|
|
// OSC 11 with multiple values creates only BG and cursor event
|
|
await inputHandler.parseP('\x1b]11;?;?;?;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: SpecialColorIndex.BACKGROUND }], [{ type: ColorRequestType.REPORT, index: SpecialColorIndex.CURSOR }]]);
|
|
stack.length = 0;
|
|
// set background color events
|
|
await inputHandler.parseP('\x1b]11;rgb:01/02/03\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: SpecialColorIndex.BACKGROUND, color: [1, 2, 3] }]]);
|
|
stack.length = 0;
|
|
await inputHandler.parseP('\x1b]11;#aabbcc\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: SpecialColorIndex.BACKGROUND, color: [170, 187, 204] }]]);
|
|
stack.length = 0;
|
|
// set BG and cursor color at once
|
|
await inputHandler.parseP('\x1b]11;#001122;rgb:12/34/56\x07');
|
|
assert.deepEqual(stack, [
|
|
[{ type: ColorRequestType.SET, index: SpecialColorIndex.BACKGROUND, color: [0, 17, 34] }],
|
|
[{ type: ColorRequestType.SET, index: SpecialColorIndex.CURSOR, color: [18, 52, 86] }]
|
|
]);
|
|
});
|
|
it('111: restore BG color', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
await inputHandler.parseP('\x1b]111\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.RESTORE, index: SpecialColorIndex.BACKGROUND }]]);
|
|
});
|
|
it('12: cursor color set & query events', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
// single cursor query --> color undefined
|
|
await inputHandler.parseP('\x1b]12;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: SpecialColorIndex.CURSOR }]]);
|
|
stack.length = 0;
|
|
// OSC 12 with multiple values creates only cursor event
|
|
await inputHandler.parseP('\x1b]12;?;?;?;?\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.REPORT, index: SpecialColorIndex.CURSOR }]]);
|
|
stack.length = 0;
|
|
// set cursor color events
|
|
await inputHandler.parseP('\x1b]12;rgb:01/02/03\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: SpecialColorIndex.CURSOR, color: [1, 2, 3] }]]);
|
|
stack.length = 0;
|
|
await inputHandler.parseP('\x1b]12;#aabbcc\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.SET, index: SpecialColorIndex.CURSOR, color: [170, 187, 204] }]]);
|
|
});
|
|
it('112: restore cursor color', async () => {
|
|
const stack: IColorEvent[] = [];
|
|
inputHandler.onColor(ev => stack.push(ev));
|
|
await inputHandler.parseP('\x1b]112\x07');
|
|
assert.deepEqual(stack, [[{ type: ColorRequestType.RESTORE, index: SpecialColorIndex.CURSOR }]]);
|
|
});
|
|
});
|
|
|
|
// issue #3362 and #2979
|
|
describe('EL/ED cursor at buffer.cols', () => {
|
|
beforeEach(() => {
|
|
bufferService.resize(10, 5);
|
|
});
|
|
describe('cursor should stay at cols / does not overflow', () => {
|
|
it('EL0', async () => {
|
|
await inputHandler.parseP('##########\x1b[0K');
|
|
assert.equal(bufferService.buffer.x, 10);
|
|
assert.deepEqual(getLines(bufferService), ['#'.repeat(10), '', '', '', '']);
|
|
});
|
|
it('EL1', async () => {
|
|
await inputHandler.parseP('##########\x1b[1K');
|
|
assert.equal(bufferService.buffer.x, 10);
|
|
assert.deepEqual(getLines(bufferService), ['', '', '', '', '']);
|
|
});
|
|
it('EL2', async () => {
|
|
await inputHandler.parseP('##########\x1b[2K');
|
|
assert.equal(bufferService.buffer.x, 10);
|
|
assert.deepEqual(getLines(bufferService), ['', '', '', '', '']);
|
|
});
|
|
it('ED0', async () => {
|
|
await inputHandler.parseP('##########\x1b[0J');
|
|
assert.equal(bufferService.buffer.x, 10);
|
|
assert.deepEqual(getLines(bufferService), ['#'.repeat(10), '', '', '', '']);
|
|
});
|
|
it('ED1', async () => {
|
|
await inputHandler.parseP('##########\x1b[1J');
|
|
assert.equal(bufferService.buffer.x, 10);
|
|
assert.deepEqual(getLines(bufferService), ['', '', '', '', '']);
|
|
});
|
|
it('ED2', async () => {
|
|
await inputHandler.parseP('##########\x1b[2J');
|
|
assert.equal(bufferService.buffer.x, 10);
|
|
assert.deepEqual(getLines(bufferService), ['', '', '', '', '']);
|
|
});
|
|
it('ED3', async () => {
|
|
await inputHandler.parseP('##########\x1b[3J');
|
|
assert.equal(bufferService.buffer.x, 10);
|
|
assert.deepEqual(getLines(bufferService), ['#'.repeat(10), '', '', '', '']);
|
|
});
|
|
});
|
|
describe('following sequence keeps working', () => {
|
|
// sequences to test (cursor related ones)
|
|
const SEQ = [
|
|
/* ICH */ '\x1b[10@',
|
|
/* SL */ '\x1b[10 @',
|
|
/* CUU */ '\x1b[10A',
|
|
/* SR */ '\x1b[10 A',
|
|
/* CUD */ '\x1b[10B',
|
|
/* CUF */ '\x1b[10C',
|
|
/* CUB */ '\x1b[10D',
|
|
/* CNL */ '\x1b[10E',
|
|
/* CPL */ '\x1b[10F',
|
|
/* CHA */ '\x1b[10G',
|
|
/* CUP */ '\x1b[10;10H',
|
|
/* CHT */ '\x1b[10I',
|
|
/* IL */ '\x1b[10L',
|
|
/* DL */ '\x1b[10M',
|
|
/* DCH */ '\x1b[10P',
|
|
/* SU */ '\x1b[10S',
|
|
/* SD */ '\x1b[10T',
|
|
/* ECH */ '\x1b[10X',
|
|
/* CBT */ '\x1b[10Z',
|
|
/* HPA */ '\x1b[10`',
|
|
/* HPR */ '\x1b[10a',
|
|
/* REP */ '\x1b[10b',
|
|
/* VPA */ '\x1b[10d',
|
|
/* VPR */ '\x1b[10e',
|
|
/* HVP */ '\x1b[10;10f',
|
|
/* TBC */ '\x1b[0g',
|
|
/* SCOSC */ '\x1b[s',
|
|
/* DECIC */ '\x1b[10\'}',
|
|
/* DECDC */ '\x1b[10\'~'
|
|
];
|
|
it('cursor never advances beyond cols', async () => {
|
|
for (const seq of SEQ) {
|
|
await inputHandler.parseP('##########\x1b[2J' + seq);
|
|
assert.equal(bufferService.buffer.x <= bufferService.cols, true);
|
|
inputHandler.reset();
|
|
bufferService.reset();
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('DECSCA and DECSED/DECSEL', () => {
|
|
it('default is unprotected', async () => {
|
|
await inputHandler.parseP('some text');
|
|
await inputHandler.parseP('\x1b[?2K');
|
|
assert.deepEqual(getLines(bufferService, 2), ['', '']);
|
|
await inputHandler.parseP('some text');
|
|
await inputHandler.parseP('\x1b[?2J');
|
|
assert.deepEqual(getLines(bufferService, 2), ['', '']);
|
|
});
|
|
it('DECSCA 1 with DECSEL', async () => {
|
|
await inputHandler.parseP('###\x1b[1"qlineerase\x1b[0"q***');
|
|
await inputHandler.parseP('\x1b[?2K');
|
|
assert.deepEqual(getLines(bufferService, 2), [' lineerase', '']);
|
|
// normal EL works as before
|
|
await inputHandler.parseP('\x1b[2K');
|
|
assert.deepEqual(getLines(bufferService, 2), ['', '']);
|
|
});
|
|
it('DECSCA 1 with DECSED', async () => {
|
|
await inputHandler.parseP('###\x1b[1"qdisplayerase\x1b[0"q***');
|
|
await inputHandler.parseP('\x1b[?2J');
|
|
assert.deepEqual(getLines(bufferService, 2), [' displayerase', '']);
|
|
// normal ED works as before
|
|
await inputHandler.parseP('\x1b[2J');
|
|
assert.deepEqual(getLines(bufferService, 2), ['', '']);
|
|
});
|
|
it('DECRQSS reports correct DECSCA state', async () => {
|
|
const sendStack: string[] = [];
|
|
coreService.onData(d => sendStack.push(d));
|
|
// DCS $ q " q ST
|
|
await inputHandler.parseP('\x1bP$q"q\x1b\\');
|
|
// default - DECSCA unset (0 or 2)
|
|
assert.deepEqual(sendStack.pop(), '\x1bP1$r0"q\x1b\\');
|
|
// DECSCA 1 - protected set
|
|
await inputHandler.parseP('###\x1b[1"q');
|
|
await inputHandler.parseP('\x1bP$q"q\x1b\\');
|
|
assert.deepEqual(sendStack.pop(), '\x1bP1$r1"q\x1b\\');
|
|
// DECSCA 2 - protected reset (same as 0)
|
|
await inputHandler.parseP('###\x1b[2"q');
|
|
await inputHandler.parseP('\x1bP$q"q\x1b\\');
|
|
assert.deepEqual(sendStack.pop(), '\x1bP1$r0"q\x1b\\'); // reported as DECSCA 0
|
|
});
|
|
});
|
|
describe('DECRQM', () => {
|
|
const reportStack: string[] = [];
|
|
beforeEach(() => {
|
|
reportStack.length = 0;
|
|
coreService.onData(data => reportStack.push(data));
|
|
});
|
|
it('ANSI 2 (keyboard action mode)', async () => {
|
|
await inputHandler.parseP('\x1b[2$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[2;4$y'); // always reset
|
|
});
|
|
it('ANSI 4 (insert mode)', async () => {
|
|
await inputHandler.parseP('\x1b[4$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[4;2$y'); // reset by default
|
|
await inputHandler.parseP('\x1b[4h');
|
|
await inputHandler.parseP('\x1b[4$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[4;1$y'); // now active
|
|
await inputHandler.parseP('\x1b[4l');
|
|
await inputHandler.parseP('\x1b[4$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[4;2$y'); // again reset
|
|
});
|
|
it('ANSI 12 (send/receive)', async () => {
|
|
await inputHandler.parseP('\x1b[12$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[12;3$y'); // always set
|
|
});
|
|
it('ANSI 20 (newline mode)', async () => {
|
|
await inputHandler.parseP('\x1b[20$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[20;2$y'); // reset by default
|
|
await inputHandler.parseP('\x1b[20h');
|
|
await inputHandler.parseP('\x1b[20$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[20;1$y'); // now active
|
|
await inputHandler.parseP('\x1b[20l');
|
|
await inputHandler.parseP('\x1b[20$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[20;2$y'); // again reset
|
|
});
|
|
it('ANSI unknown', async () => {
|
|
await inputHandler.parseP('\x1b[1234$p');
|
|
assert.deepEqual(reportStack.pop(), '\x1b[1234;0$y'); // not recognized
|
|
});
|
|
it('DEC privates with set/reset semantic', async () => {
|
|
// initially reset
|
|
const reset = [1, 6, 9, 12, 45, 66, 1000, 1002, 1003, 1004, 1006, 1016, 47, 1047, 1049, 2004, 2026];
|
|
for (const mode of reset) {
|
|
await inputHandler.parseP(`\x1b[?${mode}$p`);
|
|
assert.deepEqual(reportStack.pop(), `\x1b[?${mode};2$y`); // initial reset
|
|
await inputHandler.parseP(`\x1b[?${mode}h`);
|
|
await inputHandler.parseP(`\x1b[?${mode}$p`);
|
|
assert.deepEqual(reportStack.pop(), `\x1b[?${mode};1$y`); // now active
|
|
await inputHandler.parseP(`\x1b[?${mode}l`);
|
|
await inputHandler.parseP(`\x1b[?${mode}$p`);
|
|
assert.deepEqual(reportStack.pop(), `\x1b[?${mode};2$y`); // again reset
|
|
}
|
|
// initially set
|
|
const set = [7, 25];
|
|
for (const mode of set) {
|
|
await inputHandler.parseP(`\x1b[?${mode}$p`);
|
|
assert.deepEqual(reportStack.pop(), `\x1b[?${mode};1$y`); // initial set
|
|
await inputHandler.parseP(`\x1b[?${mode}l`);
|
|
await inputHandler.parseP(`\x1b[?${mode}$p`);
|
|
assert.deepEqual(reportStack.pop(), `\x1b[?${mode};2$y`); // now inactive
|
|
await inputHandler.parseP(`\x1b[?${mode}h`);
|
|
await inputHandler.parseP(`\x1b[?${mode}$p`);
|
|
assert.deepEqual(reportStack.pop(), `\x1b[?${mode};1$y`); // again set
|
|
}
|
|
});
|
|
it('DEC privates perma modes', async () => {
|
|
// [mode number, state value]
|
|
const perma = [[3, 0], [8, 3], [67, 4], [1005, 4], [1015, 4], [1048, 1]];
|
|
for (const [mode, value] of perma) {
|
|
await inputHandler.parseP(`\x1b[?${mode}$p`);
|
|
assert.deepEqual(reportStack.pop(), `\x1b[?${mode};${value}$y`);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
|
|
describe('InputHandler - async handlers', () => {
|
|
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);
|
|
coreService.onData(data => { console.log(data); });
|
|
|
|
inputHandler = new TestInputHandler(bufferService, new MockCharsetService(), coreService, new MockLogService(), optionsService, new MockOscLinkService(), new MockCoreMouseService(), new MockUnicodeService());
|
|
});
|
|
|
|
it('async CUP with CPR check', async () => {
|
|
const cup: number[][] = [];
|
|
const cpr: number[][] = [];
|
|
inputHandler.registerCsiHandler({ final: 'H' }, async params => {
|
|
cup.push(params.toArray() as number[]);
|
|
await new Promise(res => setTimeout(res, 50));
|
|
// late call of real repositioning
|
|
return inputHandler.cursorPosition(params);
|
|
});
|
|
coreService.onData(data => {
|
|
const m = data.match(/\x1b\[(.*?);(.*?)R/);
|
|
if (m) {
|
|
cpr.push([parseInt(m[1]), parseInt(m[2])]);
|
|
}
|
|
});
|
|
await inputHandler.parseP('aaa\x1b[3;4H\x1b[6nbbb\x1b[6;8H\x1b[6n');
|
|
assert.deepEqual(cup, cpr);
|
|
});
|
|
it('async OSC between', async () => {
|
|
inputHandler.registerOscHandler(1000, async data => {
|
|
await new Promise(res => setTimeout(res, 50));
|
|
assert.deepEqual(getLines(bufferService, 2), ['hello world!', '']);
|
|
assert.equal(data, 'some data');
|
|
return true;
|
|
});
|
|
await inputHandler.parseP('hello world!\r\n\x1b]1000;some data\x07second line');
|
|
assert.deepEqual(getLines(bufferService, 2), ['hello world!', 'second line']);
|
|
});
|
|
it('async DCS between', async () => {
|
|
inputHandler.registerDcsHandler({ final: 'a' }, async (data, params) => {
|
|
await new Promise(res => setTimeout(res, 50));
|
|
assert.deepEqual(getLines(bufferService, 2), ['hello world!', '']);
|
|
assert.equal(data, 'some data');
|
|
assert.deepEqual(params.toArray(), [1, 2]);
|
|
return true;
|
|
});
|
|
await inputHandler.parseP('hello world!\r\n\x1bP1;2asome data\x1b\\second line');
|
|
assert.deepEqual(getLines(bufferService, 2), ['hello world!', 'second line']);
|
|
});
|
|
});
|